Examples with Action org.platformlayer.core.model.Action used on opensource projects

Example 1 with Action

use of org.platformlayer.core.model.Action in project platformlayer by platformlayer.

the class OperationInvoker method isCandidate.

private boolean isCandidate(Method method, BindingScope scope) {
    Action action = scope.getInstance(Action.class);
    Handler handler = method.getAnnotation(Handler.class);
    if (handler != null) {
        if (!canHandleAction(handler, action, true)) {
            return false;
        }
        return true;
    }
    int managedCount = 0;
    for (Class<?> parameterType : method.getParameterTypes()) {
        if (parameterType.equals(ItemBase.class)) {
            managedCount++;
        }
    }
    // We require that we take at least one 'Managed<?>' parameter
    if (managedCount == 0) {
        return false;
    }
    return true;
}

Example 2 with Action

use of org.platformlayer.core.model.Action in project platformlayer by platformlayer.

the class OperationWorker method doOperation.

Object doOperation() throws OpsException {
    final Action action = activeJob.getAction();
    final PlatformLayerKey targetItemKey = activeJob.getTargetItemKey();
    RenameThread rename = new RenameThread(action.getClass().getSimpleName() + " " + targetItemKey);
    try {
        OpsContextBuilder opsContextBuilder = opsSystem.getInjector().getInstance(OpsContextBuilder.class);
        final ProjectAuthorization project = activeJob.getProjectAuthorization();
        final OpsContext opsContext = opsContextBuilder.buildOpsContext(activeJob);
        final ServiceType serviceType = activeJob.getServiceType();
        final ServiceProvider serviceProvider = opsSystem.getServiceProvider(serviceType);
        try {
            return OpsContext.runInContext(opsContext, new CheckedCallable<Object, Exception>() {

                @Override
                public Object call() throws Exception {
                    log.info("Starting job");
                    activeJob.setState(JobState.RUNNING);
                    ItemBase item;
                    ManagedItemRepository repository = opsSystem.getManagedItemRepository();
                    try {
                        boolean fetchTags = true;
                        item = repository.getManagedItem(targetItemKey, fetchTags, SecretProvider.from(project));
                    } catch (RepositoryException e) {
                        throw new OpsException("Error reading item from repository", e);
                    }
                    if (item == null) {
                        throw new WebApplicationException(404);
                    }
                    List<Object> scopeItems = Lists.newArrayList();
                    addActionScopeItems(action, item, scopeItems);
                    Object controller = serviceProvider.getController(item);
                    scopeItems.add(item);
                    scopeItems.add(action);
                    BindingScope scope = BindingScope.push(scopeItems);
                    opsContext.recurseOperation(scope, controller);
                    // TODO: Should we run a verify operation before -> ACTIVE??
                    // (we need to fix the states as well)
                    ManagedItemState newState = finishAction(action, scope);
                    if (newState != null) {
                        repository.changeState(targetItemKey, newState);
                        item.state = newState;
                    }
                    log.info("Job finished with SUCCESS");
                    activeJob.setState(JobState.SUCCESS);
                    return null;
                }

                private ManagedItemState finishAction(Action action, BindingScope scope) throws OpsException {
                    ManagedItemState newState = null;
                    if (action instanceof ConfigureAction) {
                        newState = ManagedItemState.ACTIVE;
                    }
                    if (action instanceof ValidateAction) {
                    // TODO: Change state to healthy??
                    }
                    if (action instanceof DeleteAction) {
                        newState = ManagedItemState.DELETED;
                    }
                    if (action instanceof BackupAction) {
                        BackupContext backupContext = scope.getInstance(BackupContext.class);
                        backupContext.writeDescriptor();
                    }
                    return newState;
                }

                private void addActionScopeItems(Action action, ItemBase item, List<Object> scopeItems) throws OpsException {
                    if (action instanceof BackupAction) {
                        // TODO: Don't hard-code this
                        BackupHelpers backupHelpers = opsSystem.getInjector().getInstance(BackupHelpers.class);
                        BackupContext backupContext = backupHelpers.createBackupContext(item);
                        scopeItems.add(backupContext);
                    }
                }
            });
        } catch (Throwable e) {
            log.warn("Error running operation", e);
            log.warn("Job finished with FAILED");
            // boolean isDone = false; // We will retry
            activeJob.setState(JobState.FAILED);
            TimeSpan retry = null;
            HasRetryInfo retryInfo = ExceptionHelpers.findRetryInfo(e);
            if (retryInfo != null) {
                retry = retryInfo.getRetry();
            }
            if (retry == null) {
                // TODO: Eventually give up??
                retry = ApplicationMode.isDevelopment() ? TimeSpan.ONE_MINUTE : TimeSpan.FIVE_MINUTES;
            }
            // TODO: State transition??
            // managedItem.setState(ManagedItemState.ACTIVE, true);
            log.warn("Scheduling retry in " + retry);
            activeJob.enqueueRetry(retry);
            return null;
        } finally {
            try {
                activeJob.recordJobEnd();
            } catch (OpsException e) {
                log.error("Error recording job in registry", e);
            }
        }
    } finally {
        IoUtils.safeClose(rename);
    }
}

