ดาวน์โหลด node ipc - ดาวน์โหลดซอร์สโค้ด node ipc

โหนด-ipc

โมดูล nodejs สำหรับการสื่อสารระหว่างกระบวนการภายในและระยะไกล พร้อมการรองรับ Linux, Mac และ Windows อย่างเต็มรูปแบบ นอกจากนี้ยังรองรับการสื่อสารซ็อกเก็ตทุกรูปแบบตั้งแต่ซ็อกเก็ต unix และ windows ระดับต่ำไปจนถึง UDP และซ็อกเก็ต TLS และ TCP ที่ปลอดภัย

โซลูชันที่ยอดเยี่ยมสำหรับ Neural Networking แบบหลายกระบวนการที่ซับซ้อนใน Node.JS

npm install node-ipc

สำหรับโหนด <v14

npm install node-ipc@^9.0.0

รวม v10 หรือสูงกว่าไว้ในโค้ดของคุณ

 //es6
import ipc from 'node-ipc'

//commonjs
const ipc = require ( 'node-ipc' ) . default ;

สถิติ NPM

ข้อมูล npm : ดูแนวโน้มและสถิติ npm สำหรับ node-ipc

ข้อมูล GitHub:

ข้อมูลการครอบคลุมโค้ด:

เรียกใช้ npm run coverage เพื่อโฮสต์รายงานความครอบคลุมเวอร์ชันท้องถิ่นบน localhost:8080 ซึ่งเป็นรูปแบบเดียวกับอิสตันบูลและ NYC มันควรจะคุ้นเคยมาก

ทดสอบด้วย vanilla-test
vanilla-test ทำงานร่วมกับ c8 เพื่อความครอบคลุม ESM ดั้งเดิมโดยไม่จำเป็นต้องแปลงโค้ดของคุณ ในขณะที่เขียน นี่เป็นวิธีเดียวที่จะทดสอบ ESM แบบเนทีฟ และมันน่าทึ่งมาก!

เว็บไซต์รายละเอียดแพ็คเกจ :

เว็บไซต์ GitHub.io เวอร์ชันที่สวยกว่าของไซต์นี้
โมดูล NPM หน้า npm สำหรับโมดูล node-ipc

งานนี้ได้รับอนุญาตผ่านใบอนุญาต MIT

โหนดเวอร์ชันเก่า

node-ipc เวอร์ชันล่าสุดอาจใช้งานได้กับแฟล็ก --harmony อย่างเป็นทางการ เรารองรับโหนด v4 และใหม่กว่าด้วย es5 และ es6

การทดสอบ

npm test จะดำเนินการทดสอบ jasmine ด้วยอิสตันบูลสำหรับ node-ipc และสร้างรายงานความครอบคลุมในโฟลเดอร์ spec

คุณอาจต้องการติดตั้งจัสมินและอิสตันบูลทั่วโลกด้วย sudo npm install -g jasmine istanbul

สารบัญ

ประเภทของซ็อกเก็ต IPC และระบบปฏิบัติการที่รองรับ
การกำหนดค่า IPC
วิธีการ IPC
1. บันทึก
2. เชื่อมต่อถึง
3. เชื่อมต่อToNet
4. ตัดการเชื่อมต่อ
5. ให้บริการ
6. เสิร์ฟเน็ต
ร้านค้า IPC และตัวแปรเริ่มต้น
เหตุการณ์ไอพีซี
อินสแตนซ์ IPC หลายรายการ
ตัวอย่างพื้นฐาน
1. เซิร์ฟเวอร์สำหรับ Unix||ซ็อกเก็ต Windows และซ็อกเก็ต TCP
2. ไคลเอนต์สำหรับ Unix||ซ็อกเก็ต Windows และซ็อกเก็ต TCP
3. เซิร์ฟเวอร์และไคลเอนต์สำหรับซ็อกเก็ต UDP
4. Raw Buffers, เรียลไทม์และ / หรือ Binary Sockets
การทำงานกับเซิร์ฟเวอร์และไคลเอนต์ซ็อกเก็ต TLS/SSL
ตัวอย่างรหัสโหนด

ประเภทของซ็อกเก็ต IPC

พิมพ์	ความมั่นคง	คำนิยาม
ซ็อกเก็ต Unix หรือซ็อกเก็ต Windows	มั่นคง	ให้การสื่อสารที่รวดเร็วปานสายฟ้าสำหรับ Linux, Mac และ Windows และหลีกเลี่ยงการ์ดเครือข่ายเพื่อลดค่าใช้จ่ายและเวลาแฝง ตัวอย่าง Local Unix และ Windows Socket
ซ็อกเก็ต TCP	มั่นคง	ให้การสื่อสารที่เชื่อถือได้มากที่สุดผ่านเครือข่าย สามารถใช้สำหรับ IPC ในเครื่องได้เช่นกัน แต่จะช้ากว่าการใช้ Unix Socket ของ # 1 เนื่องจากซ็อกเก็ต TCP ผ่านการ์ดเครือข่ายในขณะที่ Unix Sockets และ Windows Sockets ไม่ผ่าน ตัวอย่างซ็อกเก็ต TCP เครือข่ายท้องถิ่นหรือระยะไกล
ซ็อกเก็ต TLS	มั่นคง	ซ็อกเก็ตเครือข่ายที่กำหนดค่าได้และปลอดภัยผ่าน SSL เทียบเท่ากับ https. เอกสาร TLS/SSL
ซ็อกเก็ต UDP	มั่นคง	ให้ การสื่อสารผ่านเครือข่ายรวดเร็วที่สุด UDP มีความน่าเชื่อถือน้อยกว่า แต่เร็วกว่า TCP มาก เหมาะที่สุดสำหรับการสตรีมข้อมูลที่ไม่สำคัญ เช่น เสียง วิดีโอ หรือข้อมูลเกมที่มีผู้เล่นหลายคน เนื่องจากอาจปล่อยแพ็กเก็ตขึ้นอยู่กับการเชื่อมต่อเครือข่ายและปัจจัยอื่นๆ UDP สามารถใช้สำหรับ IPC ในเครื่องได้เช่นกัน แต่ช้ากว่าการใช้ Unix Socket หรือ Windows Socket Implementation # 1 เนื่องจากซ็อกเก็ต UDP ผ่านการ์ดเครือข่ายในขณะที่ Unix และ Windows Sockets ไม่ผ่าน ตัวอย่างซ็อกเก็ต UDP เครือข่ายท้องถิ่นหรือระยะไกล

