Java 类io.dropwizard.jetty.HttpConnectorFactory 实例源码

private static int getPort(Config config) {
    int port = 0;
    DefaultServerFactory serverFactory = (DefaultServerFactory) config.getServerFactory();
    List<ConnectorFactory> connectorFactories = serverFactory.getApplicationConnectors();
    if (Preconditions.checkNotNull(connectorFactories).size() != 1) {
        throw new RuntimeException(
                String.format("Unexpected number of connectorFactories %s, check 'applicationConnectors' in the YAML config",
                        connectorFactories.size()));
    }

    HttpConnectorFactory connector = (HttpConnectorFactory) connectorFactories.get(0);
    if (connector.getClass().isAssignableFrom(HttpConnectorFactory.class)) {
        port = connector.getPort();
    }
    return port;
}

private HostAndPort getHostAndPortFromConnectorFactories(List<ConnectorFactory> connectors) {
    // find the first connector that matches and return it host/port information (in practice there should
    // be one, and just one, match)
    try {
        HttpConnectorFactory httpConnectorFactory = (HttpConnectorFactory) Iterables.find(connectors, Predicates.instanceOf(HttpConnectorFactory.class));

        String host = httpConnectorFactory.getBindHost();
        if (host == null) {
            host = getLocalHost().getHostAddress();
        }
        int port = httpConnectorFactory.getPort();
        return HostAndPort.fromParts(host, port);
    } catch (NoSuchElementException ex) {
        throw new IllegalStateException("Did not find a valid HttpConnector for the server", ex);
    }
}

@Provides
@Singleton
public BaragonAgentMetadata providesAgentMetadata(BaragonAgentConfiguration config) throws Exception {
  final SimpleServerFactory simpleServerFactory = (SimpleServerFactory) config.getServerFactory();
  final HttpConnectorFactory httpFactory = (HttpConnectorFactory) simpleServerFactory.getConnector();

  final int httpPort = httpFactory.getPort();
  final String hostname = config.getHostname().or(JavaUtils.getHostAddress());
  final Optional<String> domain = config.getLoadBalancerConfiguration().getDomain();
  final String appRoot = simpleServerFactory.getApplicationContextPath();

  final String baseAgentUri = String.format(config.getBaseUrlTemplate(), hostname, httpPort, appRoot);
  final String agentId = String.format("%s:%s", hostname, httpPort);

  return new BaragonAgentMetadata(baseAgentUri, agentId, domain, BaragonAgentEc2Metadata.fromEnvironment(), config.getExtraAgentData(), true);
}

@Override
public void run(SimpleFormConfiguration configuration, Environment environment) throws Exception {

    environment.jersey().setUrlPattern("/api/*");
    environment.jersey().register(new SimpleFormRest());

    /*
        very ugly code, but does not seem that Dropwizard gives you any alternative :(
     */
    HttpConnectorFactory applicationConnector = ((HttpConnectorFactory)
            ((DefaultServerFactory) configuration.getServerFactory())
                    .getApplicationConnectors().get(0));
    applicationConnector.setPort(port);

    ((HttpConnectorFactory) ((DefaultServerFactory) configuration.getServerFactory())
            .getAdminConnectors().get(0)).setPort(0);

    environment.lifecycle().addServerLifecycleListener(server -> jettyServer = server);


    BeanConfig beanConfig = new BeanConfig();
    beanConfig.setVersion("0.0.1");
    beanConfig.setSchemes(new String[]{"http"});
    //beanConfig.setHost("localhost:8080");
    beanConfig.setBasePath("/api");
    beanConfig.setResourcePackage("com.foo.rest.examples.dw.simpleform");
    beanConfig.setScan(true);
    environment.jersey().register(new io.swagger.jaxrs.listing.ApiListingResource());
    environment.jersey().register(new io.swagger.jaxrs.listing.SwaggerSerializers());
}

