| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.twill.api; |
| |
| import org.apache.twill.internal.Constants; |
| |
| import java.util.Collections; |
| import java.util.Map; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * A callback handler for acting on application events related to {@link TwillRunnable} lifecycle events. |
| */ |
| public abstract class EventHandler { |
| |
| protected EventHandlerContext context; |
| |
| /** |
| * Represents action to act upon runnable launch timeout. |
| */ |
| public static final class TimeoutAction { |
| |
| // Next timeout in milliseconds. |
| private final long timeout; |
| |
| /** |
| * Creates a {@link TimeoutAction} to indicate aborting the application. |
| */ |
| public static TimeoutAction abort() { |
| return new TimeoutAction(-1); |
| } |
| |
| /** |
| * Creates a {@link TimeoutAction} to indicate recheck again after the given time has passed. |
| * @param elapse Time to elapse before checking for the timeout again. |
| * @param unit Unit of the elapse time. |
| */ |
| public static TimeoutAction recheck(long elapse, TimeUnit unit) { |
| return new TimeoutAction(TimeUnit.MILLISECONDS.convert(elapse, unit)); |
| } |
| |
| private TimeoutAction(long timeout) { |
| this.timeout = timeout; |
| } |
| |
| /** |
| * Returns timeout in milliseconds or {@code -1} if to abort the application. |
| */ |
| public long getTimeout() { |
| return timeout; |
| } |
| } |
| |
| /** |
| * This class holds information about a launch timeout event. |
| */ |
| public static final class TimeoutEvent { |
| private final String runnableName; |
| private final int expectedInstances; |
| private final int actualInstances; |
| private final long requestTime; |
| |
| public TimeoutEvent(String runnableName, int expectedInstances, int actualInstances, long requestTime) { |
| this.runnableName = runnableName; |
| this.expectedInstances = expectedInstances; |
| this.actualInstances = actualInstances; |
| this.requestTime = requestTime; |
| } |
| |
| public String getRunnableName() { |
| return runnableName; |
| } |
| |
| public int getExpectedInstances() { |
| return expectedInstances; |
| } |
| |
| public int getActualInstances() { |
| return actualInstances; |
| } |
| |
| public long getRequestTime() { |
| return requestTime; |
| } |
| } |
| |
| /** |
| * Returns an {@link EventHandlerSpecification} for configuring this handler class. |
| */ |
| public EventHandlerSpecification configure() { |
| return new EventHandlerSpecification() { |
| @Override |
| public String getClassName() { |
| return EventHandler.this.getClass().getName(); |
| } |
| |
| @Override |
| public Map<String, String> getConfigs() { |
| return EventHandler.this.getConfigs(); |
| } |
| }; |
| } |
| |
| /** |
| * Invoked by the application to initialize this EventHandler instance. |
| * |
| * @param context context object for accessing the event handler execution context. |
| */ |
| public void initialize(EventHandlerContext context) { |
| this.context = context; |
| } |
| |
| /** |
| * Invoked by the application when it starts. |
| */ |
| public void started() { |
| // No-op |
| } |
| |
| /** |
| * Invoked by the application when new container is launched for a {@link TwillRunnable}. |
| * |
| * @param runnableName name of the runnable to be run in the new container |
| * @param instanceId the instance ID of the runnable instance to be run in the new container |
| * @param containerId the ID of the newly launched container |
| */ |
| public void containerLaunched(String runnableName, int instanceId, String containerId) { |
| // No-op |
| } |
| |
| /** |
| * Invoked by the application when the container allocated for a {@link TwillRunnable} is stopped. |
| * |
| * @param runnableName name of the runnable in the stopped container |
| * @param instanceId the instance ID of the runnable instance run in the stopped container |
| * @param containerId the ID of the stopped container |
| * @param exitStatus the exit status of the container |
| */ |
| public void containerStopped(String runnableName, int instanceId, String containerId, int exitStatus) { |
| // No-op |
| } |
| |
| /** |
| * Invoked by the application when all containers complete. |
| */ |
| public void completed() { |
| // No-op |
| } |
| |
| /** |
| * Invoked by the application when stop command is received to kill the current application. |
| * |
| */ |
| public void killed() { |
| // No-op |
| } |
| |
| /** |
| * Invoked by the application when the application is aborted because of timeout. |
| */ |
| public void aborted() { |
| // No-op |
| } |
| |
| /** |
| * Invoked by the application when shutting down. |
| */ |
| public void destroy() { |
| // No-op |
| } |
| |
| /** |
| * Invoked when the number of expected instances doesn't match with number of actual instances. |
| * @param timeoutEvents An Iterable of {@link TimeoutEvent} that contains information about runnable launch timeout. |
| * @return A {@link TimeoutAction} to govern action to act. By default it is to recheck after 60 seconds. |
| */ |
| public TimeoutAction launchTimeout(Iterable<TimeoutEvent> timeoutEvents) { |
| return new TimeoutAction(Constants.PROVISION_TIMEOUT); |
| } |
| |
| /** |
| * Returns set of configurations available at runtime for access. |
| */ |
| protected Map<String, String> getConfigs() { |
| return Collections.emptyMap(); |
| } |
| } |