push.rocks/smartuniverse
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
2020-09-24 18:17:52 +00:00
parent 5d8c2064e0
commit 820ce76fe3
19 changed files with 140 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ts/smartuniverse.classes.broadcastevent.ts
View File

@ -7,14 +7,9 @@ import * as plugins from './smartuniverse.plugins';
export class BroadcastEvent<T extends plugins.typedrequestInterfaces.ITypedEvent<any>> {
public eventSubject = new plugins.smartrx.rxjs.Subject<T['payload']>();
constructor() {
};
public fire(eventPayloadArg: T['payload']) {
};
constructor() {}
public fire(eventPayloadArg: T['payload']) {}
public subscribe(funcArg: (nextArg: T['payload']) => void): plugins.smartrx.rxjs.Subscription {
return this.eventSubject.subscribe(funcArg);

22
ts/smartuniverse.classes.clientuniverse.ts
View File

@ -57,7 +57,7 @@ export class ClientUniverse {
* @param passphraseArg
*/
public getChannel(channelName: string): ClientUniverseChannel {
const clientUniverseChannel = this.clientUniverseCache.channelMap.find(channel => {
const clientUniverseChannel = this.clientUniverseCache.channelMap.find((channel) => {
return channel.name === channelName;
});
return clientUniverseChannel;
@ -69,7 +69,7 @@ export class ClientUniverse {
*/
public removeChannel(channelNameArg, notifyServer = true) {
const clientUniverseChannel = this.clientUniverseCache.channelMap.findOneAndRemove(
channelItemArg => {
(channelItemArg) => {
return channelItemArg.name === channelNameArg;
}
);
@ -99,11 +99,11 @@ export class ClientUniverse {
password: 'UniverseClient',
port: parseInt(parsedURL.port, 10),
role: 'UniverseClient',
url: parsedURL.protocol + '//' + parsedURL.hostname
url: parsedURL.protocol + '//' + parsedURL.hostname,
};
this.smartsocketClient = new SmartsocketClient(socketConfig);
this.smartsocketClient.eventSubject.subscribe(async eventArg => {
this.smartsocketClient.eventSubject.subscribe(async (eventArg) => {
switch (eventArg) {
case 'disconnected':
this.disconnect('upstreamEvent');
@ -119,14 +119,14 @@ export class ClientUniverse {
funcName: 'unsubscribe',
allowedRoles: [],
funcDef: async (dataArg: interfaces.IServerUnsubscribeActionPayload) => {
const channel = this.clientUniverseCache.channelMap.find(channelArg => {
const channel = this.clientUniverseCache.channelMap.find((channelArg) => {
return channelArg.name === dataArg.name;
});
if (channel) {
channel.unsubscribe();
}
return {};
}
},
});
/**
@ -137,7 +137,7 @@ export class ClientUniverse {
>({
funcName: 'processMessage',
allowedRoles: [],
funcDef: async messageDescriptorArg => {
funcDef: async (messageDescriptorArg) => {
logger.log('info', 'Got message from server');
const clientUniverseMessage = ClientUniverseMessage.createMessageFromMessageDescriptor(
messageDescriptorArg
@ -149,14 +149,14 @@ export class ClientUniverse {
if (targetChannel) {
await targetChannel.emitMessageLocally(clientUniverseMessage);
return {
messageStatus: 'ok'
messageStatus: 'ok',
};
} else {
return {
messageStatus: 'channel not found'
messageStatus: 'channel not found',
};
}
}
},
});
// add functions
@ -165,7 +165,7 @@ export class ClientUniverse {
await this.smartsocketClient.connect();
logger.log('info', 'universe client connected successfully');
await this.clientUniverseCache.channelMap.forEach(async clientUniverseChannelArg => {
await this.clientUniverseCache.channelMap.forEach(async (clientUniverseChannelArg) => {
await clientUniverseChannelArg.populateSubscriptionToServer();
});
}

8
ts/smartuniverse.classes.clientuniversechannel.ts
View File

@ -55,10 +55,10 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
*/
public subscribe(observingFunctionArg: (messageArg: ClientUniverseMessage<any>) => void) {
return this.subject.subscribe(
messageArg => {
(messageArg) => {
observingFunctionArg(messageArg);
},
error => console.log(error)
(error) => console.log(error)
);
}
@ -73,7 +73,7 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
interfaces.ISocketRequest_SubscribeChannel
>('subscribeChannel', {
name: this.name,
passphrase: this.passphrase
passphrase: this.passphrase,
});
this.status = response.subscriptionStatus;
}
@ -95,7 +95,7 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
passphrase: this.passphrase,
targetChannelName: this.name,
messageText: messageArg.messageText,
payload: messageArg.payload
payload: messageArg.payload,
};
await this.clientUniverseRef.smartsocketClient.serverCall(
'processMessage',

8
ts/smartuniverse.classes.reactionrequest.ts
View File

@ -64,16 +64,16 @@ export class ReactionRequest<T extends plugins.typedrequestInterfaces.ITypedRequ
typedRequestPayload: {
method: this.method,
request: requestDataArg,
response: null
}
response: null,
},
};
channel.sendMessage({
messageText: 'reactionRequest',
payload
payload,
});
}
plugins.smartdelay.delayFor(timeoutMillisArg).then(async () => {
await subscriptionMap.forEach(subscriptionArg => {
await subscriptionMap.forEach((subscriptionArg) => {
subscriptionArg.unsubscribe();
});
reactionResult.complete();

8
ts/smartuniverse.classes.reactionresponse.ts
View File

@ -28,7 +28,7 @@ export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedReq
this.channels.addArray(optionsArg.channels);
this.funcDef = optionsArg.funcDef;
for (const channel of this.channels.getArray()) {
channel.subscribe(messageArg => {
channel.subscribe((messageArg) => {
this.processMessageForReaction(channel, messageArg);
});
}
@ -51,12 +51,12 @@ export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedReq
...messageArg.payload,
typedRequestPayload: {
...messageArg.payload.typedRequestPayload,
response
}
response,
},
};
channelArg.sendMessage({
messageText: 'reactionResponse',
payload
payload,
});
}
}

4
ts/smartuniverse.classes.reactionresult.ts
View File

@ -7,7 +7,7 @@ export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedReque
private completeDeferred = plugins.smartpromise.defer<Array<T['response']>>();
constructor() {
this.resultSubscribe(responseArg => {
this.resultSubscribe((responseArg) => {
this.endResult.push(responseArg);
});
}
@ -29,7 +29,7 @@ export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedReque
*/
public async getFirstResult() {
const done = plugins.smartpromise.defer<T['response']>();
const subscription = this.resultReplaySubject.subscribe(result => {
const subscription = this.resultReplaySubject.subscribe((result) => {
done.resolve(result);
subscription.unsubscribe();
});

26
ts/smartuniverse.classes.universe.ts
View File

@ -70,7 +70,7 @@ export class Universe {
* returns a channel
*/
public getChannel(channelNameArg: string) {
return this.universeCache.channelMap.find(channelArg => {
return this.universeCache.channelMap.find((channelArg) => {
return channelArg.name === channelNameArg;
});
}
@ -87,7 +87,7 @@ export class Universe {
return `smartuniverse server ${this.getUniverseVersion()}`;
},
forceSsl: false,
port: portArg
port: portArg,
});
} else {
console.log('Universe is using externally supplied server');
@ -100,7 +100,7 @@ export class Universe {
// add a role for the clients
const ClientRole = new plugins.smartsocket.SocketRole({
name: 'UniverseClient',
passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient') // authentication happens on another level
passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient'), // authentication happens on another level
});
// add the role to smartsocket
@ -115,13 +115,13 @@ export class Universe {
const universeConnection = new UniverseConnection({
universe: this,
socketConnection: socketConnectionArg,
authenticationRequests: [dataArg]
authenticationRequests: [dataArg],
});
await UniverseConnection.addConnectionToCache(this, universeConnection);
return {
subscriptionStatus: 'subscribed'
subscriptionStatus: 'subscribed',
};
}
},
});
const socketFunctionProcessMessage = new plugins.smartsocket.SocketFunction({
@ -133,17 +133,11 @@ export class Universe {
socketConnectionArg
);
if (universeConnection) {
logger.log(
'ok',
'found UniverseConnection for socket for incoming message'
);
logger.log('ok', 'found UniverseConnection for socket for incoming message');
} else {
logger.log(
'warn',
'found no Authorized channel for incoming message'
);
logger.log('warn', 'found no Authorized channel for incoming message');
return {
error: 'You need to authenticate for a channel'
error: 'You need to authenticate for a channel',
};
}
const unauthenticatedMessage = UniverseMessage.createMessageFromPayload(
@ -158,7 +152,7 @@ export class Universe {
const authenticatedMessage = unauthenticatedMessage;
await this.universeCache.addMessage(authenticatedMessage);
}
}
},
});
// add socket functions

4
ts/smartuniverse.classes.universecache.ts
View File

@ -58,7 +58,7 @@ export class UniverseCache {
messageArg.setUniverseCache(this);
UniverseChannel.authorizeAMessageForAChannel(this, messageArg);
this.messageMap.add(messageArg);
messageArg.universeChannelList.forEach(universeChannel => {
messageArg.universeChannelList.forEach((universeChannel) => {
universeChannel.push(messageArg);
});
}
@ -71,7 +71,7 @@ export class UniverseCache {
channelName?: string
): Observable<UniverseMessage<any>> {
const messageObservable = from(this.messageMap.getArray()).pipe(
filter(messageArg => {
filter((messageArg) => {
return messageArg.smartTimestamp.isYoungerThanMilliSeconds(this.destructionTime);
})
);

16
ts/smartuniverse.classes.universechannel.ts
View File

@ -34,7 +34,7 @@ export class UniverseChannel {
* returns boolean wether certain channel exists
*/
public static async doesChannelExists(universeCacheArg: UniverseCache, channelNameArg: string) {
const channel = universeCacheArg.channelMap.find(channelArg => {
const channel = universeCacheArg.channelMap.find((channelArg) => {
return channelArg.name === channelNameArg;
});
if (channel) {
@ -55,7 +55,7 @@ export class UniverseChannel {
universeCacheArg: UniverseCache,
universeMessageArg: UniverseMessage<any>
): UniverseChannel {
const foundChannel = universeCacheArg.channelMap.find(universeChannel => {
const foundChannel = universeCacheArg.channelMap.find((universeChannel) => {
const result = universeChannel.authenticate(universeMessageArg);
return result;
});
@ -73,7 +73,7 @@ export class UniverseChannel {
}
public static getUniverseChannelByName(universeRef: Universe, universeChannelName: string) {
return universeRef.universeCache.channelMap.find(channelArg => {
return universeRef.universeCache.channelMap.find((channelArg) => {
return channelArg.name === universeChannelName;
});
}
@ -118,7 +118,7 @@ export class UniverseChannel {
public async push(messageArg: UniverseMessage<any>) {
this.subject.next(messageArg);
const universeConnectionsWithChannelAccess: UniverseConnection[] = [];
await this.universeRef.universeCache.connectionMap.forEach(async socketConnection => {
await this.universeRef.universeCache.connectionMap.forEach(async (socketConnection) => {
if (socketConnection.authenticatedChannels.includes(this)) {
universeConnectionsWithChannelAccess.push(socketConnection);
}
@ -132,7 +132,7 @@ export class UniverseChannel {
passphrase: messageArg.passphrase,
targetChannelName: this.name,
messageText: messageArg.messageText,
payload: messageArg.payload
payload: messageArg.payload,
};
smartsocket.clientCall(
'processMessage',
@ -145,10 +145,10 @@ export class UniverseChannel {
// functions to interact with a channel locally
public subscribe(observingFunctionArg: (messageArg: UniverseMessage<any>) => void) {
return this.subject.subscribe(
messageArg => {
(messageArg) => {
observingFunctionArg(messageArg);
},
error => console.log(error)
(error) => console.log(error)
);
}
@ -162,7 +162,7 @@ export class UniverseChannel {
payload: messageDescriptor.payload,
targetChannelName: this.name,
passphrase: this.passphrase,
timestamp: Date.now()
timestamp: Date.now(),
});
this.universeRef.universeCache.addMessage(messageToSend);
}

6
ts/smartuniverse.classes.universeconnection.ts
View File

@ -37,7 +37,7 @@ export class UniverseConnection {
universeConnectionArg: UniverseConnection
): Promise<UniverseConnection> {
let connectionToReturn: UniverseConnection;
universeCache.connectionMap.forEach(async existingConnection => {
universeCache.connectionMap.forEach(async (existingConnection) => {
if (existingConnection.socketConnection === universeConnectionArg.socketConnection) {
connectionToReturn = await this.mergeUniverseConnections(
existingConnection,
@ -87,7 +87,7 @@ export class UniverseConnection {
universeCache: UniverseCache,
socketConnectionArg: plugins.smartsocket.SocketConnection
): UniverseConnection {
const universeConnection = universeCache.connectionMap.find(universeConnectionArg => {
const universeConnection = universeCache.connectionMap.find((universeConnectionArg) => {
return universeConnectionArg.socketConnection === socketConnectionArg;
});
return universeConnection;
@ -124,7 +124,7 @@ export class UniverseConnection {
this.universeRef = optionsArg.universe;
this.authenticationRequests = optionsArg.authenticationRequests;
this.socketConnection = optionsArg.socketConnection;
this.socketConnection.eventSubject.subscribe(async eventArg => {
this.socketConnection.eventSubject.subscribe(async (eventArg) => {
switch (eventArg) {
case 'disconnected':
await this.disconnect('upstreamevent');

2
ts/smartuniverse.classes.universemessage.ts
View File

@ -81,7 +81,7 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
.then(async () => {
this.universeCache.messageMap.remove(this);
})
.catch(err => {
.catch((err) => {
console.log(err);
console.log(this);
});

2
ts/smartuniverse.plugins.ts
View File

@ -34,5 +34,5 @@ export {
smartrequest,
smartsocket,
smarttime,
smartunique
smartunique,
};