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

Example 31 with ItemBase

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

the class ActionsResource method doAction.

private JobData doAction(Action action) throws RepositoryException, OpsException {
    boolean fetchTags = true;
    // Check we can get the item
    ItemBase managedItem = getManagedItem(fetchTags);
    // String actionName = action.getName();
    // if (Strings.isNullOrEmpty(actionName)) {
    // actionName = action.getClass().getSimpleName();
    // // throw new IllegalArgumentException("Action is required");
    // action.name = actionName;
    // }
    // OperationType operationType = EnumUtils.valueOfCaseInsensitive(OperationType.class, actionName);
    PlatformLayerKey itemKey = getPlatformLayerKey();
    return jobRegistry.enqueueOperation(action, getProjectAuthorization(), itemKey);
}

Example 32 with ItemBase

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

the class ItemServiceImpl method ensureItem.

<T extends ItemBase> T ensureItem(final ProjectAuthorization auth, final T item, final boolean canExist, final boolean generateUniqueName, final String uniqueTagKey) throws OpsException {
    final ModelClass<T> modelClass = (ModelClass<T>) serviceProviderDirectory.getModelClass(item.getClass());
    if (modelClass == null) {
        throw new IllegalStateException("Unknown item type");
    }
    final Class<T> javaClass = modelClass.getJavaClass();
    // JaxbHelper jaxbHelper = JaxbHelper.get(javaClass);
    final ServiceProvider serviceProvider = modelClass.getProvider();
    String id = item.getId();
    if (Strings.isNullOrEmpty(id)) {
        if (generateUniqueName) {
            id = serviceProvider.buildItemId(modelClass, item);
        } else {
            // otherwise we end up with lots of randomly named items
            throw new OpsException("Must specify item id");
        // id = UUID.randomUUID().toString();
        // item.setId(id);
        }
    }
    ProjectId project = getProjectId(auth);
    PlatformLayerKey itemKey = new PlatformLayerKey(null, project, modelClass.getServiceType(), modelClass.getItemType(), new ManagedItemId(id));
    item.setKey(itemKey);
    item.state = ManagedItemState.CREATION_REQUESTED;
    final OpsContext opsContext = buildTemporaryOpsContext(modelClass.getServiceType(), auth);
    T created = OpsContext.runInContext(opsContext, new CheckedCallable<T, Exception>() {

        @Override
        public T call() throws Exception {
            PlatformLayerKey itemKey = item.getKey();
            T existing;
            SecretProvider secretProvider = SecretProvider.from(auth);
            if (uniqueTagKey != null) {
                boolean fetchTags = true;
                Tag uniqueTag = null;
                for (Tag tag : item.getTags()) {
                    if (Objects.equal(tag.getKey(), uniqueTagKey)) {
                        uniqueTag = tag;
                    }
                }
                if (uniqueTag == null) {
                    throw new IllegalArgumentException("Could not find unique tag");
                }
                Filter filter = TagFilter.byTag(uniqueTag);
                filter = StateFilter.excludeDeleted(filter);
                existing = null;
                List<T> existingList = repository.findAll(modelClass, itemKey.getProject(), fetchTags, secretProvider, filter);
                if (!existingList.isEmpty()) {
                    if (existingList.size() != 1) {
                        throw new IllegalArgumentException("Found multiple items with unique tag");
                    }
                    existing = existingList.get(0);
                }
                if (existing == null) {
                    itemKey = findUniqueId(item, itemKey, secretProvider);
                }
            } else {
                if (generateUniqueName) {
                    itemKey = findUniqueId(item, itemKey, secretProvider);
                }
                try {
                    boolean fetchTags = true;
                    existing = Casts.checkedCast(repository.getManagedItem(itemKey, fetchTags, secretProvider), javaClass);
                } catch (RepositoryException e) {
                    throw new OpsException("Error fetching item from database", e);
                }
            }
            if (!canExist && existing != null) {
                throw new OpsException("Item already exists");
            }
            serviceProvider.beforeCreateItem(item);
            ProjectId project = getProjectId(auth);
            T newItem;
            try {
                if (existing == null) {
                    newItem = repository.createManagedItem(project, item);
                } else {
                    item.secret = existing.secret;
                    item.setKey(existing.getKey());
                    newItem = repository.updateManagedItem(project, item);
                    TagChanges tagChanges = new TagChanges();
                    for (Tag tag : item.getTags()) {
                        if (newItem.getTags().hasTag(tag)) {
                            continue;
                        }
                        boolean uniqueTagKey = false;
                        if (tag.getKey().equals(Tag.PARENT.getKey())) {
                            uniqueTagKey = true;
                        }
                        tagChanges.addTags.add(tag);
                        if (uniqueTagKey) {
                            for (Tag oldTag : newItem.getTags().findTags(tag.getKey())) {
                                tagChanges.removeTags.add(oldTag);
                            }
                        }
                    }
                    if (!tagChanges.isEmpty()) {
                        repository.changeTags(modelClass, project, newItem.getKey().getItemId(), tagChanges, null);
                    }
                }
            } catch (RepositoryException e) {
                throw new OpsException("Error writing object to database", e);
            }
            itemKey = newItem.getKey();
            JobData jobKey = changeQueue.notifyChange(auth, itemKey, ManagedItemState.CREATION_REQUESTED);
            return newItem;
        }

        private <T extends ItemBase> PlatformLayerKey findUniqueId(final T item, final PlatformLayerKey itemKey, SecretProvider secretProvider) throws RepositoryException {
            int sequence = 0;
            while (true) {
                String tryId = item.getId();
                if (sequence != 0) {
                    tryId += sequence;
                }
                final PlatformLayerKey tryKey = itemKey.withId(new ManagedItemId(tryId));
                boolean fetchTags = false;
                ItemBase found = repository.getManagedItem(tryKey, fetchTags, secretProvider);
                if (found == null) {
                    item.setKey(tryKey);
                    return tryKey;
                }
                sequence++;
            }
        }
    });
    return created;
}