ระบบปฏิบัติการ	ซ็อกเก็ตที่รองรับ
ลินุกซ์	ยูนิกซ์, Posix, TCP, TLS, UDP
แม็ค	ยูนิกซ์, Posix, TCP, TLS, UDP
ชนะ	Windows, TCP, TLS, UDP

การกำหนดค่า IPC

ipc.config

ตั้งค่าตัวแปรเหล่านี้ในขอบเขต ipc.config เพื่อเขียนทับหรือตั้งค่าเริ่มต้น

    {
        appspace        : 'app.' ,
        socketRoot      : '/tmp/' ,
        id              : os . hostname ( ) ,
        networkHost     : 'localhost' , //should resolve to 127.0.0.1 or ::1 see the table below related to this
        networkPort     : 8000 ,
        readableAll     : false ,
        writableAll     : false ,
        encoding        : 'utf8' ,
        rawBuffer       : false ,
        delimiter       : 'f' ,
        sync            : false ,
        silent          : false ,
        logInColor      : true ,
        logDepth        : 5 ,
        logger          : console . log ,
        maxConnections  : 100 ,
        retry           : 500 ,
        maxRetries      : false ,
        stopRetrying    : false ,
        unlink          : true ,
        interfaces      : {
            localAddress : false ,
            localPort   : false ,
            family      : false ,
            hints       : false ,
            lookup      : false
        }
    }

ตัวแปร	เอกสารประกอบ
พื้นที่แอป	ใช้สำหรับเนมสเปซ Unix Socket (Unix Domain Socket) หากไม่ได้ตั้งค่าไว้โดยเฉพาะ Unix Domain Socket จะรวม socketRoot, appspace และ id เพื่อสร้าง Unix Socket Path สำหรับการสร้างหรือการเชื่อมโยง ใช้ได้ในกรณีที่คุณมีแอปจำนวนมากที่ทำงานอยู่บนระบบของคุณ คุณอาจมีหลายซ็อกเก็ตที่มีรหัสเดียวกัน แต่ถ้าคุณเปลี่ยนพื้นที่แอป คุณจะยังคงมีซ็อกเก็ตเฉพาะเฉพาะของแอปอยู่
socketRoot	ไดเร็กทอรีที่จะสร้างหรือผูกเข้ากับ Unix Socket
รหัส	รหัสของซ็อกเก็ตหรือบริการนี้
เครือข่ายโฮสต์	โฮสต์ภายในเครื่องหรือระยะไกลที่ซ็อกเก็ต TCP, TLS หรือ UDP ควรเชื่อมต่อ
พอร์ตเครือข่าย	พอร์ตเริ่มต้นที่ซ็อกเก็ต TCP, TLS หรือ UDP ควรเชื่อมต่อ
อ่านได้ทั้งหมด	ทำให้ไปป์สามารถอ่านได้สำหรับผู้ใช้ทุกคนรวมถึงบริการของ windows
เขียนได้ทั้งหมด	ทำให้ไปป์สามารถเขียนได้สำหรับผู้ใช้ทุกคนรวมถึงบริการ windows
การเข้ารหัส	การเข้ารหัสเริ่มต้นสำหรับข้อมูลที่ส่งบนซ็อกเก็ต ส่วนใหญ่จะใช้หากตั้งค่า rawBuffer เป็นจริง ค่าที่ถูกต้องคือ: `ascii` `utf8` `utf16le` `ucs2` `base64` `hex`
rawBuffer	หากเป็นจริง ข้อมูลจะถูกส่งและรับเป็นโหนดดิบ `Buffer` ไม่ใช่ `Object` เป็น JSON ซึ่งเหมาะสำหรับ Binary หรือ Hex IPC และการสื่อสารกับกระบวนการอื่นๆ ในภาษาเช่น C และ C++
ตัวคั่น	ตัวคั่นที่ส่วนท้ายของแต่ละแพ็กเก็ตข้อมูล
ซิงค์	คำขอแบบซิงโครนัส ลูกค้าจะไม่ส่งคำขอใหม่จนกว่าเซิร์ฟเวอร์จะตอบกลับ
เงียบ	การเปิด/ปิดค่าเริ่มต้นการบันทึกเป็นเท็จ ซึ่งหมายความว่าเปิดการบันทึกอยู่
เข้าสู่ระบบสี	เปิด/ปิด util.inspect สีสำหรับ ipc.log
เข้าสู่ระบบความลึก	ตั้งค่าความลึกสำหรับ util.inspect ระหว่าง ipc.log
คนตัดไม้	ฟังก์ชั่นรับเอาต์พุตจาก ipc.log ควรใช้อาร์กิวเมนต์สตริงเดียว
การเชื่อมต่อสูงสุด	นี่คือจำนวนการเชื่อมต่อสูงสุดที่อนุญาตให้ใช้กับซ็อกเก็ต ขณะนี้มีการตั้งค่าบน Unix Sockets เท่านั้น ซ็อกเก็ตประเภทอื่นใช้ค่าเริ่มต้นของระบบ
ลองอีกครั้ง	นี่คือเวลาในหน่วยมิลลิวินาทีที่ไคลเอ็นต์จะรอก่อนที่จะพยายามเชื่อมต่อกับเซิร์ฟเวอร์อีกครั้งหากการเชื่อมต่อขาดหาย สิ่งนี้จะไม่ส่งผลต่อซ็อกเก็ต UDP เนื่องจากไม่มีความสัมพันธ์แบบไคลเอ็นต์เซิร์ฟเวอร์ เช่น Unix Sockets และ TCP Sockets
maxRetries	หากตั้งค่าไว้ จะแสดงจำนวนครั้งสูงสุดในการลองใหม่หลังจากการตัดการเชื่อมต่อแต่ละครั้ง ก่อนที่จะยกเลิกการเชื่อมต่อและยุติการเชื่อมต่อเฉพาะ
หยุดลองอีกครั้ง	ค่าเริ่มต้นเป็นเท็จ หมายความว่าไคลเอ็นต์จะพยายามเชื่อมต่อกับเซิร์ฟเวอร์อีกครั้งอย่างไม่มีกำหนดในช่วงเวลาการลองใหม่ หากตั้งค่าเป็นหมายเลขใดๆ ไคลเอนต์จะหยุดลองใหม่เมื่อเกินจำนวนนั้นหลังจากยกเลิกการเชื่อมต่อแต่ละครั้ง หากตั้งค่าเป็นจริงแบบเรียลไทม์ ระบบจะหยุดพยายามเชื่อมต่อทันทีโดยไม่คำนึงถึง maxRetries หากตั้งค่าเป็น 0 ไคลเอนต์จะ ไม่ พยายามเชื่อมต่อใหม่
ยกเลิกการเชื่อมโยง	ค่าเริ่มต้นเป็นความหมายที่แท้จริงว่าโมดูลจะดูแลการลบซ็อกเก็ต IPC ก่อนที่จะเริ่มต้น หากคุณใช้ `node-ipc` ในสภาพแวดล้อมแบบคลัสเตอร์ซึ่งจะมี Listener จำนวนมากบนซ็อกเก็ตเดียวกัน คุณต้องตั้งค่านี้เป็น `false` จากนั้นจึงดูแลการลบซ็อกเก็ตในโค้ดของคุณเอง
อินเทอร์เฟซ	ใช้เป็นหลักเมื่อระบุอินเทอร์เฟซที่ไคลเอ็นต์ควรเชื่อมต่อผ่าน ดูเอกสารประกอบของ socket.connect ใน node.js api

