Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
public async init() {
// launching a "mock socket server" so that we can mock a peer
this.serverProcess = fork(__dirname + "/index.js");
await delay(2000);
// client socket so we can send mocking instructions to our mock server
this.clientSocket = socketCluster.create({
port: 4009,
hostname: "127.0.0.1",
});
}
? peerConfig.connectTimeout
? peerConfig.connectTimeout
: DEFAULT_CONNECT_TIMEOUT
: DEFAULT_CONNECT_TIMEOUT,
ackTimeout: peerConfig
? peerConfig.connectTimeout
? peerConfig.connectTimeout
: DEFAULT_CONNECT_TIMEOUT
: DEFAULT_ACK_TIMEOUT,
multiplex: false,
autoConnect: false,
autoReconnect: false,
pingTimeoutDisabled: true,
};
const outboundSocket = socketClusterClient.create(clientOptions);
// Attaching handlers for various events that could be used future for logging or any other application
outboundSocket.emit(
REMOTE_EVENT_RPC_REQUEST,
{
type: '/RPCRequest',
procedure: requestPacket.procedure,
},
(err: Error | undefined, responseData: unknown) => {
if (err) {
reject(err);
return;
}
if (responseData) {
const responsePacket = responseData as P2PResponsePacket;
resolve({
private create(peer: P2P.IPeer): SCClientSocket {
const connection = create({
port: peer.port,
hostname: peer.ip,
perMessageDeflate: true,
});
const socket = (connection as any).transport.socket;
socket.on("ping", () => this.terminate(peer));
socket.on("pong", () => this.terminate(peer));
socket.on("message", data => {
if (data === "#1") {
// this is to establish some rate limit on #1 messages
// a simple rate limit of 1 per second doesnt seem to be enough, so decided to give some margin
// and allow up to 10 per second which should be more than enough
const timeNow: number = new Date().getTime();
socket._last10Pings = socket._last10Pings || [];
this.hosts = hosts.map(host => {
host.socket = socketCluster.create({
...host,
autoReconnectOptions: {
initialDelay: 1000,
maxDelay: 1000,
},
});
host.socket.on("error", err => {
if (err.message !== "Socket hung up") {
this.logger.error(err.message);
}
});
return host;
});
const clientOptions: ClientOptionsUpdated = {
hostname: this._ipAddress,
port: this._wsPort,
query: querystring.stringify({
...legacyNodeInfo,
options: JSON.stringify(legacyNodeInfo),
}),
connectTimeout,
ackTimeout,
multiplex: false,
autoConnect: false,
autoReconnect: false,
pingTimeoutDisabled: true,
};
const outboundSocket = socketClusterClient.create(clientOptions);
this._bindHandlersToOutboundSocket(outboundSocket);
return outboundSocket;
}
query: querystring.stringify({
...legacyNodeInfo,
options:
legacyNodeInfo && legacyNodeInfo.options
? JSON.stringify(legacyNodeInfo.options)
: undefined,
}),
connectTimeout,
ackTimeout,
multiplex: false,
autoConnect: false,
autoReconnect: false,
pingTimeoutDisabled: true,
};
const outboundSocket = socketClusterClient.create(clientOptions);
this._bindHandlersToOutboundSocket(outboundSocket);
return outboundSocket;
}
const clientOptions: ClientOptionsUpdated = {
hostname: this.ipAddress,
port: this.wsPort,
query: querystring.stringify({
...this._serverNodeInfo,
options: JSON.stringify(this._serverNodeInfo),
}),
connectTimeout,
ackTimeout,
multiplex: false,
autoConnect: false,
autoReconnect: false,
maxPayload: this._peerConfig.wsMaxPayload,
};
const outboundSocket = socketClusterClient.create(clientOptions);
this._bindHandlersToOutboundSocket(outboundSocket);
return outboundSocket;
}
function connectToServer(options) {
if (socket) return;
let socketOptions;
if (options.port) {
socketOptions = {
port: options.port,
hostname: getHostForRN(options.hostname || 'localhost'),
secure: !!options.secure
};
} else socketOptions = defaultSocketOptions;
socket = socketCluster.create(socketOptions);
watch();
}