Example 33 with ItemBase

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

the class ItemServiceImpl method deleteItem.

@Override
public JobData deleteItem(final ProjectAuthorization auth, final PlatformLayerKey targetItemKey) throws OpsException {
    SecretProvider secretProvider = SecretProvider.from(auth);
    boolean fetchTags = true;
    ItemBase targetItem;
    try {
        targetItem = repository.getManagedItem(targetItemKey, fetchTags, secretProvider);
    } catch (RepositoryException e) {
        throw new OpsException("Error reading item", e);
    }
    if (targetItem == null) {
        throw new IllegalStateException("Item not found");
    }
    targetItem.state = ManagedItemState.DELETE_REQUESTED;
    final ServiceProvider serviceProvider = serviceProviderDirectory.getServiceProvider(targetItemKey.getServiceType());
    if (serviceProvider == null) {
        throw new IllegalStateException("Unknown service type");
    }
    final OpsContext opsContext = buildTemporaryOpsContext(targetItemKey.getServiceType(), auth);
    JobData jobKey = OpsContext.runInContext(opsContext, new CheckedCallable<JobData, Exception>() {

        @Override
        public JobData call() throws Exception {
            try {
                repository.changeState(targetItemKey, ManagedItemState.DELETE_REQUESTED);
            } catch (RepositoryException e) {
                throw new OpsException("Error writing object to database", e);
            }
            return changeQueue.notifyChange(auth, targetItemKey, ManagedItemState.DELETE_REQUESTED);
        }
    });
    return jobKey;
}

Example 34 with ItemBase

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

the class ManagedItemResource method listChildren.

@GET
@Produces({ XML, JSON })
@Path("children")
public ManagedItemCollection<ItemBase> listChildren(@QueryParam("deleted") boolean includeDeleted) throws OpsException, RepositoryException {
    boolean fetchTags = true;
    ItemBase item = getManagedItem(fetchTags);
    Tag parentTag = Tag.buildParentTag(item.getKey());
    Filter filter = TagFilter.byTag(parentTag);
    if (!includeDeleted) {
        filter = StateFilter.excludeDeleted(filter);
    }
    List<ItemBase> roots = itemService.listAll(getProjectAuthorization(), filter);
    ManagedItemCollection<ItemBase> collection = new ManagedItemCollection<ItemBase>();
    collection.items = roots;
    return cleanup(collection);
}

Example 35 with ItemBase

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

the class JdbcManagedItemRepository method listAll.

@Override
@JdbcTransaction
public List<ItemBase> listAll(ProjectId project, Filter filter, SecretProvider secretProvider) throws RepositoryException {
    DbHelper db = new DbHelper(project);
    try {
        log.debug("listAll with filter: {}", filter);
        // TODO: Use this logic for item selection as well
        List<Tag> requiredTags = filter.getRequiredTags();
        JoinedQueryResult result;
        if (!requiredTags.isEmpty()) {
            Tag requiredTag = requiredTags.get(0);
            int projectId = db.mapToValue(project);
            result = db.queries.listAllItemsWithTag(projectId, projectId, requiredTag.getKey(), requiredTag.getValue());
        } else {
            log.warn("Unable to optimize filter; selecting all items.  Filter={}", filter);
            result = db.listAllItems();
        }
        List<ItemBase> items = mapItemsAndTags(project, secretProvider, db, result);
        return applyFilter(items, filter);
    } catch (SQLException e) {
        throw new RepositoryException("Error fetching items", e);
    } finally {
        db.close();
    }
}