วิธีการ IPC

วิธีการเหล่านี้มีอยู่ในขอบเขต IPC

บันทึก

ipc.log(a,b,c,d,e...);

ipc.log จะยอมรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ และหากไม่ได้ตั้งค่า ipc.config.silent จะเชื่อมต่ออาร์กิวเมนต์ทั้งหมดด้วยช่องว่าง ' ' ระหว่างอาร์กิวเมนต์เหล่านั้น จากนั้นจึงบันทึกอาร์กิวเมนต์เหล่านั้นลงในคอนโซล สิ่งนี้รวดเร็วเนื่องจากจะป้องกันการต่อข้อมูลใด ๆ ที่เกิดขึ้นหากตั้งค่า ipc.config.silent เป็น true ด้วยวิธีนี้ หากคุณปล่อยให้การเข้าสู่ระบบอยู่กับที่ ก็แทบจะไม่มีผลกระทบต่อประสิทธิภาพการทำงานเลย

บันทึกยังใช้ util.inspect คุณสามารถควบคุมได้ว่าควรบันทึกสี ความลึกของบันทึก และปลายทางผ่าน ipc.config

    ipc . config . logInColor = true ; //default
    ipc . config . logDepth = 5 ; //default    
    ipc . config . logger = console . log . bind ( console ) ; // default

เชื่อมต่อถึง

ipc.connectTo(id,path,callback);

ใช้สำหรับเชื่อมต่อในฐานะไคลเอ็นต์กับ Unix Sockets และ Windows Sockets ในเครื่อง นี่เป็นวิธีที่เร็วที่สุดสำหรับกระบวนการบนเครื่องเดียวกันในการสื่อสาร เนื่องจากจะข้ามการ์ดเครือข่ายที่ TCP และ UDP ต้องใช้ทั้งคู่

ตัวแปร	ที่จำเป็น	คำนิยาม
รหัส	ที่จำเป็น	คือรหัสสตริงของซ็อกเก็ตที่กำลังเชื่อมต่ออยู่ ซ็อกเก็ตที่มีรหัสนี้จะถูกเพิ่มไปยังวัตถุ ipc.of เมื่อสร้างขึ้น
เส้นทาง	ไม่จำเป็น	คือเส้นทางของไฟล์ซ็อกเก็ตโดเมน Unix หากระบบเป็น Windows สิ่งนี้จะถูกแปลงเป็นไปป์ที่เหมาะสมโดยอัตโนมัติโดยมีข้อมูลเดียวกันกับไฟล์ซ็อกเก็ตโดเมน Unix หากไม่ได้ตั้งค่า ค่าเริ่มต้นจะเป็น `ipc.config.socketRoot` + `ipc.config.appspace` + `id`
โทรกลับ	ไม่จำเป็น	นี่คือฟังก์ชันที่จะดำเนินการเมื่อสร้างซ็อกเก็ตแล้ว

