/** * Add requests to the supplied composite request. * * @param composite the composite request to which the requests are to be added * @param requests the requests to wrap * @return the requests wrapped in a CompositeRequest, or if only one request is supplied that single request, or null if * there are no request * @throws IllegalArgumentException if the composite request is null */ public static CompositeRequest add( CompositeRequest composite, Request... requests ) { CheckArg.isNotNull(composite, "composite"); if (requests == null || requests.length == 0) return composite; List<Request> list = new ArrayList<Request>(requests.length + composite.size()); boolean readOnly = composite.isReadOnly(); if (composite.size() != 0) list.addAll(composite.getRequests()); for (Request request : requests) { if (request == null) continue; if (RequestType.COMPOSITE == request.getType()) { CompositeRequest compositeRequest = (CompositeRequest)request; list.addAll(compositeRequest.getRequests()); if (!compositeRequest.isReadOnly()) readOnly = false; } else { list.add(request); if (!request.isReadOnly()) readOnly = false; } } return new CompositeRequest(list, readOnly); }
/** * {@inheritDoc} * * @see org.modeshape.graph.request.Request#hasError() */ @Override public boolean hasError() { return compositeError != null || super.hasError(); } }
/** * {@inheritDoc} * * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals( Object obj ) { if (obj == this) return true; if (obj instanceof CompositeRequest) { CompositeRequest that = (CompositeRequest)obj; if (this.size() != that.size()) return false; Iterator<Request> thisIter = this.iterator(); Iterator<Request> thatIter = that.iterator(); while (thisIter.hasNext()) { Request thisRequest = thisIter.next(); Request thatRequest = thatIter.next(); if (thisRequest == null) { if (thatRequest != null) return false; } else { if (!thisRequest.equals(thatRequest)) return false; } } return true; } return false; }
@Override public String toString() { StringBuffer buff = new StringBuffer(); buff.append("[CompositeRequest (" + size() + ")"); for (Request r : this.getRequests()) { buff.append("\n\t").append(r); } buff.append("]"); return buff.toString(); }
@Test public void shouldCreateCompositeFromMultipleRequests() { request = CompositeRequest.with(requests); assertThat(request, is(instanceOf(CompositeRequest.class))); CompositeRequest composite = (CompositeRequest)request; assertThat(composite.size(), is(3)); assertThat(composite.size(), is(requests.length)); assertThat(composite.getRequests(), hasItems(requests)); Iterator<Request> actual = composite.iterator(); Iterator<Request> expected = requestList.iterator(); while (actual.hasNext() && expected.hasNext()) { assertThat(actual.next(), is(sameInstance(expected.next()))); } assertThat(actual.hasNext(), is(expected.hasNext())); assertThat(composite.hasError(), is(false)); }
@Override protected Request createRequest() { return CompositeRequest.with(requests); }
/** * Return a request that either wraps multiple requests, or the single request if only one is supplied. * * @param requests the requests to wrap * @return the requests wrapped in a CompositeRequest, or if only one request is supplied that single request * @throws IllegalArgumentException if there requests are null, empty, or contains only nulls */ public static Request with( Iterator<? extends Request> requests ) { CheckArg.isNotNull(requests, "requests"); boolean readOnly = true; List<Request> list = new LinkedList<Request>(); while (requests.hasNext()) { Request request = requests.next(); if (request == null) continue; if (RequestType.COMPOSITE == request.getType()) { CompositeRequest composite = (CompositeRequest)request; list.addAll(composite.getRequests()); if (!composite.isReadOnly()) readOnly = false; } else { list.add(request); if (!request.isReadOnly()) readOnly = false; } } if (list.size() == 1) { return list.get(0); } CheckArg.isNotEmpty(list, "requests"); return new CompositeRequest(list, readOnly); }
if (request == null) return; boolean hasErrors = false; boolean readonly = request.isReadOnly(); Iterator<Request> iter = request.iterator(); while (iter.hasNext()) { Request embedded = iter.next(); request.setError(embedded.getError()); request.checkForErrors();
protected boolean shouldProcessSynchronously( Request request ) { if (RequestType.COMPOSITE == request.getType()) { CompositeRequest composite = (CompositeRequest)request; if (composite.size() <= 1) return true; // There is more than one request, and the JoinRequestProcessor needs to be able to run even if // the ForkRequestProcessor is processing incoming requests. Normally this would work fine, // but if the incoming request is a CompositeRequestChannel.CompositeRequest, the ForkRequestProcessor // will block if the channel is still open. In a synchronous mode, this prevents the JoinRequestProcessor // from completing the incoming requests. See ModeShape-616 for details. return false; } // Otherwise, its just a single request ... return true; }
private void cancelAllRequestsDueToError( Throwable t ) { LOGGER.error(t, GraphI18n.executingRequest, sourceName); try { for (Request request : this.composite.getRequests()) { try { request.cancel(); } finally { request.freeze(); } } cancel(true); } finally { this.composite.freeze(); } }
protected void extractRequestsFromComposite() { Request request = executedRequests.poll(); assertThat(request, is(instanceOf(CompositeRequest.class))); executedRequests.addAll(0, ((CompositeRequest)request).getRequests()); }
@Test public void shouldImportXmlContentAndGenerateTheCorrectCommands() throws Exception { // System.out.println(xmlContent); Graph.Batch batch = importer.importXml(xmlContent, Location.create(destinationPath)); batch.execute(); // 'lastExecutedCommand' assertThat(lastExecutedRequest, is(instanceOf(CompositeRequest.class))); Iterator<Request> iter = ((CompositeRequest)lastExecutedRequest).iterator(); // assertCreateNode(iter, "/a/b/", "jcr:primaryType={http://www.modeshape.org/xml/1.0}document"); assertCreateNode(iter, "/a/b/mode:system[1]", "jcr:primaryType={http://www.jcp.org/jcr/nt/1.0}unstructured"); assertCreateNode(iter, "/a/b/mode:system[1]/mode:sources[1]", "jcr:primaryType={http://www.jcp.org/jcr/nt/1.0}unstructured"); assertCreateNode(iter, "/a/b/mode:system[1]/mode:sources[1]/sourceA[1]", "repositoryName=repositoryA", "retryLimit=3", "jcr:primaryType={http://www.modeshape.org/1.0}xyz", "mode:classname=org.modeshape.connector.inmemory.InMemoryRepositorySource"); assertCreateNode(iter, "/a/b/mode:system[1]/mode:sources[1]/sourceB[1]", "repositoryName=repositoryB", "jcr:primaryType={http://www.jcp.org/jcr/nt/1.0}unstructured", "mode:classname=org.modeshape.connector.inmemory.InMemoryRepositorySource"); assertThat(iter.hasNext(), is(false)); }
/** * Cancel this forked channel, stopping work as soon as possible. If the channel has not yet been started, this method * * @param mayInterruptIfRunning true if the channel is still being worked on, and the thread on which its being worked on may * be interrupted, or false if the channel should be allowed to finish if it is already in work. */ public void cancel( boolean mayInterruptIfRunning ) { if (this.future == null || this.future.isDone() || this.future.isCancelled()) return; // Mark the composite as cancelled first, so that the next composed request will be marked as // cancelled. this.composite.cancel(); // Now mark the channel as being done ... close(); // Now, mark the channel as being cancelled (do allow interrupting the worker thread) ... this.future.cancel(mayInterruptIfRunning); }
/** * Return a request that either wraps multiple requests, or the single request if only one is supplied. * * @param requests the requests to wrap * @return the requests wrapped in a CompositeRequest, or if only one request is supplied that single request * @throws IllegalArgumentException if there requests are null or empty */ public static Request with( List<? extends Request> requests ) { CheckArg.isNotEmpty(requests, "requests"); if (requests.size() == 1) { return requests.get(0); } boolean readOnly = true; for (Request request : requests) { readOnly = request.isReadOnly(); if (!readOnly) break; } return new CompositeRequest(requests, readOnly); }
((CompositeRequest)request).checkForErrors();
@Test public void shouldCreateCompositeFromIteratorOverRequests() { request = CompositeRequest.with(requestList.iterator()); assertThat(request, is(instanceOf(CompositeRequest.class))); CompositeRequest composite = (CompositeRequest)request; assertThat(composite.size(), is(3)); assertThat(composite.size(), is(requestList.size())); assertThat(composite.getRequests(), hasItems(requests)); Iterator<Request> actual = composite.iterator(); Iterator<Request> expected = requestList.iterator(); while (actual.hasNext() && expected.hasNext()) { assertThat(actual.next(), is(sameInstance(expected.next()))); } assertThat(actual.hasNext(), is(expected.hasNext())); assertThat(composite.hasError(), is(false)); }
protected Map<Location, Property> execute( List<ReadPropertyRequest> requests ) { // Create a composite request ... Request composite = CompositeRequest.with(requests); Graph.this.execute(composite); Map<Location, Property> results = new HashMap<Location, Property>(); for (ReadPropertyRequest request : requests) { Property property = request.getProperty(); Location location = request.getActualLocationOfNode(); results.put(location, property); } return results; } };
/** * Return a request that either wraps multiple requests, or the single request if only one is supplied. * * @param requests the requests to wrap * @return the requests wrapped in a CompositeRequest, or if only one request is supplied that single request * @throws IllegalArgumentException if there requests are null, empty, or contains only nulls */ public static Request with( Request... requests ) { CheckArg.isNotEmpty(requests, "requests"); if (requests.length == 1) { CheckArg.isNotNull(requests[0], "requests[0]"); return requests[0]; } boolean readOnly = true; List<Request> list = new ArrayList<Request>(requests.length); for (Request request : requests) { if (request == null) continue; if (RequestType.COMPOSITE == request.getType()) { CompositeRequest composite = (CompositeRequest)request; list.addAll(composite.getRequests()); if (!composite.isReadOnly()) readOnly = false; } else { list.add(request); if (!request.isReadOnly()) readOnly = false; } } CheckArg.isNotEmpty(list, "requests"); return new CompositeRequest(list, readOnly); }