@Override
public void run(PIConfiguration configuration, Environment environment) throws Exception {

    environment.jersey().setUrlPattern("/api/*");
    environment.jersey().register(new PositiveIntegerRest());

    /*
        very ugly code, but does not seem that Dropwizard gives you any alternative :(
     */
    HttpConnectorFactory applicationConnector = ((HttpConnectorFactory)
            ((DefaultServerFactory) configuration.getServerFactory())
                    .getApplicationConnectors().get(0));
    applicationConnector.setPort(port);

    ((HttpConnectorFactory) ((DefaultServerFactory) configuration.getServerFactory())
            .getAdminConnectors().get(0)).setPort(0);

    environment.lifecycle().addServerLifecycleListener(server -> jettyServer = server);


    BeanConfig beanConfig = new BeanConfig();
    beanConfig.setVersion("0.0.1");
    beanConfig.setSchemes(new String[]{"http"});
    //beanConfig.setHost("localhost:8080");
    beanConfig.setBasePath("/api");
    beanConfig.setResourcePackage("com.foo.rest.examples.dw.positiveinteger");
    beanConfig.setScan(true);
    environment.jersey().register(new io.swagger.jaxrs.listing.ApiListingResource());
    environment.jersey().register(new io.swagger.jaxrs.listing.SwaggerSerializers());
}

@Inject
SingularityHostAndPortProvider(final SingularityConfiguration configuration, @Named(HOST_NAME_PROPERTY) String hostname) {
  checkNotNull(configuration, "configuration is null");
  this.hostname = configuration.getHostname().or(hostname);

  SimpleServerFactory simpleServerFactory = (SimpleServerFactory) configuration.getServerFactory();
  HttpConnectorFactory httpFactory = (HttpConnectorFactory) simpleServerFactory.getConnector();

  this.httpPort = httpFactory.getPort();
}

private static void updatePortsToAvoidCollision(Collection<ConnectorFactory> connectorFactoryCollection) {
    for (ConnectorFactory connectorFactory : connectorFactoryCollection) {
        if (connectorFactory instanceof HttpConnectorFactory) {
            HttpConnectorFactory httpConnectorFactory = (HttpConnectorFactory)connectorFactory;
            httpConnectorFactory.setPort(httpConnectorFactory.getPort() + 100);
        }
    }
}

protected String getAdminBaseURI () {
    int httpPort = 0;
    for(ConnectorFactory connector: ((DefaultServerFactory)_config.getServerFactory()).getAdminConnectors()) {
        if (connector.getClass().isAssignableFrom(HttpConnectorFactory.class)) {
            httpPort = ((HttpConnectorFactory) connector).getPort();
            break;
        }
    }

    return format("http://localhost:%d", httpPort);
}

protected String getServiceBaseURI () {
    int port = 0;
    for(ConnectorFactory connector: ((DefaultServerFactory)_config.getServerFactory()).getApplicationConnectors()) {
        if (connector.getClass().isAssignableFrom(HttpConnectorFactory.class)) {
            port = ((HttpConnectorFactory) connector).getPort();
            break;
        }
    }

    return format("http://localhost:%d", port);
}

protected int getServiceBasePort () {
    int port = 0;
    for(ConnectorFactory connector: ((DefaultServerFactory)_config.getServerFactory()).getApplicationConnectors()) {
        if (connector.getClass().isAssignableFrom(HttpConnectorFactory.class)) {
            port = ((HttpConnectorFactory) connector).getPort();
            break;
        }
    }

    return port;
}

private static int getPort(Configuration config) {
  DefaultServerFactory serverFactory = (DefaultServerFactory) config.getServerFactory();
  ConnectorFactory connectorFactory = serverFactory.getApplicationConnectors().get(0);

  if (connectorFactory instanceof HttpsConnectorFactory) {
    return ((HttpsConnectorFactory) connectorFactory).getPort();
  } else if (connectorFactory instanceof HttpConnectorFactory) {
    return ((HttpConnectorFactory) connectorFactory).getPort();
  }

  throw new IllegalArgumentException("Could not extract main application port from configuration");
}

