Examples with Step oracle.kubernetes.operator.work.Step used on opensource projects

Example 1 with Step

use of oracle.kubernetes.operator.work.Step in project weblogic-kubernetes-operator by oracle.

the class Main method begin.

private static void begin() {
    // read the operator configuration
    String namespace = System.getenv("OPERATOR_NAMESPACE");
    if (namespace == null) {
        namespace = "default";
    }
    Collection<String> targetNamespaces = getTargetNamespaces(namespace);
    String serviceAccountName = tuningAndConfig.get("serviceaccount");
    if (serviceAccountName == null) {
        serviceAccountName = "default";
    }
    principal = "system:serviceaccount:" + namespace + ":" + serviceAccountName;
    LOGGER.info(MessageKeys.OP_CONFIG_NAMESPACE, namespace);
    StringBuilder tns = new StringBuilder();
    Iterator<String> it = targetNamespaces.iterator();
    while (it.hasNext()) {
        tns.append(it.next());
        if (it.hasNext()) {
            tns.append(", ");
        }
    }
    LOGGER.info(MessageKeys.OP_CONFIG_TARGET_NAMESPACES, tns.toString());
    LOGGER.info(MessageKeys.OP_CONFIG_SERVICE_ACCOUNT, serviceAccountName);
    try {
        // Initialize logging factory with JSON serializer for later logging
        // that includes k8s objects
        LoggingFactory.setJSON(new JSON());
        // start the REST server
        startRestServer(principal, targetNamespaces);
        // create the Custom Resource Definitions if they are not already there
        CRDHelper.checkAndCreateCustomResourceDefinition();
        try {
            HealthCheckHelper healthCheck = new HealthCheckHelper(namespace, targetNamespaces);
            version = healthCheck.performK8sVersionCheck();
            healthCheck.performNonSecurityChecks();
            healthCheck.performSecurityChecks(serviceAccountName);
        } catch (ApiException e) {
            LOGGER.warning(MessageKeys.EXCEPTION, e);
        }
        // check for any existing resources and add the watches on them
        // this would happen when the Domain was running BEFORE the Operator starts up
        LOGGER.info(MessageKeys.LISTING_DOMAINS);
        for (String ns : targetNamespaces) {
            initialized.put(ns, Boolean.TRUE);
            Step domainList = callBuilderFactory.create().listDomainAsync(ns, new ResponseStep<DomainList>(null) {

                @Override
                public NextAction onFailure(Packet packet, ApiException e, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (statusCode == CallBuilder.NOT_FOUND) {
                        return onSuccess(packet, null, statusCode, responseHeaders);
                    }
                    return super.onFailure(packet, e, statusCode, responseHeaders);
                }

                @Override
                public NextAction onSuccess(Packet packet, DomainList result, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (result != null) {
                        for (Domain dom : result.getItems()) {
                            doCheckAndCreateDomainPresence(dom);
                        }
                    }
                    // main logic now happens in the watch handlers
                    domainWatchers.put(ns, createDomainWatcher(ns, result != null ? result.getMetadata().getResourceVersion() : ""));
                    return doNext(packet);
                }
            });
            Step initialize = ConfigMapHelper.createScriptConfigMapStep(ns, new ConfigMapAfterStep(ns, callBuilderFactory.create().with($ -> {
                $.labelSelector = LabelConstants.DOMAINUID_LABEL + "," + LabelConstants.CREATEDBYOPERATOR_LABEL;
            }).listPodAsync(ns, new ResponseStep<V1PodList>(callBuilderFactory.create().with($ -> {
                $.labelSelector = LabelConstants.DOMAINUID_LABEL + "," + LabelConstants.CREATEDBYOPERATOR_LABEL;
            }).listServiceAsync(ns, new ResponseStep<V1ServiceList>(callBuilderFactory.create().with($ -> {
                $.labelSelector = LabelConstants.DOMAINUID_LABEL + "," + LabelConstants.CREATEDBYOPERATOR_LABEL;
            }).listIngressAsync(ns, new ResponseStep<V1beta1IngressList>(domainList) {

                @Override
                public NextAction onFailure(Packet packet, ApiException e, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (statusCode == CallBuilder.NOT_FOUND) {
                        return onSuccess(packet, null, statusCode, responseHeaders);
                    }
                    return super.onFailure(packet, e, statusCode, responseHeaders);
                }

                @Override
                public NextAction onSuccess(Packet packet, V1beta1IngressList result, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (result != null) {
                        for (V1beta1Ingress ingress : result.getItems()) {
                            String domainUID = IngressWatcher.getIngressDomainUID(ingress);
                            String clusterName = IngressWatcher.getIngressClusterName(ingress);
                            if (domainUID != null && clusterName != null) {
                                DomainPresenceInfo created = new DomainPresenceInfo(ns);
                                DomainPresenceInfo info = domains.putIfAbsent(domainUID, created);
                                if (info == null) {
                                    info = created;
                                }
                                info.getIngresses().put(clusterName, ingress);
                            }
                        }
                    }
                    ingressWatchers.put(ns, createIngressWatcher(ns, result != null ? result.getMetadata().getResourceVersion() : ""));
                    return doNext(packet);
                }
            })) {

                @Override
                public NextAction onFailure(Packet packet, ApiException e, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (statusCode == CallBuilder.NOT_FOUND) {
                        return onSuccess(packet, null, statusCode, responseHeaders);
                    }
                    return super.onFailure(packet, e, statusCode, responseHeaders);
                }

                @Override
                public NextAction onSuccess(Packet packet, V1ServiceList result, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (result != null) {
                        for (V1Service service : result.getItems()) {
                            String domainUID = ServiceWatcher.getServiceDomainUID(service);
                            String serverName = ServiceWatcher.getServiceServerName(service);
                            String channelName = ServiceWatcher.getServiceChannelName(service);
                            if (domainUID != null && serverName != null) {
                                DomainPresenceInfo created = new DomainPresenceInfo(ns);
                                DomainPresenceInfo info = domains.putIfAbsent(domainUID, created);
                                if (info == null) {
                                    info = created;
                                }
                                ServerKubernetesObjects csko = new ServerKubernetesObjects();
                                ServerKubernetesObjects current = info.getServers().putIfAbsent(serverName, csko);
                                ServerKubernetesObjects sko = current != null ? current : csko;
                                if (channelName != null) {
                                    sko.getChannels().put(channelName, service);
                                } else {
                                    sko.getService().set(service);
                                }
                            }
                        }
                    }
                    serviceWatchers.put(ns, createServiceWatcher(ns, result != null ? result.getMetadata().getResourceVersion() : ""));
                    return doNext(packet);
                }
            })) {

                @Override
                public NextAction onFailure(Packet packet, ApiException e, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (statusCode == CallBuilder.NOT_FOUND) {
                        return onSuccess(packet, null, statusCode, responseHeaders);
                    }
                    return super.onFailure(packet, e, statusCode, responseHeaders);
                }

                @Override
                public NextAction onSuccess(Packet packet, V1PodList result, int statusCode, Map<String, List<String>> responseHeaders) {
                    if (result != null) {
                        for (V1Pod pod : result.getItems()) {
                            String domainUID = PodWatcher.getPodDomainUID(pod);
                            String serverName = PodWatcher.getPodServerName(pod);
                            if (domainUID != null && serverName != null) {
                                DomainPresenceInfo created = new DomainPresenceInfo(ns);
                                DomainPresenceInfo info = domains.putIfAbsent(domainUID, created);
                                if (info == null) {
                                    info = created;
                                }
                                ServerKubernetesObjects csko = new ServerKubernetesObjects();
                                ServerKubernetesObjects current = info.getServers().putIfAbsent(serverName, csko);
                                ServerKubernetesObjects sko = current != null ? current : csko;
                                sko.getPod().set(pod);
                            }
                        }
                    }
                    podWatchers.put(ns, createPodWatcher(ns, result != null ? result.getMetadata().getResourceVersion() : ""));
                    return doNext(packet);
                }
            })));
            engine.createFiber().start(initialize, new Packet(), new CompletionCallback() {

                @Override
                public void onCompletion(Packet packet) {
                // no-op
                }

                @Override
                public void onThrowable(Packet packet, Throwable throwable) {
                    LOGGER.severe(MessageKeys.EXCEPTION, throwable);
                }
            });
        }
        // delete stranded resources
        for (Map.Entry<String, DomainPresenceInfo> entry : domains.entrySet()) {
            String domainUID = entry.getKey();
            DomainPresenceInfo info = entry.getValue();
            if (info != null) {
                if (info.getDomain() == null) {
                    // no domain resource
                    deleteDomainPresence(info.getNamespace(), domainUID);
                }
            }
        }
    } catch (Throwable e) {
        LOGGER.warning(MessageKeys.EXCEPTION, e);
    } finally {
        LOGGER.info(MessageKeys.OPERATOR_SHUTTING_DOWN);
    }
}