อาร์กิวเมนต์ ตัวอย่าง สามารถละเว้นได้ตราบใดที่ยังคงอยู่ตามลำดับ

    ipc . connectTo ( 'world' ) ;

หรือใช้เพียง ID และการโทรกลับ

    ipc . connectTo (
        'world' ,
        function ( ) {
            ipc . of . world . on (
                'hello' ,
                function ( data ) {
                    ipc . log ( data . debug ) ;
                    //if data was a string, it would have the color set to the debug style applied to it
                }
            )
        }
    ) ;

หรือกำหนดเส้นทางให้ชัดเจน

    ipc . connectTo (
        'world' ,
        'myapp.world'
    ) ;

หรือกำหนดเส้นทางอย่างชัดเจนด้วยการโทรกลับ

    ipc . connectTo (
        'world' ,
        'myapp.world' ,
        function ( ) {
            ...
        }
    ) ;

เชื่อมต่อToNet

ipc.connectToNet(id,host,port,callback)

ใช้เพื่อเชื่อมต่อในฐานะไคลเอ็นต์กับซ็อกเก็ต TCP หรือ TLS ผ่านทางการ์ดเครือข่าย ซึ่งอาจเป็นแบบโลคัลหรือระยะไกล หากเป็นแบบโลคัล ขอแนะนำให้คุณใช้ Unix และ Windows Socket Implementaion ของ connectTo แทน เนื่องจากจะเร็วกว่ามากเนื่องจากจะหลีกเลี่ยงการ์ดเครือข่ายโดยสิ้นเชิง

สำหรับซ็อกเก็ต TLS และ SSL โปรดดูเอกสาร node-ipc TLS และ SSL พวกเขามีข้อกำหนดเพิ่มเติมบางประการ และสิ่งที่ควรรู้ จึงมีเอกสารเป็นของตัวเอง

ตัวแปร	ที่จำเป็น	คำนิยาม
รหัส	ที่จำเป็น	คือรหัสสตริงของซ็อกเก็ตที่กำลังเชื่อมต่ออยู่ สำหรับซ็อกเก็ต TCP & TLS รหัสนี้จะถูกเพิ่มไปยังออบเจ็กต์ `ipc.of` เมื่อสร้างซ็อกเก็ตโดยมีการอ้างอิงถึงซ็อกเก็ต
เจ้าภาพ	ไม่จำเป็น	เป็นโฮสต์ที่มีซ็อกเก็ต TCP หรือ TLS อยู่ นี่จะเป็นค่าเริ่มต้นเป็น `ipc.config.networkHost` หากไม่ได้ระบุ
ท่าเรือ	ไม่จำเป็น	พอร์ตที่มีซ็อกเก็ต TCP หรือ TLS อยู่
โทรกลับ	ไม่จำเป็น	นี่คือฟังก์ชันที่จะดำเนินการเมื่อสร้างซ็อกเก็ตแล้ว

อาร์กิวเมนต์ ตัวอย่าง สามารถละเว้นได้ตราบใดที่ยังคงอยู่ตามลำดับ
ดังนั้นในขณะที่ค่าเริ่มต้นคือ: (id,host,port,callback) ตัวอย่างต่อไปนี้จะยังคงใช้งานได้เนื่องจากยังคงอยู่ในลำดับ (id,port,callback) หรือ (id,host,callback) หรือ (id,port) ฯลฯ .

    ipc . connectToNet ( 'world' ) ;

หรือใช้เพียง ID และการโทรกลับ

    ipc . connectToNet (
        'world' ,
        function ( ) {
            ...
        }
    ) ;

หรือกำหนดโฮสต์และเส้นทางอย่างชัดเจน

    ipc . connectToNet (
        'world' ,
        'myapp.com' , serve ( path , callback )
        3435
    ) ;

หรือเฉพาะการตั้งค่าพอร์ตและการโทรกลับอย่างชัดเจน

    ipc . connectToNet (
        'world' ,
        3435 ,
        function ( ) {
            ...
        }
    ) ;

ตัดการเชื่อมต่อ

ipc.disconnect(id)

ใช้เพื่อยกเลิกการเชื่อมต่อไคลเอนต์จากซ็อกเก็ต Unix, Windows, TCP หรือ TLS ซ็อกเก็ตและการอ้างอิงจะถูกลบออกจากหน่วยความจำและขอบเขต ipc.of นี่อาจเป็นแบบท้องถิ่นหรือระยะไกล ไคลเอนต์ UDP ไม่รักษาการเชื่อมต่อ ดังนั้นจึงไม่มีไคลเอนต์ และวิธีการนี้ไม่มีคุณค่าสำหรับพวกเขา

ตัวแปร	ที่จำเป็น	คำนิยาม
รหัส	ที่จำเป็น	คือรหัสสตริงของซ็อกเก็ตที่จะตัดการเชื่อมต่อ

ตัวอย่าง

    ipc . disconnect ( 'world' ) ;

ให้บริการ

ipc.serve(path,callback);

ใช้เพื่อสร้าง Unix Socket Server ในเครื่องหรือ Windows Socket Server ที่ไคลเอ็นต์สามารถผูกได้ เซิร์ฟเวอร์สามารถ emit เหตุการณ์ไปยัง Client Sockets เฉพาะ หรือ broadcast เหตุการณ์ไปยัง Client Sockets ที่รู้จักทั้งหมด

