import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
public DeploymentState resolve(ContainerStatus containerStatus) {

		Stream<Predicate<ContainerStatus>> conditionsStream = Stream.of(conditions);
		Boolean allConditionsMet = conditionsStream.reduce((x, y) -> x.and(y)).get().test(containerStatus);

		if (allConditionsMet) {
			logger.debug("deployment state is " + resolvedState.name());
			return this.resolvedState;
		}
		else {
			Stream<ContainerStatusCondition> report = Stream.of(conditions);
			report.filter(c -> {
				boolean result= false;
				try {
					result = c.test(containerStatus);
				}
				catch (NullPointerException e) {

				}
				return !result;

			}).forEach(c -> logger.debug(c + " is not satisfied"));

		}
		return null;
	}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
/**
 * Log the last lines of containers logs
 */
private void logLastLines(List<ContainerStatus> containers, String podId, String namespace, KubernetesSlave slave,
                          Map<String, Integer> errors, KubernetesClient client) {
    for (ContainerStatus containerStatus : containers) {
        String containerName = containerStatus.getName();
        PrettyLoggable<String, LogWatch> tailingLines = client.pods().inNamespace(namespace)
                .withName(podId).inContainer(containerStatus.getName()).tailingLines(30);
        String log = tailingLines.getLog();
        if (!StringUtils.isBlank(log)) {
            String msg = errors != null ? String.format(" exited with error %s", errors.get(containerName))
                    : "";
            LOGGER.log(Level.SEVERE,
                    "Error in provisioning; agent={0}, template={1}. Container {2}{3}. Logs: {4}",
                    new Object[]{slave, slave.getTemplate(), containerName, msg, tailingLines.getLog()});
        }
    }
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
/**
 * Creates any missing containers; updating the currentState with the new values.
 */
public static String createMissingContainers(final ProcessManager processManager, final KubernetesModel model, final Pod pod,
                                             final PodStatus currentState, List<Container> containers) throws Exception {
    Map<String, ContainerStatus> currentContainers = KubernetesHelper.getCurrentContainers(currentState);

    for (final Container container : containers) {
        // lets update the pod model if we update the ports
        podTransaction(model, pod, new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                createContainer(processManager, model, container, pod, currentState);
                return null;
            }
        });
    }

    return null;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
/**
 * Returns all the current containers and their pods
 */
