import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@BeforeClass
public static void setup() throws IOException {
    OpenShiftClient oc = new DefaultOpenShiftClient();
    List<Route> routes = oc.routes().inNamespace(oc.getNamespace()).list().getItems();

    String ssoAuthUrl = routes.stream()
            .filter(r -> "secure-sso".equals(r.getMetadata().getName()))
            .findFirst()
            .map(r -> "https://" + r.getSpec().getHost())
            .orElseThrow(() -> new IllegalStateException("Couldn't find secure-sso route"));

    InputStream configStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("keycloak.json");
    if (configStream == null) {
        throw new IllegalStateException("Could not find any keycloak.json file in classpath.");
    }
    System.setProperty("sso.auth.server.url", ssoAuthUrl);
    Configuration config = JsonSerialization.readValue(configStream, Configuration.class, true);
    authzClient = AuthzClient.create(config);

    applicationUrls = routes.stream()
            .filter(r -> r.getMetadata().getName().contains("secured"))
            .map(r -> "http://" + r.getSpec().getHost())
            .collect(toList());

}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
public String getUrl(final OpenShiftClient client, final String namespace) throws RouteNotFoundException {
    Route route = getRouteByName(client, namespace, cheRoute);
    if (route == null) {
        LOG.warn("Route '" + cheRoute + "' not found. Trying to get '" + cheHostRoute + "' route");
        route = getRouteByName(client, namespace, cheHostRoute);
    }
    if (route != null) {
        String host = route.getSpec().getHost();
        String protocol = getProtocol(route);
        LOG.info("Host '{}' has been found", host);
        LOG.info("Route protocol '{}'", protocol);
        return protocol + "://" + host;
    }
    throw new RouteNotFoundException(
            "Routes '" + cheRoute + "'/'" + cheHostRoute + "' not found in '" + namespace + "' namespace");
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
public Route createRestRoute() {

		final Route route = new RouteBuilder()
					.withNewMetadata()
						.withName("syndesis-rest")
					.endMetadata()
					.withNewSpec()
						.withPath("/api").withHost("rest-" + TestConfiguration.openShiftNamespace() + "." + TestConfiguration.syndesisUrlSuffix())
						.withWildcardPolicy("None")
						.withNewTls()
							.withTermination("edge")
						.endTls()
						.withNewTo()
							.withKind("Service").withName("syndesis-rest")
						.endTo()
					.endSpec()
				.build();

		return withDefaultUser(client -> client.resource(route).createOrReplace());
	}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
/**
 * Check if a maven artifact repository is running in Openshift.
 * Repository is searched for under a route with name 'maven'.
 *
 * @return true if http GET on route's host URL returns 200, false otherwise
 */
public static boolean checkRepositoryAvailability() {
	Optional<Route> routeOptional = OpenshiftUtil.getInstance().withAdminUser(x -> x.routes().inNamespace("test-infra").list().getItems()).stream()
			.filter(r -> r.getSpec().getHost().startsWith("maven"))
			.findAny();

	if(routeOptional.isPresent()) {
		try {
			HttpUtil.httpGet("http://"+routeOptional.get().getSpec().getHost());
		} catch(Exception e) {
			return false;
		}
	} else {
		return false;
	}
	return true;
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Override
public void provision(OpenShiftEnvironment osEnv, RuntimeIdentity identity)
    throws InfrastructureException {
  final String workspaceId = identity.getWorkspaceId();
  final Set<Pod> pods = new HashSet<>(osEnv.getPods().values());
  osEnv.getPods().clear();
  for (Pod pod : pods) {
    final ObjectMeta podMeta = pod.getMetadata();
    putLabel(pod, Constants.CHE_ORIGINAL_NAME_LABEL, podMeta.getName());
    final String podName = Names.uniquePodName(podMeta.getName(), workspaceId);
    podMeta.setName(podName);
    osEnv.getPods().put(podName, pod);
  }
  final Set<Route> routes = new HashSet<>(osEnv.getRoutes().values());
  osEnv.getRoutes().clear();
  for (Route route : routes) {
    final ObjectMeta routeMeta = route.getMetadata();
    putLabel(route, Constants.CHE_ORIGINAL_NAME_LABEL, routeMeta.getName());
    final String routeName = Names.uniqueRouteName();
    routeMeta.setName(routeName);
    osEnv.getRoutes().put(routeName, route);
  }
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
/**
 * Creates OpenShift pods and resolves machine servers based on routes and services.
 *
 * @param services created OpenShift services
 * @param routes created OpenShift routes
 * @throws InfrastructureException when any error occurs while creating OpenShift pods
 */
@VisibleForTesting
void createPods(List<Service> services, List<Route> routes) throws InfrastructureException {
  final ServerResolver serverResolver = ServerResolver.of(services, routes);
  final OpenShiftEnvironment environment = getContext().getEnvironment();
  final Map<String, InternalMachineConfig> machineConfigs = environment.getMachines();
  for (Pod toCreate : environment.getPods().values()) {
    final Pod createdPod = project.pods().create(toCreate);
    final ObjectMeta podMetadata = createdPod.getMetadata();
    for (Container container : createdPod.getSpec().getContainers()) {
      String machineName = Names.machineName(toCreate, container);
      OpenShiftMachine machine =
          new OpenShiftMachine(
              machineName,
              podMetadata.getName(),
              container.getName(),
              serverResolver.resolve(machineName),
              project,
              MachineStatus.STARTING,
              machineConfigs.get(machineName).getAttributes());
      machines.put(machine.getName(), machine);
      sendStartingEvent(machine.getName());
    }
  }
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
private Route build() {
  io.fabric8.openshift.api.model.RouteBuilder builder =
      new io.fabric8.openshift.api.model.RouteBuilder();

  return builder
      .withNewMetadata()
      .withName(name.replace("/", "-"))
      .withAnnotations(
          Annotations.newSerializer()
              .servers(serversConfigs)
              .machineName(machineName)
              .annotations())
      .endMetadata()
      .withNewSpec()
      .withNewTo()
      .withName(serviceName)
      .endTo()
      .withNewPort()
      .withTargetPort(targetPort)
      .endPort()
      .endSpec()
      .build();
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void
    testResolvingServersWhenThereIsNoTheCorrespondingServiceAndRouteForTheSpecifiedMachine() {
  // given
  Service nonMatchedByPodService =
      createService("nonMatched", "foreignMachine", CONTAINER_PORT, null);
  Route route =
      createRoute(
          "nonMatched",
          "foreignMachine",
          ImmutableMap.of(
              "http-server", new ServerConfigImpl("3054", "http", "/api", ATTRIBUTES_MAP)));

  ServerResolver serverResolver =
      ServerResolver.of(singletonList(nonMatchedByPodService), singletonList(route));

  // when
  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  // then
  assertTrue(resolved.isEmpty());
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void testResolvingServersWhenThereIsMatchedRouteForTheSpecifiedMachine() {
  Route route =
      createRoute(
          "matched",
          "machine",
          ImmutableMap.of(
              "http-server", new ServerConfigImpl("3054", "http", "/api", ATTRIBUTES_MAP)));

  ServerResolver serverResolver = ServerResolver.of(emptyList(), singletonList(route));

  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  assertEquals(resolved.size(), 1);
  assertEquals(
      resolved.get("http-server"),
      new ServerImpl()
          .withUrl("http://localhost/api")
          .withStatus(UNKNOWN)
          .withAttributes(ATTRIBUTES_MAP));
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void testResolvingServersWhenThereIsMatchedRouteForMachineAndServerPathIsNull() {
  Route route =
      createRoute(
          "matched",
          "machine",
          singletonMap(
              "http-server", new ServerConfigImpl("3054", "http", null, ATTRIBUTES_MAP)));

  ServerResolver serverResolver = ServerResolver.of(emptyList(), singletonList(route));

  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  assertEquals(resolved.size(), 1);
  assertEquals(
      resolved.get("http-server"),
      new ServerImpl()
          .withUrl("http://localhost")
          .withStatus(UNKNOWN)
          .withAttributes(ATTRIBUTES_MAP));
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void testResolvingServersWhenThereIsMatchedRouteForMachineAndServerPathIsEmpty() {
  Route route =
      createRoute(
          "matched",
          "machine",
          singletonMap("http-server", new ServerConfigImpl("3054", "http", "", ATTRIBUTES_MAP)));

  ServerResolver serverResolver = ServerResolver.of(emptyList(), singletonList(route));

  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  assertEquals(resolved.size(), 1);
  assertEquals(
      resolved.get("http-server"),
      new ServerImpl()
          .withUrl("http://localhost")
          .withStatus(UNKNOWN)
          .withAttributes(ATTRIBUTES_MAP));
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void testResolvingServersWhenThereIsMatchedRouteForMachineAndServerPathIsRelative() {
  Route route =
      createRoute(
          "matched",
          "machine",
          singletonMap(
              "http-server", new ServerConfigImpl("3054", "http", "api", ATTRIBUTES_MAP)));

  ServerResolver serverResolver = ServerResolver.of(emptyList(), singletonList(route));

  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  assertEquals(resolved.size(), 1);
  assertEquals(
      resolved.get("http-server"),
      new ServerImpl()
          .withUrl("http://localhost/api")
          .withStatus(UNKNOWN)
          .withAttributes(ATTRIBUTES_MAP));
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void testResolvingInternalServers() {
  Service service =
      createService(
          "service11",
          "machine",
          CONTAINER_PORT,
          singletonMap(
              "http-server", new ServerConfigImpl("3054", "http", "api", ATTRIBUTES_MAP)));
  Route route = createRoute("matched", "machine", null);

  ServerResolver serverResolver = ServerResolver.of(singletonList(service), singletonList(route));

  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  assertEquals(resolved.size(), 1);
  assertEquals(
      resolved.get("http-server"),
      new ServerImpl()
          .withUrl("http://service11:3054/api")
          .withStatus(UNKNOWN)
          .withAttributes(ATTRIBUTES_MAP));
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Test
public void testResolvingInternalServersWithPortWithTransportProtocol() {
  Service service =
      createService(
          "service11",
          "machine",
          CONTAINER_PORT,
          singletonMap(
              "http-server", new ServerConfigImpl("3054/udp", "xxx", "api", ATTRIBUTES_MAP)));
  Route route = createRoute("matched", "machine", null);

  ServerResolver serverResolver = ServerResolver.of(singletonList(service), singletonList(route));

  Map<String, ServerImpl> resolved = serverResolver.resolve("machine");

  assertEquals(resolved.size(), 1);
  assertEquals(
      resolved.get("http-server"),
      new ServerImpl()
          .withUrl("xxx://service11:3054/api")
          .withStatus(UNKNOWN)
          .withAttributes(ATTRIBUTES_MAP));
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
private Route createRoute(
    String name, String machineName, Map<String, ServerConfigImpl> servers) {
  Serializer serializer = Annotations.newSerializer();
  serializer.machineName(machineName);
  if (servers != null) {
    serializer.servers(servers);
  }
  return new RouteBuilder()
      .withNewMetadata()
      .withName(name)
      .withAnnotations(serializer.annotations())
      .endMetadata()
      .withNewSpec()
      .withHost(ROUTE_HOST)
      .withNewTo()
      .withName(name)
      .endTo()
      .endSpec()
      .build();
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
public OpenShiftRuntimeEndpoint getRuntimeEndpoint(String id) throws OpenShiftClientException {
    try {
        OpenShiftRuntimeId runtimeId = OpenShiftRuntimeId.fromString(id);
        String prjName = runtimeId.project();
        String svcName = runtimeId.service();
        OpenShiftRuntimeEndpoint endpoint = new OpenShiftRuntimeEndpoint();
        Route route = delegate.routes().inNamespace(prjName).withName(svcName).get();
        if (route != null) {
            RouteSpec routeSpec = route.getSpec();
            endpoint.setProtocol(routeSpec.getTls() != null ? "https" : "http");
            endpoint.setHost(routeSpec.getHost());
            RoutePort routePort = routeSpec.getPort();
            if (routePort != null) {
                IntOrString targetPort = routePort.getTargetPort();
                if (targetPort != null) {
                    endpoint.setPort(targetPort.getIntVal());
                }
            }
        }
        return endpoint;
    } catch (Throwable t) {
        throw new OpenShiftClientException(t.getMessage(), t);
    }
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
public static void setRoutes(RouteList routeList, String routerHost) {
    InetAddress routerAddr;
    try {
        routerAddr = routerHost == null ? null : InetAddress.getByName(routerHost);
    } catch (UnknownHostException e) {
        throw new IllegalArgumentException("Invalid IP for router host", e);
    }
    if (routeList != null) {
        synchronized (ROUTING) {
            for (Route route : routeList.getItems()) {
                String host = route.getSpec().getHost();
                if (routerAddr != null) {
                    System.out.println(String.format("Adding route (router -> host): %s -> %s", routerHost, host));
                    ROUTING.put(host, routerAddr);
                } else {
                    ROUTING.remove(host);
                }
            }
        }
    }
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
public Route getRoute(final String name) {
	List<Route> candidates = getRoutesNamedWithPrefix(name).collect(Collectors.toList());
	if (candidates.size() == 1) {
		return candidates.get(0);
	}
	throw new IllegalArgumentException("Cannot find unique route, there is " + candidates.size() + "candidate(s)");
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
@Override
public Route build() {
	RouteSpecBuilder spec = new RouteSpecBuilder()
			.withHost(hostName)
			.withNewTo()
			.withKind("Service")
			.withName(serviceName)
			.endTo();

	if (targetPort != 0) {
		spec.withNewPort().withNewTargetPort(targetPort).endPort();
	}

	if (tlsType != TLSType.NONE) {
		TLSConfigBuilder tls = new TLSConfigBuilder()
				.withTermination(tlsType.toString().toLowerCase());

		if (StringUtils.isNotBlank(routeKey)) {
			tls.withKey(routeKey);
		}
		if (StringUtils.isNotBlank(routeCertificate)) {
			tls.withCertificate(routeCertificate);
		}
		if (StringUtils.isNotBlank(routeCA)) {
			tls.withCaCertificate(routeCA);
		}
		if (StringUtils.isNotBlank(serverCA)) {
			tls.withDestinationCACertificate(serverCA);
		}
		spec.withTls(tls.build());
	}

	return new io.fabric8.openshift.api.model.RouteBuilder()
			.withMetadata(metadataBuilder().build())
			.withSpec(spec.build())
			.build();
}
 

import io.fabric8.openshift.api.model.Route; //导入依赖的package包/类
private Endpoint routeToEndpoint(Route route) {
    String secretName = route.getMetadata().getAnnotations().get(AnnotationKeys.CERT_SECRET_NAME);
    Endpoint.Builder builder = new Endpoint.Builder()
            .setName(route.getMetadata().getName())
            .setHost(route.getSpec().getHost())
            .setPort(443)
            .setService(route.getSpec().getTo().getName());

    if (secretName != null) {
        builder.setCertProvider(new SecretCertProvider(secretName));
    }

    return builder.build();
}