Example 2 with Step

use of oracle.kubernetes.operator.work.Step in project weblogic-kubernetes-operator by oracle.

the class Main method scheduleDomainStatusUpdating.

private static void scheduleDomainStatusUpdating(DomainPresenceInfo info) {
    AtomicInteger unchangedCount = new AtomicInteger(0);
    AtomicReference<ScheduledFuture<?>> statusUpdater = info.getStatusUpdater();
    Runnable command = new Runnable() {

        public void run() {
            // resolve visibility
            Runnable r = this;
            Packet packet = new Packet();
            packet.getComponents().put(ProcessingConstants.DOMAIN_COMPONENT_NAME, Component.createFor(info, version));
            MainTuning main = tuningAndConfig.getMainTuning();
            Step strategy = DomainStatusUpdater.createStatusStep(main.statusUpdateTimeoutSeconds, null);
            engine.createFiber().start(strategy, packet, new CompletionCallback() {

                @Override
                public void onCompletion(Packet packet) {
                    Boolean isStatusUnchanged = (Boolean) packet.get(ProcessingConstants.STATUS_UNCHANGED);
                    ScheduledFuture<?> existing = null;
                    if (Boolean.TRUE.equals(isStatusUnchanged)) {
                        if (unchangedCount.incrementAndGet() == main.unchangedCountToDelayStatusRecheck) {
                            // slow down retries because of sufficient unchanged statuses
                            existing = statusUpdater.getAndSet(engine.getExecutor().scheduleWithFixedDelay(r, main.eventualLongDelay, main.eventualLongDelay, TimeUnit.SECONDS));
                        }
                    } else {
                        // reset to trying after shorter delay because of changed status
                        unchangedCount.set(0);
                        existing = statusUpdater.getAndSet(engine.getExecutor().scheduleWithFixedDelay(r, main.initialShortDelay, main.initialShortDelay, TimeUnit.SECONDS));
                        if (existing != null) {
                            existing.cancel(false);
                        }
                    }
                    if (existing != null) {
                        existing.cancel(false);
                    }
                }

                @Override
                public void onThrowable(Packet packet, Throwable throwable) {
                    LOGGER.severe(MessageKeys.EXCEPTION, throwable);
                    // retry to trying after shorter delay because of exception
                    unchangedCount.set(0);
                    ScheduledFuture<?> existing = statusUpdater.getAndSet(engine.getExecutor().scheduleWithFixedDelay(r, main.initialShortDelay, main.initialShortDelay, TimeUnit.SECONDS));
                    if (existing != null) {
                        existing.cancel(false);
                    }
                }
            });
        }
    };
    MainTuning main = tuningAndConfig.getMainTuning();
    ScheduledFuture<?> existing = statusUpdater.getAndSet(engine.getExecutor().scheduleWithFixedDelay(command, main.initialShortDelay, main.initialShortDelay, TimeUnit.SECONDS));
    if (existing != null) {
        existing.cancel(false);
    }
}