ตัวแปร	ที่จำเป็น	คำนิยาม
เส้นทาง	ไม่จำเป็น	นี่คือเส้นทางของไฟล์ซ็อกเก็ตโดเมน Unix หากระบบเป็น Windows สิ่งนี้จะถูกแปลงเป็นไปป์ที่เหมาะสมโดยอัตโนมัติโดยมีข้อมูลเดียวกันกับไฟล์ซ็อกเก็ตโดเมน Unix หากไม่ได้ตั้งค่า ค่าเริ่มต้นจะเป็น `ipc.config.socketRoot` + `ipc.config.appspace` + `id`
โทรกลับ	ไม่จำเป็น	นี่คือฟังก์ชันที่จะเรียกใช้หลังจากที่เซิร์ฟเวอร์เริ่มทำงานแล้ว ซึ่งสามารถทำได้โดยการรวมเหตุการณ์เข้ากับเหตุการณ์ start เช่น `ipc.server.on('start',function(){});`

อาร์กิวเมนต์ ตัวอย่าง สามารถละเว้นได้ตราบใดที่ยังคงอยู่ตามลำดับ

    ipc . serve ( ) ;

หรือระบุการโทรกลับ

    ipc . serve (
        function ( ) { ... }
    ) ;

หรือระบุเส้นทาง

    ipc . serve (
        '/tmp/myapp.myservice'
    ) ;

หรือระบุทุกอย่าง

    ipc . serve (
        '/tmp/myapp.myservice' ,
        function ( ) { ... }
    ) ;

เสิร์ฟเน็ต

serveNet(host,port,UDPType,callback)

ใช้เพื่อสร้างเซิร์ฟเวอร์ซ็อกเก็ต TCP, TLS หรือ UDP ซึ่งไคลเอนต์สามารถผูกหรือเซิร์ฟเวอร์อื่นสามารถส่งข้อมูลไปได้ เซิร์ฟเวอร์สามารถ emit เหตุการณ์ไปยังซ็อกเก็ตไคลเอนต์เฉพาะ หรือ broadcast เหตุการณ์ไปยังซ็อกเก็ตไคลเอนต์ที่รู้จักทั้งหมด

ตัวแปร	ที่จำเป็น	คำนิยาม
เจ้าภาพ	ไม่จำเป็น	หากไม่ได้ระบุค่าเริ่มต้นนี้จะเป็นที่อยู่แรกใน os.networkInterfaces() สำหรับเซิร์ฟเวอร์ TCP, TLS & UDP มักจะเป็น 127.0.0.1 หรือ ::1
ท่าเรือ	ไม่จำเป็น	พอร์ตที่เซิร์ฟเวอร์ TCP, UDP หรือ TLS Socket จะถูกผูกไว้ ค่าเริ่มต้นนี้เป็น 8000 หากไม่ได้ระบุ
ประเภท UDP	ไม่จำเป็น	หากตั้งค่านี้จะสร้างเซิร์ฟเวอร์เป็นซ็อกเก็ต UDP 'udp4' หรือ 'udp6' เป็นค่าที่ถูกต้อง ค่าเริ่มต้นนี้ไม่ได้ตั้งค่าไว้ เมื่อใช้ udp6 ตรวจสอบให้แน่ใจว่าได้ระบุโฮสต์ IPv6 ที่ถูกต้อง เช่น `::1`
โทรกลับ	ไม่จำเป็น	ฟังก์ชั่นที่จะเรียกใช้เมื่อมีการสร้างเซิร์ฟเวอร์

อาร์กิวเมนต์ ตัวอย่าง สามารถละเว้นได้ตราบใดที่ยังคงอยู่ตามลำดับ

เซิร์ฟเวอร์ TCP เริ่มต้น

    ipc . serveNet ( ) ;

เซิร์ฟเวอร์ udp เริ่มต้น

    ipc . serveNet ( 'udp4' ) ;

หรือระบุเซิร์ฟเวอร์ TCP พร้อมการโทรกลับ

    ipc . serveNet (
        function ( ) { ... }
    ) ;

หรือระบุเซิร์ฟเวอร์ UDP พร้อมการโทรกลับ

    ipc . serveNet (
        'udp4' ,
        function ( ) { ... }
    ) ;

หรือระบุพอร์ต

    ipc . serveNet (
        3435
    ) ;

หรือระบุทุกอย่าง TCP

    ipc . serveNet (
        'MyMostAwesomeApp.com' ,
        3435 ,
        function ( ) { ... }
    ) ;

หรือระบุทุกอย่าง UDP

    ipc . serveNet (
        'MyMostAwesomeApp.com' ,
        3435 ,
        'udp4' ,
        function ( ) { ... }
    ) ;

ร้านค้า IPC และตัวแปรเริ่มต้น

ตัวแปร คำนิยาม

ไอพีซีออฟ นี่คือที่ที่การอ้างอิงการเชื่อมต่อซ็อกเก็ตจะถูกจัดเก็บเมื่อเชื่อมต่อกับพวกเขาในฐานะไคลเอนต์ผ่าน ipc.connectTo หรือ iupc.connectToNet โดยจะถูกจัดเก็บตาม ID ที่ใช้สร้าง เช่น : ipc.of.mySocket

ipc.เซิร์ฟเวอร์ นี่คือการอ้างอิงถึงเซิร์ฟเวอร์ที่สร้างโดย ipc.serve หรือ ipc.serveNet

ตัวแปร	คำนิยาม
ไอพีซีออฟ	นี่คือที่ที่การอ้างอิงการเชื่อมต่อซ็อกเก็ตจะถูกจัดเก็บเมื่อเชื่อมต่อกับพวกเขาในฐานะไคลเอนต์ผ่าน `ipc.connectTo` หรือ `iupc.connectToNet` โดยจะถูกจัดเก็บตาม ID ที่ใช้สร้าง เช่น : ipc.of.mySocket
ipc.เซิร์ฟเวอร์	นี่คือการอ้างอิงถึงเซิร์ฟเวอร์ที่สร้างโดย `ipc.serve` หรือ `ipc.serveNet`

