/** * Returns {@link Protocol} for an URI * * @param uri resource address URI * @return protocol for the given URI */ public Protocol getProtocol(URI uri) { return getProtocol(uri.getScheme()); }
private Map<String, DefaultTransportContext> resolveTransports(TransportFactory transportFactory) throws Exception { for (String transportName : transportFactory.getTransportNames()) { Transport transport = transportFactory.getTransport(transportName); DefaultTransportContext transportContext = new DefaultTransportContext(transportName, transport); transportContextsByName.put(transportName, transportContext); } return transportContextsByName; }
/** * Inject the given resources plus all available transport acceptors and connectors into every available acceptor * and connector. * @param resources Resources that should be injected (in addition to available transport acceptors and connectors) * @return A map containing the given input resources plus entries for the acceptor and connector of each available * transport. This can be used to inject resources into other objects which require acceptors or connectors to be injected. */ public Map<String, Object> injectResources(Map<String, Object> resources) { Map<String, Object> allResources = new HashMap<>(resources); for (Entry<String, Transport> entry : transportsByName.entrySet()) { allResources.put(entry.getKey() + ".acceptor", entry.getValue().getAcceptor()); allResources.put(entry.getKey() + ".connector", entry.getValue().getConnector()); } for (Transport transport : transportsByName.values()) { BridgeAcceptor acceptor = transport.getAcceptor(); if (acceptor != null) { injectResources(acceptor, allResources); } BridgeConnector connector = transport.getConnector(); if (connector != null) { injectResources(transport.getConnector(), allResources); } for (Object extension: transport.getExtensions()) { injectResources(extension, allResources); } } return allResources; }
@Override protected void doSessionCreated(IoSessionEx session) throws Exception { LoggingFilter.addIfNeeded(logger, session, transportName); ResourceAddress candidateAddress = getCandidateResourceAddress(session); NextProtocolBindings.NextProtocolBinding nextBinding = bindings.getBinding0(candidateAddress); if (nextBinding == null) { // next-protocol not currently bound for this address session.close(true); return; } SortedSet<String> nextProtocolNames = nextBinding.getNextProtocolNames(); if (nextProtocolNames == null || nextProtocolNames.isEmpty()) { NEXT_PROTOCOL_KEY.set(session, null); } else if (nextProtocolNames.size() == 1) { NEXT_PROTOCOL_KEY.set(session, nextProtocolNames.first()); } else { Collection<ProtocolDispatcher> dispatchers = bridgeServiceFactory.getTransportFactory().getProtocolDispatchers().values(); // sessionCreated will be sent down pipeline again when next-protocol has been determined NextProtocolFilter nextProtocol = new NextProtocolFilter(dispatchers); IoFilterChain filterChain = session.getFilterChain(); filterChain.addLast(AbstractNioAcceptor.NEXT_PROTOCOL_FILTER, nextProtocol); } }
/** * Creates a new transport factory. The factory is configured using given configuration. * * @param configuration for the newly created transport factory * @return a transport factory */ public static TransportFactory newTransportFactory(Map<String, ?> configuration) { return newTransportFactory(load(TransportFactorySpi.class), configuration); }
Transport tcp = transportFactory.getTransport("tcp"); assert tcp != null; BridgeAcceptor bridgeAcceptor = tcp.getAcceptor();
Collection<ProtocolDispatcher> dispatchers = bridgeServiceFactory.getTransportFactory().getProtocolDispatchers().values();
public BridgeServiceFactory() { this(TransportFactory.newTransportFactory(Collections.emptyMap())); }
private IoHandler selectConnectHandler(ResourceAddress address) { Protocol protocol = bridgeServiceFactory.getTransportFactory().getProtocol(address.getResource()); if ( protocol instanceof HttpProtocol ) { return httpHandler; } throw new RuntimeException(getClass()+ ": Cannot select a connect handler for address "+address); }
sessionCreated0(session); } else { Collection<ProtocolDispatcher> dispatchers = bridgeServiceFactory.getTransportFactory().getProtocolDispatchers().values();
public static TransportFactory newTransportFactory(ClassLoader loader, Map<String, ?> configuration) { return newTransportFactory(load(TransportFactorySpi.class, loader), configuration); }
private void injectResources(Collection<ServiceContext> services, BridgeServiceFactory bridgeServiceFactory, Map<String, Object> dependencyContexts, Map<String, Object> injectables) { // add all of the transport acceptors, connectors and extensions injectables = bridgeServiceFactory.getTransportFactory().injectResources(injectables); // inject services for (ServiceContext serviceContext : services) { injectResources(serviceContext.getService(), injectables); } // in case any of the DependencyContexts have dependencies on each other, // or the other resources added to the map, inject resources for them as well. for (Object obj : dependencyContexts.values()) { injectResources(obj, injectables); } }
private IoHandler selectTransportHandler(ResourceAddress address) { Protocol protocol = bridgeServiceFactory.getTransportFactory().getProtocol(address.getResource()); if ( protocol instanceof HttpProtocol ) { return bridgeHandler; } throw new RuntimeException(getClass()+": Cannot find handler for address "+address); }
Collection<ProtocolDispatcher> dispatchers = bridgeServiceFactory.getTransportFactory().getProtocolDispatchers().values(); filterChain.addLast(NEXT_PROTOCOL_FILTER, new NextProtocolFilter(dispatchers));
false, 1, TransportFactory.newTransportFactory(Collections.EMPTY_MAP), ResourceAddressFactory.newResourceAddressFactory(), null,
private IoHandler selectConnectHandler(ResourceAddress address) { Protocol protocol = bridgeServiceFactory.getTransportFactory().getProtocol(address.getResource()); if ( protocol instanceof HttpProtocol) { return createHandler; } throw new RuntimeException(getClass()+ ": Cannot select a connect handler for address "+address); }
Map<String, Object> dependencyContexts = resolveDependencyContext(); ResourceAddressFactory resourceAddressFactory = resolveResourceAddressFactories(); TransportFactory transportFactory = TransportFactory.newTransportFactory((Map) configuration); ServiceFactory serviceFactory = ServiceFactory.newServiceFactory(); Collection<ServiceContext> services =
private IoHandler selectConnectHandler(ResourceAddress address) { Protocol protocol = bridgeServiceFactory.getTransportFactory().getProtocol(address.getResource()); if ( protocol instanceof HttpProtocol ) { return createHandler; } throw new RuntimeException(getClass()+ ": Cannot select a connect handler for address "+address); }
private IoHandler selectConnectHandler(ResourceAddress address) { Protocol protocol = bridgeServiceFactory.getTransportFactory().getProtocol(address.getResource()); if ( protocol instanceof HttpProtocol) { return httpBridgeHandler; } throw new RuntimeException(getClass()+ ": Cannot select a connect handler for address "+address); }
private IoHandler selectCreateHandler(ResourceAddress transport) { Protocol protocol = bridgeServiceFactory.getTransportFactory().getProtocol(transport.getResource()); if ( protocol instanceof HttpProtocol) { return wsrCreateHandler; } throw new RuntimeException("Unable to locate a WSR create handler for address "+transport); }