Example 3 with Step

use of oracle.kubernetes.operator.work.Step in project weblogic-kubernetes-operator by oracle.

the class CallBuilderTest method testListDomains.

@Test
public void testListDomains() throws InterruptedException {
    Step stepline = new SetupStep(null);
    Packet p = new Packet();
    Semaphore signal = new Semaphore(0);
    List<Throwable> throwables = Collections.synchronizedList(new ArrayList<Throwable>());
    p.put(THROW, throwables);
    engine.createFiber().start(stepline, p, new CompletionCallback() {

        @Override
        public void onCompletion(Packet packet) {
            signal.release();
        }

        @Override
        public void onThrowable(Packet packet, Throwable throwable) {
            throwables.add(throwable);
            signal.release();
        }
    });
    boolean result = signal.tryAcquire(20, TimeUnit.MINUTES);
    assertTrue(result);
    assertTrue(throwables.isEmpty());
    DomainList list = (DomainList) p.get(KEY);
    assertNotNull(list);
}

Example 4 with Step

use of oracle.kubernetes.operator.work.Step in project weblogic-kubernetes-operator by oracle.

the class IngressHelperTest method testAddThenRemoveServer.

@Test
public void testAddThenRemoveServer() throws Throwable {
    Packet p = new Packet();
    p.getComponents().put(ProcessingConstants.DOMAIN_COMPONENT_NAME, Component.createFor(info));
    p.put(ProcessingConstants.SERVER_SCAN, info.getScan().getServerConfig(server1Name));
    p.put(ProcessingConstants.CLUSTER_SCAN, info.getScan().getClusterConfig(clusterName));
    p.put(ProcessingConstants.SERVER_NAME, server1Name);
    Fiber f = engine.createFiber();
    Step s = IngressHelper.createClusterStep(null);
    AtomicReference<Throwable> t = new AtomicReference<>();
    f.start(s, p, new CompletionCallback() {

        @Override
        public void onCompletion(Packet packet) {
        // no-op
        }

        @Override
        public void onThrowable(Packet packet, Throwable throwable) {
            t.set(throwable);
        }
    });
    f.get(30, TimeUnit.SECONDS);
    if (t.get() != null) {
        throw t.get();
    }
    // Now check
    CallBuilderFactory factory = new CallBuilderFactory(null);
    V1beta1Ingress v1beta1Ingress = factory.create().readIngress(ingressName, namespace);
    List<V1beta1HTTPIngressPath> v1beta1HTTPIngressPaths = getPathArray(v1beta1Ingress);
    Assert.assertEquals("IngressPaths should have one instance of IngressPath", 1, v1beta1HTTPIngressPaths.size());
    V1beta1HTTPIngressPath v1beta1HTTPIngressPath = v1beta1HTTPIngressPaths.get(0);
    Assert.assertEquals("/", v1beta1HTTPIngressPath.getPath());
    V1beta1IngressBackend v1beta1IngressBackend = v1beta1HTTPIngressPath.getBackend();
    Assert.assertNotNull("IngressBackend Object should not be null", v1beta1IngressBackend);
    Assert.assertEquals("Service name should be " + clusterServiceName, clusterServiceName, v1beta1IngressBackend.getServiceName());
    Assert.assertEquals("Service port should be " + server1Port, server1Port, v1beta1IngressBackend.getServicePort().getIntValue());
}