วิธีการเซิร์ฟเวอร์ IPC

วิธี	คำนิยาม
เริ่ม	เริ่มให้บริการจำเป็นต้องเรียก `serve` หรือ `serveNet` ก่อนเพื่อตั้งค่าเซิร์ฟเวอร์
หยุด	ปิดเซิร์ฟเวอร์และหยุดให้บริการ

กิจกรรมไอพีซี

ชื่อเหตุการณ์	พารามิเตอร์	คำนิยาม
ข้อผิดพลาด	ผิดพลาด obj	เกิดขึ้นเมื่อมีข้อผิดพลาดเกิดขึ้น
เชื่อมต่อ		ทริกเกอร์เมื่อเชื่อมต่อซ็อกเก็ต
ตัดการเชื่อมต่อ		ทริกเกอร์โดยไคลเอนต์เมื่อซ็อกเก็ตถูกตัดการเชื่อมต่อจากเซิร์ฟเวอร์
ซ็อกเก็ตถูกตัดการเชื่อมต่อ	ซ็อกเก็ตถูกทำลายSocketID	ทริกเกอร์โดยเซิร์ฟเวอร์เมื่อซ็อกเก็ตไคลเอนต์ถูกตัดการเชื่อมต่อ
ทำลาย		ทริกเกอร์เมื่อซ็อกเก็ตถูกทำลายโดยสิ้นเชิง จะไม่มีการลองใหม่อัตโนมัติอีกต่อไป และการอ้างอิงทั้งหมดจะหายไป
ข้อมูล	บัฟเฟอร์	ทริกเกอร์เมื่อ ipc.config.rawBuffer เป็นจริงและได้รับข้อความ
ประเภทกิจกรรมของคุณ	ข้อมูลกิจกรรมของคุณ	ทริกเกอร์เมื่อได้รับข้อความ JSON ชื่อเหตุการณ์จะเป็นสตริงประเภทจากข้อความของคุณและพารามิเตอร์จะเป็นวัตถุข้อมูลจากข้อความของคุณ เช่น : `{ type:'myEvent',data:{a:1}}`

อินสแตนซ์ IPC หลายรายการ

บางครั้งคุณอาจต้องการอินสแตนซ์ของ node-ipc ที่ชัดเจนและเป็นอิสระ สำหรับสถานการณ์ดังกล่าว เราได้เปิดเผยคลาส IPC หลักบน IPC singleton

    import { IPCModule } from 'node-ipc' ;

    const ipc = new RawIPC ;
    const someOtherExplicitIPC = new RawIPC ;


    //OR

    const ipc = from 'node-ipc' ) ;
    const someOtherExplicitIPC = new ipc . IPC ;


    //setting explicit configs

    //keep one silent and the other verbose
    ipc . config . silent = true ;
    someOtherExplicitIPC . config . silent = true ;

    //make one a raw binary and the other json based ipc
    ipc . config . rawBuffer = false ;

    someOtherExplicitIPC . config . rawBuffer = true ;
    someOtherExplicitIPC . config . encoding = 'hex' ;

ตัวอย่างพื้นฐาน

คุณสามารถค้นหาตัวอย่างขั้นสูงได้ในโฟลเดอร์ตัวอย่าง ในตัวอย่าง คุณจะพบการสาธิตที่ซับซ้อนยิ่งขึ้น รวมถึงตัวอย่างลูกค้าหลายราย

เซิร์ฟเวอร์สำหรับซ็อกเก็ต Unix, ซ็อกเก็ต Windows และซ็อกเก็ต TCP

เซิร์ฟเวอร์เป็นกระบวนการที่เปิดซ็อกเก็ตสำหรับ IPC ซ็อกเก็ตหลายตัวสามารถเชื่อมต่อกับเซิร์ฟเวอร์นี้และพูดคุยกับมันได้ นอกจากนี้ยังสามารถถ่ายทอดไปยังไคลเอนต์ทั้งหมดหรือส่งไปยังไคลเอนต์เฉพาะได้อีกด้วย นี่เป็นตัวอย่างพื้นฐานที่สุดซึ่งจะใช้ได้กับซ็อกเก็ต Unix และ Windows ภายในเครื่อง รวมถึงซ็อกเก็ต TCP เครือข่ายภายในหรือระยะไกล

    import ipc from 'node-ipc' ;

    ipc . config . id   = 'world' ;
    ipc . config . retry = 1500 ;

    ipc . serve (
        function ( ) {
            ipc . server . on (
                'message' ,
                function ( data , socket ) {
                    ipc . log ( 'got a message : ' . debug , data ) ;
                    ipc . server . emit (
                        socket ,
                        'message' ,  //this can be anything you want so long as
                                    //your client knows.
                        data + ' world!'
                    ) ;
                }
            ) ;
			ipc . server . on (
				'socket.disconnected' ,
				function ( socket , destroyedSocketID ) {
					ipc . log ( 'client ' + destroyedSocketID + ' has disconnected!' ) ;
				}
			) ;
        }
    ) ;

    ipc . server . start ( ) ;

ไคลเอนต์สำหรับ Unix Sockets และ TCP Sockets

