public MulticastReceiver createMulticastReceiver(NetworkAddressFactory networkAddressFactory) { return new MulticastReceiverImpl( new MulticastReceiverConfigurationImpl( networkAddressFactory.getMulticastGroup(), networkAddressFactory.getMulticastPort() ) ); }
synchronized public void send(OutgoingDatagramMessage message) { if (log.isLoggable(Level.FINE)) { log.fine("Sending message from address: " + localAddress); } DatagramPacket packet = datagramProcessor.write(message); if (log.isLoggable(Level.FINE)) { log.fine("Sending UDP datagram packet to: " + message.getDestinationAddress() + ":" + message.getDestinationPort()); } send(packet); }
networkAddressFactory = getConfiguration().createNetworkAddressFactory(); startInterfaceBasedTransports(networkAddressFactory.getNetworkInterfaces()); startAddressBasedTransports(networkAddressFactory.getBindAddresses()); if (!networkAddressFactory.hasUsableNetwork()) { throw new NoNetworkException( "No usable network interface and/or addresses available, check the log for errors." );
synchronized public void init(InetAddress bindAddress, final Router router) throws InitializationException { try { if (log.isLoggable(Level.FINE)) log.fine("Setting executor service on servlet container adapter"); getConfiguration().getServletContainerAdapter().setExecutorService( router.getConfiguration().getStreamServerExecutorService() ); if (log.isLoggable(Level.FINE)) log.fine("Adding connector: " + bindAddress + ":" + getConfiguration().getListenPort()); hostAddress = bindAddress.getHostAddress(); localPort = getConfiguration().getServletContainerAdapter().addConnector( hostAddress, getConfiguration().getListenPort() ); String contextPath = router.getConfiguration().getNamespace().getBasePath().getPath(); getConfiguration().getServletContainerAdapter().registerServlet(contextPath, createServlet(router)); } catch (Exception ex) { throw new InitializationException("Could not initialize " + getClass().getSimpleName() + ": " + ex.toString(), ex); } }
public StreamServer createStreamServer(NetworkAddressFactory networkAddressFactory) { return new StreamServerImpl( new StreamServerConfigurationImpl( networkAddressFactory.getStreamListenPort() ) ); }
/** * Sends the given bytes as a broadcast on all bound {@link org.fourthline.cling.transport.spi.DatagramIO}s, * using source port 9. * <p> * TODO: Support source port parameter * </p> * * @param bytes The byte payload of the UDP datagram. */ public void broadcast(byte[] bytes) throws RouterException { lock(readLock); try { if (enabled) { for (Map.Entry<InetAddress, DatagramIO> entry : datagramIOs.entrySet()) { InetAddress broadcast = networkAddressFactory.getBroadcastAddress(entry.getKey()); if (broadcast != null) { log.fine("Sending UDP datagram to broadcast address: " + broadcast.getHostAddress()); DatagramPacket packet = new DatagramPacket(bytes, bytes.length, broadcast, 9); entry.getValue().send(packet); } } } else { log.fine("Router disabled, not broadcasting bytes: " + bytes.length); } } finally { unlock(readLock); } }
new NetworkAddress( preferredAddress, preferredServer.getPort(), networkAddressFactory.getHardwareAddress(preferredAddress) byte[] hardwareAddress = networkAddressFactory.getHardwareAddress(entry.getKey()); streamServerAddresses.add( new NetworkAddress(entry.getKey(), entry.getValue().getPort(), hardwareAddress) );
protected void discoverNetworkInterfaces() throws InitializationException { try { Enumeration<NetworkInterface> interfaceEnumeration = NetworkInterface.getNetworkInterfaces(); for (NetworkInterface iface : Collections.list(interfaceEnumeration)) { //displayInterfaceInformation(iface); log.finer("Analyzing network interface: " + iface.getDisplayName()); if (isUsableNetworkInterface(iface)) { log.fine("Discovered usable network interface: " + iface.getDisplayName()); synchronized (networkInterfaces) { networkInterfaces.add(iface); } } else { log.finer("Ignoring non-usable network interface: " + iface.getDisplayName()); } } } catch (Exception ex) { throw new InitializationException("Could not not analyze local network interfaces: " + ex, ex); } }
public void run() { getConfiguration().getServletContainerAdapter().startIfNotRunning(); }
/** * Sends the UDP datagram on all bound {@link org.fourthline.cling.transport.spi.DatagramIO}s. * * @param msg The UDP datagram message to send. */ public void send(OutgoingDatagramMessage msg) throws RouterException { lock(readLock); try { if (enabled) { for (DatagramIO datagramIO : datagramIOs.values()) { datagramIO.send(msg); } } else { log.fine("Router disabled, not sending datagram: " + msg); } } finally { unlock(readLock); } }
/** * Sends the TCP stream request with the {@link org.fourthline.cling.transport.spi.StreamClient}. * * @param msg The TCP (HTTP) stream message to send. * @return The return value of the {@link org.fourthline.cling.transport.spi.StreamClient#sendRequest(StreamRequestMessage)} * method or <code>null</code> if no <code>StreamClient</code> is available. */ public StreamResponseMessage send(StreamRequestMessage msg) throws RouterException { lock(readLock); try { if (enabled) { if (streamClient == null) { log.fine("No StreamClient available, not sending: " + msg); return null; } log.fine("Sending via TCP unicast stream: " + msg); try { return streamClient.sendRequest(msg); } catch (InterruptedException ex) { throw new RouterException("Sending stream request was interrupted", ex); } } else { log.fine("Router disabled, not sending stream request: " + msg); return null; } } finally { unlock(readLock); } }
protected void handleResponse(IncomingActionResponseMessage responseMsg) throws ActionException { try { log.fine("Received response for outgoing call, reading SOAP response body: " + responseMsg); getUpnpService().getConfiguration().getSoapActionProcessor().readBody(responseMsg, actionInvocation); } catch (UnsupportedDataException ex) { log.fine("Error reading SOAP body: " + ex); log.log(Level.FINE, "Exception root cause: ", Exceptions.unwrap(ex)); throw new ActionException( ErrorCode.ACTION_FAILED, "Error reading SOAP response message. " + ex.getMessage(), false ); } }
synchronized public void stop() { getConfiguration().getServletContainerAdapter().removeConnector(hostAddress, localPort); }
@Override public StreamServer createStreamServer(NetworkAddressFactory networkAddressFactory) { // Use Jetty, start/stop a new shared instance of JettyServletContainer return new AsyncServletStreamServerImpl( new AsyncServletStreamServerConfigurationImpl( JettyServletContainer.INSTANCE, networkAddressFactory.getStreamListenPort() ) ); }
public MulticastReceiver createMulticastReceiver(NetworkAddressFactory networkAddressFactory) { return new MulticastReceiverImpl( new MulticastReceiverConfigurationImpl( networkAddressFactory.getMulticastGroup(), networkAddressFactory.getMulticastPort() ) ); }
synchronized public void init(InetAddress bindAddress, Router router) throws InitializationException { try { InetSocketAddress socketAddress = new InetSocketAddress(bindAddress, configuration.getListenPort()); server = HttpServer.create(socketAddress, configuration.getTcpConnectionBacklog()); server.createContext("/", new RequestHttpHandler(router)); log.info("Created server (for receiving TCP streams) on: " + server.getAddress()); } catch (Exception ex) { throw new InitializationException("Could not initialize " + getClass().getSimpleName() + ": " + ex.toString(), ex); } }
@Override public StreamServer createStreamServer(NetworkAddressFactory networkAddressFactory) { return new org.fourthline.cling.transport.impl.AsyncServletStreamServerImpl( new org.fourthline.cling.transport.impl.AsyncServletStreamServerConfigurationImpl( org.fourthline.cling.transport.impl.jetty.JettyServletContainer.INSTANCE, networkAddressFactory.getStreamListenPort() ) ); } }
public StreamClientImpl(StreamClientConfigurationImpl configuration) throws InitializationException { this.configuration = configuration; log.info("Starting Jetty HttpClient..."); client = new HttpClient(); // Jetty client needs threads for its internal expiration routines, which we don't need but // can't disable, so let's abuse the request executor service for this client.setThreadPool( new ExecutorThreadPool(getConfiguration().getRequestExecutorService()) { @Override protected void doStop() throws Exception { // Do nothing, don't shut down the Cling ExecutorService when Jetty stops! } } ); // These are some safety settings, we should never run into these timeouts as we // do our own expiration checking client.setTimeout((configuration.getTimeoutSeconds()+5) * 1000); client.setConnectTimeout((configuration.getTimeoutSeconds()+5) * 1000); client.setMaxRetries(configuration.getRequestRetryCount()); try { client.start(); } catch (Exception ex) { throw new InitializationException( "Could not start Jetty HTTP client: " + ex, ex ); } }
public StreamServer createStreamServer(NetworkAddressFactory networkAddressFactory) { return new StreamServerImpl( new StreamServerConfigurationImpl( networkAddressFactory.getStreamListenPort() ) ); }