public boolean onUpload(String fileName, String contentType, InputStream uploadData) throws Exception { Object[] args = new Object[]{fileName, uploadData}; WorkContext workContext = WorkContextCache.getAndResetThreadWorkContext(); Message input = MessageCache.getAndResetMessage(); try { // set the header value for the request context workContext.setHeader(FtpConstants.HEADER_CONTENT_TYPE, contentType); input.setWorkContext(workContext); input.setBody(args); Message response = getInterceptor().invoke(input); if (response.isFault()) { monitor.fileProcessingError(servicePath, (Throwable) response.getBody()); input.reset(); return false; } return true; } finally { input.reset(); workContext.reset(); } }
public Message invoke(Message msg) { byte[] body = (byte[]) msg.getBody(); WorkContext workContext = msg.getWorkContext(); byte[] value = sender.sendAndReply(body, index, workContext); msg.setBody(value); return msg; }
Object[] payload = (Object[]) message.getBody(); message.setBody(new Object[]{omElement}); Object result = response.getBody(); response.setBodyWithFault(fault); } catch (InstantiationException e) { throw new AssertionError(); response.setBody(jaxbObject);
public Message invoke(Message msg) { byte[] body = (byte[]) msg.getBody(); WorkContext workContext = msg.getWorkContext(); sender.send(body, index, workContext); return ONE_WAY_RESPONSE; }
private Message transformOutput(Message ret) { // FIXME For exception transformation, if it is checked convert as application fault Object body = ret.getBody(); // TODO handle null types if (body != null) { try { Object transformed = outTransformer.transform(body, outLoader); if (ret.isFault()) { ret.setBodyWithFault(transformed); } else { ret.setBody(transformed); } } catch (ClassCastException e) { // an unexpected type was returned by the target service or an interceptor later in the chain. This is an error in the extension or // interceptor and not user code since errors should be trapped and returned in the format expected by the transformer if (body instanceof Throwable) { throw new ServiceRuntimeException("Unexpected exception returned", (Throwable) body); } else { throw new ServiceRuntimeException("Unexpected type returned: " + body.getClass()); } } catch (TransformationException e) { throw new ServiceRuntimeException(e); } } return ret; }
Object[] payload = (Object[]) msg.getBody(); OMElement message = payload == null ? null : (OMElement) payload[0]; options.setProperty(Constants.Configuration.ENABLE_MTOM, Constants.VALUE_TRUE); Subject subject = msg.getWorkContext().getSubject(); if (subject != null && !subject.getPrincipals().isEmpty()) { Principal primaryPrincipal = subject.getPrincipals().iterator().next(); throw e; //retry ret.setBodyWithFault(e.getDetail()); Object result = sender.sendReceive(message); if (result instanceof Throwable) { ret.setBodyWithFault(result); } else { ret.setBody(result);
public Message invoke(Message message) { Object[] args = (Object[]) message.getBody(); ClassLoader old = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(getClass().getClassLoader()); Object body = response.build(args); message.reset(); message.setBody(body); } catch (RuntimeException e) { throw new ServiceRuntimeException(e); } finally { Thread.currentThread().setContextClassLoader(old); } return message; }
public void run() { Message request = MessageCache.getAndResetMessage(); try { request.setBody(frames[0]); int methodIndex = ByteBuffer.wrap(frames[1]).getInt(); WorkContext context = setWorkContext(frames[2]); request.setWorkContext(context); Interceptor interceptor = interceptors[methodIndex]; interceptor.invoke(request); } finally { request.reset(); } } });
ftpClient.connect(hostAddress, port); monitor.onResponse(ftpClient.getReplyString()); String type = msg.getWorkContext().getHeader(String.class, FtpConstants.HEADER_CONTENT_TYPE); if (type != null && type.equalsIgnoreCase(FtpConstants.BINARY_TYPE)) { monitor.onCommand("TYPE I"); monitor.onResponse(ftpClient.getReplyString()); Object[] args = (Object[]) msg.getBody(); String fileName = (String) args[0]; String remoteFileLocation = fileName; msg.reset(); return msg;
public Message invoke(Message msg) { WorkContext workContext = msg.getWorkContext(); try { SecuritySubject subject = workContext.getSubject(); if (subject == null) { msg.setBodyWithFault(new ServiceRuntimeException("Subject not authenticated")); return msg; } authorizationService.checkRoles(subject, roles); return next.invoke(msg); } catch (AuthorizationException e) { msg.setBodyWithFault(new ServiceRuntimeException(e)); return msg; } }
private Object handleFault(Message ret) throws InvocationTargetException { if (ret.getBody() instanceof ServiceRuntimeException) { ServiceRuntimeException e = (ServiceRuntimeException) ret.getBody(); if (e.getCause() instanceof NotAuthorizedException) { // authorization exceptions need to be mapped to a client 403 response throw new InvocationTargetException(new WebApplicationException(Response.Status.FORBIDDEN)); } throw new InvocationTargetException(e); } throw new InvocationTargetException((Throwable) ret.getBody()); }
public Message invoke(Message msg) { Object ret = null; // TODO cater for the overloaded createEntityManager method if ("createEntityManager".equals(opName)) { ret = entityManagerFactory.createEntityManager(); } else if ("close".equals(opName)) { entityManagerFactory.close(); } else if ("isOpen".equals(opName)) { ret = entityManagerFactory.isOpen(); } Message result = new MessageImpl(); result.setBody(ret); return result; }
public Message invoke(Message msg) { SecuritySubject subject = msg.getWorkContext().getSubject(); Authentication old = SecurityContextHolder.getContext().getAuthentication(); try { if (subject != null) { Authentication authentication = subject.getDelegate(Authentication.class); SecurityContextHolder.getContext().setAuthentication(authentication); } return next.invoke(msg); } finally { SecurityContextHolder.getContext().setAuthentication(old); } }
private Message interceptService(Message message) { Object[] payload = (Object[]) message.getBody(); if (payload != null && payload.length > 0) { OMElement omElement = (OMElement) payload[0]; Object jaxbObject = inTransformer.transform(omElement, null); message.setBody(new Object[]{jaxbObject}); } Message response = next.invoke(message); Object result; if (response.isFault()) { Object webFault = response.getBody(); result = getFault(webFault); } else { result = response.getBody(); } if (result != null) { OMElement omElement = outTransformer.transform(result, null); response.setBody(omElement); } return response; }
public Message invoke(Message msg) { Object body = msg.getBody(); if (body == null || !body.getClass().isArray()) { return next.invoke(msg); } Object[] payload = (Object[]) body; if (payload.length != 1) { throw new ServiceRuntimeException("Unexpected payload size: " + payload.length); } msg.setBody(payload[0]); return next.invoke(msg); }
public Message invoke(final Message msg) { WorkContext workContext = msg.getWorkContext(); List<CallbackReference> newStack = null; List<CallbackReference> stack = workContext.getCallbackReferences(); if (stack != null && !stack.isEmpty()) { // clone the callstack to avoid multiple threads seeing changes newStack = new ArrayList<CallbackReference>(stack); } Map<String, Object> newHeaders = null; Map<String, Object> headers = workContext.getHeaders(); if (headers != null && !headers.isEmpty()) { // clone the headers to avoid multiple threads seeing changes newHeaders = new HashMap<String, Object>(headers); } SecuritySubject subject = workContext.getSubject(); Object payload = msg.getBody(); AsyncRequest request = new AsyncRequest(next, payload, subject, newStack, newHeaders, monitor); executorService.execute(request); return RESPONSE; }