// Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
-import { AvailabilityType, BootNotificationRequest, IncomingRequest, IncomingRequestCommand, Request } from '../types/ocpp/Requests';
+import { AvailabilityType, BootNotificationRequest, CachedRequest, IncomingRequest, IncomingRequestCommand, RequestCommand } from '../types/ocpp/Requests';
import { BootNotificationResponse, RegistrationStatus } from '../types/ocpp/Responses';
import ChargingStationConfiguration, { ConfigurationKey } from '../types/ChargingStationConfiguration';
import ChargingStationTemplate, { CurrentType, PowerUnits, Voltage } from '../types/ChargingStationTemplate';
+import { Connector, Connectors, SampledValueTemplate } from '../types/Connectors';
import { ConnectorPhaseRotation, StandardParametersKey, SupportedFeatureProfiles } from '../types/ocpp/Configuration';
-import Connectors, { Connector, SampledValueTemplate } from '../types/Connectors';
import { MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
import { WSError, WebSocketCloseEventStatusCode } from '../types/WebSocket';
import WebSocket, { ClientOptions, Data, OPEN } from 'ws';
public stationInfo!: ChargingStationInfo;
public connectors: Connectors;
public configuration!: ChargingStationConfiguration;
- public hasStopped: boolean;
public wsConnection!: WebSocket;
- public requests: Map<string, Request>;
- public messageQueue: string[];
+ public requests: Map<string, CachedRequest>;
public performanceStatistics!: PerformanceStatistics;
public heartbeatSetInterval!: NodeJS.Timeout;
- public ocppIncomingRequestService!: OCPPIncomingRequestService;
public ocppRequestService!: OCPPRequestService;
private index: number;
private bootNotificationRequest!: BootNotificationRequest;
private bootNotificationResponse!: BootNotificationResponse | null;
private connectorsConfigurationHash!: string;
+ private ocppIncomingRequestService!: OCPPIncomingRequestService;
+ private messageQueue: string[];
private wsConnectionUrl!: URL;
- private hasSocketRestarted: boolean;
+ private wsConnectionRestarted: boolean;
+ private stopped: boolean;
private autoReconnectRetryCount: number;
- private automaticTransactionGeneration!: AutomaticTransactionGenerator;
+ private automaticTransactionGenerator!: AutomaticTransactionGenerator;
private webSocketPingSetInterval!: NodeJS.Timeout;
constructor(index: number, stationTemplateFile: string) {
this.connectors = {} as Connectors;
this.initialize();
- this.hasStopped = false;
- this.hasSocketRestarted = false;
+ this.stopped = false;
+ this.wsConnectionRestarted = false;
this.autoReconnectRetryCount = 0;
- this.requests = new Map<string, Request>();
+ this.requests = new Map<string, CachedRequest>();
this.messageQueue = new Array<string>();
this.authorizedTags = this.getAuthorizedTags();
return this.bootNotificationRequest;
}
- public getRandomTagId(): string {
+ public getRandomIdTag(): string {
const index = Math.floor(Utils.secureRandom() * this.authorizedTags.length);
return this.authorizedTags[index];
}
if (!Constants.SUPPORTED_MEASURANDS.includes(sampledValueTemplates[index]?.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER)) {
logger.warn(`${this.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
} else if (phase && sampledValueTemplates[index]?.phase === phase && sampledValueTemplates[index]?.measurand === measurand
- && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
+ && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
return sampledValueTemplates[index];
} else if (!phase && !sampledValueTemplates[index].phase && sampledValueTemplates[index]?.measurand === measurand
- && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
+ && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
return sampledValueTemplates[index];
} else if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
- && (!sampledValueTemplates[index].measurand || sampledValueTemplates[index].measurand === measurand)) {
+ && (!sampledValueTemplates[index].measurand || sampledValueTemplates[index].measurand === measurand)) {
return sampledValueTemplates[index];
}
}
this.performanceStatistics.stop();
}
this.bootNotificationResponse = null;
- this.hasStopped = true;
+ this.stopped = true;
}
public getConfigurationKey(key: string | StandardParametersKey, caseInsensitive = false): ConfigurationKey | undefined {
if (!Utils.isEmptyArray(this.getConnector(connectorId).chargingProfiles)) {
this.getConnector(connectorId).chargingProfiles?.forEach((chargingProfile: ChargingProfile, index: number) => {
if (chargingProfile.chargingProfileId === cp.chargingProfileId
- || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
+ || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
this.getConnector(connectorId).chargingProfiles[index] = cp;
cpReplaced = true;
}
this.stationInfo.randomConnectors = true;
}
const connectorsConfigHash = crypto.createHash('sha256').update(JSON.stringify(this.stationInfo.Connectors) + maxConnectors.toString()).digest('hex');
- // FIXME: Handle shrinking the number of connectors
- if (!this.connectors || (this.connectors && this.connectorsConfigurationHash !== connectorsConfigHash)) {
+ const connectorsConfigChanged = !Utils.isEmptyObject(this.connectors) && this.connectorsConfigurationHash !== connectorsConfigHash;
+ if (Utils.isEmptyObject(this.connectors) || connectorsConfigChanged) {
+ connectorsConfigChanged && (this.connectors = {} as Connectors);
this.connectorsConfigurationHash = connectorsConfigHash;
// Add connector Id 0
let lastConnector = '0';
// Generate all connectors
if ((this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
for (let index = 1; index <= maxConnectors; index++) {
- const randConnectorId = this.stationInfo.randomConnectors ? Utils.getRandomInt(Utils.convertToInt(lastConnector), 1) : index;
+ const randConnectorId = this.stationInfo.randomConnectors ? Utils.getRandomInteger(Utils.convertToInt(lastConnector), 1) : index;
this.connectors[index] = Utils.cloneObject<Connector>(this.stationInfo.Connectors[randConnectorId]);
this.connectors[index].availability = AvailabilityType.OPERATIVE;
if (Utils.isUndefined(this.connectors[lastConnector]?.chargingProfiles)) {
delete this.stationInfo.Connectors;
// Initialize transaction attributes on connectors
for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && !this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
+ if (Utils.convertToInt(connector) > 0 && !this.getConnector(Utils.convertToInt(connector))?.transactionStarted) {
this.initTransactionAttributesOnConnector(Utils.convertToInt(connector));
}
}
this.addConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests, 'true');
}
if (!this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled)
- && this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles).value.includes(SupportedFeatureProfiles.Local_Auth_List_Management)) {
+ && this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles).value.includes(SupportedFeatureProfiles.Local_Auth_List_Management)) {
this.addConfigurationKey(StandardParametersKey.LocalAuthListEnabled, 'false');
}
if (!this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
}
if (this.isRegistered()) {
await this.startMessageSequence();
- this.hasStopped && (this.hasStopped = false);
- if (this.hasSocketRestarted && this.isWebSocketConnectionOpened()) {
+ this.stopped && (this.stopped = false);
+ if (this.wsConnectionRestarted && this.isWebSocketConnectionOpened()) {
this.flushMessageQueue();
}
} else {
logger.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
}
this.autoReconnectRetryCount = 0;
- this.hasSocketRestarted = false;
+ this.wsConnectionRestarted = false;
}
private async onClose(code: number, reason: string): Promise<void> {
let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, {}, {}];
let responseCallback: (payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>) => void;
let rejectCallback: (error: OCPPError) => void;
+ let requestCommandName: RequestCommand | IncomingRequestCommand;
let requestPayload: Record<string, unknown>;
- let cachedRequest: Request;
+ let cachedRequest: CachedRequest;
let errMsg: string;
try {
const request = JSON.parse(data.toString()) as IncomingRequest;
// Respond
cachedRequest = this.requests.get(messageId);
if (Utils.isIterable(cachedRequest)) {
- [responseCallback, , requestPayload] = cachedRequest;
+ [responseCallback, , , requestPayload] = cachedRequest;
} else {
- throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Response request for message id ${messageId} is not iterable`, commandName);
+ throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} response is not iterable`, commandName);
}
if (!responseCallback) {
// Error
- throw new OCPPError(ErrorType.INTERNAL_ERROR, `Response request for unknown message id ${messageId}`, commandName);
+ throw new OCPPError(ErrorType.INTERNAL_ERROR, `Response for unknown message id ${messageId}`, commandName);
}
- this.requests.delete(messageId);
responseCallback(commandName, requestPayload);
break;
// Error Message
case MessageType.CALL_ERROR_MESSAGE:
cachedRequest = this.requests.get(messageId);
- if (!cachedRequest) {
- // Error
- throw new OCPPError(ErrorType.INTERNAL_ERROR, `Error request for unknown message id ${messageId}`);
- }
if (Utils.isIterable(cachedRequest)) {
- [, rejectCallback] = cachedRequest;
+ [, rejectCallback, requestCommandName] = cachedRequest;
} else {
- throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Error request for message id ${messageId} is not iterable`);
+ throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} error response is not iterable`);
+ }
+ if (!rejectCallback) {
+ // Error
+ throw new OCPPError(ErrorType.INTERNAL_ERROR, `Error response for unknown message id ${messageId}`, requestCommandName);
}
- this.requests.delete(messageId);
- rejectCallback(new OCPPError(commandName, commandPayload.toString(), null, errorDetails));
+ rejectCallback(new OCPPError(commandName, commandPayload.toString(), requestCommandName, errorDetails));
break;
// Error
default:
}
} catch (error) {
// Log
- logger.error('%s Incoming request message %j processing error %j on content type %j', this.logPrefix(), data, error, this.requests.get(messageId));
+ logger.error('%s Incoming OCPP message %j matching cached request %j processing error %j', this.logPrefix(), data, this.requests.get(messageId), error);
// Send error
- messageType !== MessageType.CALL_ERROR_MESSAGE && await this.ocppRequestService.sendError(messageId, error, commandName);
+ messageType === MessageType.CALL_MESSAGE && await this.ocppRequestService.sendError(messageId, error, commandName);
}
}
private getNumberOfRunningTransactions(): number {
let trxCount = 0;
for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
+ if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector))?.transactionStarted) {
trxCount++;
}
}
for (const connector in this.connectors) {
if (Utils.convertToInt(connector) === 0) {
continue;
- } else if (!this.hasStopped && !this.getConnector(Utils.convertToInt(connector))?.status && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
+ } else if (!this.stopped && !this.getConnector(Utils.convertToInt(connector))?.status && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
// Send status in template at startup
await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
this.getConnector(Utils.convertToInt(connector)).status = this.getConnector(Utils.convertToInt(connector)).bootStatus;
- } else if (this.hasStopped && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
+ } else if (this.stopped && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
// Send status in template after reset
await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
this.getConnector(Utils.convertToInt(connector)).status = this.getConnector(Utils.convertToInt(connector)).bootStatus;
- } else if (!this.hasStopped && this.getConnector(Utils.convertToInt(connector))?.status) {
+ } else if (!this.stopped && this.getConnector(Utils.convertToInt(connector))?.status) {
// Send previous status at template reload
await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).status);
} else {
private startAutomaticTransactionGenerator() {
if (this.stationInfo.AutomaticTransactionGenerator.enable) {
- if (!this.automaticTransactionGeneration) {
- this.automaticTransactionGeneration = new AutomaticTransactionGenerator(this);
+ if (!this.automaticTransactionGenerator) {
+ this.automaticTransactionGenerator = new AutomaticTransactionGenerator(this);
}
- if (this.automaticTransactionGeneration.timeToStop) {
- this.automaticTransactionGeneration.start();
+ if (!this.automaticTransactionGenerator.started) {
+ this.automaticTransactionGenerator.start();
}
}
}
this.stopHeartbeat();
// Stop the ATG
if (this.stationInfo.AutomaticTransactionGenerator.enable &&
- this.automaticTransactionGeneration &&
- !this.automaticTransactionGeneration.timeToStop) {
- await this.automaticTransactionGeneration.stop(reason);
+ this.automaticTransactionGenerator &&
+ this.automaticTransactionGenerator.started) {
+ this.automaticTransactionGenerator.stop();
} else {
for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionStarted) {
+ if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector))?.transactionStarted) {
const transactionId = this.getConnector(Utils.convertToInt(connector)).transactionId;
await this.ocppRequestService.sendStopTransaction(transactionId, this.getEnergyActiveImportRegisterByTransactionId(transactionId),
this.getTransactionIdTag(transactionId), reason);
private startStationTemplateFileMonitoring(): void {
try {
- fs.watch(this.stationTemplateFile, async (event, filename): Promise<void> => {
+ fs.watch(this.stationTemplateFile, (event, filename): void => {
if (filename && event === 'change') {
try {
logger.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile + ' have changed, reload');
this.initialize();
// Restart the ATG
if (!this.stationInfo.AutomaticTransactionGenerator.enable &&
- this.automaticTransactionGeneration) {
- await this.automaticTransactionGeneration.stop();
+ this.automaticTransactionGenerator) {
+ this.automaticTransactionGenerator.stop();
}
this.startAutomaticTransactionGenerator();
if (this.getEnableStatistics()) {
// Stop the ATG if needed
if (this.stationInfo.AutomaticTransactionGenerator.enable &&
this.stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
- this.automaticTransactionGeneration &&
- !this.automaticTransactionGeneration.timeToStop) {
- await this.automaticTransactionGeneration.stop();
+ this.automaticTransactionGenerator &&
+ this.automaticTransactionGenerator.started) {
+ this.automaticTransactionGenerator.stop();
}
if (this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
this.autoReconnectRetryCount++;
await Utils.sleep(reconnectDelay);
logger.error(this.logPrefix() + ' Socket: reconnecting try #' + this.autoReconnectRetryCount.toString());
this.openWSConnection({ handshakeTimeout: reconnectTimeout }, true);
- this.hasSocketRestarted = true;
+ this.wsConnectionRestarted = true;
} else if (this.getAutoReconnectMaxRetries() !== -1) {
logger.error(`${this.logPrefix()} Socket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
}