dave/smsgw-tester
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Working commit

Browse Source
This commit is contained in:
David Majdandžić
2023-04-05 16:51:29 +02:00
parent 3acb1f0889
commit eb22a43ee2
13 changed files with 104 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Center/Center.ts
View File

@@ -1,8 +1,9 @@
import {PDU} from "../CommonObjects";
import {Job} from "../Job/Job";
import Logger from "../Logger";
import {DebugPduProcessor} from "../PDUProcessor/DebugPduProcessor";
import {PduProcessor} from "../PDUProcessor/PduProcessor";
import {DebugPduProcessor} from "../PDUProcessor/Postprocessor/Center/DebugPduProcessor";
import ProcessorManager from "../PDUProcessor/ProcessorManager";
import {SmppSession} from "../SmppSession";
const NanoTimer = require('nanotimer');
@@ -117,7 +118,6 @@ export class Center extends SmppSession {
initialize(): void {
this.server = smpp.createServer({}, this.eventSessionConnected.bind(this));
this.server.listen(this.port);
PduProcessor.attachProcessor(this, PduProcessor.getProcessor(DebugPduProcessor.name));
this.setStatus(0);
}
@@ -142,7 +142,7 @@ export class Center extends SmppSession {
defaultSingleJob: this._defaultSingleJob.serialize(),
defaultMultipleJob: this._defaultMultipleJob.serialize(),
processors: this.pduProcessors.map(p => p.serialize()),
availableProcessors: PduProcessor.getProcessorsForType(Center.name)
availableProcessors: ProcessorManager.getProcessorsForType(this.constructor.name)
};
}

8
src/Client/Client.ts
View File

@@ -1,9 +1,9 @@
import {Center} from "../Center/Center";
import {PDU} from "../CommonObjects";
import {Job} from "../Job/Job";
import Logger from "../Logger";
import {DeliverSmReplyProcessor} from "../PDUProcessor/Client/DeliverSmReplyProcessor";
import {PduProcessor} from "../PDUProcessor/PduProcessor";
import {DeliverSmReplyProcessor} from "../PDUProcessor/Postprocessor/Client/DeliverSmReplyProcessor";
import ProcessorManager from "../PDUProcessor/ProcessorManager";
import PersistentPromise from "../PersistentPromise";
import {SmppSession} from "../SmppSession";
@@ -43,8 +43,6 @@ export class Client extends SmppSession {
this._defaultSingleJob = Job.createEmptySingle('submit_sm');
this._defaultMultipleJob = Job.createEmptyMultiple('submit_sm');
this.addPduProcessor(PduProcessor.getProcessor(DeliverSmReplyProcessor.name));
this.logger = new Logger(`Client-${id}`);
}
@@ -124,7 +122,7 @@ export class Client extends SmppSession {
defaultSingleJob: this._defaultSingleJob.serialize(),
defaultMultipleJob: this._defaultMultipleJob.serialize(),
processors: this.pduProcessors.map(p => p.serialize()),
availableProcessors: PduProcessor.getProcessorsForType(Client.name)
availableProcessors: ProcessorManager.getProcessorsForType(this.constructor.name)
};
}

1
src/HttpServer/ClientRequestHandler.ts
View File

@@ -1,4 +1,3 @@
import {Center} from "../Center/Center";
import {Client} from "../Client/Client";
import ClientSessionManager from "../Client/ClientSessionManager";
import Logger from "../Logger";

40
src/PDUProcessor/PduProcessor.ts
View File

