static Future start()

in webdev/lib/src/serve/webdev_server.dart [84:202]
107 lines of code
13 McCabe index (conditional complexity)

  static Future<WebDevServer> start(
      ServerOptions options, Stream<daemon.BuildResults> buildResults) async {
    var pipeline = const Pipeline();

    if (options.configuration.logRequests) {
      pipeline = pipeline.addMiddleware(logRequests());
    }

    pipeline = pipeline.addMiddleware(interceptFavicon);

    // Only provide relevant build results
    var filteredBuildResults = buildResults.asyncMap<BuildResult>((results) {
      var result = results.results
          .firstWhere((result) => result.target == options.target);
      switch (result.status) {
        case daemon.BuildStatus.started:
          return BuildResult((b) => b.status = BuildStatus.started);
        case daemon.BuildStatus.failed:
          return BuildResult((b) => b.status = BuildStatus.failed);
        case daemon.BuildStatus.succeeded:
          return BuildResult((b) => b.status = BuildStatus.succeeded);
      }
      throw StateError('Unexpected Daemon build result: $result');
    });

    var cascade = Cascade();
    var client = IOClient(HttpClient()
      ..maxConnectionsPerHost = 200
      ..idleTimeout = const Duration(seconds: 30)
      ..connectionTimeout = const Duration(seconds: 30));
    var assetHandler = proxyHandler(
        'http://localhost:${options.daemonPort}/${options.target}/',
        client: client);

    Dwds dwds;
    ExpressionCompilerService ddcService;
    if (options.configuration.enableInjectedClient) {
      var assetReader = ProxyServerAssetReader(
        options.daemonPort,
        root: options.target,
      );

      var loadStrategy = BuildRunnerRequireStrategyProvider(
              assetHandler, options.configuration.reload, assetReader)
          .strategy;

      if (options.configuration.enableExpressionEvaluation) {
        ddcService = ExpressionCompilerService(
          options.configuration.hostname,
          options.port,
          assetHandler,
          options.configuration.verbose,
        );
      }
      var shouldServeDevTools =
          options.configuration.debug || options.configuration.debugExtension;
      dwds = await Dwds.start(
          hostname: options.configuration.hostname,
          assetReader: assetReader,
          buildResults: filteredBuildResults,
          chromeConnection: () async =>
              (await Chrome.connectedInstance).chromeConnection,
          loadStrategy: loadStrategy,
          enableDebugExtension: options.configuration.debugExtension,
          enableDebugging: options.configuration.debug,
          spawnDds: !options.configuration.disableDds,
          expressionCompiler: ddcService,
          devtoolsLauncher: shouldServeDevTools
              ? (String hostname) async {
                  var server = await DevToolsServer().serveDevTools(
                    hostname: hostname,
                    enableStdinCommands: false,
                    customDevToolsPath: devToolsPath,
                  );
                  return DevTools(server.address.host, server.port, server);
                }
              : null);
      pipeline = pipeline.addMiddleware(dwds.middleware);
      cascade = cascade.add(dwds.handler);
      cascade = cascade.add(assetHandler);
      if (ddcService != null) {
        cascade = cascade.add(ddcService.handler);
      }
    } else {
      cascade = cascade.add(assetHandler);
    }

    var hostname = options.configuration.hostname;
    var tlsCertChain = options.configuration.tlsCertChain;
    var tlsCertKey = options.configuration.tlsCertKey;

    HttpServer server;
    var protocol =
        (tlsCertChain != null && tlsCertKey != null) ? 'https' : 'http';
    if (protocol == 'https') {
      var serverContext = SecurityContext()
        ..useCertificateChain(tlsCertChain)
        ..usePrivateKey(tlsCertKey);
      server =
          await HttpMultiServer.loopbackSecure(options.port, serverContext);
    } else {
      server = await HttpMultiServer.bind(hostname, options.port);
    }

    serveHttpRequests(server, pipeline.addHandler(cascade.handler), (e, s) {
      _logger.warning('Error serving requests', e, s);
    });

    return WebDevServer._(
      options.target,
      server,
      client,
      protocol,
      filteredBuildResults,
      options.configuration.autoRun,
      dwds: dwds,
      ddcService: ddcService,
    );
  }