openflow/OpenFlow/src/WebServer.ts at 0bf49cf9dea1f7e2e37cf22c507b34751dd6bf11 · ITCSsDeveloper/openflow · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import * as path from "path";
import * as winston from "winston";
import * as http from "http";
import * as https from "https";
import * as express from "express";
import * as compression from "compression";
import * as bodyParser from "body-parser";
import * as cookieParser from "cookie-parser";
import * as cookieSession from "cookie-session";
import * as crypto from "crypto";
import * as flash from "flash";
import * as morgan from "morgan";

import * as samlp from "samlp";
import { SamlProvider } from "./SamlProvider";
import { LoginProvider } from "./LoginProvider";
import { DatabaseConnection } from "./DatabaseConnection";
import { Config } from "./Config";

import * as promBundle from "express-prom-bundle";
import * as client from "prom-client";
import { NoderedUtil } from "openflow-api";
const { RateLimiterMemory } = require('rate-limiter-flexible')
import * as url from "url";

const BaseRateLimiter = new RateLimiterMemory({
    points: Config.api_rate_limit_points,
    duration: Config.api_rate_limit_duration,
});

const rateLimiter = (req: express.Request, res: express.Response, next: express.NextFunction): void => {
    BaseRateLimiter
        .consume(req.ip)
        .then((e) => {
            // console.log("API_O_RATE_LIMIT consumedPoints: " + e.consumedPoints + " remainingPoints: " + e.remainingPoints);
            next();
        })
        .catch((e) => {
            const route = url.parse(req.url).pathname;
            webserver_rate_limit.inc();
            webserver_rate_limit.labels(route).inc();
            console.log("API_RATE_LIMIT consumedPoints: " + e.consumedPoints + " remainingPoints: " + e.remainingPoints + " msBeforeNext: " + e.msBeforeNext);
            res.status(429).json({ response: 'RATE_LIMIT' });
        });
};
const webserver_rate_limit = new client.Counter({
    name: 'openflow_webserver_rate_limit_count',
    help: 'Total number of rate limited web request',
    labelNames: ["route"]
})

export class WebServer {
    private static _logger: winston.Logger;
    public static app: express.Express;

    static async configure(logger: winston.Logger, baseurl: string, register: client.Registry): Promise<http.Server> {
        this._logger = logger;

        this.app = express();
        if (!NoderedUtil.IsNullUndefinded(register)) {
            const metricsMiddleware = promBundle({ includeMethod: true, includePath: true, promRegistry: register, autoregister: true });
            this.app.use(metricsMiddleware);
            if (!NoderedUtil.IsNullUndefinded(register)) register.registerMetric(webserver_rate_limit);
        }

        const loggerstream = {
            write: function (message, encoding) {
                logger.silly(message);
            }
        };
        this.app.use(morgan('combined', { stream: loggerstream }));
        this.app.use(compression());
        this.app.use(bodyParser.urlencoded({ extended: true }));
        this.app.use(bodyParser.json());
        this.app.use(cookieParser());
        this.app.use(cookieSession({
            name: "session", secret: Config.cookie_secret
        }));
        this.app.use(flash());
        if (Config.api_rate_limit) this.app.use(rateLimiter);


        // Add headers
        this.app.use(function (req, res, next) {

            // Website you wish to allow to connect
            res.setHeader('Access-Control-Allow-Origin', '*');

            // Request methods you wish to allow
            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');

            // Request headers you wish to allow
            res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');

            // Set to true if you need the website to include cookies in the requests sent
            // to the API (e.g. in case you use sessions)
            res.setHeader('Access-Control-Allow-Credentials', "true");

            // Pass to next layer of middleware
            next();
        });
        this.app.use("/", express.static(path.join(__dirname, "/public")));
        await LoginProvider.configure(this._logger, this.app, baseurl);
        await SamlProvider.configure(this._logger, this.app, baseurl);
        let server: http.Server = null;
        if (Config.tls_crt != '' && Config.tls_key != '') {
            let options: any = {
                cert: Config.tls_crt,
                key: Config.tls_key
            };
            if (Config.tls_crt.indexOf("---") == -1) {
                options = {
                    cert: Buffer.from(Config.tls_crt, 'base64').toString('ascii'),
                    key: Buffer.from(Config.tls_key, 'base64').toString('ascii')
                };
            }
            let ca: string = Config.tls_ca;
            if (ca !== "") {
                if (ca.indexOf("---") === -1) {
                    ca = Buffer.from(Config.tls_ca, 'base64').toString('ascii');
                }
                options.ca = ca;
                // options.cert += "\n" + ca;
            }
            if (Config.tls_passphrase !== "") {
                options.passphrase = Config.tls_passphrase;
            }
            server = https.createServer(options, this.app);
        } else {
            server = http.createServer(this.app);
        }

        const port = Config.port;
        server.listen(port);
        return server;
    }
}