cloudcms-server 0.9.270 → 0.9.271

package/temp/node-http-proxy/lib/http-proxy/passes/ws-incoming.js

@@ -0,0 +1,179 @@
+const http = require('http'),
+  https = require('https'),
+  common = require('../common');
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, socket, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+/*
+ * Websockets Passes
+ *
+ */
+
+module.exports = {
+  /**
+   * WebSocket requests must have the `GET` method and
+   * the `upgrade:websocket` header
+   *
+   * @param {ClientRequest} req Request object
+   * @param {Socket} socket
+   *
+   * @api private
+   */
+
+  checkMethodAndHeader: function checkMethodAndHeader(req, socket) {
+    if (req.method !== 'GET' || !req.headers.upgrade) {
+      socket.destroy();
+      return true;
+    }
+
+    if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+      socket.destroy();
+      return true;
+    }
+  },
+
+  /**
+   * Sets `x-forwarded-*` headers if specified in config.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {Socket} socket
+   * @param {Object} options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  XHeaders: function XHeaders(req, socket, options) {
+    if (!options.xfwd) return;
+
+    const values = {
+      for: req.connection.remoteAddress || req.socket.remoteAddress,
+      port: common.getPort(req),
+      proto: common.hasEncryptedConnection(req) ? 'wss' : 'ws',
+    };
+
+    ['for', 'port', 'proto'].forEach(function (header) {
+      req.headers['x-forwarded-' + header] =
+        (req.headers['x-forwarded-' + header] || '') +
+        (req.headers['x-forwarded-' + header] ? ',' : '') +
+        values[header];
+    });
+  },
+
+  /**
+   * Does the actual proxying. Make the request and upgrade it
+   * send the Switching Protocols request and pipe the sockets.
+   *
+   * @param {ClientRequest} req Request object
+   * @param {Socket} socket
+   * @param {Object} options Config object passed to the proxy
+   *
+   * @api private
+   */
+  stream: function stream(req, socket, options, head, server, clb) {
+    const createHttpHeader = function (line, headers) {
+      return (
+        Object.keys(headers)
+          .reduce(
+            function (head, key) {
+              const value = headers[key];
+
+              if (!Array.isArray(value)) {
+                head.push(key + ': ' + value);
+                return head;
+              }
+
+              for (let i = 0; i < value.length; i++) {
+                head.push(key + ': ' + value[i]);
+              }
+              return head;
+            },
+            [line],
+          )
+          .join('\r\n') + '\r\n\r\n'
+      );
+    };
+
+    common.setupSocket(socket);
+
+    if (head && head.length) socket.unshift(head);
+
+    const proxyReq = (
+      common.isSSL.test(options.target.protocol) ? https : http
+    ).request(common.setupOutgoing(options.ssl || {}, options, req));
+
+    // Enable developers to modify the proxyReq before headers are sent
+    if (server) {
+      server.emit('proxyReqWs', proxyReq, req, socket, options, head);
+    }
+
+    // Error Handler
+    proxyReq.on('error', onOutgoingError);
+    proxyReq.on('response', function (res) {
+      // if upgrade event isn't going to happen, close the socket
+      if (!res.upgrade) {
+        socket.write(
+          createHttpHeader(
+            'HTTP/' +
+              res.httpVersion +
+              ' ' +
+              res.statusCode +
+              ' ' +
+              res.statusMessage,
+            res.headers,
+          ),
+        );
+        res.pipe(socket);
+      }
+    });
+
+    proxyReq.on('upgrade', function (proxyRes, proxySocket, proxyHead) {
+      proxySocket.on('error', onOutgoingError);
+
+      // Allow us to listen when the websocket has completed
+      proxySocket.on('end', function () {
+        server.emit('close', proxyRes, proxySocket, proxyHead);
+      });
+
+      // The pipe below will end proxySocket if socket closes cleanly, but not
+      // if it errors (eg, vanishes from the net and starts returning
+      // EHOSTUNREACH). We need to do that explicitly.
+      socket.on('error', function () {
+        proxySocket.end();
+      });
+
+      common.setupSocket(proxySocket);
+
+      if (proxyHead && proxyHead.length) proxySocket.unshift(proxyHead);
+
+      //
+      // Remark: Handle writing the headers to the socket when switching protocols
+      // Also handles when a header is an array
+      //
+      socket.write(
+        createHttpHeader('HTTP/1.1 101 Switching Protocols', proxyRes.headers),
+      );
+
+      proxySocket.pipe(socket).pipe(proxySocket);
+
+      server.emit('open', proxySocket);
+      server.emit('proxySocket', proxySocket); //DEPRECATED.
+    });
+
+    return proxyReq.end(); // XXX: CHECK IF THIS IS THIS CORRECT
+
+    function onOutgoingError(err) {
+      if (clb) {
+        clb(err, req, socket);
+      } else {
+        server.emit('error', err, req, socket);
+      }
+      socket.end();
+    }
+  },
+};

package/temp/node-http-proxy/lib/index.ts