Example 3 with Action

use of org.platformlayer.core.model.Action in project platformlayer by platformlayer.

the class ScheduleController method handler.

@Handler
public void handler() throws OpsException {
    if (OpsContext.isConfigure()) {
        String key = model.getKey().getUrl();
        PlatformLayerKey target = model.targetItem;
        PlatformLayerEndpointInfo endpoint = platformLayer.getEndpointInfo(target);
        JobSchedule schedule = model.schedule;
        Action action = model.action;
        actionScheduler.putJob(key, endpoint, schedule, target, action);
    }
}

Example 4 with Action

use of org.platformlayer.core.model.Action in project platformlayer by platformlayer.

the class JobExecutionDataFormatter method visit.

@Override
public void visit(CliContext context, JobExecutionData o, OutputSink sink) throws IOException {
    LinkedHashMap<String, Object> values = Maps.newLinkedHashMap();
    values.put("jobId", o.getJobId());
    values.put("executionId", o.getExecutionId());
    JobData job = o.getJob();
    values.put("target", job != null ? job.getTargetItemKey() : null);
    Action action = null;
    if (job != null) {
        action = job.getAction();
    }
    values.put("action", action != null ? action.getType() : null);
    values.put("startedAt", o.getStartedAt());
    values.put("endedAt", o.getEndedAt());
    values.put("state", o.getState());
    sink.outputRow(values);
}

Example 5 with Action

use of org.platformlayer.core.model.Action in project platformlayer by platformlayer.

the class ActionsResource method doActionJson.

@POST
@Consumes({ JSON })
@Produces({ XML, JSON })
public JobData doActionJson(String json) throws IOException, RepositoryException, OpsException {
    JSONObject jsonObject;
    String actionType = null;
    try {
        jsonObject = new JSONObject(json);
        Object typeObject = jsonObject.remove("type");
        if (typeObject != null) {
            actionType = typeObject.toString();
        }
        // Remove type attribute
        json = jsonObject.toString();
    } catch (JSONException e) {
        throw new IllegalArgumentException("Malformed JSON", e);
    }
    if (Strings.isNullOrEmpty(actionType)) {
        throw new IllegalArgumentException("Must pass type attribute");
    }
    Map<String, Class<? extends Action>> actionMap = Maps.newHashMap();
    actionMap.put("configureaction", ConfigureAction.class);
    actionMap.put("validateaction", ValidateAction.class);
    // actionMap.put("deleteaction", DeleteAction.class);
    actionMap.put("backupaction", BackupAction.class);
    for (Class<? extends Action> action : getServiceProvider().getActions()) {
        String key = action.getSimpleName().toLowerCase();
        actionMap.put(key, action);
    }
    Class<? extends Action> actionClass = actionMap.get(actionType.toLowerCase());
    if (actionClass == null) {
        throw new IllegalArgumentException("Unknown action: " + actionType);
    }
    Action action = jsonMapper.readItem(actionClass, json);
    return doAction(action);
}