@@ -1,51 +1,11 @@
import {PDU} from "../CommonObjects";
import Logger from "../Logger";
import {SmppSession} from "../SmppSession";
export abstract class PduProcessor {
static processors: PduProcessor[] = [];
private static logger: Logger = new Logger("PduProcessor");
abstract readonly serverSessionType: string;
readonly name: string = this.constructor.name;
readonly logger: Logger = new Logger(`PduProcessor: ${this.name}`);
static getProcessor(name: string): PduProcessor {
this.logger.log1(`Looking for processor with name ${name}...`);
let pduProcessor = this.processors.find((processor: PduProcessor) => processor.name === name);
if (pduProcessor) {
this.logger.log1(`Found processor with name ${name}`);
return pduProcessor;
} else {
this.logger.log1(`Processor with name ${name} not found`);
return this.processors[0];
}
}
static attachProcessor(session: SmppSession, processor: PduProcessor): void {
this.logger.log1(`Trying to attach processor ${processor.name} to session ${session.constructor.name}-${session.id}`);
if (PduProcessor.areCompatible(session, processor)) {
session.addPduProcessor(processor);
}
}
static detachProcessor(session: SmppSession, processor: PduProcessor): void {
this.logger.log1(`Trying to detach processor ${processor.name} from session ${session.constructor.name}-${session.id}`);
session.removePduProcessor(processor);
}
static areCompatible(session: SmppSession, processor: PduProcessor): boolean {
this.logger.log1(`Checking compatibility between session ${session.constructor.name}-${session.id} and processor ${processor.name}`);
return session.constructor.name === processor.serverSessionType;
}
static addProcessor(processor: new () => PduProcessor): void {
PduProcessor.processors.push(new processor());
}
static getProcessorsForType(type: string): PduProcessor[] {
return this.processors.filter((processor: PduProcessor) => processor.serverSessionType === type);
}
abstract processPdu(session: any, pdu: PDU, ...args: any[]): Promise<any>;
serialize(): object {

8
src/PDUProcessor/DebugPduProcessor.ts → src/PDUProcessor/Postprocessor/Center/DebugPduProcessor.ts
View File

@@ -1,8 +1,8 @@
import {Center} from "../Center/Center";
import {PDU} from "../CommonObjects";
import {PduProcessor} from "./PduProcessor";
import {Center} from "../../../Center/Center";
import {PDU} from "../../../CommonObjects";
import Postprocessor from "../Postprocessor";
export class DebugPduProcessor extends PduProcessor {
export class DebugPduProcessor extends Postprocessor {
serverSessionType: string = Center.name;
processPdu(session: any, pdu: PDU, ...args: any[]): Promise<any> {

8
src/PDUProcessor/EchoPduProcessor.ts → src/PDUProcessor/Postprocessor/Center/EchoPduProcessor.ts
View File

@@ -1,10 +1,10 @@
import {Center} from "../Center/Center";
import {PDU} from "../CommonObjects";
import {PduProcessor} from "./PduProcessor";
import {Center} from "../../../Center/Center";
import {PDU} from "../../../CommonObjects";
import Postprocessor from "../Postprocessor";
const smpp = require("smpp");
export class EchoPduProcessor extends PduProcessor {
export class EchoPduProcessor extends Postprocessor {
serverSessionType: string = Center.name;
processPdu(session: any, pdu: PDU, ...args: any[]): Promise<any> {

8
src/PDUProcessor/Client/DeliverSmReplyProcessor.ts → src/PDUProcessor/Postprocessor/Client/DeliverSmReplyProcessor.ts
View File

@@ -1,8 +1,8 @@
import {Client} from "../../Client/Client";
import {PDU} from "../../CommonObjects";
import {PduProcessor} from "../PduProcessor";
import {Client} from "../../../Client/Client";
import {PDU} from "../../../CommonObjects";
import Postprocessor from "../Postprocessor";
export class DeliverSmReplyProcessor extends PduProcessor {
export class DeliverSmReplyProcessor extends Postprocessor {
serverSessionType: string = Client.name;
processPdu(session: any, pdu: PDU, ...args: any[]): Promise<any> {

5
src/PDUProcessor/Postprocessor/Postprocessor.ts Normal file
View File

@@ -0,0 +1,5 @@
import {PduProcessor} from "../PduProcessor";
export default abstract class Postprocessor extends PduProcessor {
readonly type: string = this.name;
}

8
src/PDUProcessor/Client/DestinationEnumeratorProcessor.ts → src/PDUProcessor/Preprocessor/Client/DestinationEnumeratorProcessor.ts
View File

@@ -1,8 +1,8 @@
import {Client} from "../../Client/Client";
import {PDU} from "../../CommonObjects";
import {PduProcessor} from "../PduProcessor";
import {Client} from "../../../Client/Client";
import {PDU} from "../../../CommonObjects";
import Preprocessor from "../Preprocessor";
export class DestinationEnumeratorProcessor extends PduProcessor {
export class DestinationEnumeratorProcessor extends Preprocessor {
serverSessionType: string = Client.name;
private iterator = 0;

8
src/PDUProcessor/Client/SourceEnumeratorProcessor.ts → src/PDUProcessor/Preprocessor/Client/SourceEnumeratorProcessor.ts
View File

@@ -1,8 +1,8 @@
import {Client} from "../../Client/Client";
import {PDU} from "../../CommonObjects";
import {PduProcessor} from "../PduProcessor";
import {Client} from "../../../Client/Client";
import {PDU} from "../../../CommonObjects";
import Preprocessor from "../Preprocessor";
export class SourceEnumeratorProcessor extends PduProcessor {
export class SourceEnumeratorProcessor extends Preprocessor {
serverSessionType: string = Client.name;
private iterator = 0;

5
src/PDUProcessor/Preprocessor/Preprocessor.ts Normal file
View File

@@ -0,0 +1,5 @@
import {PduProcessor} from "../PduProcessor";
export default abstract class Preprocessor extends PduProcessor {
readonly type: string = this.name;
}

61
src/PDUProcessor/ProcessorManager.ts Normal file
View File

@@ -0,0 +1,61 @@
import Logger from "../Logger";
import {SmppSession} from "../SmppSession";
import {PduProcessor} from "./PduProcessor";
import {DebugPduProcessor} from "./Postprocessor/Center/DebugPduProcessor";
import {EchoPduProcessor} from "./Postprocessor/Center/EchoPduProcessor";
import {DeliverSmReplyProcessor} from "./Postprocessor/Client/DeliverSmReplyProcessor";
import {DestinationEnumeratorProcessor} from "./Preprocessor/Client/DestinationEnumeratorProcessor";
import {SourceEnumeratorProcessor} from "./Preprocessor/Client/SourceEnumeratorProcessor";
export default class ProcessorManager {
static readonly preprocessors: PduProcessor[] = [
new DestinationEnumeratorProcessor(),
new SourceEnumeratorProcessor()
];
static readonly postprocessors: PduProcessor[] = [
new DebugPduProcessor(),
new EchoPduProcessor(),
new DeliverSmReplyProcessor(),
];
private static readonly logger: Logger = new Logger(this.name);
constructor() {
}
static get processors(): PduProcessor[] {
return this.preprocessors.concat(this.postprocessors);
}
static getProcessor(name: string): PduProcessor {
this.logger.log1(`Looking for processor with name ${name}...`);
let pduProcessor: PduProcessor | undefined = this.processors.find((processor: PduProcessor) => processor.name === name);
if (pduProcessor) {
this.logger.log1(`Found processor with name ${name}`);
return pduProcessor;
} else {
this.logger.log1(`Processor with name ${name} not found`);
return this.processors[0];
}
}
static attachProcessor(session: SmppSession, processor: PduProcessor): void {
this.logger.log1(`Trying to attach processor ${processor.name} to session ${session.constructor.name}-${session.id}`);
if (this.areCompatible(session, processor)) {
session.addPduProcessor(processor);
}
}
static detachProcessor(session: SmppSession, processor: PduProcessor): void {
this.logger.log1(`Trying to detach processor ${processor.name} from session ${session.constructor.name}-${session.id}`);
session.removePduProcessor(processor);
}
static areCompatible(session: SmppSession, processor: PduProcessor): boolean {
this.logger.log1(`Checking compatibility between session ${session.constructor.name}-${session.id} and processor ${processor.name}`);
return session.constructor.name === processor.serverSessionType;
}
static getProcessorsForType(type: string): PduProcessor[] {
return this.processors.filter((processor: PduProcessor) => processor.serverSessionType === type);
}
}

20
src/main.ts
View File

@@ -4,31 +4,25 @@ import {Client} from "./Client/Client";
import ClientSessionManager from "./Client/ClientSessionManager";
import {HttpServer} from "./HttpServer/HttpServer";
import Logger from "./Logger";
import {DeliverSmReplyProcessor} from "./PDUProcessor/Client/DeliverSmReplyProcessor";
import {DestinationEnumeratorProcessor} from "./PDUProcessor/Client/DestinationEnumeratorProcessor";
import {SourceEnumeratorProcessor} from "./PDUProcessor/Client/SourceEnumeratorProcessor";
import {DebugPduProcessor} from "./PDUProcessor/DebugPduProcessor";
import {EchoPduProcessor} from "./PDUProcessor/EchoPduProcessor";
import {PduProcessor} from "./PDUProcessor/PduProcessor";
import {DebugPduProcessor} from "./PDUProcessor/Postprocessor/Center/DebugPduProcessor";
import {EchoPduProcessor} from "./PDUProcessor/Postprocessor/Center/EchoPduProcessor";
import {DeliverSmReplyProcessor} from "./PDUProcessor/Postprocessor/Client/DeliverSmReplyProcessor";
import {DestinationEnumeratorProcessor} from "./PDUProcessor/Preprocessor/Client/DestinationEnumeratorProcessor";
import {SourceEnumeratorProcessor} from "./PDUProcessor/Preprocessor/Client/SourceEnumeratorProcessor";
import {WSServer} from "./WS/WSServer";
const {PDU} = require("smpp");
let logger = new Logger("main");
PduProcessor.addProcessor(DebugPduProcessor);
PduProcessor.addProcessor(EchoPduProcessor);
PduProcessor.addProcessor(DestinationEnumeratorProcessor);
PduProcessor.addProcessor(SourceEnumeratorProcessor);
PduProcessor.addProcessor(DeliverSmReplyProcessor);
let clientManager: ClientSessionManager = new ClientSessionManager();
let centerManager: CenterSessionManager = new CenterSessionManager();
// TODO: Add support for encodings
// TODO: Fix reading and writing processors
// TODO: Try creating multiple entries with the same arg
let wss: WSServer = new WSServer([clientManager, centerManager]);
let httpServer: HttpServer = new HttpServer(clientManager, centerManager);
// let wss: WSServer = new WSServer([clientManager, centerManager]);
// let httpServer: HttpServer = new HttpServer(clientManager, centerManager);
function cleanup(): void {
logger.log1("Cleaning up...");