@@ -0,0 +1,13 @@
+/*!
+ * Caron dimonio, con occhi di bragia
+ * loro accennando, tutte le raccoglie;
+ * batte col remo qualunque s’adagia
+ *
+ * Charon the demon, with the eyes of glede,
+ * Beckoning to them, collects them all together,
+ * Beats with his oar whoever lags behind
+ *
+ *          Dante - The Divine Comedy (Canto III)
+ */
+
+export = './http-proxy';

package/temp/node-http-proxy/lib/types.d.ts

@@ -0,0 +1,277 @@
+// Type definitions for node-http-proxy 1.17
+// Project: https://github.com/nodejitsu/node-http-proxy
+// Definitions by: Maxime LUCE <https://github.com/SomaticIT>
+//                 Florian Oellerich <https://github.com/Raigen>
+//                 Daniel Schmidt <https://github.com/DanielMSchmidt>
+//                 Jordan Abreu <https://github.com/jabreu610>
+//                 Samuel Bodin <https://github.com/bodinsamuel>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+/// <reference types="node" />
+
+import * as net from 'net';
+import * as http from 'http';
+import * as events from 'events';
+import * as url from 'url';
+import * as stream from 'stream';
+
+interface ProxyTargetDetailed {
+  host: string;
+  port: number;
+  protocol?: string | undefined;
+  hostname?: string | undefined;
+  socketPath?: string | undefined;
+  key?: string | undefined;
+  passphrase?: string | undefined;
+  pfx?: Buffer | string | undefined;
+  cert?: string | undefined;
+  ca?: string | undefined;
+  ciphers?: string | undefined;
+  secureProtocol?: string | undefined;
+}
+
+declare class Server extends events.EventEmitter {
+  /**
+   * Creates the proxy server with specified options.
+   * @param options - Config object passed to the proxy
+   */
+  constructor(options?: Server.ServerOptions);
+
+  /**
+   * Used for proxying regular HTTP(S) requests
+   * @param req - Client request.
+   * @param res - Client response.
+   * @param options - Additional options.
+   */
+  web(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    options?: Server.ServerOptions,
+    callback?: Server.ErrorCallback,
+  ): void;
+
+  /**
+   * Used for proxying regular HTTP(S) requests
+   * @param req - Client request.
+   * @param socket - Client socket.
+   * @param head - Client head.
+   * @param options - Additionnal options.
+   */
+  ws(
+    req: http.IncomingMessage,
+    socket: any,
+    head: any,
+    options?: Server.ServerOptions,
+    callback?: Server.ErrorCallback,
+  ): void;
+
+  /**
+   * A function that wraps the object in a webserver, for your convenience
+   * @param port - Port to listen on
+   */
+  listen(port: number): Server;
+
+  /**
+   * A function that closes the inner webserver and stops listening on given port
+   */
+  close(callback?: () => void): void;
+
+  /**
+   * Creates the proxy server with specified options.
+   * @param options Config object passed to the proxy
+   * @returns Proxy object with handlers for `ws` and `web` requests
+   */
+  static createProxyServer(options?: Server.ServerOptions): Server;
+
+  /**
+   * Creates the proxy server with specified options.
+   * @param options Config object passed to the proxy
+   * @returns Proxy object with handlers for `ws` and `web` requests
+   */
+  static createServer(options?: Server.ServerOptions): Server;
+
+  /**
+   * Creates the proxy server with specified options.
+   * @param options Config object passed to the proxy
+   * @returns Proxy object with handlers for `ws` and `web` requests
+   */
+  static createProxy(options?: Server.ServerOptions): Server;
+
+  addListener(event: string, listener: () => void): this;
+
+  on(event: string, listener: () => void): this;
+  on(event: 'error', listener: Server.ErrorCallback): this;
+  on(event: 'start', listener: Server.StartCallback): this;
+  on(event: 'proxyReq', listener: Server.ProxyReqCallback): this;
+  on(event: 'proxyRes', listener: Server.ProxyResCallback): this;
+  on(event: 'proxyReqWs', listener: Server.ProxyReqWsCallback): this;
+  on(event: 'econnreset', listener: Server.EconnresetCallback): this;
+  on(event: 'end', listener: Server.EndCallback): this;
+  on(event: 'open', listener: Server.OpenCallback): this;
+  on(event: 'close', listener: Server.CloseCallback): this;
+
+  once(event: string, listener: () => void): this;
+  once(event: 'error', listener: Server.ErrorCallback): this;
+  once(event: 'start', listener: Server.StartCallback): this;
+  once(event: 'proxyReq', listener: Server.ProxyReqCallback): this;
+  once(event: 'proxyRes', listener: Server.ProxyResCallback): this;
+  once(event: 'proxyReqWs', listener: Server.ProxyReqWsCallback): this;
+  once(event: 'econnreset', listener: Server.EconnresetCallback): this;
+  once(event: 'end', listener: Server.EndCallback): this;
+  once(event: 'open', listener: Server.OpenCallback): this;
+  once(event: 'close', listener: Server.CloseCallback): this;
+
+  removeListener(event: string, listener: () => void): this;
+
+  removeAllListeners(event?: string): this;
+
+  getMaxListeners(): number;
+
+  setMaxListeners(n: number): this;
+
+  listeners(event: string): Array<() => void>;
+
+  emit(event: string, ...args: any[]): boolean;
+
+  listenerCount(type: string): number;
+}
+
+declare namespace Server {
+  type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
+  type ProxyTargetUrl = string | Partial<url.Url>;
+
+  interface ServerOptions {
+    /** URL string to be parsed with the url module. */
+    target?: ProxyTarget | undefined;
+    /** URL string to be parsed with the url module. */
+    forward?: ProxyTargetUrl | undefined;
+    /** Object to be passed to http(s).request. */
+    agent?: any;
+    /** Object to be passed to https.createServer(). */
+    ssl?: any;
+    /** If you want to proxy websockets. */
+    ws?: boolean | undefined;
+    /** Adds x- forward headers. */
+    xfwd?: boolean | undefined;
+    /** Verify SSL certificate. */
+    secure?: boolean | undefined;
+    /** Explicitly specify if we are proxying to another proxy. */
+    toProxy?: boolean | undefined;
+    /** Specify whether you want to prepend the target's path to the proxy path. */
+    prependPath?: boolean | undefined;
+    /** Specify whether you want to ignore the proxy path of the incoming request. */
+    ignorePath?: boolean | undefined;
+    /** Local interface string to bind for outgoing connections. */
+    localAddress?: string | undefined;
+    /** Changes the origin of the host header to the target URL. */
+    changeOrigin?: boolean | undefined;
+    /** specify whether you want to keep letter case of response header key */
+    preserveHeaderKeyCase?: boolean | undefined;
+    /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+    auth?: string | undefined;
+    /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+    hostRewrite?: string | undefined;
+    /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+    autoRewrite?: boolean | undefined;
+    /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+    protocolRewrite?: string | undefined;
+    /** rewrites domain of set-cookie headers. */
+    cookieDomainRewrite?:
+      | false
+      | string
+      | { [oldDomain: string]: string }
+      | undefined;
+    /** rewrites path of set-cookie headers. Default: false */
+    cookiePathRewrite?:
+      | false
+      | string
+      | { [oldPath: string]: string }
+      | undefined;
+    /** object with extra headers to be added to target requests. */
+    headers?: { [header: string]: string } | undefined;
+    /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+    proxyTimeout?: number | undefined;
+    /** Timeout (in milliseconds) for incoming requests */
+    timeout?: number | undefined;
+    /** Specify whether you want to follow redirects. Default: false */
+    followRedirects?: boolean | undefined;
+    /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+    selfHandleResponse?: boolean | undefined;
+    /** Buffer */
+    buffer?: stream.Stream | undefined;
+  }
+
+  type StartCallback<
+    TIncomingMessage = http.IncomingMessage,
+    TServerResponse = http.ServerResponse,
+  > = (
+    req: TIncomingMessage,
+    res: TServerResponse,
+    target: ProxyTargetUrl,
+  ) => void;
+  type ProxyReqCallback<
+    TClientRequest = http.ClientRequest,
+    TIncomingMessage = http.IncomingMessage,
+    TServerResponse = http.ServerResponse,
+  > = (
+    proxyReq: TClientRequest,
+    req: TIncomingMessage,
+    res: TServerResponse,
+    options: ServerOptions,
+  ) => void;
+  type ProxyResCallback<
+    TIncomingMessage = http.IncomingMessage,
+    TServerResponse = http.ServerResponse,
+  > = (
+    proxyRes: TIncomingMessage,
+    req: TIncomingMessage,
+    res: TServerResponse,
+  ) => void;
+  type ProxyReqWsCallback<
+    TClientRequest = http.ClientRequest,
+    TIncomingMessage = http.IncomingMessage,
+  > = (
+    proxyReq: TClientRequest,
+    req: TIncomingMessage,
+    socket: net.Socket,
+    options: ServerOptions,
+    head: any,
+  ) => void;
+  type EconnresetCallback<
+    TError = Error,
+    TIncomingMessage = http.IncomingMessage,
+    TServerResponse = http.ServerResponse,
+  > = (
+    err: TError,
+    req: TIncomingMessage,
+    res: TServerResponse,
+    target: ProxyTargetUrl,
+  ) => void;
+  type EndCallback<
+    TIncomingMessage = http.IncomingMessage,
+    TServerResponse = http.ServerResponse,
+  > = (
+    req: TIncomingMessage,
+    res: TServerResponse,
+    proxyRes: TIncomingMessage,
+  ) => void;
+  type OpenCallback = (proxySocket: net.Socket) => void;
+  type CloseCallback<TIncomingMessage = http.IncomingMessage> = (
+    proxyRes: TIncomingMessage,
+    proxySocket: net.Socket,
+    proxyHead: any,
+  ) => void;
+  type ErrorCallback<
+    TError = Error,
+    TIncomingMessage = http.IncomingMessage,
+    TServerResponse = http.ServerResponse,
+  > = (
+    err: TError,
+    req: TIncomingMessage,
+    res: TServerResponse | net.Socket,
+    target?: ProxyTargetUrl,
+  ) => void;
+}
+
+export = Server;