push.rocks/smartsocket
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(core): update

Browse Source
This commit is contained in:
Philipp Kunz 2022-01-20 16:50:25 +01:00
parent 608669ec44
commit 7c98e19988
5 changed files with 73 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
test/test.reconnect.ts
View File

@ -117,15 +117,16 @@ tap.test('should be able to make a functionCall from server to client', async ()
expect(response.hi).to.equal('hi there from server');
});
tap.test('client should disconnect and reconnect', async (tools) => {
tap.test('client should disconnect and reconnect', async (toolsArg) => {
await testSmartsocketClient.disconnect();
await testSmartsocketClient.connect();
await toolsArg.delayFor(2000);
expect(testSmartsocket.socketConnections.getArray().length).to.equal(1);
});
// class smartsocket
tap.test('should be able to switch to a new server', async (toolsArg) => {
await testSmartsocket.stop();
await toolsArg.delayFor(5000);
testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
await testSmartsocket.start();
await toolsArg.delayFor(30000);

2
ts/smartsocket.classes.smartsocket.ts
View File

@ -47,7 +47,7 @@ export class Smartsocket {
*/
public async start() {
const socketIoModule = this.smartenv.getSafeNodeModule('socket.io');
this.io = socketIoModule(this.socketServer.getServerForSocketIo());
this.io = socketIoModule(await this.socketServer.getServerForSocketIo());
await this.socketServer.start();
this.io.on('connection', (socketArg) => {
this._handleSocketConnection(socketArg);

116
ts/smartsocket.classes.smartsocketclient.ts
View File

@ -105,82 +105,81 @@ export class SmartsocketClient {
authenticated: false,
side: 'client',
smartsocketHost: this,
socket: await socketIoClient.connect(socketUrl, {
multiplex: false,
reconnectionAttempts: 5,
rejectUnauthorized: socketUrl.startsWith('https://localhost') ? false : true,
}),
socket: await socketIoClient
.connect(socketUrl, {
multiplex: false,
autoConnect: false,
reconnectionAttempts: 0,
rejectUnauthorized: socketUrl.startsWith('https://localhost') ? false : true,
})
.open(),
});
const timer = new plugins.smarttime.Timer(5000);
timer.start();
timer.completed.then(() => {
logger.log('warn', 'connection to server timed out.');
this.disconnect();
this.disconnect(true);
});
// authentication flow
this.socketConnection.socket.on(
'requestAuth',
(dataArg: interfaces.IRequestAuthPayload) => {
timer.reset();
logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
this.socketConnection.socket.on('requestAuth', (dataArg: interfaces.IRequestAuthPayload) => {
timer.reset();
logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
// lets register the authenticated event
this.socketConnection.socket.on('authenticated', async () => {
this.remoteShortId = dataArg.serverAlias;
logger.log('info', 'client is authenticated');
this.socketConnection.authenticated = true;
await this.socketConnection.listenToFunctionRequests();
});
// lets register the authenticated event
this.socketConnection.socket.on('authenticated', async () => {
this.remoteShortId = dataArg.serverAlias;
logger.log('info', 'client is authenticated');
this.socketConnection.authenticated = true;
await this.socketConnection.listenToFunctionRequests();
});
this.socketConnection.socket.on('serverFullyReactive', async () => {
// lets take care of retagging
const oldTagStore = this.tagStore;
this.tagStoreSubscription?.unsubscribe();
for (const keyArg of Object.keys(this.tagStore)) {
this.socketConnection.addTag(this.tagStore[keyArg]);
this.socketConnection.socket.on('serverFullyReactive', async () => {
// lets take care of retagging
const oldTagStore = this.tagStore;
this.tagStoreSubscription?.unsubscribe();
for (const keyArg of Object.keys(this.tagStore)) {
this.socketConnection.addTag(this.tagStore[keyArg]);
}
this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
(tagStoreArg) => {
this.tagStore = tagStoreArg;
}
this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
(tagStoreArg) => {
this.tagStore = tagStoreArg;
}
);
);
for (const tag of Object.keys(oldTagStore)) {
await this.addTag(oldTagStore[tag]);
}
done.resolve();
});
for (const tag of Object.keys(oldTagStore)) {
await this.addTag(oldTagStore[tag]);
}
this.updateStatus('connected');
done.resolve();
});
// lets register the forbidden event
this.socketConnection.socket.on('forbidden', async () => {
logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
await this.disconnect();
});
// lets register the forbidden event
this.socketConnection.socket.on('forbidden', async () => {
logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
await this.disconnect();
});
// lets provide the actual auth data
this.socketConnection.socket.emit('dataAuth', {
alias: this.alias,
});
}
);
// lets provide the actual auth data
this.socketConnection.socket.emit('dataAuth', {
alias: this.alias,
});
});
// handle connection
this.socketConnection.socket.on('connect', async () => {
this.updateStatus('connected');
});
this.socketConnection.socket.on('connect', async () => {});
// handle disconnection and errors
this.socketConnection.socket.on('disconnect', async () => {
await this.disconnect();
await this.disconnect(true);
});
this.socketConnection.socket.on('reconnect_failed', async () => {
await this.disconnect();
await this.disconnect(true);
});
this.socketConnection.socket.on('connect_error', async () => {
await this.disconnect();
await this.disconnect(true);
});
return done.promise;
}
@ -188,19 +187,25 @@ export class SmartsocketClient {
/**
* disconnect from the server
*/
public async disconnect() {
public async disconnect(useAutoconnectSetting = false) {
if (this.eventStatus === 'disconnecting') {
return;
}
this.updateStatus('disconnecting');
this.tagStoreSubscription?.unsubscribe();
if (this.socketConnection) {
await this.socketConnection.disconnect();
this.socketConnection = undefined;
logger.log('ok', 'disconnected!');
logger.log('ok', 'disconnected socket!');
}
logger.log('warn', `disconnected from server ${this.remoteShortId}`);
this.remoteShortId = null;
this.updateStatus('disconnected');
if (this.autoReconnect) {
if (this.autoReconnect && useAutoconnectSetting && this.eventStatus !== 'connecting') {
this.updateStatus('connecting');
this.tryDebouncedReconnect();
} else if (this.eventStatus === 'connected') {
this.updateStatus('disconnected');
}
}
@ -216,6 +221,7 @@ export class SmartsocketClient {
* try a reconnection
*/
public async tryDebouncedReconnect() {
console.log('debounced reconnect!');
await plugins.smartdelay.delayForRandom(10000, 20000);
await this.connect();
}

2
ts/smartsocket.classes.socketconnection.ts
View File

@ -197,7 +197,7 @@ export class SocketConnection {
this.remoteTagStoreObservable.next(tagStoreArg);
});
logger.log('info', `now listening to function requests for ${this.alias}`);
logger.log('info', `now listening to function requests for ${this.alias} on side ${this.side}`);
done.resolve(this);
} else {
const errMessage = 'socket needs to be authenticated first';

8
ts/smartsocket.classes.socketserver.ts
View File

@ -11,6 +11,7 @@ import { logger } from './smartsocket.logging';
*/
export class SocketServer {
private smartsocket: Smartsocket;
private httpServerDeferred: plugins.smartpromise.Deferred<any>;
private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
/**
@ -30,14 +31,19 @@ export class SocketServer {
serverType: 'smartexpress',
serverArg: pluginsTyped.smartexpress.Server
) {
this.httpServerDeferred = plugins.smartpromise.defer();
await serverArg.startedPromise;
this.httpServer = serverArg.httpServer;
this.httpServerDeferred.resolve();
}
/**
* gets the server for socket.io
*/
public getServerForSocketIo() {
public async getServerForSocketIo() {
if (this.httpServerDeferred) {
await this.httpServerDeferred.promise;
}
if (this.httpServer) {
return this.httpServer;
} else {