ไคลเอนต์เชื่อมต่อกับซ็อกเก็ตเซิร์ฟเวอร์สำหรับการสื่อสารระหว่างกระบวนการ ซ็อกเก็ตจะได้รับเหตุการณ์ที่ปล่อยออกมาโดยเฉพาะ เช่นเดียวกับเหตุการณ์ที่เซิร์ฟเวอร์ออกอากาศบนซ็อกเก็ต นี่คือตัวอย่างพื้นฐานที่สุดซึ่งจะใช้ได้กับทั้งซ็อกเก็ต Unix ภายในและซ็อกเก็ต TCP เครือข่ายท้องถิ่นหรือระยะไกล

    import ipc from 'node-ipc' ;

    ipc . config . id   = 'hello' ;
    ipc . config . retry = 1500 ;

    ipc . connectTo (
        'world' ,
        function ( ) {
            ipc . of . world . on (
                'connect' ,
                function ( ) {
                    ipc . log ( '## connected to world ##' . rainbow , ipc . config . delay ) ;
                    ipc . of . world . emit (
                        'message' ,  //any event or message type your server listens for
                        'hello'
                    )
                }
            ) ;
            ipc . of . world . on (
                'disconnect' ,
                function ( ) {
                    ipc . log ( 'disconnected from world' . notice ) ;
                }
            ) ;
            ipc . of . world . on (
                'message' ,  //any event or message type your server listens for
                function ( data ) {
                    ipc . log ( 'got a message from world : ' . debug , data ) ;
                }
            ) ;
        }
    ) ;

เซิร์ฟเวอร์และไคลเอนต์สำหรับซ็อกเก็ต UDP

ซ็อกเก็ต UDP แตกต่างจากซ็อกเก็ต Unix, Windows และ TCP เนื่องจากต้องเชื่อมโยงกับพอร์ตเฉพาะบนเครื่องเพื่อรับข้อความ ตัวอย่างเช่น ไคลเอ็นต์ TCP, Unix หรือ Windows Socket สามารถเชื่อมต่อกับเซิร์ฟเวอร์ TCP, Unix หรือ Windows Socket ที่แยกต่างหากได้ ลูกค้ารายนั้นสามารถแลกเปลี่ยนทั้งส่งและรับข้อมูลบนพอร์ตเซิร์ฟเวอร์หรือที่ตั้งได้ ซ็อกเก็ต UDP ไม่สามารถทำได้ พวกเขาจะต้องผูกเข้ากับพอร์ตเพื่อรับหรือส่งข้อมูล

ซึ่งหมายความว่าไคลเอ็นต์และเซิร์ฟเวอร์ UDP เป็นสิ่งเดียวกัน เนื่องจากในการรับข้อมูล ซ็อกเก็ต UDP จะต้องมีพอร์ตของตัวเองเพื่อรับข้อมูล และมีเพียงกระบวนการเดียวเท่านั้นที่สามารถใช้พอร์ตนี้ได้ในแต่ละครั้ง นอกจากนี้ยังหมายความว่าในการที่จะ emit หรือ broadcast ข้อมูล เซิร์ฟเวอร์ UDP จะต้องทราบโฮสต์และพอร์ตของซ็อกเก็ตที่ต้องการจะออกอากาศข้อมูลไป

นี่คือตัวอย่างพื้นฐานที่สุดซึ่งจะใช้ได้กับซ็อกเก็ต UDP ทั้งภายในและระยะไกล

เซิร์ฟเวอร์ UDP 1 - "โลก"

    import ipc from 'node-ipc' ;

    ipc . config . id   = 'world' ;
    ipc . config . retry = 1500 ;

    ipc . serveNet (
        'udp4' ,
        function ( ) {
            console . log ( 123 ) ;
            ipc . server . on (
                'message' ,
                function ( data , socket ) {
                    ipc . log ( 'got a message from ' . debug , data . from . variable , ' : ' . debug , data . message . variable ) ;
                    ipc . server . emit (
                        socket ,
                        'message' ,
                        {
                            from    : ipc . config . id ,
                            message : data . message + ' world!'
                        }
                    ) ;
                }
            ) ;

            console . log ( ipc . server ) ;
        }
    ) ;

    ipc . server . start ( ) ;

เซิร์ฟเวอร์ UDP 2 - "สวัสดี"

โปรดทราบว่า เราตั้งค่าพอร์ตที่นี่เป็น 8001 เนื่องจากเซิร์ฟเวอร์โลกใช้ค่าเริ่มต้น ipc.config.networkPort ที่ 8000 ดังนั้นเราจึงไม่สามารถผูกกับ 8000 ในขณะที่ world กำลังใช้งานอยู่

    ipc . config . id   = 'hello' ;
    ipc . config . retry = 1500 ;

    ipc . serveNet (
        8001 ,
        'udp4' ,
        function ( ) {
            ipc . server . on (
                'message' ,
                function ( data ) {
                    ipc . log ( 'got Data' ) ;
                    ipc . log ( 'got a message from ' . debug , data . from . variable , ' : ' . debug , data . message . variable ) ;
                }
            ) ;
            ipc . server . emit (
                {
                    address : '127.0.0.1' , //any hostname will work
                    port    : ipc . config . networkPort
                } ,
                'message' ,
                {
                    from    : ipc . config . id ,
                    message : 'Hello'
                }
            ) ;
        }
    ) ;

    ipc . server . start ( ) ;

Raw Buffer หรือ Binary Sockets

ซ็อกเก็ตไบนารีหรือบัฟเฟอร์สามารถใช้กับซ็อกเก็ตประเภทใดก็ได้ข้างต้น อย่างไรก็ตาม วิธีการส่งเหตุการณ์ข้อมูลจะแตกต่างออกไป เล็กน้อย สิ่งเหล่านี้อาจมีประโยชน์หากทำงานกับระบบฝังตัวหรือกระบวนการ C / C++ คุณสามารถตรวจสอบให้แน่ใจว่าตรงกับการพิมพ์สตริง C หรือ C++