private static HostAndPort portFromConnectorFactory(ConnectorFactory connectorFactory)
{
    if ( (connectorFactory != null) && HttpConnectorFactory.class.isAssignableFrom(connectorFactory.getClass()) )
    {
        HttpConnectorFactory factory = (HttpConnectorFactory)connectorFactory;
        String bindHost = MoreObjects.firstNonNull(factory.getBindHost(), "localhost");
        return HostAndPort.fromParts(bindHost, factory.getPort());
    }
    return defaultHostAndPort;
}

public static Integer getPort(ConnectorFactory connectorFactory) {
   if(connectorFactory instanceof HttpConnectorFactory) {
      return ((HttpConnectorFactory)connectorFactory).getPort();
   }
   if(connectorFactory instanceof HttpsConnectorFactory) {
      return ((HttpsConnectorFactory)connectorFactory).getPort();
   }
   throw new RuntimeException("Unable to infer Port of " + connectorFactory);
}

public static Integer getPort(ConnectorFactory connectorFactory) {
   if(connectorFactory instanceof HttpConnectorFactory) {
      return ((HttpConnectorFactory)connectorFactory).getPort();
   }
   if(connectorFactory instanceof HttpsConnectorFactory) {
      return ((HttpsConnectorFactory)connectorFactory).getPort();
   }
   throw new RuntimeException("Unable to infer Port of " + connectorFactory);
}

public static Integer getPort(ConnectorFactory connectorFactory) {
   if(connectorFactory instanceof HttpConnectorFactory) {
      return ((HttpConnectorFactory)connectorFactory).getPort();
   }
   if(connectorFactory instanceof HttpsConnectorFactory) {
      return ((HttpsConnectorFactory)connectorFactory).getPort();
   }
   throw new RuntimeException("Unable to infer Port of " + connectorFactory);
}

private @Nonnull HttpConnectorFactory getConnectorFactoy(ServerFactory serverFactory) {
    if(serverFactory instanceof DefaultServerFactory) {
        return getDefaultServerFactory(serverFactory);
    } else if(serverFactory instanceof SimpleServerFactory) {
        return getSimpleServerFactory(serverFactory);
    }
    throw new IllegalArgumentException(
            String.format("Unknonw ServerFactory instance '%s'", serverFactory.getClass().getName()));
}

private @Nonnull HttpConnectorFactory getSimpleServerFactory(ServerFactory serverFactory) {
    HttpConnectorFactory connector = (HttpConnectorFactory) ((SimpleServerFactory)serverFactory).getConnector();
    if (connector.getClass().isAssignableFrom(HttpConnectorFactory.class)) {
        return connector;
    }
    throw new IllegalArgumentException(String.format("Failed to find any server ConnectorFactory in serverFactory '%s'",
            serverFactory.getClass().getName()));       
}

private @Nonnull HttpConnectorFactory getDefaultServerFactory(ServerFactory serverFactory) {
    for (ConnectorFactory connector : ((DefaultServerFactory)serverFactory).getApplicationConnectors()) {
        if (connector.getClass().isAssignableFrom(HttpConnectorFactory.class)) {
            return (HttpConnectorFactory) connector;
        }
    }
    throw new IllegalArgumentException(String.format("Failed to find any server ConnectorFactory in serverFactory '%s'",
            serverFactory.getClass().getName()));
}

private static void setPort(Configuration config, int port) {
  DefaultServerFactory serverFactory = (DefaultServerFactory) config.getServerFactory();
  HttpConnectorFactory connectorFactory = (HttpConnectorFactory) serverFactory.getApplicationConnectors().get(0);
  connectorFactory.setPort(port);
}

private static void setAdminPort(Configuration config, int port) {
  DefaultServerFactory serverFactory = (DefaultServerFactory) config.getServerFactory();
  HttpConnectorFactory connectorFactory = (HttpConnectorFactory) serverFactory.getAdminConnectors().get(0);
  connectorFactory.setPort(port);
}

void useRandomPorts() {
    DefaultServerFactory serverFactory = (DefaultServerFactory) getServerFactory();
    ((HttpConnectorFactory) serverFactory.getApplicationConnectors().get(0)).setPort(0);
    ((HttpConnectorFactory) serverFactory.getAdminConnectors().get(0)).setPort(0);
}