Peerjs: 'RTCPeerConnection': Tidak dapat membuat begitu banyak PeerConnection

Sepertinya Anda membuat banyak koneksi baru. Bisakah Anda menunjukkan kode Anda?
Juga akan sangat membantu jika Anda menggunakan versi perpustakaan yang tidak diperkecil, Anda memilikinya di dist/peer.js

Juga sepertinya Anda menggunakan versi peerjs lama, versi npm terbaru adalah 0.3.16:
https://www.npmjs.com/package/peerjs

Tentu saja. Kode saya adalah ini:

             var P2PMaze = P2PMaze || {};

             // global variable 
             var map;

             var backgroudLayer; 

             var blockedLayer;

             var player; 

             var toOpponentPlayer = []; 
             var cursor; 

             var items; 

            var logicalOrder = {};

            var playerOrder = 1; // the player starts to 1 for compare the item to take 

           var createdOpponentPlayer = false;

           var opponentPlayer;

       var jump = false;
       var hitPlatformO;
      P2PMaze.send = function(data){     
    var id = P2PMaze.peer.getConnectTo().getId();
    var conn = P2PMaze.peer.conn(id);
    P2PMaze.peer.sendData(conn, data);    
     }; 

      P2PMaze.GameMultiplayer = function(){
    console.log("%cStarting GameMultiplayer", "color:black; background:yellow");
};

