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-19 15:34:52 +01:00
parent a8aeeaaa6c
commit da78da27e5
10 changed files with 14 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/common/test.ts
View File

@ -1 +0,0 @@
console.log('TODO');

15
test/test.expressserver.ts
View File

@ -8,7 +8,6 @@ import smartsocket = require('../ts/index');
let testSmartsocket: smartsocket.Smartsocket;
let testSmartsocketClient: smartsocket.SmartsocketClient;
let testSocketRole1: smartsocket.SocketRole;
let testSocketFunction1: smartsocket.SocketFunction<any>;
let myseServer: smartexpress.Server;
@ -18,7 +17,7 @@ const testConfig = {
// class smartsocket
tap.test('should create a new smartsocket', async () => {
testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver', port: testConfig.port });
expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
});
@ -34,19 +33,10 @@ tap.test('Should accept an smartExpressServer as server', async () => {
await myseServer.start();
});
// class socketrole
tap.test('should add a socketrole', async () => {
testSocketRole1 = new smartsocket.SocketRole({
name: 'testRole1',
passwordHash: await isohash.sha256FromString('testPassword'),
});
testSmartsocket.addSocketRoles([testSocketRole1]);
});
// class SocketFunction
tap.test('should register a new Function', async () => {
testSocketFunction1 = new smartsocket.SocketFunction({
allowedRoles: [testSocketRole1],
funcDef: async (dataArg, socketConnectionArg) => {
return dataArg;
},
@ -65,12 +55,9 @@ tap.test('should react to a new websocket connection from client', async () => {
testSmartsocketClient = new smartsocket.SmartsocketClient({
port: testConfig.port,
url: 'http://localhost',
password: 'testPassword',
alias: 'testClient1',
role: 'testRole1',
});
testSmartsocketClient.addSocketFunction(testSocketFunction1);
console.log(testSmartsocketClient.socketFunctions);
await testSmartsocketClient.connect();
});

16
test/test.tagging.ts
View File

@ -7,7 +7,6 @@ import * as isohash from '@pushrocks/isohash';
let testSmartsocket: smartsocket.Smartsocket;
let testSmartsocketClient: smartsocket.SmartsocketClient;
let testSocketConnection: smartsocket.SocketConnection;
let testSocketRole1: smartsocket.SocketRole;
let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
let testSocketFunctionClient: smartsocket.SocketFunction<any>;
@ -37,23 +36,13 @@ const testConfig = {
// class smartsocket
tap.test('should create a new smartsocket', async () => {
testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
});
// class socketrole
tap.test('should add a socketrole', async () => {
testSocketRole1 = new smartsocket.SocketRole({
name: 'testRole1',
passwordHash: await isohash.sha256FromString('testPassword'),
});
testSmartsocket.addSocketRoles([testSocketRole1]);
});
// class SocketFunction
tap.test('should register a new Function', async () => {
testSocketFunctionForServer = new smartsocket.SocketFunction({
allowedRoles: [testSocketRole1],
funcDef: async (dataArg, socketConnectionArg) => {
return dataArg;
},
@ -62,7 +51,6 @@ tap.test('should register a new Function', async () => {
testSmartsocket.addSocketFunction(testSocketFunctionForServer);
testSocketFunctionClient = new smartsocket.SocketFunction({
allowedRoles: [],
funcDef: async (dataArg, socketConnectionArg) => {
return dataArg;
},
@ -81,9 +69,7 @@ tap.test('should react to a new websocket connection from client', async () => {
testSmartsocketClient = new smartsocket.SmartsocketClient({
port: testConfig.port,
url: 'http://localhost',
password: 'testPassword',
alias: 'testClient1',
role: 'testRole1',
});
testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
console.log(testSmartsocketClient.socketFunctions);

1
ts/index.ts
View File

@ -4,5 +4,4 @@ export * from './smartsocket.classes.smartsocketclient';
// export further classes and objects
export * from './smartsocket.classes.socketfunction';
export * from './smartsocket.classes.socketrole';
export * from './smartsocket.classes.socketconnection';

2
ts/interfaces/connection.ts
View File

@ -1,5 +1,5 @@
export interface IRequestAuthPayload {
serverShortId: string;
serverAlias: string;
}
export type TConnectionStatus =

17
ts/smartsocket.classes.smartsocket.ts
View File

@ -9,12 +9,12 @@ import {
ISocketFunctionCallDataResponse,
} from './smartsocket.classes.socketfunction';
import { SocketRequest } from './smartsocket.classes.socketrequest';
import { SocketRole } from './smartsocket.classes.socketrole';
import { SocketServer } from './smartsocket.classes.socketserver';
import { logger } from './smartsocket.logging';
export interface ISmartsocketConstructorOptions {
alias: string;
port?: number;
}
@ -22,12 +22,11 @@ export class Smartsocket {
/**
* a unique id to detect server restarts
*/
public shortId = plugins.isounique.uni();
public alias: string;
public smartenv = new plugins.smartenv.Smartenv();
public options: ISmartsocketConstructorOptions;
public io: pluginsTyped.socketIo.Server;
public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
@ -35,6 +34,7 @@ export class Smartsocket {
constructor(optionsArg: ISmartsocketConstructorOptions) {
this.options = optionsArg;
this.alias = plugins.isounique.uni(this.options.alias);
}
// tslint:disable-next-line:member-ordering
@ -96,16 +96,6 @@ export class Smartsocket {
return result;
}
/**
* adds socketRoles
*/
public addSocketRoles(socketRolesArray: SocketRole[]): void {
for (const socketRole of socketRolesArray) {
this.socketRoles.add(socketRole);
}
return;
}
public addSocketFunction(socketFunction: SocketFunction<any>) {
this.socketFunctions.add(socketFunction);
}
@ -117,7 +107,6 @@ export class Smartsocket {
const socketConnection: SocketConnection = new SocketConnection({
alias: undefined,
authenticated: false,
role: undefined,
side: 'server',
smartsocketHost: this,
socket: socketArg,

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

@ -8,7 +8,6 @@ import {
SocketFunction,
} from './smartsocket.classes.socketfunction';
import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
import { SocketRole } from './smartsocket.classes.socketrole';
import { logger } from './smartsocket.logging';
/**
@ -18,8 +17,6 @@ export interface ISmartsocketClientOptions {
port: number;
url: string;
alias: string; // an alias makes it easier to identify this client in a multo client environment
role: string;
password: string; // by setting a password access to functions can be limited
autoReconnect?: boolean;
}
@ -31,7 +28,6 @@ export class SmartsocketClient {
public remoteShortId: string = null;
public alias: string;
public socketRole: SocketRole;
public socketConnection: SocketConnection;
public serverUrl: string;
public serverPort: number;
@ -43,7 +39,6 @@ export class SmartsocketClient {
public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
// tagStore
private tagStore: { [key: string]: interfaces.ITag } = {};
@ -83,16 +78,11 @@ export class SmartsocketClient {
this.alias = optionsArg.alias;
this.serverUrl = optionsArg.url;
this.serverPort = optionsArg.port;
this.socketRole = new SocketRole({
name: optionsArg.role,
passwordHash: optionsArg.password,
});
this.autoReconnect = optionsArg.autoReconnect;
}
public addSocketFunction(socketFunction: SocketFunction<any>) {
this.socketFunctions.add(socketFunction);
this.socketRole.allowedFunctions.add(socketFunction);
}
/**
@ -113,7 +103,6 @@ export class SmartsocketClient {
this.socketConnection = new SocketConnection({
alias: this.alias,
authenticated: false,
role: this.socketRole,
side: 'client',
smartsocketHost: this,
socket: await socketIoClient.connect(socketUrl, {
@ -139,7 +128,7 @@ export class SmartsocketClient {
// lets register the authenticated event
this.socketConnection.socket.on('authenticated', async () => {
this.remoteShortId = requestAuthPayload.serverShortId;
this.remoteShortId = requestAuthPayload.serverAlias;
logger.log('info', 'client is authenticated');
this.socketConnection.authenticated = true;
await this.socketConnection.listenToFunctionRequests();
@ -172,8 +161,6 @@ export class SmartsocketClient {
// lets provide the actual auth data
this.socketConnection.socket.emit('dataAuth', {
role: this.socketRole.name,
password: this.socketRole.passwordHash,
alias: this.alias,
});
}

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

@ -5,7 +5,6 @@ import * as interfaces from './interfaces';
import { Smartsocket } from './smartsocket.classes.smartsocket';
import { SocketFunction } from './smartsocket.classes.socketfunction';
import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
import { SocketRole } from './smartsocket.classes.socketrole';
// socket.io
import * as pluginsTyped from './smartsocket.pluginstyped';
@ -25,7 +24,6 @@ export type TSocketConnectionSide = 'server' | 'client';
export interface ISocketConnectionConstructorOptions {
alias: string;
authenticated: boolean;
role: SocketRole;
side: TSocketConnectionSide;
smartsocketHost: Smartsocket | SmartsocketClient;
socket: SocketIO.Socket | SocketIOClient.Socket;
@ -35,9 +33,7 @@ export interface ISocketConnectionConstructorOptions {
* interface for authentication data
*/
export interface ISocketConnectionAuthenticationObject {
role: 'coreflowContainer';
password: 'somePassword';
alias: 'coreflow1';
alias: string;
}
// export classes
@ -50,7 +46,6 @@ export class SocketConnection {
public alias: string;
public side: TSocketConnectionSide;
public authenticated: boolean = false;
public role: SocketRole;
public smartsocketRef: Smartsocket | SmartsocketClient;
public socket: SocketIO.Socket | SocketIOClient.Socket;
@ -64,7 +59,6 @@ export class SocketConnection {
constructor(optionsArg: ISocketConnectionConstructorOptions) {
this.alias = optionsArg.alias;
this.authenticated = optionsArg.authenticated;
this.role = optionsArg.role;
this.side = optionsArg.side;
this.smartsocketRef = optionsArg.smartsocketHost;
this.socket = optionsArg.socket;
@ -134,24 +128,23 @@ export class SocketConnection {
public authenticate() {
const done = plugins.smartpromise.defer();
this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
logger.log('info', 'received authentication data. now hashing and comparing...');
logger.log('info', 'received authentication data...');
this.socket.removeAllListeners('dataAuth');
if (await SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) {
if (dataArg.alias) {
// TODO: authenticate password
this.alias = dataArg.alias;
this.authenticated = true;
this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role);
this.socket.emit('authenticated');
logger.log('ok', `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
done.resolve(this);
} else {
this.authenticated = false;
await this.disconnect();
done.reject('not authenticated');
done.reject('a socket tried to connect, but could not authenticated.');
}
});
const requestAuthPayload: interfaces.IRequestAuthPayload = {
serverShortId: this.smartsocketRef.shortId,
serverAlias: this.smartsocketRef.alias,
};
this.socket.emit('requestAuth', requestAuthPayload);
return done.promise;
@ -168,7 +161,7 @@ export class SocketConnection {
this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
// check if requested function is available to the socket's scope
// logger.log('info', 'function request received');
const referencedFunction: SocketFunction<any> = this.role.allowedFunctions.findSync(
const referencedFunction: SocketFunction<any> = this.smartsocketRef.socketFunctions.findSync(
(socketFunctionArg) => {
return socketFunctionArg.name === dataArg.funcCallData.funcName;
}

14
ts/smartsocket.classes.socketfunction.ts
View File

@ -1,7 +1,6 @@
import * as plugins from './smartsocket.plugins';
// import classes
import { SocketRole } from './smartsocket.classes.socketrole';
import { SocketConnection } from './smartsocket.classes.socketconnection';
import { Smartsocket } from './smartsocket.classes.smartsocket';
import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
@ -16,7 +15,6 @@ export interface ISocketFunctionConstructorOptions<
> {
funcName: T['method'];
funcDef: TFuncDef<T>;
allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
}
/**
@ -66,7 +64,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
// INSTANCE
public name: string;
public funcDef: TFuncDef<T>;
public roles: SocketRole[];
/**
* the constructor for SocketFunction
@ -74,10 +71,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
this.name = optionsArg.funcName;
this.funcDef = optionsArg.funcDef;
this.roles = optionsArg.allowedRoles;
for (const socketRoleArg of this.roles) {
this._notifyRole(socketRoleArg);
}
}
/**
@ -97,11 +90,4 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
throw new Error("SocketFunction.name does not match the data argument's .name!");
}
}
/**
* notifies a role about access to this SocketFunction
*/
private _notifyRole(socketRoleArg: SocketRole) {
socketRoleArg.addSocketFunction(this);
}
}

59
ts/smartsocket.classes.socketrole.ts
View File

@ -1,59 +0,0 @@
import * as plugins from './smartsocket.plugins';
// import classes
import { SocketFunction } from './smartsocket.classes.socketfunction';
import { Smartsocket } from './smartsocket.classes.smartsocket';
import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection';
/**
* interface for class SocketRole
*/
export interface ISocketRoleOptions {
name: string;
passwordHash: string;
}
/**
* A socketrole defines access to certain routines.
*/
export class SocketRole {
// STATIC
public static getSocketRoleByName(
referenceSmartsocket: Smartsocket | SmartsocketClient,
socketRoleNameArg: string
): SocketRole {
return referenceSmartsocket.socketRoles.findSync((socketRoleArg) => {
return socketRoleArg.name === socketRoleNameArg;
});
}
public static async checkPasswordForRole(
dataArg: ISocketConnectionAuthenticationObject,
referenceSmartsocket: Smartsocket | SmartsocketClient
): Promise<boolean> {
const targetPasswordHash = SocketRole.getSocketRoleByName(
referenceSmartsocket,
dataArg.role
).passwordHash;
const computedCompareHash = await plugins.isohash.sha256FromString(dataArg.password);
return targetPasswordHash === computedCompareHash;
}
// INSTANCE
public name: string;
public passwordHash: string;
public allowedFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
constructor(optionsArg: ISocketRoleOptions) {
this.name = optionsArg.name;
this.passwordHash = optionsArg.passwordHash;
}
/**
* adds the socketfunction to the socketrole
* @param socketFunctionArg
*/
public addSocketFunction(socketFunctionArg: SocketFunction<any>) {
this.allowedFunctions.add(socketFunctionArg);
}
}