Example 5 with Step

use of oracle.kubernetes.operator.work.Step in project weblogic-kubernetes-operator by oracle.

the class Main method doCheckAndCreateDomainPresence.

private static void doCheckAndCreateDomainPresence(Domain dom, boolean explicitRecheck, boolean explicitRestartAdmin, List<String> explicitRestartServers, List<String> explicitRestartClusters) {
    LOGGER.entering();
    boolean hasExplicitRestarts = explicitRestartAdmin || explicitRestartServers != null || explicitRestartClusters != null;
    DomainSpec spec = dom.getSpec();
    normalizeDomainSpec(spec);
    String domainUID = spec.getDomainUID();
    DomainPresenceInfo created = new DomainPresenceInfo(dom);
    DomainPresenceInfo info = domains.putIfAbsent(domainUID, created);
    if (info == null) {
        info = created;
    } else {
        // Has the spec actually changed?  We will get watch events for status updates
        Domain current = info.getDomain();
        if (current != null) {
            if (!explicitRecheck && !hasExplicitRestarts && spec.equals(current.getSpec())) {
                // nothing in the spec has changed
                LOGGER.fine(MessageKeys.NOT_STARTING_DOMAINUID_THREAD, domainUID);
                return;
            }
        }
        info.setDomain(dom);
    }
    String ns = dom.getMetadata().getNamespace();
    if (initialized.getOrDefault(ns, Boolean.FALSE) && !stopping.get()) {
        LOGGER.info(MessageKeys.PROCESSING_DOMAIN, domainUID);
        Step managedServerStrategy = bringManagedServersUp(DomainStatusUpdater.createEndProgressingStep(null));
        Step adminServerStrategy = bringAdminServerUp(connectToAdminAndInspectDomain(managedServerStrategy));
        Step strategy = DomainStatusUpdater.createProgressingStep(DomainStatusUpdater.INSPECTING_DOMAIN_PROGRESS_REASON, true, new DomainPrescenceStep(adminServerStrategy, managedServerStrategy));
        Packet p = new Packet();
        PodWatcher pw = podWatchers.get(ns);
        p.getComponents().put(ProcessingConstants.DOMAIN_COMPONENT_NAME, Component.createFor(info, version, pw));
        p.put(ProcessingConstants.PRINCIPAL, principal);
        if (explicitRestartAdmin) {
            p.put(ProcessingConstants.EXPLICIT_RESTART_ADMIN, Boolean.TRUE);
        }
        p.put(ProcessingConstants.EXPLICIT_RESTART_SERVERS, explicitRestartServers);
        p.put(ProcessingConstants.EXPLICIT_RESTART_CLUSTERS, explicitRestartClusters);
        if (explicitRestartAdmin) {
            LOGGER.info(MessageKeys.RESTART_ADMIN_STARTING, domainUID);
        }
        if (explicitRestartServers != null) {
            LOGGER.info(MessageKeys.RESTART_SERVERS_STARTING, domainUID, explicitRestartServers);
        }
        if (explicitRestartClusters != null) {
            LOGGER.info(MessageKeys.ROLLING_CLUSTERS_STARTING, domainUID, explicitRestartClusters);
        }
        domainUpdaters.startFiber(domainUID, strategy, p, new CompletionCallback() {

            @Override
            public void onCompletion(Packet packet) {
                if (explicitRestartAdmin) {
                    LOGGER.info(MessageKeys.RESTART_ADMIN_COMPLETE, domainUID);
                }
                if (explicitRestartServers != null) {
                    LOGGER.info(MessageKeys.RESTART_SERVERS_COMPLETE, domainUID, explicitRestartServers);
                }
                if (explicitRestartClusters != null) {
                    LOGGER.info(MessageKeys.ROLLING_CLUSTERS_COMPLETE, domainUID, explicitRestartClusters);
                }
            }

            @Override
            public void onThrowable(Packet packet, Throwable throwable) {
                LOGGER.severe(MessageKeys.EXCEPTION, throwable);
                domainUpdaters.startFiberIfLastFiberMatches(domainUID, Fiber.getCurrentIfSet(), DomainStatusUpdater.createFailedStep(throwable, null), p, new CompletionCallback() {

                    @Override
                    public void onCompletion(Packet packet) {
                    // no-op
                    }

                    @Override
                    public void onThrowable(Packet packet, Throwable throwable) {
                        LOGGER.severe(MessageKeys.EXCEPTION, throwable);
                    }
                });
            // TODO: consider retrying domain update after a delay
            }
        });
        scheduleDomainStatusUpdating(info);
    }
    LOGGER.exiting();
}