@Override
public ImmutableMap<String, PodCurrentContainer> getPodRunningContainers(KubernetesModel model) {
    Map<String, PodCurrentContainer> answer = new HashMap<>();
    for (Map.Entry<String, Pod> entry : getInternalPodMap(namespace).entrySet()) {
        String podId = entry.getKey();
        Pod podSchema = entry.getValue();
        Map<String, ContainerStatus> currentContainers = KubernetesHelper.getCurrentContainers(podSchema);
        for (Map.Entry<String, ContainerStatus> containerEntry : currentContainers.entrySet()) {
            String containerId = containerEntry.getKey();
            ContainerStatus currentContainer = containerEntry.getValue();
            PodCurrentContainer podCurrentContainer = new PodCurrentContainer(model, podId, podSchema, containerId, currentContainer);
            answer.put(containerId, podCurrentContainer);
        }
    }
    return ImmutableMap.copyOf(answer);
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
private boolean allContainersReady(List<ContainerStatus> containerStatuses) {
    boolean errorPresent = containerStatuses.stream()
            .filter(cs -> !cs.getReady().booleanValue())
            .findFirst()
            .isPresent();

    return !errorPresent ;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
private static Optional<Event> isInErrorState(WorkflowInstance workflowInstance, Pod pod) {
  final PodStatus status = pod.getStatus();
  final String phase = status.getPhase();

  switch (phase) {
    case "Pending":
      // check if one or more docker contains failed to pull their image, a possible silent error
      return status.getContainerStatuses().stream()
          .filter(IS_STYX_CONTAINER.and(KubernetesPodEventTranslator::hasPullImageError))
          .findAny()
          .map((x) -> Event.runError(workflowInstance, "One or more containers failed to pull their image"));

    case "Succeeded":
    case "Failed":
      final Optional<ContainerStatus> containerStatusOpt =
          pod.getStatus().getContainerStatuses().stream()
              .filter(IS_STYX_CONTAINER)
              .findFirst();

      if (!containerStatusOpt.isPresent()) {
        return Optional.of(Event.runError(workflowInstance, "Could not find our container in pod"));
      }

      final ContainerStatus containerStatus = containerStatusOpt.get();
      final ContainerStateTerminated terminated = containerStatus.getState().getTerminated();
      if (terminated == null) {
        return Optional.of(Event.runError(workflowInstance, "Unexpected null terminated status"));
      }
      return Optional.empty();

    case "Unknown":
      return Optional.of(Event.runError(workflowInstance, "Pod entered Unknown phase"));

    default:
      return Optional.empty();
  }
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
static boolean hasPullImageError(ContainerStatus cs) {
  ContainerStateWaiting waiting = cs.getState().getWaiting();
  return waiting != null && (
      "PullImageError".equals(waiting.getReason())
      || "ErrImagePull".equals(waiting.getReason())
      || "ImagePullBackOff".equals(waiting.getReason()));
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
private void deletePodIfNonDeletePeriodExpired(WorkflowInstance workflowInstance,
                                               String executionId,
                                               ContainerStatus containerStatus) {
  if (isNonDeletePeriodExpired(containerStatus)) {
    // if terminated and after graceful period, delete the pod
    // otherwise wait until next polling happens
    deletePod(workflowInstance, executionId);
  }
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
private void cleanup(WorkflowInstance workflowInstance, String executionId, 
                     Consumer<List<ContainerStatus>> cleaner) {
  Optional.ofNullable(client.pods().withName(executionId).get()).ifPresent(pod -> {
    final List<ContainerStatus> containerStatuses = pod.getStatus().getContainerStatuses();
    if (!containerStatuses.isEmpty()) {
      cleaner.accept(containerStatuses);
    } else {
      // for some cases such as evicted pod, there is no container status, so we delete directly
      deletePod(workflowInstance, executionId);
    }
  });
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
private boolean isNonDeletePeriodExpired(ContainerStatus containerStatus) {
  return Optional.ofNullable(containerStatus.getState().getTerminated().getFinishedAt())
      .map(finishedAt -> Instant.parse(finishedAt)
          .isBefore(clock.instant().minus(
              Duration.ofSeconds(podDeletionDelaySeconds))))
      .orElse(true);
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
ContainerReady(KubernetesDeployerProperties properties) {
	super(properties, DeploymentState.deployed, new ContainerStatusCondition("container ready") {
		@Override
		public boolean test(ContainerStatus containerStatus) {
			return containerStatus.getReady();
		}
	});
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
@Override
public DeploymentState resolve(ContainerStatus containerStatus) {
	for (RunningPhaseDeploymentStateResolver resolver: delegates) {
		DeploymentState deploymentState = resolver.resolve(containerStatus);
		if (deploymentState != null) {
			return deploymentState;
		}
	}
	return null;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
/**
 * Returns the current container map for the current pod state; lazily creating if required
 */
public static List<ContainerStatus> getOrCreateContainerStatuses(Pod pod) {
    PodStatus currentState = getOrCreatetStatus(pod);
    List<ContainerStatus> containerStatuses = currentState.getContainerStatuses();
    if (containerStatuses == null) {
        containerStatuses = new ArrayList<>();
        currentState.setContainerStatuses(containerStatuses);
    }
    return containerStatuses;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
/**
 * Returns the containers state, lazily creating any objects if required.
 */
public static ContainerState getOrCreateContainerState(Pod pod, String containerName) {
    ContainerStatus containerInfo = getOrCreateContainerInfo(pod, containerName);
    ContainerState state = containerInfo.getState();
    if (state == null) {
        state = new ContainerState();
        containerInfo.setState(state);
    }
    return state;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
/**
 * Returns the container information for the given pod and container name, lazily creating as required
 */
public static ContainerStatus getOrCreateContainerInfo(Pod pod, String containerName) {
    List<ContainerStatus> containerStatuses = getOrCreateContainerStatuses(pod);
    for (ContainerStatus containerStatus : containerStatuses) {
        String containerID = containerStatus.getContainerID();
        if (Objects.equal(containerName, containerID)) {
            return containerStatus;
        }
    }
    ContainerStatus status = new ContainerStatus();
    status.setContainerID(containerName);
    containerStatuses.add(status);
    return status;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
public static void containerAlive(Pod pod, String id, boolean alive) {
    PodStatus currentState = getOrCreatetStatus(pod);
    if (alive) {
        setPodRunning(currentState);
    } else {
        // lets check if we're waiting...
        List<ContainerStatus> containerStatuses = getOrCreateContainerStatuses(pod);
        if (containerStatuses.isEmpty() || isWaiting(containerStatuses)) {
            setPodWaiting(currentState);
        } else {
            setPodTerminated(currentState, "Failed");
        }
    }
    setContainerRunningState(pod, id, alive);
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
protected static boolean isWaiting(List<ContainerStatus> containerStatuses) {
    for (ContainerStatus status : containerStatuses) {
        ContainerState state = status.getState();
        if (state != null && state.getWaiting() != null) {
            return true;
        }
    }
    return false;
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
public static void setPodTerminated(PodStatus podStatus, String message) {
    List<ContainerStatus> containerStatuses = podStatus.getContainerStatuses();
    if (containerStatuses == null) {
        containerStatuses = new ArrayList<ContainerStatus>();
        podStatus.setContainerStatuses(containerStatuses);
    }
    containerStatuses.clear();
    ContainerStatus status = new ContainerStatusBuilder().withNewState().
            withNewTermination().withMessage(message).withFinishedAt(createAtString()).endTermination().endState().
            build();
    containerStatuses.add(status);
    podStatus.setContainerStatuses(containerStatuses);
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
public static void setPodRunning(PodStatus podStatus) {
    List<ContainerStatus> containerStatuses = podStatus.getContainerStatuses();
    if (containerStatuses == null) {
        containerStatuses = new ArrayList<ContainerStatus>();
        podStatus.setContainerStatuses(containerStatuses);
    }
    containerStatuses.clear();
    ContainerStatus status = new ContainerStatusBuilder().withNewState().
            withNewRunning().withStartedAt(createAtString()).endRunning().endState().
            build();
    containerStatuses.add(status);
    podStatus.setContainerStatuses(containerStatuses);
}
 

import io.fabric8.kubernetes.api.model.ContainerStatus; //导入依赖的package包/类
public static void setPodWaiting(PodStatus podStatus, String reason) {
    List<ContainerStatus> containerStatuses = podStatus.getContainerStatuses();
    if (containerStatuses == null) {
        containerStatuses = new ArrayList<ContainerStatus>();
        podStatus.setContainerStatuses(containerStatuses);
    }
    containerStatuses.clear();
    ContainerStatus status = new ContainerStatusBuilder().withNewState().
            withNewWaiting().withReason(reason).endWaiting().endState().
            build();
    containerStatuses.add(status);
    podStatus.setContainerStatuses(containerStatuses);
}