เมื่อตั้งค่าซ็อกเก็ต rawBuffer คุณต้องระบุดังนี้:

    ipc . config . rawBuffer = true ;

คุณยังสามารถระบุประเภทการเข้ารหัสได้ ค่าเริ่มต้นคือ utf8

    ipc . config . encoding = 'utf8' ;

ปล่อยบัฟเฟอร์สตริง:

    //server
    ipc . server . emit (
        socket ,
        'hello'
    ) ;

    //client
    ipc . of . world . emit (
        'hello'
    )

ปล่อยบัฟเฟอร์อาร์เรย์ไบต์:

    //hex encoding may work best for this.
    ipc . config . encoding = 'hex' ;

    //server
    ipc . server . emit (
        socket ,
        [ 10 , 20 , 30 ]
    ) ;

    //client
    ipc . server . emit (
        [ 10 , 20 , 30 ]
    ) ;

ปล่อยไบนารีหรือบัฟเฟอร์อาเรย์ฐานสิบหก ซึ่งเหมาะที่สุดสำหรับการถ่ายโอนข้อมูลแบบเรียลไทม์ โดยเฉพาะอย่างยิ่งเมื่อเชื่อมต่อกับกระบวนการ C หรือ C++ หรือระบบฝังตัว:

    ipc . config . encoding = 'hex' ;

    //server
    ipc . server . emit (
        socket ,
        [ 0x05 , 0x6d , 0x5c ]
    ) ;

    //client
    ipc . server . emit (
        [ 0x05 , 0x6d , 0x5c ]
    ) ;

การเขียนบัฟเฟอร์ที่ชัดเจน, ประเภท int, doubles, floats ฯลฯ รวมถึงข้อมูล big endian และ little endian ลงในบัฟเฟอร์ดิบที่มีคุณค่าอย่างมากเมื่อเชื่อมต่อกับกระบวนการ C หรือ C++ หรือระบบฝังตัว (ดูข้อมูลโดยละเอียดเพิ่มเติมเกี่ยวกับบัฟเฟอร์ตลอดจน UInt, Int , สองเท่า ฯลฯ ที่นี่)[https://nodejs.org/api/buffer.html]:

    ipc . config . encoding = 'hex' ;

    //make a 6 byte buffer for example
    const myBuffer = Buffer . alloc ( 6 ) . fill ( 0 ) ;

    //fill the first 2 bytes with a 16 bit (2 byte) short unsigned int

    //write a UInt16 (2 byte or short) as Big Endian
    myBuffer . writeUInt16BE (
        2 , //value to write
        0 //offset in bytes
    ) ;
    //OR
    myBuffer . writeUInt16LE ( 0x2 , 0 ) ;
    //OR
    myBuffer . writeUInt16LE ( 0x02 , 0 ) ;

    //fill the remaining 4 bytes with a 32 bit (4 byte) long unsigned int

    //write a UInt32 (4 byte or long) as Big Endian
    myBuffer . writeUInt32BE (
        16772812 , //value to write
        2 //offset in bytes
    ) ;
    //OR
    myBuffer . writeUInt32BE ( 0xffeecc , 0 )

    //server
    ipc . server . emit (
        socket ,
        myBuffer
    ) ;

    //client
    ipc . server . emit (
        myBuffer
    ) ;

เซิร์ฟเวอร์ที่มีโมดูล `cluster`

node-ipc สามารถใช้กับโมดูลคลัสเตอร์ของ Node.js เพื่อให้มีความสามารถในการมีเครื่องอ่านหลายตัวสำหรับซ็อกเก็ตเดียว การทำเช่นนี้เพียงต้องการให้คุณตั้งค่าคุณสมบัติ unlink ในการกำหนดค่าเป็น false และดูแลการยกเลิกการเชื่อมโยงเส้นทางซ็อกเก็ตในกระบวนการหลัก:

เซิร์ฟเวอร์

    import fs  from 'fs' ;
    import ipc from 'node-ipc' ;
    import { cpus }  from 'os' ;
    import cluster  from 'cluster' ;
    
    const cpuCount = cpus ( ) . length ;

    const socketPath = '/tmp/ipc.sock' ;

    ipc . config . unlink = false ;

    if ( cluster . isMaster ) {
       if ( fs . existsSync ( socketPath ) ) {
           fs . unlinkSync ( socketPath ) ;
       }

       for ( let i = 0 ; i < cpuCount ; i ++ ) {
           cluster . fork ( ) ;
       }
    } else {
       ipc . serve (
         socketPath ,
         function ( ) {
           ipc . server . on (
             'currentDate' ,
             function ( data , socket ) {
               console . log ( `pid ${ process . pid } got: ` , data ) ;
             }
           ) ;
         }
      ) ;

      ipc . server . start ( ) ;
      console . log ( `pid ${ process . pid } listening on ${ socketPath } ` ) ;
    }

ลูกค้า

    import fs  from 'fs' ;
    import ipc  from 'node-ipc' ;

    const socketPath = '/tmp/ipc.sock' ;

    //loop forever so you can see the pid of the cluster sever change in the logs
    setInterval (
      function ( ) {
        ipc . connectTo (
          'world' ,
          socketPath ,
          connecting
         ) ;
      } ,
      2000
    ) ;

    function connecting ( socket ) {
      ipc . of . world . on (
        'connect' ,
        function ( ) {
          ipc . of . world . emit (
            'currentDate' ,
            {
                 message : new Date ( ) . toISOString ( )
            }
          ) ;
          ipc . disconnect ( 'world' ) ;
        }
      ) ;
    }