fix(core): update

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -1,7 +1,6 @@
import * as plugins from './smartsocket.plugins'; import * as plugins from './smartsocket.plugins';
// import classes // import classes
import { SocketRole } from './smartsocket.classes.socketrole';
import { SocketConnection } from './smartsocket.classes.socketconnection'; import { SocketConnection } from './smartsocket.classes.socketconnection';
import { Smartsocket } from './smartsocket.classes.smartsocket'; import { Smartsocket } from './smartsocket.classes.smartsocket';
import { SmartsocketClient } from './smartsocket.classes.smartsocketclient'; import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
@ -16,7 +15,6 @@ export interface ISocketFunctionConstructorOptions<
> { > {
funcName: T['method']; funcName: T['method'];
funcDef: TFuncDef<T>; 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 // INSTANCE
public name: string; public name: string;
public funcDef: TFuncDef<T>; public funcDef: TFuncDef<T>;
public roles: SocketRole[];
/** /**
* the constructor for SocketFunction * the constructor for SocketFunction
@ -74,10 +71,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
constructor(optionsArg: ISocketFunctionConstructorOptions<T>) { constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
this.name = optionsArg.funcName; this.name = optionsArg.funcName;
this.funcDef = optionsArg.funcDef; 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!"); 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);
}
} }

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);
}
}