protected void setSubscriptionsOnDescriptor(MuleDescriptor descriptor) throws UMOException { List endpoints = new ArrayList(); for (Iterator iterator = listeners.iterator(); iterator.hasNext(); ) { ApplicationListener listener = (ApplicationListener) iterator.next(); if (listener instanceof AsynchronousEventListener) { listener = ((AsynchronousEventListener) listener).getListener(); } if (listener instanceof MuleSubscriptionEventListener) { String[] subscriptions = ((MuleSubscriptionEventListener) listener).getSubscriptions(); for (int i = 0; i < subscriptions.length; i++) { if (subscriptions[i].indexOf("*") == -1 && MuleEndpointURI.isMuleUri(subscriptions[i])) { boolean isSoap = registerAsSoap(subscriptions[i], listener); if (!isSoap) { endpoints.add(subscriptions[i]); } } } } } if (endpoints.size() > 0) { for (Iterator iterator = endpoints.iterator(); iterator.hasNext(); ) { String endpoint = (String) iterator.next(); MuleEndpoint ep = new MuleEndpoint(endpoint, true); // check whether the endpoint has already been set on the MuleEventMulticastor if (descriptor.getInboundRouter().getEndpoint(ep.getName()) == null) { descriptor.getInboundRouter().addEndpoint(ep); } } } }
public void initialise() throws InitialisationException { if (wireFormat == null) { wireFormat = new SerializationWireFormat(); } try { if (StringUtils.isEmpty(serverUri)) { // no serverUrl specified, warn a user logger.warn( "No serverUriUrl specified, MuleAdminAgent will not start. E.g. use " + "<mule:admin-agent serverUri=\"tcp://example.com:60504\"/> "); // abort the agent registration process managementContext.getRegistry().unregisterAgent(this.getName()); return; } // Check for override if (ModelHelper.isComponentRegistered(MuleManagerComponent.MANAGER_COMPONENT_NAME)) { logger.info("Mule manager component has already been initialised, ignoring server url"); } else { if (managementContext.getRegistry().lookupConnector(DEFAULT_MANAGER_ENDPOINT) != null) { throw new AlreadyInitialisedException("Server Components", this); } MuleEndpoint writableEndpoint; // Check to see if we have an endpoint identifier UMOImmutableEndpoint endpoint = managementContext.getRegistry().lookupEndpoint(serverUri); if (endpoint == null) { UMOEndpointURI endpointUri = new MuleEndpointURI(serverUri); UMOConnector connector = TransportFactory.getOrCreateConnectorByProtocol(endpointUri); // If this connector has already been initialised i.e. it's a // pre-existing connector don't reinit if (managementContext.getRegistry().lookupConnector(connector.getName()) == null) { connector.setName(DEFAULT_MANAGER_ENDPOINT); connector.initialise(); managementContext.getRegistry().registerConnector(connector); } writableEndpoint = new MuleEndpoint(); writableEndpoint.setConnector(connector); writableEndpoint.setEndpointURI(endpointUri); } else { writableEndpoint = new MuleEndpoint(endpoint); } logger.info("Registering Admin listener on: " + serverUri); UMODescriptor descriptor = MuleManagerComponent.getDescriptor( writableEndpoint, wireFormat, RegistryContext.getConfiguration().getDefaultEncoding(), RegistryContext.getConfiguration().getDefaultSynchronousEventTimeout()); ModelHelper.registerSystemComponent(descriptor); } } catch (UMOException e) { throw new InitialisationException(e, this); } }
private MuleEndpoint buildEndpoint(String urlStr) throws EndpointException, MalformedEndpointException, UMOException { MuleEndpoint endpoint = new MuleEndpoint(); endpoint.setEndpointURI(new MuleEndpointURI(urlStr)); endpoint.setType(UMOEndpoint.ENDPOINT_TYPE_RECEIVER); endpoint.setFilter(new NotFilter(new WildcardFilter("*xyz*"))); // endpoint.setTransformer(new HttpRequestToString()); endpoint.setConnector(buildConnector(urlStr)); return endpoint; }
protected Object receiveAction(AdminNotification action, UMOEventContext context) throws UMOException { UMOMessage result = null; try { UMOEndpointURI endpointUri = new MuleEndpointURI(action.getResourceIdentifier()); UMOEndpoint endpoint = MuleEndpoint.getOrCreateEndpointForUri(endpointUri, UMOEndpoint.ENDPOINT_TYPE_SENDER); UMOMessageDispatcher dispatcher = endpoint.getConnector().getDispatcher(endpoint); long timeout = MapUtils.getLongValue( action.getProperties(), MuleProperties.MULE_EVENT_TIMEOUT_PROPERTY, MuleManager.getConfiguration().getSynchronousEventTimeout()); UMOEndpointURI ep = new MuleEndpointURI(action.getResourceIdentifier()); result = dispatcher.receive(ep, timeout); if (result != null) { // See if there is a default transformer on the connector UMOTransformer trans = ((AbstractConnector) endpoint.getConnector()).getDefaultInboundTransformer(); if (trans != null) { Object payload = trans.transform(result.getPayload()); result = new MuleMessage(payload, result); } ByteArrayOutputStream out = new ByteArrayOutputStream(); wireFormat.write(out, result); return out.toByteArray(); } else { return null; } } catch (Exception e) { return handleException(result, e); } }
/** * Depending on the session state this methods either Passes an event synchronously to the next * available Mule UMO in the pool or via the endpointUri configured for the event * * @param message the event message payload to send * @param endpointUri The endpointUri to disptch the event through * @return the return Message from the call or null if there was no result * @throws org.mule.umo.UMOException if the event fails to be processed by the component or the * transport for the endpointUri */ public UMOMessage sendEvent(UMOMessage message, UMOEndpointURI endpointUri) throws UMOException { UMOEndpoint endpoint = MuleEndpoint.getOrCreateEndpointForUri(endpointUri, UMOEndpoint.ENDPOINT_TYPE_SENDER); // If synchronous receive has not been explicitly set, default it to // true setRemoteSync(message, endpoint); return session.sendEvent(message, endpoint); }
public RollbackExceptionListener(CountDownLatch countDown, UMOEndpointURI deadLetter) throws UMOException { this.countDown = countDown; UMOEndpoint ep = MuleEndpoint.createEndpointFromUri(deadLetter, UMOEndpoint.ENDPOINT_TYPE_SENDER); // lets include dispatch to the deadLetter queue in the sme tx. ep.setTransactionConfig(new MuleTransactionConfig()); ep.getTransactionConfig().setAction(UMOTransactionConfig.ACTION_JOIN_IF_POSSIBLE); super.addEndpoint(ep); }
/** * Will dispatch an application event through Mule * * @param applicationEvent the Spring event to be dispatched * @throws ApplicationEventException if the event cannot be dispatched i.e. if the underlying * transport throws an exception */ protected void dispatchEvent(MuleApplicationEvent applicationEvent) throws ApplicationEventException { UMOEndpoint endpoint = null; try { endpoint = MuleEndpoint.getOrCreateEndpointForUri( applicationEvent.getEndpoint(), UMOEndpoint.ENDPOINT_TYPE_SENDER); } catch (UMOException e) { throw new ApplicationEventException( "Failed to get endpoint for endpointUri: " + applicationEvent.getEndpoint(), e); } if (endpoint != null) { try { // if (applicationEvent.getEndpoint() != null) { // endpoint.setEndpointURI(applicationEvent.getEndpoint()); // } MuleMessage message = new MuleMessage(applicationEvent.getSource(), applicationEvent.getProperties()); // has dispatch been triggered using beanFactory.publish() // without a current event if (applicationEvent.getMuleEventContext() != null) { // tell mule not to try and route this event itself applicationEvent.getMuleEventContext().setStopFurtherProcessing(true); applicationEvent.getMuleEventContext().dispatchEvent(message, endpoint); } else { UMOSession session = new MuleSession( message, ((AbstractConnector) endpoint.getConnector()).getSessionHandler(), component); RequestContext.setEvent(new MuleEvent(message, endpoint, session, false)); // transform if necessary if (endpoint.getTransformer() != null) { message = new MuleMessage( endpoint.getTransformer().transform(applicationEvent.getSource()), applicationEvent.getProperties()); } endpoint.dispatch(new MuleEvent(message, endpoint, session, false)); } } catch (Exception e1) { throw new ApplicationEventException("Failed to dispatch event: " + e1.getMessage(), e1); } } else { throw new ApplicationEventException( "Failed endpoint using name: " + applicationEvent.getEndpoint()); } }
public UMOEndpoint createEndpoint( String uri, String name, boolean inbound, String transformers, UMOFilter filter) throws UMOException { UMOEndpoint ep = MuleEndpoint.createEndpointFromUri( new MuleEndpointURI(uri), (inbound ? UMOEndpoint.ENDPOINT_TYPE_RECEIVER : UMOEndpoint.ENDPOINT_TYPE_SENDER)); ep.setName(name); if (transformers != null) { String delim = (transformers.indexOf(",") > -1 ? "," : " "); ep.setTransformer(MuleObjectHelper.getTransformer(transformers, delim)); } ep.setFilter(filter); return ep; }
protected UMOStreamMessageAdapter sendStream(String uri, UMOStreamMessageAdapter sa) throws UMOException { UMOEndpoint ep = MuleEndpoint.getOrCreateEndpointForUri(uri, UMOEndpoint.ENDPOINT_TYPE_SENDER); ep.setStreaming(true); UMOMessage message = new MuleMessage(sa); UMOEvent event = new MuleEvent(message, ep, RequestContext.getEventContext().getSession(), true); UMOMessage result = ep.send(event); if (result != null) { if (result.getAdapter() instanceof UMOStreamMessageAdapter) { return (UMOStreamMessageAdapter) result.getAdapter(); } else { // TODO i18n (though this case should never happen...) throw new IllegalStateException( "Mismatch of stream states. A stream was used for outbound channel, but a stream was not used for the response"); } } return null; }
protected UMODescriptor getDefaultDescriptor() throws UMOException { // When the the beanFactory is refreshed all the beans get // reloaded so we need to unregister the component from Mule UMOModel model = MuleManager.getInstance().lookupModel(ModelHelper.SYSTEM_MODEL); if (model == null) { model = new SedaModel(); model.setName(ModelHelper.SYSTEM_MODEL); MuleManager.getInstance().registerModel(model); } UMODescriptor descriptor = model.getDescriptor(EVENT_MULTICASTER_DESCRIPTOR_NAME); if (descriptor != null) { model.unregisterComponent(descriptor); } descriptor = new MuleDescriptor(EVENT_MULTICASTER_DESCRIPTOR_NAME); if (subscriptions == null) { logger.info("No receive endpoints have been set, using default '*'"); descriptor.setInboundEndpoint(new MuleEndpoint("vm://*", true)); } else { // Set multiple inbound subscriptions on the descriptor UMOInboundRouterCollection messageRouter = descriptor.getInboundRouter(); for (int i = 0; i < subscriptions.length; i++) { String subscription = subscriptions[i]; UMOEndpointURI endpointUri = new MuleEndpointURI(subscription); UMOEndpoint endpoint = MuleEndpoint.getOrCreateEndpointForUri(endpointUri, UMOEndpoint.ENDPOINT_TYPE_RECEIVER); if (!asynchronous) { endpoint.setSynchronous(true); } messageRouter.addEndpoint(endpoint); } } // set the implementation name to this bean so Mule will manage it descriptor.setImplementation( AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME); return descriptor; }
/** * Requests a synchronous receive of an event on the component * * @param endpointUri the endpointUri on which the event will be received * @param timeout time in milliseconds before the request timesout * @return The requested event or null if the request times out * @throws org.mule.umo.UMOException if the request operation fails */ public UMOMessage receiveEvent(UMOEndpointURI endpointUri, long timeout) throws UMOException { UMOEndpoint endpoint = MuleEndpoint.getOrCreateEndpointForUri(endpointUri, UMOEndpoint.ENDPOINT_TYPE_SENDER); return session.receiveEvent(endpoint, timeout); }
/** * Depending on the session state this methods either Passes an event asynchronously to the next * available Mule UMO in the pool or via the endpointUri configured for the event * * @param message the event message payload to send * @param endpointUri the endpointUri to dispatc the event to first on the component configuration * and then on the mule manager configuration * @throws org.mule.umo.UMOException if the event fails to be processed by the component or the * transport for the endpointUri */ public void dispatchEvent(UMOMessage message, UMOEndpointURI endpointUri) throws UMOException { UMOEndpoint endpoint = MuleEndpoint.getOrCreateEndpointForUri(endpointUri, UMOEndpoint.ENDPOINT_TYPE_SENDER); session.dispatchEvent(message, endpoint); }