@abtnode/blocklet-services 1.6.26 → 1.6.29

package/lib/index.js

@@ -1,443 +0,0 @@
-const path = require('path');
-const http = require('http');
-const get = require('lodash/get');
-const morgan = require('morgan');
-const express = require('express');
-require('express-async-errors');
-const cors = require('cors');
-const compression = require('compression');
-const cookieParser = require('cookie-parser');
-const bodyParser = require('body-parser');
-const RotatingFileStream = require('rotating-file-stream');
-const httpProxy = require('http-proxy');
-const serveStatic = require('serve-static');
-const moment = require('dayjs');
-const minimatch = require('minimatch');
-const { NODE_SERVICES } = require('@abtnode/constant');
-const { BlockletEvents } = require('@blocklet/meta/lib/constants');
-const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
-const eventHub =
-  process.env.NODE_ENV === 'test' ? require('@arcblock/event-hub/single') : require('@arcblock/event-hub');
-const getBlockletInfo = require('@blocklet/meta/lib/info');
-
-const logger = require('@abtnode/logger')(require('../package.json').name);
-
-const authModule = require('../services/auth');
-
-const mount = require('./mount');
-const cache = require('./cache');
-const { ensureProxyUrl } = require('./util');
-
-const logFileGenerator = (time, index) => {
-  if (!time) {
-    return 'service.log';
-  }
-
-  let filename = `service-${moment(time).subtract(1, 'day').format('YYYY-MM-DD')}`; // prev date
-
-  if (index > 1) {
-    filename = `${filename}-${index}`;
-  }
-
-  return `${filename}.log.gz`;
-};
-
-const isProduction = process.env.NODE_ENV === 'production' || process.env.ABT_NODE_SERVICE_ENV === 'production';
-const isE2E = process.env.NODE_ENV === 'e2e';
-
-// Format context: https://github.com/graphql/express-graphql
-const formatContext = (ctx = {}) => {
-  if (ctx && ctx.user) {
-    delete ctx.user.avatar;
-  }
-
-  const port = isProduction ? get(ctx, 'headers[x-real-port]', '') : '';
-  const hostname = get(ctx, 'headers[x-real-hostname]', ctx.hostname);
-  const protocol = get(ctx, 'headers[x-real-protocol]', 'http').replace(/:$/, '');
-
-  return {
-    protocol,
-    user: ctx.user || null,
-    url: ctx.originalUrl,
-    query: ctx.query,
-    hostname,
-    port: Number(port) === 80 ? '' : Number(port),
-  };
-};
-
-// eslint-disable-next-line no-shadow
-const attachSharedUtils = (node, req, options) => {
-  req.getBlockletUrl = () => req.headers['x-blocklet-url'] || get(options, 'blockletUrl', '');
-  req.getBlockletDid = () => req.headers['x-blocklet-did'] || get(options, 'blockletDid', '');
-  req.getBlockletRealDid = () => req.headers['x-blocklet-real-did'] || get(options, 'blockletRealDid', '');
-  req.getRoutingRuleId = () => req.headers['x-routing-rule-id'] || get(options, 'routingRuleId', '');
-
-  req.getServiceContext = () => formatContext(req);
-
-  req.getRoutingRule = async () => {
-    const ruleId = req.getRoutingRuleId(req);
-    if (!ruleId) {
-      return null;
-    }
-
-    let rule = cache.get(ruleId);
-
-    if (!rule) {
-      rule = await node.getRoutingRuleById(ruleId);
-      cache.set(ruleId, rule);
-    }
-
-    return rule;
-  };
-
-  /**
-   * @return obj | null
-   */
-  req.getServiceConfig = async (serviceName) => {
-    const ruleId = req.getRoutingRuleId(req);
-    const name = serviceName || get(req, 'service.current', '');
-    if (!ruleId || !name) {
-      return null;
-    }
-
-    const cacheKeys = {
-      rule: cache.keyFns.routingRule(ruleId),
-      config: cache.keyFns.serviceConfig(ruleId, name),
-    };
-
-    // Return cached config if exists
-    const cached = cache.get(cacheKeys.config);
-    if (cached) {
-      return cached;
-    }
-
-    // Find rule
-    let rule = cache.get(cacheKeys.rule);
-    if (!rule) {
-      rule = await node.getRoutingRuleById(ruleId);
-      cache.set(cacheKeys.rule, rule);
-    }
-    if (!rule) {
-      return null;
-    }
-
-    // if is auth service, get config from blocklet meta
-    if (name === NODE_SERVICES.AUTH_SERVICE) {
-      // find blocklet
-      let blocklet = await req.getBlocklet();
-      if (!blocklet) {
-        return null;
-      }
-
-      const realDid = req.getBlockletRealDid();
-      if (realDid && blocklet.meta.did !== realDid) {
-        blocklet = (blocklet.children || []).find((x) => x.meta.did === realDid);
-      }
-      if (!blocklet) {
-        return null;
-      }
-
-      // find interface
-      let interfaceName = rule.to.realInterfaceName;
-
-      // we should only use rule.to.realInterfaceName, rule.to.interfaceName is for backward compatible
-      if (!interfaceName) {
-        logger.error(
-          `rule.to.realInterfaceName was not fround, please reInstall blocklet ${rule.to.did} to eliminate hidden bugs`
-        );
-        interfaceName = rule.to.interfaceName;
-      }
-
-      const _interface = blocklet.meta.interfaces.find((x) => x.name === interfaceName);
-      if (!_interface) {
-        return null;
-      }
-
-      // find service
-      const service = (_interface.services || []).find((x) => x.name === NODE_SERVICES.AUTH_SERVICE);
-      if (!service) {
-        return null;
-      }
-
-      return service.config;
-    }
-
-    // Parse config from rule
-    const services = rule.services || [];
-    const service = services.find((x) => x.name === name);
-    if (service) {
-      let config = {};
-      try {
-        logger.info('service config deserialize', service);
-        config = JSON.parse(service.config || '{}');
-        cache.set(cacheKeys.config, config);
-      } catch (err) {
-        logger.error('service config deserialize error', { error: err });
-      }
-      return config;
-    }
-
-    return null;
-  };
-
-  req.getBlocklet = async () => {
-    const did = req.getBlockletDid();
-    if (!did) {
-      return null;
-    }
-
-    const cacheKey = cache.keyFns.blocklet(did);
-    let blocklet = cache.get(cacheKey);
-    if (!blocklet) {
-      const context = req.getServiceContext();
-      blocklet = await node.getBlocklet({ did, attachRuntimeInfo: false }, context);
-      if (blocklet) {
-        cache.set(cacheKey, blocklet);
-      }
-    }
-
-    return blocklet;
-  };
-
-  req.getNodeInfo = async () => {
-    const cacheKey = cache.keyFns.node();
-    let nodeInfo = cache.get(cacheKey);
-    if (!nodeInfo) {
-      nodeInfo = await node.states.node.read();
-      cache.set(cacheKey, nodeInfo);
-    }
-
-    return nodeInfo;
-  };
-
-  req.getBlockletInfo = async () => {
-    const [blocklet, info] = await Promise.all([req.getBlocklet(), req.getNodeInfo()]);
-    if (!blocklet) {
-      throw new Error('Blocklet does not exist');
-    }
-
-    return getBlockletInfo(blocklet, info.sk);
-  };
-
-  req.cache = cache;
-};
-
-const distDir = path.resolve(__dirname, '../build');
-
-module.exports = function createServer(node, serverOptions = {}, serviceModules = []) {
-  const server = express();
-  const proxy = httpProxy.createProxyServer({});
-
-  // simple router, let each service handle the websocket connection
-  const wsRoutingRules = [
-    // final route: directly proxy all websocket request to target blocklet
-    {
-      path: '**',
-      handle: async (req, socket, head) => {
-        const { target } = ensureProxyUrl(req);
-        if (target) {
-          proxy.ws(req, socket, head, { target }, (error) => {
-            if (error) {
-              logger.error('socket proxy error', { error });
-            }
-          });
-        } else {
-          logger.error('socket proxy error: cannot find target service');
-          socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
-          socket.destroy();
-        }
-      },
-    },
-  ];
-  const wsRouter = {
-    // eslint-disable-next-line no-shadow
-    use(path, handler) {
-      const finalRoute = wsRoutingRules.pop();
-      wsRoutingRules.push({ path, handle: handler });
-      wsRoutingRules.push(finalRoute);
-    },
-  };
-
-  // eslint-disable-next-line no-unused-vars
-  proxy.on('proxyReq', (proxyReq, req, res, options) => {
-    if (req.rawBody) {
-      // Since we already consumed request stream, we need to write req.rawBody to proxy request here
-      proxyReq.write(req.rawBody);
-    }
-  });
-
-  // Bust cache on events from daemon
-  [BlockletEvents.updated, BlockletEvents.started, BlockletEvents.removed, BlockletEvents.statusChange].forEach(
-    (name) => {
-      eventHub.on(name, (data) => {
-        const did = get(data, 'meta.did');
-        if (did) {
-          logger.info('delete blocklet cache on update', { did, pid: process.pid });
-          cache.del(cache.keyFns.blocklet(did));
-        }
-      });
-    }
-  );
-  eventHub.on('node.updated', () => {
-    logger.info('node update', { pid: process.pid });
-    cache.del(cache.keyFns.node());
-  });
-
-  logger.info('init params', { isProduction, serverOptions });
-
-  server.set('trust proxy', 'loopback');
-  server.disable('x-powered-by');
-
-  server.use(compression());
-  server.use(cookieParser());
-
-  server.use(
-    bodyParser.json({
-      // We have to set a larger hard limit since
-      limit: '2mb',
-
-      // https://flaviocopes.com/express-get-raw-body/
-      // Side effects: this will double the memory consumption
-      verify: (req, res, buf) => {
-        req.rawBody = buf;
-      },
-    })
-  );
-
-  // NOTE: will be overwrite by Blocklet Server in production
-  server.use(cors());
-
-  // Shared util functions on current request
-  server.use((req, res, next) => {
-    attachSharedUtils(node, req, serverOptions);
-    next();
-  });
-
-  /* istanbul ignore if */
-  if (isProduction) {
-    const accessLogStream = RotatingFileStream.createStream(logFileGenerator, {
-      interval: '1d',
-      path: process.env.ABT_NODE_LOG_DIR,
-      compress: 'gzip',
-    });
-    server.use(morgan('combined', { stream: accessLogStream }));
-    /* istanbul ignore else */
-  } else {
-    server.use(
-      morgan((tokens, req, res) => {
-        const log = [
-          tokens.method(req, res),
-          tokens.url(req, res),
-          tokens.status(req, res),
-          tokens.res(req, res, 'content-length'),
-          '-',
-          tokens['response-time'](req, res),
-          'ms',
-        ].join(' ');
-
-        return log;
-      })
-    );
-  }
-
-  // Serve static assets from the service
-  if (isProduction || isE2E) {
-    server.use('/.service/@abtnode/auth-service', serveStatic(distDir, { index: false }));
-  }
-
-  // Mount services
-  // Each service can mount any number of middleware function or api function
-
-  // mount Auth Service
-  if (process.env.NODE_ENV !== 'test') {
-    mount({
-      node,
-      server,
-      wsRouter,
-      service: {
-        options: Object.assign({}, serverOptions, {
-          sessionSecret: process.env.ABT_NODE_SESSION_SECRET,
-          sessionTtl: process.env.ABT_NODE_SESSION_TTL,
-        }),
-        name: NODE_SERVICES.AUTH_SERVICE,
-        module: authModule,
-      },
-    });
-  }
-  serviceModules.forEach((serviceModule) => {
-    mount({
-      node,
-      server,
-      wsRouter,
-      service: serviceModule,
-    });
-  });
-
-  // After all service middleware, we can now safely pass all traffic to blocklets
-  server.use((req, res, next) => {
-    const { target } = ensureProxyUrl(req);
-
-    if (target) {
-      proxy.web(
-        req,
-        res,
-        {
-          target,
-        },
-        (error) => {
-          if (error) {
-            console.error(error);
-            logger.error('http proxy error', { error });
-            res.status(502).send(`Can not proxy to upstream blocklet: ${target}`);
-          }
-        }
-      );
-    } else {
-      next();
-    }
-  });
-
-  // Following handlers exist just in case
-
-  // 404 handler
-  server.use((req, res) => {
-    res.status(404).send('Blocklet Service: You should not be here!');
-  });
-
-  // error handler
-  // eslint-disable-next-line no-unused-vars
-  server.use((err, req, res, next) => {
-    console.error('service error', { error: err });
-    res.status(500).send('Blocklet Service: Something broke!');
-  });
-
-  // handle websocket connect request like http
-  const httpServer = http.createServer(server);
-
-  httpServer.on('upgrade', async (req, socket, head) => {
-    attachSharedUtils(node, req, serverOptions);
-
-    // find matched handler registered by each service
-    const { pathname } = new URL(req.url, `http://${req.headers.host || 'unknown'}`);
-    const routes = wsRoutingRules.filter((x) => minimatch(normalizePathPrefix(pathname), normalizePathPrefix(x.path)));
-
-    let routeIndex = 0;
-    const next = () => {
-      const route = routes[routeIndex];
-      if (route) {
-        routeIndex++;
-        route.handle(req, socket, head, next);
-      }
-    };
-
-    next();
-  });
-
-  server.listen = httpServer.listen.bind(httpServer);
-
-  return server;
-};
-
-module.exports.formatContext = formatContext;
-module.exports.logFileGenerator = logFileGenerator;
-module.exports.attachSharedUtils = attachSharedUtils;

