Java Template类代码示例

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
public OpenShiftTemplate(OpenShiftClient client, OpenShiftRuntimeConfig runtimeConfig) {
    Loadable<TemplateResource<Template, KubernetesList, DoneableTemplate>> loadable = null;
    String prjName = runtimeConfig.getProjectName();
    String templateUri = runtimeConfig.getResourceTemplateUri();
    String templateName = runtimeConfig.getResourceTemplateName();
    if (prjName != null) {
        loadable = client.getDelegate().templates().inNamespace(prjName);
    } else {
        loadable = client.getDelegate().templates();
    }
    TemplateResource<Template, KubernetesList, DoneableTemplate> res = null;
    if (templateUri != null) {
        URL templateUrl = client.toUrl(templateUri);
        if (templateUrl != null) {
            res = loadable.load(templateUrl);
        }
    } else if (templateName != null && !templateName.isEmpty()) {
        res = loadable.load(templateName);
    }
    resource = res;
    template = res != null ? res.get() : null;
    if (template == null) {
        throw new OpenShiftClientException(String.format("could not load template with project [%s] and uri [%s] or name [%s]", prjName, templateUri, templateName));
    }
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
private void applyParameterValueProperties(final OpenShiftProject project, final Template template) {
    RouteList routes = null;
    for (Parameter parameter : template.getParameters()) {
        // Find any parameters with special "fabric8-value" properties
        if (parameter.getAdditionalProperties().containsKey("fabric8-value")
                && parameter.getValue() == null) {
            String value = parameter.getAdditionalProperties().get("fabric8-value").toString();
            Matcher m = PARAM_VAR_PATTERN.matcher(value);
            StringBuffer newval = new StringBuffer();
            while (m.find()) {
                String type = m.group(1);
                String routeName = m.group(2);
                String propertyPath = m.group(3);
                String propertyValue = "";
                // We only support "route/XXX[.spec.host]" for now,
                // but we're prepared for future expansion
                if ("route".equals(type) && ".spec.host".equals(propertyPath)) {
                    // Try to find a Route with that name and use its host name
                    if (routes == null) {
                        routes = client.routes().inNamespace(project.getName()).list();
                    }
                    propertyValue = routes.getItems().stream()
                            .filter(r -> routeName.equals(r.getMetadata().getName()))
                            .map(r -> r.getSpec().getHost())
                            .filter(Objects::nonNull)
                            .findAny()
                            .orElse(propertyValue);
                }
                m.appendReplacement(newval, Matcher.quoteReplacement(propertyValue));
            }
            m.appendTail(newval);
            parameter.setValue(newval.toString());
        }
    }
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
public KubernetesList processTemplate(Template template, Map<String, String> parameters) {
	ParameterValue[] values = processParameters(parameters);

	return withDefaultUser(client -> {
		client.templates().createOrReplace(template);

		return client.templates().withName(template.getMetadata().getName()).process(values);
	});
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
public static Template getTemplate() {
	try (InputStream is = new URL(TEMPLATE_URL).openStream()) {
		return OpenShiftUtils.getInstance().withDefaultUser(client -> client.templates().load(is).get());
	} catch (IOException ex) {
		throw new IllegalArgumentException("Unable to read template ", ex);
	}
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
public static void deploy() {
	Template template = null;
	try (InputStream is = ClassLoader.getSystemResourceAsStream("templates/syndesis-amq.yml")) {
		template = OpenShiftUtils.getInstance().withDefaultUser(client -> client.templates().load(is).get());
	} catch (IOException ex) {
		throw new IllegalArgumentException("Unable to read template ", ex);
	}
	Map<String, String> templateParams = new HashMap<>();
	templateParams.put("MQ_USERNAME", "amq");
	templateParams.put("MQ_PASSWORD", "topSecret");

	// try to clean previous broker
	cleanUp();
	OpenShiftUtils.getInstance().withDefaultUser(c -> c.templates().withName("syndesis-amq").delete());

	KubernetesList processedTemplate = OpenShiftUtils.getInstance().processTemplate(template, templateParams);
	OpenShiftUtils.getInstance().createResources(processedTemplate);

	try {
		OpenShiftWaitUtils.waitFor(OpenShiftWaitUtils.isAPodReady("application", "broker"));
	} catch (InterruptedException | TimeoutException e) {
		log.error("Wait for syndesis-rest failed ", e);
	}
	Account amqAccount = new Account();
	amqAccount.setService("amq");
	Map<String, String> accountParameters = new HashMap<>();
	accountParameters.put("brokerUrl", "tcp://broker-amq:61616");
	accountParameters.put("username", "amq");
	accountParameters.put("password", "topSecret");
	accountParameters.put("clientId", UUID.randomUUID().toString());
	amqAccount.setProperties(accountParameters);
	AccountsDirectory.getInstance().addAccount("AMQ", amqAccount);
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
/**
 * This method will delete the existing template and replace it with a new
 * one (all in current namespace) and process it afterwards.
 */
public KubernetesList processTemplate(Template template, Map<String, String> parameters) {
	ParameterValue[] values = processParameters(parameters);

	return withDefaultUser(client -> {
		// delete existing
		client.templates().withName(template.getMetadata().getName()).delete();
		// create new
		client.templates().create(template);
		// return processed template
		return client.templates().withName(template.getMetadata().getName()).process(values);
	});
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
private void applyParameterValueProperties(final OpenShiftProject project, final Template template) {
    RouteList routes = null;
    for (Parameter parameter : template.getParameters()) {
        // Find any parameters with special "fabric8-value" properties
        if (parameter.getAdditionalProperties().containsKey("fabric8-value")
                && parameter.getValue() == null) {
            String value = parameter.getAdditionalProperties().get("fabric8-value").toString();
            Matcher m = PARAM_VAR_PATTERN.matcher(value);
            StringBuffer newval = new StringBuffer();
            while (m.find()) {
                String type = m.group(1);
                String routeName = m.group(2);
                String propertyPath = m.group(3);
                String propertyValue = "";
                // We only support "route/XXX[.spec.host]" for now,
                // but we're prepared for future expansion
                if ("route".equals(type) && ".spec.host".equals(propertyPath)) {
                    // Try to find a Route with that name and use its host name
                    if (routes == null) {
                        routes = client.routes().inNamespace(project.getName()).list();
                    }
                    propertyValue = routes.getItems().stream()
                        .filter(r -> routeName.equals(r.getMetadata().getName()))
                        .map(r -> r.getSpec().getHost())
                        .filter(Objects::nonNull)
                        .findAny()
                        .orElse(propertyValue);
                }
                m.appendReplacement(newval, Matcher.quoteReplacement(propertyValue));
            }
            m.appendTail(newval);
            parameter.setValue(newval.toString());
        }
    }
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
@Test
public void createCheServer() throws Exception {
    OpenShiftClient openShiftClient = null;
    try {
        openShiftClient = client.get(endpoint, username, password);

        ProjectRequest projectRequest = createTestProject(openShiftClient);
        LOG.info("Number of projects: {}", getNumberOfProjects(openShiftClient));

        LOG.info("Test project has been deleted: {}", deleteTestProject(openShiftClient, projectRequest));
        LOG.info("Number of projects: {}", getNumberOfProjects(openShiftClient));

        // Controller controller = new Controller(client);
        // controller.applyJson(template.get());

        Template template = loadTemplate(openShiftClient);

        List<Parameter> parameters = template.getParameters();
        LOG.info("Number of template parameters: {}", parameters.size());

        List<ParameterValue> pvs = new ArrayList<>();
        for (Parameter parameter : parameters) {
            String name = parameter.getName();
            String value = parameter.getValue();
            LOG.info("Template Parameter Name: {}", name);
            LOG.info("Template Parameter Value: {}", value);
            if (CHE_OPENSHIFT_ENDPOINT.equals(name) && value.isEmpty()) {
                value = endpoint;
            }
            pvs.add(new ParameterValue(name, value));
        }

        KubernetesList list = processTemplate(openShiftClient, pvs);
        createResources(openShiftClient, list);

        Pod pod = openShiftClient.pods().inNamespace(project).withName("che-host").get();

        Route route = openShiftClient.routes().inNamespace(project).withName("che-host").get();

        LOG.info("Pods: {}", getNumberOfPods(openShiftClient));
    } finally {
        if (openShiftClient != null) {
            openShiftClient.close();
        }
    }
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
private KubernetesList processTemplate(OpenShiftClient client, List<ParameterValue> parameterValues)
        throws IOException {
    ClientTemplateResource<Template, KubernetesList, DoneableTemplate> templateHandle = client.templates()
            .load(cheServerTemplate.getInputStream());
    return templateHandle.process(parameterValues.toArray(new ParameterValue[parameterValues.size()]));
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
private Template loadTemplate(OpenShiftClient client) throws IOException {
    return client.templates().load(cheServerTemplate.getInputStream()).get();
}
 

import io.fabric8.openshift.api.model.Template; //导入依赖的package包/类
public static void deploy() {
	OpenShiftUtils.getInstance().cleanProject();

	// get & create restricted SA
	ServiceAccount serviceAccount1 = OpenShiftUtils.getInstance().withDefaultUser(client -> client.serviceAccounts().createOrReplace(getSupportSA()));
	// get token from SA `oc secrets get-token` && wait until created to prevent 404
	TestUtils.waitForEvent(Optional::isPresent,
			() -> OpenShiftUtils.getInstance().getSecrets().stream().filter(s -> s.getMetadata().getName().startsWith("syndesis-oauth-client-token")).findFirst(),
			TimeUnit.MINUTES,
			2,
			TimeUnit.SECONDS,
			5);

	Secret secret = OpenShiftUtils.getInstance().getSecrets().stream().filter(s -> s.getMetadata().getName().startsWith("syndesis-oauth-client-token")).findFirst().get();
	// token is Base64 encoded by default
	String oauthTokenEncoded = secret.getData().get("token");
	byte[] oauthTokenBytes = Base64.decodeBase64(oauthTokenEncoded);
	String oauthToken = new String(oauthTokenBytes);

	// get the template
	Template template = getTemplate();
	// set params
	Map<String, String> templateParams = new HashMap<>();
	templateParams.put("ROUTE_HOSTNAME", TestConfiguration.openShiftNamespace() + "." + TestConfiguration.syndesisUrlSuffix());
	templateParams.put("OPENSHIFT_MASTER", TestConfiguration.openShiftUrl());
	templateParams.put("OPENSHIFT_PROJECT", TestConfiguration.openShiftNamespace());
	templateParams.put("OPENSHIFT_OAUTH_CLIENT_SECRET", oauthToken);
	templateParams.put("TEST_SUPPORT_ENABLED", "true");
	// process & create
	KubernetesList processedTemplate = OpenShiftUtils.getInstance().processTemplate(template, templateParams);
	OpenShiftUtils.getInstance().createResources(processedTemplate);
	OpenShiftUtils.getInstance().createRestRoute();

	//TODO: there's a bug in openshift-client, we need to initialize manually
	OpenShiftUtils.getInstance().withDefaultUser(client -> client.roleBindings().createOrReplaceWithNew()
			.withNewMetadata()
				.withName("syndesis:editors")
	        .endMetadata()
			.withNewRoleRef().withName("edit").endRoleRef()
			.addNewSubject().withKind("ServiceAccount").withName("syndesis-rest").withNamespace(TestConfiguration.openShiftNamespace()).endSubject()
			.addToUserNames(String.format("system:serviceaccount:%s:syndesis-rest", TestConfiguration.openShiftNamespace()))
			.done()
	);
}