Java KubernetesHelper.getName方法代码示例

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
/**
 * Returns the current users kubernetes/openshift user name
 */
public String getUserName() {
    OpenShiftClient oc = getOpenShiftClientOrNull();
    if (oc != null) {
        User user = oc.users().withName("~").get();
        if (user == null) {
            LOG.warn("Failed to find current logged in user!");
        } else {
            String answer = KubernetesHelper.getName(user);
            if (Strings.isNullOrBlank(answer)) {
                LOG.warn("No name for User " + user);
            } else {
                return answer;
            }
        }
    }

    // TODO needs to use the current token to find the current user name
    return Configs.currentUserName();
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
private void cleanDeployments(Map<String, String> labels) throws Exception {
    final ReplicationControllerList rcs = client.replicationControllers().inNamespace(configuration.getNamespace()).withLabels(labels).list();
    try {
        for (ReplicationController rc : rcs.getItems()) {
            String rcId = KubernetesHelper.getName((io.fabric8.kubernetes.api.model.HasMetadata) rc.getMetadata());
            client.replicationControllers().inNamespace(configuration.getNamespace()).withName(rcId).scale(0, true);
            boolean exists = client.replicationControllers().inNamespace(configuration.getNamespace()).withName(rcId).delete();
            log.info(String.format("ReplicationController [%s] delete: %s.", rcId, exists));
        }
    } catch (Exception e) {
        log.log(Level.WARNING, String.format("Exception while deleting rc [%s]: %s", labels, e), e);
    }
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
protected void onWatchEvent(io.fabric8.kubernetes.client.Watcher.Action action, HasMetadata entity, NotifyConfig notifyConfig) {
    if (!notifyConfig.isEnabled(action)) {
        return;
    }
    String kind = KubernetesHelper.getKind(entity);
    String name = KubernetesHelper.getName(entity);
    String namespace = getNamespace();

    String actionText = action.toString().toLowerCase();
    String room = this.roomExpression.replace("${namespace}", namespace).replace("${kind}", kind).replace("${name}", name);

    String postfix = "";
    if (action.equals(Watcher.Action.ADDED) || action.equals(Watcher.Action.MODIFIED)) {
        if (Strings.isNotBlank(consoleLink)) {
            postfix += " " + consoleLink + "/kubernetes/namespace/" + namespace + "/" + kind.toLowerCase() + "s/" + name;
        }
    }

    String message = actionText + " " + decapitalize(kind) + " " + namespace + " / " + name + postfix;
    notifier.notifyRoom(room, message);
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
public ContainerService(ServicePort servicePort, Pod pod) throws URISyntaxException {
    this.servicePort = servicePort;
    this.pod = pod;
    int serviceContainerPort = KubernetesHelper.intOrStringToInteger(servicePort.getTargetPort(), this.toString());
    int port = NodeHelper.findHostPortForService(pod, serviceContainerPort);

    // lets get host / port of the container
    String host = null;
    PodStatus currentState = pod.getStatus();
    if (currentState != null) {
        host = currentState.getHostIP();
        if (Strings.isBlank(host)) {
            host = currentState.getPodIP();
        }
    }
    if (Strings.isBlank(host)) {
        throw new IllegalArgumentException("No host for pod " + KubernetesHelper.getName(pod) + " so cannot use it with service port: " + servicePort.getName());
    } else {
        uri = new URI("tcp://" + host + ":" + port);
    }
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
/**
 * Finds the secret token we should use for the web hooks
 */
private String findBotSecret(String discoveryNamespace, String botServiceAccount) {
    if (useUiidForBotSecret) {
        return UUID.randomUUID().toString();
    } else {
        SecretList list = getKubernetesClientHelper().getKubernetesClient().secrets()
                .inNamespace(discoveryNamespace).list();
        if (list != null) {
            List<Secret> items = list.getItems();
            if (items != null) {
                for (Secret item : items) {
                    String name = KubernetesHelper.getName(item);
                    if (name.startsWith(botServiceAccount + "-token-")) {
                        Map<String, String> data = item.getData();
                        if (data != null) {
                            String token = data.get("token");
                            if (token != null) {
                                return base64decode(token);
                            }
                        }
                    }
                }
            }
        }
    }
    return null;
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
protected TablePrinter podsAsTable(PodList pods) {
    TablePrinter table = new TablePrinter();
    table.columns("id", "image(s)", "host", "labels", "status");
    List<Pod> items = pods.getItems();
    if (items == null) {
        items = Collections.EMPTY_LIST;
    }
    Filter<Pod> filter = KubernetesHelper.createPodFilter(filterText.getValue());
    for (Pod item : items) {
        if (filter.matches(item)) {
            String id = KubernetesHelper.getName(item);
            PodStatus podStatus = item.getStatus();
            String status = "";
            String host = "";
            if (podStatus != null) {
                status = KubernetesHelper.getStatusText(podStatus);
                host = podStatus.getHostIP();
            }
            Map<String, String> labelMap = item.getMetadata().getLabels();
            String labels = KubernetesHelper.toLabelsString(labelMap);
            PodSpec spec = item.getSpec();
            if (spec != null) {
                List<Container> containerList = spec.getContainers();
                for (Container container : containerList) {
                    String image = container.getImage();
                    table.row(id, image, host, labels, status);

                    id = "";
                    host = "";
                    status = "";
                    labels = "";
                }
            }
        }
    }
    return table;
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
private void printReplicationControllers(ReplicationControllerList replicationControllers, PrintStream out) {
    TablePrinter table = new TablePrinter();
    table.columns("id", "labels", "replicas", "replica selector");
    List<ReplicationController> items = replicationControllers.getItems();
    if (items == null) {
        items = Collections.EMPTY_LIST;
    }
    Filter<ReplicationController> filter = KubernetesHelper.createReplicationControllerFilter(filterText.getValue());
    for (ReplicationController item : items) {
        if (filter.matches(item)) {
            String id = KubernetesHelper.getName(item);
            String labels = KubernetesHelper.toLabelsString(item.getMetadata().getLabels());
            Integer replicas = null;
            ReplicationControllerSpec desiredState = item.getSpec();
            ReplicationControllerStatus currentState = item.getStatus();
            String selector = null;
            if (desiredState != null) {
                selector = KubernetesHelper.toLabelsString(desiredState.getSelector());
            }
            if (currentState != null) {
                replicas = currentState.getReplicas();
            }
            table.row(id, labels, toPositiveNonZeroText(replicas), selector);
        }
    }
    table.print();
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
public SubscribeResponse subscribe(SubscribeRequest request) throws InternalException {
    String namespace = request.getNamespace();
    Objects.notNull(namespace, "namespace");

    ConfigMap configMap = createSubscriptionResource(request, namespace);
    kubernetesClient.configMaps().inNamespace(namespace).create(configMap);
    return new SubscribeResponse(namespace, KubernetesHelper.getName(configMap));
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
public void cleanPods(Map<String, String> labels) throws Exception {
    final PodList pods = client.pods().inNamespace(configuration.getNamespace()).withLabels(labels).list();
    try {
        for (Pod pod : pods.getItems()) {
            String podId = KubernetesHelper.getName((io.fabric8.kubernetes.api.model.HasMetadata) pod.getMetadata());
            boolean exists = client.pods().inNamespace(configuration.getNamespace()).withName(podId).delete();
            log.info(String.format("Pod [%s] delete: %s.", podId, exists));
        }
    } catch (Exception e) {
        log.log(Level.WARNING, String.format("Exception while deleting pod [%s]: %s", labels, e), e);
    }
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
private void cleanBuilds(Map<String, String> labels) throws Exception {
    final BuildList builds = client.builds().inNamespace(configuration.getNamespace()).withLabels(labels).list();
    try {
        for (Build build : builds.getItems()) {
            String buildId = KubernetesHelper.getName((io.fabric8.kubernetes.api.model.HasMetadata) build.getMetadata());
            boolean exists = client.builds().inNamespace(configuration.getNamespace()).withName(buildId).delete();
            log.info(String.format("Build [%s] delete: %s.", buildId, exists));
        }
    } catch (Exception e) {
        log.log(Level.WARNING, String.format("Exception while deleting build [%s]: %s", labels, e), e);
    }
}
 

import io.fabric8.kubernetes.api.KubernetesHelper; //导入方法依赖的package包/类
/**
 * Returns true if the given pod matches the selection criteria
 */
public boolean isTarget(Pod pod) {
    String name = KubernetesHelper.getName(pod);
    return includeFilter.matches(name) && !excludeFilter.matches(name);
}