P2PMaze.GameMultiplayer.prototype = {
    preload: function() {
        this.game.load.tilemap('temp', 'assets/tilemaps/temp.json', null, Phaser.Tilemap.TILED_JSON);
        this.game.load.image('tempImage', 'assets/images/tiles.png');


        this.load.spritesheet('player', 'assets/images/dude.png',32,48);    

        this.load.image('redcup', 'assets/images/estintore_grande.png');
        this.load.image('greycup', 'assets/images/greencup.png');
        this.load.image('bluecup', 'assets/images/bluecup.png');
    }, 
    create: function() {
        ...

       var keyPlayer = {"key": P2PMaze.peer.getId()};
       var posx ={"posx":player.position.x};
       var posy = {"posy":player.position.y}
       var key = {"Key":player.key};       

        toOpponentPlayer.push(keyPlayer);
        toOpponentPlayer.push(posx);
        toOpponentPlayer.push(posy);
        toOpponentPlayer.push(key);
        P2PMaze.send(toOpponentPlayer);
       // move player with cursor key 
       cursor = this.game.input.keyboard.createCursorKeys();

    },
    update: function(){

        // creation opponent player
        if(P2PMaze.dataReceived!=undefined && createdOpponentPlayer==false){

            opponentPlayer = this.game.add.sprite(P2PMaze.dataReceived[1].posx, P2PMaze.dataReceived[2].posy, 'player');

            // create the phisics body. Can be a single object (as in this case) or of array of Objects
            this.game.physics.arcade.enable(opponentPlayer);

            //  Player physics properties. Give the little guy a slight bounce.
            opponentPlayer.body.bounce.y = 0.2;
            opponentPlayer.body.gravity.y = PLAYER.GRAVITY_Y;
            opponentPlayer.body.collideWorldBounds = true;

            // see image: 0, 1, 2, 3 is the frame for runring to left 
            // see image: 5, 6, 7, 8 is the frame for running to right 
            // 10 = frames per second 
            // the 'true' param tell the animation to loop 
            opponentPlayer.animations.add('left', [0, 1, 2, 3], 10, true);
            opponentPlayer.animations.add('right', [5, 6, 7, 8], 10, true);


            //the camera will follow the player in the world
            this.game.camera.follow(opponentPlayer); 

            // the opponent player start to 4 frame
            opponentPlayer.frame = 4;
            createdOpponentPlayer=true;

        }

     // collisio to do 
     // https://phaser.io/docs/2.4.4/Phaser.Physics.Arcade.html#collide
     var hitPlatform;

      hitPlatform = this.game.physics.arcade.collide(player, blockedLayer);
      if(opponentPlayer!=undefined){
        hitPlatformO = this.game.physics.arcade.collide(opponentPlayer, blockedLayer);
      }

     // player movement   
     // NB: comment these to gain less control over the sprite      
     // player.body.velocity.y = 0; 
     player.body.velocity.x = PLAYER.VELOCITY_X_START;


     if(opponentPlayer!=undefined){
        opponentPlayer.body.velocity.x = PLAYER.VELOCITY_X_START;
     }

     if(this.game.input.activePointer.justPressed()){
         // move on the direction of the input 
         this.game.physics.arcade.moveToPointer(player, 150); 
        //  player.animations.play('left');
     }

        var updatePos = [];
        if(cursor.left.isDown){
            player.body.velocity.x = PLAYER.VELOCITY_X_LEFT;         
            player.animations.play('left');

            // send to opponent player the left position of player


                var keyupdating = {"key": "left"};
                var updateX ={"updatePosx":player.x};
                var updateY ={"updatePosy":player.y}; 
                updatePos.push(keyupdating);
                updatePos.push(updateX);
                updatePos.push(updateY);

                 // SEND 
                P2PMaze.send(updatePos);



        }else if(cursor.right.isDown){
            player.body.velocity.x = PLAYER.VELOCITY_X_RIGHT;
            player.animations.play('right');



            var keyupdating = {"key": "right"};
            var updateX ={"updatePosx":player.x};
            var updateY ={"updatePosy":player.y}; 
            updatePos.push(keyupdating);
            updatePos.push(updateX);
            updatePos.push(updateY);
            P2PMaze.send(updatePos);


        }
        else{
            //  Stand still
            player.animations.stop();    
            player.frame = 4;
        }

        // if(cursor.up.isDown && player.body.touching.down){
        if(cursor.up.isDown && hitPlatform){
            player.body.velocity.y = -250;
            }


     // move the opponent player to specific LEFT position
     if(opponentPlayer!=undefined && P2PMaze.dataReceived[0].key=="left"){       

        var posx = P2PMaze.dataReceived[1].updatePosx;
        var posy = P2PMaze.dataReceived[2].updatePosy; 

        // when the opponent player came to specific position + or - 1 (for avoid loop), stop the animation and set the frame to 4
        if(Math.floor(opponentPlayer.x) === Math.floor(posx) || 
           Math.floor(opponentPlayer.x) === (Math.floor(posx) +1) ||
           Math.floor(opponentPlayer.x) === (Math.floor(posx) -1)) 
        {
            opponentPlayer.animations.stop();
            opponentPlayer.frame = 4;
        }else {
            this.game.physics.arcade.moveToXY(opponentPlayer,Math.floor(posx),Math.floor(posy)); 
            opponentPlayer.animations.play('left');
        }        

     }

     // move the opponent player to specific RIGHT position
     if(opponentPlayer!=undefined && P2PMaze.dataReceived[0].key=="right"){         

        var posx = P2PMaze.dataReceived[1].updatePosx;
        var posy = P2PMaze.dataReceived[2].updatePosy; 

        // when the opponent player came to specific position + or - 1 (for avoid loop), stop the animation and set the frame to 4
        if(Math.floor(opponentPlayer.x) === Math.floor(posx) || 
           Math.floor(opponentPlayer.x) === (Math.floor(posx) +1) ||
           Math.floor(opponentPlayer.x) === (Math.floor(posx) -1)) 
        {
            opponentPlayer.animations.stop();
            opponentPlayer.frame = 4;
        }else {
            this.game.physics.arcade.moveToXY(opponentPlayer,Math.floor(posx),Math.floor(posy)); 
            opponentPlayer.animations.play('right');
        }        

     }
     // Checks for overlaps between two game objects.
     // - The first object or array of objects to check. 
     // - The second object or array of objects to check.
     // - An optional callback function that is called if the objects overlap. 
     //      The two objects will be passed to this function in the same order in which you specified them, 
     //      unless you are checking Group vs. Sprite, in which case Sprite will always be the first parameter.
     // - A callback function that lets you perform additional checks against the two objects if 
     //     they overlap. If this is set then overlapCallback will only be called if 
     //     this callback returns true
     // - The context in which to run the callbacks.
     this.game.physics.arcade.overlap(player, items, this.collect, this.choiceItems, this);

     if(opponentPlayer!=undefined){
        this.game.physics.arcade.overlap(opponentPlayer, items, this.collect, this.choiceItems, this);
     }

    },
    ...

Saya mencoba membuat satu koneksi. Saya membuat variabel global var conn = undefined dan kemudian menetapkan koneksi dalam pembaruan:

if(P2PMaze.dataReceived!=undefined && createdOpponentPlayer==false){

            opponentPlayer = this.game.add.sprite(P2PMaze.dataReceived[1].posx, P2PMaze.dataReceived[2].posy, 'player');

            ....
            var id = P2PMaze.peer.getConnectTo().getId();
            conn = P2PMaze.peer.conn(id);
            createdOpponentPlayer=true;

        }

dan

...
...
var updatePos = [];
        if(cursor.left.isDown){
            player.body.velocity.x = PLAYER.VELOCITY_X_LEFT;         
            player.animations.play('left');

            // send to opponent player the left position of player

            if(conn!=undefined){
                    var keyupdating = {"key": "left"};
                var updateX ={"updatePosx":player.x};
                var updateY ={"updatePosy":player.y};
                updatePos.push(keyupdating);
                updatePos.push(updateX);
                updatePos.push(updateY);
                P2PMaze.send(updatePos);
             }




        }else if(cursor.right.isDown){
            player.body.velocity.x = PLAYER.VELOCITY_X_RIGHT;
            player.animations.play('right');

            // send to opponent player the right position of player
          if(conn!=undefined){
            var keyupdating = {"key": "right"};
            var updateX ={"updatePosx":player.x};
            var updateY ={"updatePosy":player.y}; 
            updatePos.push(keyupdating);
            updatePos.push(updateX);
            updatePos.push(updateY);
            P2PMaze.send(updatePos);
           }

        }
         ....

Tetapi dengan cara ini multipemain saya tidak berfungsi. Untuk ini saya pikir pendekatan yang benar adalah

         var id = P2PMaze.peer.getConnectTo().getId();
          var conn = P2PMaze.peer.conn(id);
         P2PMaze.peer.sendData(conn, data);

P2PMaze.peer adalah tugas yang saya lakukan dalam bentuk.
Saya menggunakan versi min yang saya miliki di dalam direktori lib saya.

Kalo ga salah nih :

P2PMaze.send = function(data){     
   var id = P2PMaze.peer.getConnectTo().getId();
   var conn = P2PMaze.peer.conn(id);
   P2PMaze.peer.sendData(conn, data);    
}; 

Anda membuka koneksi baru setiap kali Anda ingin mengirim pesan. Anda harus menyimpan koneksi yang Anda buat di suatu tempat, dan menggunakannya untuk semua pesan, misalnya, sesuatu seperti ini:

P2PMaze.connect = function(){     
    var id = P2PMaze.peer.getConnectTo().getId();
    P2PMaze.otherPlayer = P2PMaze.peer.conn(id);
}; 

P2PMaze.send = function(data){
    P2PMaze.otherPlayer.send(data);   
}

Gunakan metode send dari objek koneksi:
https://peerjs.com/docs/#dataconnection -send

Dan dengarkan acara data pada koneksi:
https://peerjs.com/docs/#dataconnection -on-data

Mungkin saya tidak mengerti kode Anda. Saya pikir conn adalah peerjs, dan sendData dikirim dari objek koneksi? jika tidak, silakan posting kode fungsi-fungsi itu juga.

conn dan sendData adalah dua metode kelas saya. :
`

      /**
     * Class that create a peer. The param are: 
     * <strong i="9">@param</strong> {string} id the id of my peer
     * <strong i="10">@param</strong> {string} host the path of server
     * <strong i="11">@param</strong> {int} port the number of port
     * <strong i="12">@param</strong> {path} pht the app name of the server. It is useful for establish the connection
     */

    class PeerClient {  

        constructor(id, h, p, pth){
            this._id = id;
            this._host = h;
            this._port = p;
            this._path = pth;
            this._peerToConnect = undefined;

            this._peer = new Peer(this._id, {
                host: this._host, // 'localhost',
                port: this._port, //  9000,
                path: this._path // '/peerjs'
            });

        }

        /**
         * Return the id of my peer
         */
        getId() {
            return this._id;
        }



        /**
         * Return the peer connected with me
         */
        getConnectTo() {
            return this._peerToConnect;
        }

        /**
         * This metohd is used for setting the peer with i want connect. It used when I receive the request of 
         * connection by a specific peer. 
         * <strong i="13">@param</strong> {peer} peerToConnect 
         */
        setConnectTo(peerToConnect){
            this._peerToConnect = new PeerClient(peerToConnect, this._host, this._port, this._path);
        }


        /**
         * This allow to create the player
         * <strong i="14">@param</strong> {*} x initial position x
         * <strong i="15">@param</strong> {*} y initial position y
         * <strong i="16">@param</strong> {*} identifierString the unique string by which we'll identify the image later in our code.
         */
        createPlayer(x,y, identifierString){
            return P2PMaze.game.add.sprite(x,y,identifierString)
        }

        /**
         * Make the peer avilable for the connection 
         */
        openConnection() {
            this._peer.on('open', function(id_peer) {
            console.log('My peer ID is: ' + id_peer); //DEBUG
            });
        }


        /**
         * Closes the data connection gracefully, cleaning up underlying DataChannels and PeerConnections.
         * REF:https://stackoverflow.com/questions/25797345/peerjs-manually-close-the-connection-between-peers 
         * <strong i="17">@param</strong> {object} conn i
         */
        closeConnection(conn) {
            conn.on('open', function(){            
                conn.close();
                alert("connection close"); 
            });
        }

        /**
         * See the error of peer .     * .
         */
        seeError(){
            this._peer.on('error', function(err){
                alert(err.message);
            });
        }


        /**
         * This method is used for create a connection
         * <strong i="18">@param</strong> {object} id_another_peer is the id of peer that I want to connect
         */
        conn(id_another_peer) {
            return this._peer.connect(id_another_peer);
        }




        /**
         * Sharing data among peer. The first param is the value that return from the previusly method (conn)
         * <strong i="19">@param</strong> {object} conn     this is the connection
         * <strong i="20">@param</strong> {object} data     this is the data to send
         */
        sendData(conn, data) {
            conn.on('open', function(){
                conn.send(data);
            });
        }

        /**
         * This method is used for receive data.
         * <strong i="21">@param</strong> {method} callback return the data that arrived from sender
         */
        enableReceptionData(callback) {
            this._peer.on('connection', function(conn) {
                conn.on('data', function(data){
                    console.log("--------------------------------");
                    console.log("MESSAGE RECEIVED : \n");
                    console.log(data);
                    console.log("--------------------------------");
                    callback(data);                
                });
            });
        }


    }`

Saya telah mencoba dengan solusi ini yang Anda sarankan kepada saya tetapi tidak berhasil.
Dengan kata lain: jika saya membuat banyak koneksi maka itu berfungsi. Jika saya membuat satu koneksi, pertama kali berhasil (karena saya dapat melihat pembuatannya dari rekan lain) tetapi dia berhenti untuk mengirim data. Saya tidak tahu mengapa.
Saya menggunakan peerjs versi terbaru (saya pikir) terbaru. 0.3.9 yang ditunjukkan oleh situs.

sendData(conn, data) {
       conn.on('open', function(){
            conn.send(data);
        });
}

Di sini Anda membuat pendengar baru, dan ketika acara 'terbuka' datang, Anda mengirim data. Anda hanya harus mengirim data:

sendData(conn, data) {
       conn.send(data);
}

Acara Open adalah untuk memeriksa apakah koneksi telah dibuat. Anda dapat memeriksanya, atau Anda dapat mengirim data dan membiarkannya gagal jika koneksi tidak tetap terbuka.

Acara 'terbuka' dikirim sekali setelah Anda membuka koneksi, itu sebabnya ini hanya berfungsi untuk Anda dengan banyak koneksi. Karena kedua kalinya Anda ingin mengirim data, Anda akan menunggu tanpa batas waktu untuk acara 'terbuka', yang seperti yang saya katakan, itu hanya dipancarkan satu kali ketika koneksi dibuat.

Jadi terapkan perubahan yang saya usulkan, dan buat koneksi hanya sekali.

oooh bagus sekali. Terima kasih. Aku belum mengerti. Ketika saya mencoba kode saya, saya memposting hasilnya. terima kasih terima kasih.

Ok berfungsi, tetapi sekarang saya tidak menerima data:
`
/**
* Metode ini digunakan untuk menerima data.
* @param {method} callback mengembalikan data yang datang dari pengirim
*/

enableReceptionData(callback) {

    this._peer.on('connection', function(conn) {

        conn.on('data', function(data){

            console.log("--------------------------------");
            console.log("message received : \n");
            console.log(data);
            console.log("--------------------------------");

            callback(data);                
        });
    });
}`

Saya melihat dari konsol bahwa koneksi dan berbagi data baik-baik saja, tetapi metode ini tidak berhasil. Bisakah Anda menjelaskan kepada saya mengapa?

Apakah this._peer objek koneksi?

Sesuatu seperti ini?
this._peer = peer.connect('id')

Saya juga tidak melihat di mana Anda memanggil enableReceptionData, perlu diingat bahwa jika Anda menguji di komputer lokal Anda, koneksi mungkin sangat cepat sehingga acara 'koneksi' diluncurkan segera setelah Anda memanggil peer.connect(id) . Jadi, Anda harus melakukan sesuatu seperti:

this._peer = peer.connect('id');
enableReceptionData(callback);

Jika Anda melakukan hal lain antara pembuatan koneksi dan pendengar (enableReceptionData), Anda mungkin melewatkan acara 'koneksi'.

Jika saya membatalkan unstrand conn.on('open', function(){ .. } dapat dihilangkan. Tetapi jika saya mencetak di konsol:
`

    enableReceptionData(callback) {

    console.log(conn); // IMPORTANT

    this._peer.on('connection', function(conn) {

    conn.on('data', function(data){

        console.log("--------------------------------");
        console.log("message received : \n");
        console.log(data);
        console.log("--------------------------------");

        callback(data);                
    });
});

}

`

Saya mengambil pesan ini:
d {_events: {…}, options: {…}, open: false, ketik: "data", peer: "zzz-6UsEonI", …}
Anda dapat melihat bahwa terbuka adalah palsu.
PeerClass baru saya adalah ini:
` /**
* Kelas yang membuat rekan. Paramnya adalah:
* @param {string} id id rekan saya
* @param {string} meng-host jalur server
* @param {int} port nomor port
* @param {path} dengan nama aplikasi server. Berguna untuk membuat koneksi
*/
kelas PeerClient {

        constructor(id, h, p, pth){
            this._id = id;
            this._host = h;
            this._port = p;
            this._path = pth;
            this._peerToConnect = undefined;
            this._conn = undefined;

            this._peer = new Peer(this._id, {
                host: this._host, // 'localhost',
                port: this._port, //  9000,
                path: this._path // '/peerjs'
            });

        }

        /**
         * Return the id of my peer
         */
        getId() {
            return this._id;
        }



        /**
         * Return the peer connected with me
         */
        getConnectTo() {
            return this._peerToConnect;
        }

        /**
         * This metohd is used for setting the peer with i want connect. It used when I receive the request of 
         * connection by a specific peer. 
         * <strong i="28">@param</strong> {peer} peerToConnect 
         */
        setConnectTo(peerToConnect){
            this._peerToConnect = new PeerClient(peerToConnect, this._host, this._port, this._path);
        }


        /**
         * This allow to create the player
         * <strong i="29">@param</strong> {*} x initial position x
         * <strong i="30">@param</strong> {*} y initial position y
         * <strong i="31">@param</strong> {*} identifierString the unique string by which we'll identify the image later in our code.
         */
        createPlayer(x,y, identifierString){
            return P2PMaze.game.add.sprite(x,y,identifierString)
        }

        /**
         * Make the peer avilable for the connection 
         */
        open() {
            this._peer.on('open', function(id_peer) {
            console.log('My peer ID is: ' + id_peer); //DEBUG
            });
        }

        openConnection(){
            this._conn.on('open', function(data){
                console.log(data);
            });
        }

        /**
         * Closes the data connection gracefully, cleaning up underlying DataChannels and PeerConnections.
         * REF:https://stackoverflow.com/questions/25797345/peerjs-manually-close-the-connection-between-peers 
         * <strong i="32">@param</strong> {object} conn i
         */
        closeConnection(conn) {
            conn.on('open', function(){            
                conn.close();
                alert("CONNESSIONE CHIUSA"); // TODO mettere un qualche messaggio
            });
        }

        /**
         * See the error of peer .     * .
         */
        seeError(){
            this._peer.on('error', function(err){
                alert(err.message);
            });
        }


        /**
         * This method is used for create a connection
         * <strong i="33">@param</strong> {object} id_another_peer is the id of peer that I want to connect
         */
        conn(id_another_peer) {
            this._conn =  this._peer.connect(id_another_peer);
            return this._conn;
        }

        /**
         * return the connection
         */
        getConnection(){
            return this._conn;
        }



        /**
         * Sharing data among peer. The first param is the value that return from the previusly method (conn)
         * <strong i="34">@param</strong> {object} conn     this is the connection
         * <strong i="35">@param</strong> {object} data     this is the data to send
         */
        // sendData(data) {
        //     this._conn.on('open', function(){
        //         this._conn.send(data);
        //       });
        // }
        sendData(data) {
            this._conn.send(data);
        }


        /**
         * This method is used for receive data.
         * <strong i="36">@param</strong> {method} callback return the data that arrived from sender
         */
        enableReceptionData(callback) {
            this._peer.on('connection', function(conn) {
                console.log(conn);
                conn.on('data', function(data){
                    console.log("--------------------------------");
                    console.log("MESSAGE UPDATED : \n");
                    console.log(data);
                    console.log("--------------------------------");
                    callback(data);                
                });
            });
        }


    }`

Saat Anda membuka koneksi di:

 conn(id_another_peer) {
            this._conn =  this._peer.connect(id_another_peer);
            return this._conn;
        }

Anda harus segera mulai mendengarkan acara, jadi:

 conn(id_another_peer) {
            this._conn =  this._peer.connect(id_another_peer);
            this.enableReceptionData();
            return this._conn;
 }

Maaf juga saya ketinggalan penjelasan sebelumnya, acara 'terbuka' dipancarkan ketika Anda terhubung ke PeerServer, jadi Anda harus mendengarkan acara itu sebelum mencoba terhubung ke rekan-rekan lain, dan itu akan dibuang setelah Anda melakukan Peer baru ( Indo):

var peer = new Peer();
peer.on('open', function(id) {
  console.log('My peer ID is: ' + id);
  // here you have your ID and you can start opening connections to other peers
});

jadi dengarkan acara 'buka' di konstruktor Anda setelah new Peer() dan ketika Anda mendapatkan acara 'terbuka', Anda dapat terhubung ke rekan lain.

Perhatikan bahwa untuk acara 'terbuka' seperti yang saya jelaskan sebelumnya, Anda harus mendengarkannya segera setelah new Peer() atau Anda mungkin melewatkan acara tersebut jika Anda menunggu terlalu lama untuk mendengarkannya.

ok terima kasih atas kesabarannya, segera setelah saya menerapkan kode saya akan memposting hasilnya :+1:

Tidak, ini terus tidak berhasil.

Saya menyelesaikannya dengan solusi lama.
`

            sendData(data) {

            this._conn.on('open', function(){

                this.send(data);

              });
        }`

ini bisa dianggap kompromi yang baik? Dengan cara ini, saya tidak dapat membuat pendengar baru tetapi saya menggunakan koneksi yang sama. Satu solusi yang lebih disempurnakan adalah: gunakan fungsi ini hanya satu kali dan kemudian kirim data dengan
`

    sendData(data) {

    this._conn.send(data);

        }`

Tapi saya ingin diuji sebelumnya. Apakah menurut Anda solusi yang baik?

Saya khawatir kita harus melanjutkannya besok. Apakah Anda ingin mengunggah kode Anda ke https://Gist.github.com/ ?
Jadi saya bisa melihatnya dengan lebih baik, Anda bisa menjadikannya pribadi dan mengirimi saya tautannya melalui email jika Anda tidak ingin orang lain melihatnya.

Email saya: [email protected]

terima kasih banyak atas kesempatannya. Saat ini kode saya adalah situs konstruksi terbuka. Segera setelah saya mengaturnya, saya akan menyediakannya. Sementara itu, jika Anda punya waktu, dapatkah Anda memberi tahu saya jika solusi terakhir yang saya tunjukkan dapat menjadi pendekatan yang baik untuk masalah tersebut?
Terima kasih lagi dan sampai jumpa lagi :)

Solusi kedua akan sangat direkomendasikan. Yang pertama akan memberi Anda banyak masalah karena Anda membuat banyak koneksi, satu per pesan, dan itu tidak hanya akan membawa Anda ke kesalahan pertama yang Anda dapatkan dari PeerJS, tetapi juga akan mengalahkan sumber daya Anda (cpu, ram , jaringan)

Saya mengonfirmasi bahwa dengan solusi kedua saya menghindari kesalahan. Untuk ini, sekarang saya hanya memiliki dua koneksi:

• yang pertama: dari A ke B
• yang kedua: dari B ke A
  Pertukaran data lainnya dilakukan dengan koneksi yang sama. Terima kasih @kidandcat atas dukungannya. :+1: