Examples with DistributionException org.apache.sling.distribution.common.DistributionException used on opensource projects

Example 21 with DistributionException

use of org.apache.sling.distribution.common.DistributionException in project sling by apache.

the class ImportingDistributionPackageProcessor method process.

@Override
public void process(DistributionPackage distributionPackage) {
    final long startTime = System.currentTimeMillis();
    try {
        // set up original calling RR
        ResourceResolver resourceResolver = DistributionUtils.getResourceResolver(callingUser, authenticationInfo.getAgentService(), authenticationInfo.getSlingRepository(), authenticationInfo.getSubServiceName(), authenticationInfo.getResourceResolverFactory());
        // perform importing
        distributionPackageImporter.importPackage(resourceResolver, distributionPackage);
        // collect stats
        packagesSize.addAndGet(distributionPackage.getSize());
        packagesCount.incrementAndGet();
        DistributionResponse response = new SimpleDistributionResponse(DistributionRequestState.ACCEPTED, "package imported");
        allResponses.add(response);
        final long endTime = System.currentTimeMillis();
        log.debug("PACKAGE-IMPORTED {}: packageId={}, paths={}, responses={}", requestId, distributionPackage.getId(), distributionPackage.getInfo().getPaths(), endTime - startTime, response);
    } catch (DistributionException e) {
        log.error("an error happened during package import", e);
        allResponses.add(new SimpleDistributionResponse(DistributionRequestState.DROPPED, e.toString()));
    }
}

Example 22 with DistributionException

use of org.apache.sling.distribution.common.DistributionException in project sling by apache.

the class QueueingDistributionPackageProcessor method scheduleImportPackage.

private Collection<SimpleDistributionResponse> scheduleImportPackage(DistributionPackage distributionPackage, String callingUser, String requestId, long startTime) {
    Collection<SimpleDistributionResponse> distributionResponses = new LinkedList<SimpleDistributionResponse>();
    // dispatch the distribution package to one or more queues
    try {
        // add metadata to the package
        distributionPackage.getInfo().put(DistributionPackageUtils.PACKAGE_INFO_PROPERTY_REQUEST_USER, callingUser);
        distributionPackage.getInfo().put(DistributionPackageUtils.PACKAGE_INFO_PROPERTY_REQUEST_ID, requestId);
        distributionPackage.getInfo().put(DistributionPackageUtils.PACKAGE_INFO_PROPERTY_REQUEST_START_TIME, startTime);
        // put the package in the queue
        Iterable<DistributionQueueItemStatus> states = scheduleQueueStrategy.add(distributionPackage, queueProvider);
        for (DistributionQueueItemStatus state : states) {
            DistributionRequestState requestState = getRequestStateFromQueueState(state.getItemState());
            distributionResponses.add(new SimpleDistributionResponse(requestState, state.getItemState().toString()));
        }
        distributionEventFactory.generatePackageEvent(DistributionEventTopics.AGENT_PACKAGE_QUEUED, DistributionComponentKind.AGENT, agentName, distributionPackage.getInfo());
    } catch (DistributionException e) {
        log.error("an error happened during dispatching items to the queue(s)", e);
        distributionResponses.add(new SimpleDistributionResponse(DistributionRequestState.DROPPED, e.toString()));
    }
    return distributionResponses;
}

Example 23 with DistributionException

use of org.apache.sling.distribution.common.DistributionException in project sling by apache.

the class SimpleDistributionAgent method getQueue.

public DistributionQueue getQueue(@Nonnull final String queueName) {
    Set<String> queues = getQueueNames();
    if (!queues.contains(queueName)) {
        return null;
    }
    DistributionQueue queue = null;
    try {
        queue = queueProvider.getQueue(queueName);
    } catch (DistributionException e) {
        log.error("cannot get queue", e);
    }
    if (queue != null) {
        boolean isPausedQueue = !queueProcessingEnabled && (processingQueues != null && processingQueues.contains(queueName));
        queue = new SimpleAgentDistributionQueue(queue, isPausedQueue, name);
    }
    return queue;
}

Example 24 with DistributionException

use of org.apache.sling.distribution.common.DistributionException in project sling by apache.

the class SimpleDistributionAgent method execute.