package/lib/mount.js

@@ -1,52 +0,0 @@
-/* eslint-disable global-require */
-/* eslint-disable import/no-dynamic-require */
-const fs = require('fs-extra');
-const path = require('path');
-const express = require('express');
-const set = require('lodash/set');
-
-const logger = require('@abtnode/logger')(require('../package.json').name);
-
-module.exports = function mount({ node, server, wsRouter, service }) {
-  try {
-    const serviceModule = service.module;
-
-    const dataDir = path.join(node.dataDirs.services, service.name);
-    if (!fs.pathExistsSync(dataDir)) {
-      fs.mkdirpSync(dataDir);
-    }
-    const serviceOptions = { dataDir, ...service.options };
-
-    let serviceObject = serviceModule;
-    if (typeof serviceModule === 'function') {
-      serviceObject = serviceModule(node, server, serviceOptions);
-    }
-    const { init, name, version } = serviceObject;
-
-    // Create new router for each service
-    const router = express.Router();
-
-    // Set current service before current service runs
-    router.use((req, res, next) => {
-      set(req, 'service.current', name);
-      next();
-    });
-
-    // Mount service middleware
-    init({ node, httpRouter: server, serviceHttpRouter: router, wsRouter, options: serviceOptions });
-
-    // Unset current service when all middleware is done
-    router.use((req, res, next) => {
-      set(req, 'service.current', '');
-      next();
-    });
-
-    // Attach the service router to main application
-    server.use(router);
-
-    logger.info(`service ${name}@${version} mounted successfully`, { name, version });
-  } catch (err) {
-    logger.error(`service ${service.name} failed to mount due to ${err.message}`);
-    throw err;
-  }
-};

package/lib/util.js

@@ -1,17 +0,0 @@
-const ensureProxyUrl = (req) => {
-  const target = req.headers['x-blocklet-url'];
-
-  if (target) {
-    const pathPrefix = req.headers['x-routing-rule-path-prefix'];
-
-    if (pathPrefix && pathPrefix !== '/') {
-      req.url = `${pathPrefix}${req.url}`;
-    }
-  }
-
-  return { target };
-};
-
-module.exports = {
-  ensureProxyUrl,
-};