@routr/dispatcher 2.0.5-alpha.2 → 2.0.5-alpha.3

package/dist/config/get_config.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -34,21 +23,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfig = void 0;
-var fs_1 = __importDefault(require("fs"));
-var schema_1 = require("./schema");
-var ajv_1 = __importDefault(require("ajv"));
-var E = __importStar(require("fp-ts/Either"));
-var ajv = new ajv_1.default();
-var validate = ajv.compile(schema_1.schema);
-var getConfig = function (path) {
-    var c = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
-    if (!validate(__assign({}, c))) {
+const fs_1 = __importDefault(require("fs"));
+const schema_1 = require("./schema");
+const ajv_1 = __importDefault(require("ajv"));
+const E = __importStar(require("fp-ts/Either"));
+const ajv = new ajv_1.default();
+const validate = ajv.compile(schema_1.schema);
+const getConfig = (path) => {
+    const c = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
+    if (!validate(Object.assign({}, c))) {
         return E.left(new Error(JSON.stringify(validate.errors[0].message)));
     }
     // convert funcMatch to actual functions
-    var processors = c.spec.processors.map(function (p) {
-        var ref = p.ref, isFallback = p.isFallback, addr = p.addr, methods = p.methods, matchFunc = p.matchFunc;
-        return { ref: ref, isFallback: isFallback, addr: addr, methods: methods, matchFunc: eval("(" + p.matchFunc + ")") };
+    const processors = c.spec.processors.map((p) => {
+        const { ref, isFallback, addr, methods, matchFunc } = p;
+        return { ref, isFallback, addr, methods, matchFunc: eval(`(${p.matchFunc})`) };
     });
     // Re-insert processors with matchFunc now as a function
     c.spec.processors = processors;

package/dist/connections.d.ts

@@ -1,5 +1,4 @@
 import { ProcessorGPRCConnection } from "./types";
-import { ProcessorConfig } from "@routr/common";
 /**
  * Creates a connection to all the backend processors. The function will
  * fail if any of the backends is unavailable during initialization.
@@ -7,4 +6,7 @@ import { ProcessorConfig } from "@routr/common";
  * @param processors list of backend processors
  * @returns list of connections
  */
-export default function connectToBackendProcessors(processors: ProcessorConfig[]): Map<string, ProcessorGPRCConnection>;
+export default function connectToBackend(processors: {
+    ref: string;
+    addr: string;
+}[]): Map<string, ProcessorGPRCConnection>;

package/dist/connections.js

@@ -1,39 +1,7 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("@routr/common");
-var grpc = require("@grpc/grpc-js");
+const common_1 = require("@routr/common");
+const grpc = require("@grpc/grpc-js");
 /**
  * Creates a connection to all the backend processors. The function will
  * fail if any of the backends is unavailable during initialization.
@@ -41,23 +9,12 @@ var grpc = require("@grpc/grpc-js");
  * @param processors list of backend processors
  * @returns list of connections
  */
-function connectToBackendProcessors(processors) {
-    var e_1, _a;
-    var procs = __spreadArray([], __read(processors));
-    var connections = new Map();
-    try {
-        for (var procs_1 = __values(procs), procs_1_1 = procs_1.next(); !procs_1_1.done; procs_1_1 = procs_1.next()) {
-            var processor = procs_1_1.value;
-            connections.set(processor.ref, new common_1.PROCESSOR_OBJECT_PROTO.Processor(processor.addr, grpc.credentials.createInsecure()));
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (procs_1_1 && !procs_1_1.done && (_a = procs_1.return)) _a.call(procs_1);
-        }
-        finally { if (e_1) throw e_1.error; }
+function connectToBackend(processors) {
+    const procs = processors ? [...processors] : [];
+    const connections = new Map();
+    for (const processor of procs) {
+        connections.set(processor.ref, new common_1.PROCESSOR_OBJECT_PROTO.Processor(processor.addr, grpc.credentials.createInsecure()));
     }
     return connections;
 }
-exports.default = connectToBackendProcessors;
+exports.default = connectToBackend;

package/dist/errors.d.ts

@@ -7,3 +7,7 @@ export declare class ProcessorUnavailableError extends Error {
     code: number;
     constructor(ref: string);
 }
+export declare class MiddlewareUnavailableError extends Error {
+    code: number;
+    constructor(ref: string);
+}

package/dist/errors.js

@@ -1,21 +1,6 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessorUnavailableError = exports.NotMatchingProcessorFound = void 0;
+exports.MiddlewareUnavailableError = exports.ProcessorUnavailableError = exports.NotMatchingProcessorFound = void 0;
 /*
  * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/routr
@@ -34,28 +19,31 @@ exports.ProcessorUnavailableError = exports.NotMatchingProcessorFound = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var grpc = require("@grpc/grpc-js");
-var NotMatchingProcessorFound = /** @class */ (function (_super) {
-    __extends(NotMatchingProcessorFound, _super);
-    function NotMatchingProcessorFound(ref) {
-        var _this = _super.call(this, "not matching processor found for request ref: " + ref) || this;
-        _this.code = grpc.status.NOT_FOUND;
+const grpc = require("@grpc/grpc-js");
+class NotMatchingProcessorFound extends Error {
+    constructor(ref) {
+        super(`not matching processor found for request ref: ${ref}`);
+        this.code = grpc.status.NOT_FOUND;
         // Set the prototype explicitly.
-        Object.setPrototypeOf(_this, NotMatchingProcessorFound.prototype);
-        return _this;
+        Object.setPrototypeOf(this, NotMatchingProcessorFound.prototype);
     }
-    return NotMatchingProcessorFound;
-}(Error));
+}
 exports.NotMatchingProcessorFound = NotMatchingProcessorFound;
-var ProcessorUnavailableError = /** @class */ (function (_super) {
-    __extends(ProcessorUnavailableError, _super);
-    function ProcessorUnavailableError(ref) {
-        var _this = _super.call(this, "processor ref = " + ref + " is unavailable") || this;
-        _this.code = grpc.status.UNAVAILABLE;
+class ProcessorUnavailableError extends Error {
+    constructor(ref) {
+        super(`processor ref = ${ref} is unavailable`);
+        this.code = grpc.status.UNAVAILABLE;
         // Set the prototype explicitly.
-        Object.setPrototypeOf(_this, NotMatchingProcessorFound.prototype);
-        return _this;
+        Object.setPrototypeOf(this, ProcessorUnavailableError.prototype);
     }
-    return ProcessorUnavailableError;
-}(Error));
+}
 exports.ProcessorUnavailableError = ProcessorUnavailableError;
+class MiddlewareUnavailableError extends Error {
+    constructor(ref) {
+        super(`middleware ref = ${ref} is unavailable`);
+        this.code = grpc.status.UNAVAILABLE;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MiddlewareUnavailableError.prototype);
+    }
+}
+exports.MiddlewareUnavailableError = MiddlewareUnavailableError;

package/dist/find_processor.js

@@ -1,21 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findProcessor = exports.filter = exports.hasMethod = void 0;
-var errors_1 = require("./errors");
-var hasMethod = function (config, request) {
-    return config.methods.includes(request.method);
-};
+const errors_1 = require("./errors");
+const hasMethod = (config, request) => config.methods.includes(request.method);
 exports.hasMethod = hasMethod;
 // TODO: We need a way to test the matching function
-var filter = function (request, config) {
-    return exports.hasMethod(config, request)
-        && (config.isFallback || config.matchFunc(request));
-};
+const filter = (request, config) => exports.hasMethod(config, request)
+    && (config.isFallback || config.matchFunc(request));
 exports.filter = filter;
-var findProcessor = function (list) {
-    return function (request) {
-        return list.find(function (config) { return exports.filter(request, config); })
-            || new errors_1.NotMatchingProcessorFound(request.ref);
-    };
-};
+const findProcessor = (list) => (request) => list.find((config) => exports.filter(request, config))
+    || new errors_1.NotMatchingProcessorFound(request.ref);
 exports.findProcessor = findProcessor;

package/dist/processor.d.ts

@@ -1,6 +1,7 @@
-import { MessageRequest, ProcessorConfig } from "@routr/common";
-import { NotMatchingProcessorFound, ProcessorUnavailableError } from "./errors";
-declare type CallbackErrors = NotMatchingProcessorFound | ProcessorUnavailableError | Error;
-declare type ProcessorCallback = (err: CallbackErrors, reponse?: MessageRequest) => void;
-export default function processor(configList: Array<ProcessorConfig>): (call: any, callback: ProcessorCallback) => void;
-export {};
+import { ProcessorConfig } from "@routr/common";
+import { ProcessorCallback } from "./types";
+import { MiddlewareConfig } from "@routr/common/src/types";
+export default function processor(params: {
+    processors: ProcessorConfig[];
+    middlewares?: MiddlewareConfig[];
+}): (call: any, callback: ProcessorCallback) => void;

package/dist/processor.js

@@ -21,31 +21,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var find_processor_1 = require("./find_processor");
-var connections_1 = __importDefault(require("./connections"));
-var errors_1 = require("./errors");
-var grpc = require("@grpc/grpc-js");
-function processor(configList) {
-    var connections = connections_1.default(configList);
+const connections_1 = __importDefault(require("./connections"));
+const run_processor_1 = require("./run_processor");
+const run_middlewares_1 = require("./run_middlewares");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+function processor(params) {
+    const { processors, middlewares } = params;
+    const procConns = connections_1.default(processors);
+    const middConns = connections_1.default(middlewares);
     // Upstream request and callback
-    return function (call, callback) {
-        var request = call.request;
-        var matchResult = find_processor_1.findProcessor(configList)(request);
-        if ('ref' in matchResult) {
-            var conn = connections.get(matchResult.ref);
-            // Connects to downstream processor
-            conn.processMessage(request, function (err, response) {
-                if ((err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE) {
-                    // We aument the error to indicate which processor failed
-                    callback(new errors_1.ProcessorUnavailableError(matchResult.ref));
-                    return;
-                }
-                callback(err, response);
-            });
-        }
-        else {
-            callback(matchResult);
+    return (call, callback) => {
+        const { request } = call;
+        // Messages type reponse will not be sent to middleware chain
+        if (request.message.message_type === 'response_type') {
+            return run_processor_1.runProcessor({ callback, request, processors, connections: procConns });
         }
+        run_middlewares_1.runMiddlewares({ callback, request, middlewares, connections: middConns })
+            .then((req) => {
+            // Since the chain was broken we need to skip the processor and return the updated request
+            if (req.message.message_type === "response_type") {
+                logger_1.default.verbose("skipped processsing request ref " + req.ref);
+                return callback(null, req);
+            }
+            run_processor_1.runProcessor({ callback, request: req, processors, connections: procConns });
+        })
+            .catch(callback);
     };
 }
 exports.default = processor;

package/dist/run_middlewares.d.ts

@@ -0,0 +1,3 @@
+import { RunMiddlewaresParams } from "./types";
+import { MessageRequest } from "@routr/common";
+export declare function runMiddlewares(params: RunMiddlewaresParams): Promise<MessageRequest>;

package/dist/run_middlewares.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMiddlewares = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const errors_1 = require("./errors");
+const grpc = require("@grpc/grpc-js");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+function processMessage(middlewareRef, conn, request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            conn.processMessage(request, (err, response) => {
+                return (err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE
+                    ? reject(new errors_1.MiddlewareUnavailableError(middlewareRef))
+                    : resolve(response);
+            });
+        });
+    });
+}
+function runMiddlewares(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { connections, request, middlewares = [] } = params;
+        const req = Object.assign({}, request);
+        return new Promise((resolve, rejects) => __awaiter(this, void 0, void 0, function* () {
+            for (const midd of middlewares) {
+                logger_1.default.verbose("forwarding request to middleware with ref => " + midd.ref);
+                // Get the next middleware
+                const conn = connections.get(midd.ref);
+                // Send message and re-insert response for next middleware
+                try {
+                    req.message = (yield processMessage(midd.ref, conn, req)).message;
+                    if (req.message.message_type === "response_type") {
+                        logger_1.default.verbose("found message_type to be response_type and broke the chain");
+                        break;
+                    }
+                }
+                catch (e) {
+                    rejects(e);
+                }
+            }
+            resolve(req);
+        }));
+    });
+}
+exports.runMiddlewares = runMiddlewares;

package/dist/run_processor.d.ts

@@ -0,0 +1,2 @@
+import { RunProcessorParams } from "./types";
+export declare function runProcessor(params: RunProcessorParams): any;

package/dist/run_processor.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcessor = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const errors_1 = require("./errors");
+const find_processor_1 = require("./find_processor");
+const grpc = require("@grpc/grpc-js");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+function runProcessor(params) {
+    const { callback, connections, processors, request } = params;
+    const matchResult = find_processor_1.findProcessor(processors)(request);
+    if ('code' in matchResult) {
+        return callback(matchResult);
+    }
+    logger_1.default.verbose("forwarding request to processor with ref => " + matchResult.ref);
+    const conn = connections.get(matchResult.ref);
+    // Connects to downstream processor
+    conn.processMessage(request, (err, response) => {
+        if ((err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE) {
+            // We augment the error to indicate which processor failed
+            callback(new errors_1.ProcessorUnavailableError(matchResult.ref));
+            return;
+        }
+        callback(err, response);
+    });
+}
+exports.runProcessor = runProcessor;

package/dist/runner.js

@@ -22,12 +22,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var service_1 = __importDefault(require("./service"));
-var get_config_1 = require("./config/get_config");
-var result = get_config_1.getConfig(process.env.CONFIG_PATH);
+const service_1 = __importDefault(require("./service"));
+const get_config_1 = require("./config/get_config");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+const result = get_config_1.getConfig(process.env.CONFIG_PATH);
 if (result._tag === 'Right') {
     service_1.default(result.right);
 }
 else {
-    console.log(result.left);
+    logger_1.default.error(result.left);
 }

package/dist/service.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("@routr/common");
-var util_1 = require("./util");
+const common_1 = require("@routr/common");
+const util_1 = require("./util");
 function MessageDispatcher(config) {
-    var bindAddr = config.bindAddr, processors = config.processors;
-    common_1.createService(util_1.getServiceInfo(bindAddr, processors));
+    const { bindAddr, processors, middlewares } = config;
+    common_1.createService(util_1.getServiceInfo(bindAddr, { processors, middlewares }));
 }
 exports.default = MessageDispatcher;

package/dist/types.d.ts

@@ -1,8 +1,25 @@
-import { ProcessorConfig } from "@routr/common";
+import { MessageRequest, ProcessorConfig } from "@routr/common";
+import { MiddlewareConfig } from "@routr/common/src/types";
+import { NotMatchingProcessorFound, ProcessorUnavailableError } from "./errors";
 export interface MessageDispatcherConfig {
     bindAddr: string;
-    processors: Array<ProcessorConfig>;
+    processors: ProcessorConfig[];
+    middlewares: MiddlewareConfig[];
 }
 export interface ProcessorGPRCConnection {
     processMessage: (request: unknown, callback: Function) => void;
 }
+export declare type CallbackErrors = NotMatchingProcessorFound | ProcessorUnavailableError | Error;
+export declare type ProcessorCallback = (err: CallbackErrors, reponse?: MessageRequest) => void;
+export interface RunProcessorParams {
+    callback: Function;
+    connections: Map<string, ProcessorGPRCConnection>;
+    processors: ProcessorConfig[];
+    request: MessageRequest;
+}
+export interface RunMiddlewaresParams {
+    callback: Function;
+    connections: Map<string, ProcessorGPRCConnection>;
+    middlewares: MiddlewareConfig[];
+    request: MessageRequest;
+}

package/dist/util.d.ts

@@ -1,2 +1,6 @@
 import { ProcessorConfig, ServiceInfo } from "@routr/common";
-export declare function getServiceInfo(bindAddr: string, processors: ProcessorConfig[]): ServiceInfo;
+import { MiddlewareConfig } from "@routr/common/src/types";
+export declare function getServiceInfo(bindAddr: string, backends: {
+    middlewares: MiddlewareConfig[];
+    processors: ProcessorConfig[];
+}): ServiceInfo;

package/dist/util.js

@@ -22,15 +22,15 @@ exports.getServiceInfo = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var processor_1 = __importDefault(require("./processor"));
-var common_1 = require("@routr/common");
-function getServiceInfo(bindAddr, processors) {
+const processor_1 = __importDefault(require("./processor"));
+const common_1 = require("@routr/common");
+function getServiceInfo(bindAddr, backends) {
     return {
         name: "dispatcher",
-        bindAddr: bindAddr,
+        bindAddr,
         service: common_1.PROCESSOR_OBJECT_PROTO.Processor.service,
         handlers: {
-            processMessage: processor_1.default(processors)
+            processMessage: processor_1.default(backends)
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routr/dispatcher",
-  "version": "2.0.5-alpha.2",
+  "version": "2.0.5-alpha.3",
   "description": "Receives SIP messages and forwards them to the corresponding Message Processor",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/routr#readme",
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@routr/common": "^2.0.5-alpha.2",
+    "@routr/common": "^2.0.5-alpha.3",
     "ajv": "^6.12.6",
     "fp-ts": "^2.11.8"
   },
@@ -36,5 +36,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/routr/issues"
   },
-  "gitHead": "3570106be9a96cb6672de4a850a377bfa7d9bb3e"
+  "gitHead": "7d942466133a03f4bcfe0dc100f1a922b3ed14ad"
 }