@Nonnull
public DistributionResponse execute(@Nonnull ResourceResolver resourceResolver, @Nonnull DistributionRequest distributionRequest) throws DistributionException {
    ResourceResolver agentResourceResolver = null;
    final String requestId = "DSTRQ" + nextRequestId.incrementAndGet();
    String callingUser = resourceResolver.getUserID();
    try {
        // check if the request type can be executed by this agent
        if (!isAcceptedRequestType(distributionRequest)) {
            log.debug("request type not accepted {}", distributionRequest.getRequestType());
            return new SimpleDistributionResponse(DistributionRequestState.DROPPED, "Request type not accepted");
        }
        // check if the request paths can be distributed via this agent
        if (!isAcceptedRequestRoot(distributionRequest)) {
            log.debug("request paths not accepted {}", Arrays.toString(distributionRequest.getPaths()));
            return new SimpleDistributionResponse(DistributionRequestState.DROPPED, "Request paths not accepted");
        }
        boolean silent = DistributionRequestType.PULL.equals(distributionRequest.getRequestType());
        log.info(silent, "REQUEST-START {}: {} paths={}, user={}", requestId, distributionRequest.getRequestType(), distributionRequest.getPaths(), callingUser);
        // check permissions
        distributionRequestAuthorizationStrategy.checkPermission(resourceResolver, distributionRequest);
        agentResourceResolver = DistributionUtils.getResourceResolver(callingUser, agentAuthenticationInfo.getAgentService(), agentAuthenticationInfo.getSlingRepository(), agentAuthenticationInfo.getSubServiceName(), agentAuthenticationInfo.getResourceResolverFactory());
        // export packages
        CompositeDistributionResponse distributionResponse = exportPackages(agentResourceResolver, distributionRequest, callingUser, requestId);
        log.debug("REQUEST-STARTED {}: {} paths={}, success={}, state={}, exportTime={}ms, noPackages={}, size={}B, noQueues={}", requestId, distributionRequest.getRequestType(), distributionRequest.getPaths(), distributionResponse.isSuccessful(), distributionResponse.getState(), distributionResponse.getExportTime(), distributionResponse.getPackagesCount(), distributionResponse.getPackagseSize(), distributionResponse.getQueuesCount());
        return distributionResponse;
    } catch (DistributionException e) {
        log.error("REQUEST-FAIL {}: {} paths={}, user={}, message={}", requestId, distributionRequest.getRequestType(), distributionRequest.getPaths(), callingUser, e.getMessage());
        throw e;
    } finally {
        DistributionUtils.ungetResourceResolver(agentResourceResolver);
    }
}

Example 25 with DistributionException

use of org.apache.sling.distribution.common.DistributionException in project sling by apache.

the class AsyncDeliveryDispatchingStrategy method add.

@Override
public Iterable<DistributionQueueItemStatus> add(@Nonnull DistributionPackage distributionPackage, @Nonnull DistributionQueueProvider queueProvider) throws DistributionException {
    if (!(distributionPackage instanceof SharedDistributionPackage) && deliveryMappings.size() > 1) {
        throw new DistributionException("distribution package must be a shared package to be added in multiple queues");
    }
    String distributionPackageId = distributionPackage.getId();
    List<DistributionQueueItemStatus> result = new LinkedList<DistributionQueueItemStatus>();
    for (String referenceQueueName : deliveryMappings.keySet()) {
        DistributionQueue queue = queueProvider.getQueue(referenceQueueName);
        int MAX_QUEUE_ITEMS_THRESHOLD = 100;
        if (queue.getStatus().getItemsCount() > MAX_QUEUE_ITEMS_THRESHOLD) {
            // too many items in the queue, let's send actual packages and references separately
            distributionPackage.getInfo().put("reference-required", true);
            DistributionQueueItem item = getItem(distributionPackage);
            // create and acquire reference package
            ReferencePackage referencePackage = new ReferencePackage(distributionPackage);
            DistributionPackageUtils.acquire(referencePackage, referenceQueueName);
            // acquire actual package
            String deliveryQueueName = deliveryMappings.get(referenceQueueName);
            DistributionPackageUtils.acquire(distributionPackage, deliveryQueueName);
            // add the actual package to the delivery queue
            DistributionQueue deliveryQueue = queueProvider.getQueue(deliveryQueueName);
            DistributionQueueEntry deliveryQueueEntry = deliveryQueue.add(item);
            if (deliveryQueueEntry != null) {
                DistributionQueueItemStatus status = deliveryQueueEntry.getStatus();
                log.debug("item {} added to delivery queue: {}", item, status);
                result.add(status);
            } else {
                DistributionPackageUtils.release(distributionPackage, deliveryQueueName);
                log.error("cannot add package {} to delivery queue {}", distributionPackageId, deliveryQueueName);
                result.add(new DistributionQueueItemStatus(DistributionQueueItemState.ERROR, deliveryQueue.getName()));
            }
            // add the reference package to the reference queue
            DistributionQueue referenceQueue = queueProvider.getQueue(referenceQueueName);
            DistributionQueueItem referenceQueueItem = getItem(referencePackage);
            DistributionQueueEntry referenceQueueEntry = referenceQueue.add(referenceQueueItem);
            if (referenceQueueEntry != null) {
                DistributionQueueItemStatus status = referenceQueueEntry.getStatus();
                log.debug("item {} added to reference queue: {}", referenceQueueItem, status);
            } else {
                DistributionPackageUtils.release(referencePackage, referenceQueueName);
                log.error("cannot add package {} to reference queue {}", distributionPackageId, referenceQueueName);
                result.add(new DistributionQueueItemStatus(DistributionQueueItemState.ERROR, referenceQueue.getName()));
            }
        } else {
            // normal queueing
            DistributionQueueItem item = getItem(distributionPackage);
            DistributionQueueItemStatus status = new DistributionQueueItemStatus(DistributionQueueItemState.ERROR, queue.getName());
            DistributionPackageUtils.acquire(distributionPackage, referenceQueueName);
            DistributionQueueEntry queueEntry = queue.add(item);
            if (queueEntry != null) {
                status = queueEntry.getStatus();
                log.debug("item {} added to queue: {}", item, status);
            } else {
                DistributionPackageUtils.release(distributionPackage, referenceQueueName);
                log.error("cannot add package {} to queue {}", distributionPackageId, referenceQueueName);
            }
            result.add(status);
        }
    }
    return result;
}