}, (err, stats) => {
    if (err) {
      console.error('Failed to create a production build. Reason:');
      console.error(err.message || err);
      process.exit(1);
    }

    console.log(stats.toString({
      chunks: false,
      colors: true
    }));

    const completionTime = Math.round((new Date().getTime() - startTime) / 1000 * 100) / 100;
    log('------------------------------------------');
    log(`=== Compilation and bundling completed in ${completionTime} sec.`);
    log('------------------------------------------');
    log('===== Waiting for changes... ======')
  })

export function bundleTypescriptAndWatch({entries}) {
  const webpackEntry = {};

  entries.forEach((entry) => {
    webpackEntry['build/' + entry.name + '/bundle'] = entry.src;
  });

  config.entry = webpackEntry;

  const compiler = webpack(config);

  console.log();
  log('------------------------------------------');
  log(`===> Starting compilation and bundling... `);
  log('------------------------------------------');

  let startTime = new Date().getTime();

  compiler['plugin']('invalid', () => {
    log('==== Change detected. Compiling... =====');
    startTime = new Date().getTime();
  });

  compiler.watch({
    poll: true
  }, (err, stats) => {
    if (err) {
      console.error('Failed to create a production build. Reason:');
      console.error(err.message || err);
      process.exit(1);
    }

    console.log(stats.toString({
      chunks: false,
      colors: true
    }));

    const completionTime = Math.round((new Date().getTime() - startTime) / 1000 * 100) / 100;
    log('------------------------------------------');
    log(`=== Compilation and bundling completed in ${completionTime} sec.`);
    log('------------------------------------------');
    log('===== Waiting for changes... ======')
  })
}

                this._codecs.forEach((codec) => {
                    if (codec.context == context) {
                        let result = null;

                        try {
                            result = Hcp.decode(codec.id, this.toArrayBuffer(data), size);
                        } catch (error) {
                            util.log(JSON.stringify(error));
                            return;
                        }

                        try {
                            codec.receive(result);
                        } catch (error) {
                            util.log(JSON.stringify(error));
                        }

                        results.push(result);
                    }
                });

    // see https://github.com/tutumcloud/haproxy
    //     https://serversforhackers.com/load-balancing-with-haproxy
    /**
     * Generate config and restart haproxy
     */
    async apply() {
        util.log("Generating new haproxy configuration file...");

        const config = await this.transform(false);
        if (config) {
            fs.writeFileSync(this.configFileName, config);
        }
        else {
            shell.rm(this.configFileName);
        }

        this.proxyManager.restart();
    }

    /**
     * Emit front definition with ssl certificats list for all tenants
     * Bind on port 443 or port 80 in test mode
     */
    private async emitBinding(dryrun: boolean) {
        this.frontends.push("frontend vulcain");

        if (CONTEXT.isTest()) {
            this.frontends.push(`  bind *:80`);
            return true;
        }

        // Create certificates list for https binding
        let crtFileName = Path.join(this.proxyManager.engine.configurationsFolder, "list.crt");
        let crtList = this.def.wildcardDomains.map(this.createCertificateFileName.bind(this))

        let hasFrontEnds = false;

        if (this.def.rules) {
            for (const rule of this.def.rules) {
                hasFrontEnds = true;
                if (rule && rule.tlsDomain) {
                    let domainName = rule.tlsDomain;

                    try {
                        if (domainName) {
                            let fullName = this.createCertificateFileName(domainName);
                            if (crtList.indexOf(fullName) < 0) {
                                if (!dryrun) {
                                    // Ensures certificate exist
                                    await this.proxyManager.createCertificate(domainName, this.def.tlsEmail);
                                }
                                crtList.push(fullName);
                            }
                        }
                    }
                    catch (e) {
                        util.log("Certificate creation for domain " + domainName + " failed. " + e.message);
                    }
                }
            }
        }
        if (!dryrun) {
            fs.writeFileSync(crtFileName, crtList.join('\n'));
        }

        if (crtList.length > 0) {
            this.frontends.push(`  bind *:443 ssl crt-list ${crtFileName}`);
        }
        else {
            this.frontends.push(`  bind *:80`);
        }

        return hasFrontEnds;
    }

 router.use((req: Request, res: Response, next: any)=> {
   util.log(util.format("Request to: %s:%s -- Params:%s",
     req.url, req.method, JSON.stringify(req.body)));
   res.setHeader('Access-Control-Allow-Credentials', "true");
   res.header("Access-Control-Allow-Origin", req.header("Origin"));
   res.header("Access-Control-Allow-Methods", "GET,POST,PUT,HEAD,DELETE,OPTIONS");
   res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
   if ('OPTIONS' == req.method) {
     res.sendStatus(200);
   }
   else {
     next();
   }
 });

    private emitBackends(rule: RuleDefinition, aclIf: string, path: string, cx: number) {

        let serviceName = `${rule.serviceName.replace(/\./g, "-")}_${cx}`;
        let backend = "backend_" + serviceName;

        this.frontends.push("  use_backend " + backend + aclIf);

        this.backends.push("");
        this.backends.push("# " + rule.serviceName);
        this.backends.push("backend " + backend);

        this.backends.push("  option forwardfor");
        this.backends.push("  http-request set-header X-Forwarded-Port %[dst_port]");
        this.backends.push("  http-request add-header X-Forwarded-Proto https if { ssl_fc }");
        this.backends.push("  mode http");

        // Path rewriting
        if (rule.pathRewrite && path) {
            this.backends.push(`  http-request add-header x-vulcain-publicpath ${rule.path}`);
            let rw = rule.pathRewrite;
            let parts = rw.split(':');
            if (parts.length === 1) {
                // Replace path by pathRewrite
                this.backends.push("  reqrep ^([^\\ :]*)\\ " + path + "  \\1\\ " + rw + "\\2");
            } else if (parts.length === 2) {
                this.backends.push("  reqrep ^([^\\ :]*)\\ " + this.normalizeRegex(parts[0]) + "  \\1\\ " + this.normalizeRegex(parts[1]));
            }
            else {
                util.log(`Malformed rewriting path ${rw} is ignored for rule ${rule.id}`);
            }
        }

        if (rule.backendConfig) {
            let parts = rule.backendConfig.split(';').map(p => p && p.trim());
            parts.forEach(p => {
                if (p) {
                    this.backends.push(p);
                }
            });
        }
        this.backends.push("  server " + serviceName + " " + rule.serviceName + ":" + (rule.servicePort || "8080"));
    }

import * as util from "util";

util.log('Here is our TypeScript starter project for Node.js');

 compiler['plugin']('invalid', () => {
   log('==== Change detected. Compiling... =====');
   startTime = new Date().getTime();
 });

import { Server } from './server';
import { EngineFactory } from './host';
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   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.
//
//    Copyright (c) Zenasoft
//
const util = require('util');

// -------------------------------------------------------------------
// START
// -------------------------------------------------------------------
util.log("Vulcain load balancer - version 2.0.0");

process.on('unhandledRejection', function (reason, p) {
    console.log("Unhandled rejection at: Promise ", p, " reason: ", reason);
});

const engine = EngineFactory.createEngine();
const server = new Server(engine);
server.start();