public void stop() { Thread tmp=thread; thread=null; if(diag_sock != null) socket_factory.close(diag_sock); if(tmp != null) { try { tmp.join(Global.THREAD_SHUTDOWN_WAIT_TIME); } catch(InterruptedException e){ Thread.currentThread().interrupt(); // set interrupt flag } } }
return factory.createDatagramSocket(service_name); return factory.createDatagramSocket(service_name,port); while(port < MAX_PORT) { try { return factory.createDatagramSocket(service_name,port,addr);
public static MulticastSocket createMulticastSocket(SocketFactory factory,String service_name,InetAddress mcast_addr,int port,Log log) throws IOException { if(mcast_addr != null && !mcast_addr.isMulticastAddress()) throw new IllegalArgumentException("mcast_addr (" + mcast_addr + ") is not a valid multicast address"); SocketAddress saddr=new InetSocketAddress(mcast_addr,port); MulticastSocket retval=null; try { retval=factory.createMulticastSocket(service_name,saddr); } catch(IOException ex) { if(log != null && log.isWarnEnabled()) { StringBuilder sb=new StringBuilder(); String type=mcast_addr != null? mcast_addr instanceof Inet4Address? "IPv4" : "IPv6" : "n/a"; sb.append("could not bind to ").append(mcast_addr).append(" (").append(type).append(" address)") .append("; make sure your mcast_addr is of the same type as the preferred IP stack (IPv4 or IPv6)") .append(" by checking the value of the system properties java.net.preferIPv4Stack and java.net.preferIPv6Addresses.") .append("\nWill ignore mcast_addr, but this may lead to cross talking " + "(see http://www.jboss.org/community/docs/DOC-9469 for details). ") .append("\nException was: ").append(ex); log.warn(sb.toString()); } } if(retval == null) retval=factory.createMulticastSocket(service_name,port); return retval; }
/** Creates a connection stub and binds it, use {@link #connect(Address)} to connect */ public TcpConnection(Address peer_addr, TcpBaseServer server) throws Exception { this.server=server; if(peer_addr == null) throw new IllegalArgumentException("Invalid parameter peer_addr="+ peer_addr); this.peer_addr=peer_addr; this.sock=server.socketFactory().createSocket("jgroups.tcp.sock"); setSocketParameters(sock); last_access=getTimestamp(); // last time a message was sent or received (ns) }
public static ServerSocket createServerSocket(SocketFactory factory, String service_name, InetAddress bind_addr, int start_port) { ServerSocket ret=null; try { ret=factory.createServerSocket(service_name); Util.bind(ret, bind_addr, start_port, start_port+1000, 50); return ret; } catch(Exception e) { return null; } }
default ServerSocketChannel createServerSocketChannel(String service_name, int port, int backlog) throws IOException { return createServerSocketChannel(service_name).bind(new InetSocketAddress(port), backlog); }
@Override public Map<Object, String> getSockets() { return this.factory.getSockets(); } }
/** * Creates a socket to {@code dest}, and assigns it to ping_sock. Also assigns ping_input */ protected boolean setupPingSocket(IpAddress dest) { lock.lock(); try { SocketAddress destAddr=new InetSocketAddress(dest.getIpAddress(), dest.getPort()); ping_sock=getSocketFactory().createSocket("jgroups.fd.ping_sock"); Util.bind(ping_sock, bind_addr, client_bind_port, client_bind_port+port_range); ping_sock.setSoLinger(true, 1); ping_sock.setKeepAlive(keep_alive); Util.connect(ping_sock, destAddr, sock_conn_timeout); ping_input=ping_sock.getInputStream(); return true; } catch(Throwable ex) { if(!shuttin_down) log.debug("%s: failed connecting to %s: %s", local_addr, ping_dest != null? ping_dest : dest, ex.getMessage()); return false; } finally { lock.unlock(); } }
/** * Finds first available port starting at start_port and returns server * socket. Will not bind to port >end_port. Sets srv_port */ public static ServerSocket createServerSocketAndBind(SocketFactory factory,String service_name,InetAddress bind_addr, int start_port,int end_port) throws Exception { ServerSocket ret=factory.createServerSocket(service_name); bind(ret, bind_addr, start_port, end_port); return ret; }
default ServerSocketChannel createServerSocketChannel(String service_name, int port, int backlog, InetAddress bindAddr) throws IOException { return createServerSocketChannel(service_name).bind(new InetSocketAddress(bindAddr, port), backlog); }
@Override public Map<Object, String> getSockets() { return this.factory.getSockets(); } }
public void stop() { running=false; try { getSocketFactory().close(serverSocket); } catch(Exception ignored) { } } }
public void start() throws IOException { // https://jira.jboss.org/jira/browse/JGRP-777 - this doesn't work on MacOS, and we don't have // cross talking on Windows anyway, so we just do it for Linux. (How about Solaris ?) // if(can_bind_to_mcast_addr) // diag_sock=Util.createMulticastSocket(getSocketFactory(), // Global.TP_DIAG_MCAST_SOCK, diagnostics_addr, diagnostics_port, log); //else diag_sock=socket_factory.createMulticastSocket("jgroups.tp.diag.mcast_sock", diagnostics_port); diag_sock.setTimeToLive(ttl); List<NetworkInterface> interfaces=bind_interfaces != null? bind_interfaces : Util.getAllAvailableInterfaces(); bindToInterfaces(interfaces, diag_sock); if(thread == null || !thread.isAlive()) { thread=thread_factory.newThread(this, THREAD_NAME); thread.setDaemon(true); thread.start(); } }
protected Tuple<InputStream,Object> createStreamToProvider(Address provider, StateHeader hdr) throws Exception { IpAddress address=hdr.bind_addr; Socket socket=null; try { socket=getSocketFactory().createSocket("jgroups.state_sock.sock"); socket.bind(new InetSocketAddress(bind_addr, 0)); socket.setReceiveBufferSize(buffer_size); Util.connect(socket, new InetSocketAddress(address.getIpAddress(), address.getPort()), 0); log.debug("%s: connected to state provider %s:%d", local_addr, address.getIpAddress(), address.getPort()); DataOutputStream out=new DataOutputStream(socket.getOutputStream()); Util.writeAddress(local_addr, out); return new Tuple<>(new BufferedInputStream(socket.getInputStream(), buffer_size), socket); } catch(Throwable t) { Util.close(socket); if(t instanceof Exception) throw (Exception)t; throw new Exception("failed creating socket", t); } }
public static ServerSocket createServerSocket(SocketFactory factory,String service_name,InetAddress bind_addr, int start_port,int end_port) throws Exception { int original_start_port=start_port; ServerSocket srv_sock=null; while(true) { try { if(srv_sock != null); Util.close(srv_sock); srv_sock=factory.createServerSocket(service_name); InetSocketAddress sock_addr=new InetSocketAddress(bind_addr, start_port); srv_sock.bind(sock_addr); return srv_sock; } catch(SocketException bind_ex) { if(start_port == end_port) throw new BindException(String.format("no port available in range [%d .. %d] (bind_addr=%s)", original_start_port, end_port, bind_addr)); if(bind_addr != null && !(bind_addr.isLoopbackAddress() || bind_addr.isAnyLocalAddress())) { NetworkInterface nic=NetworkInterface.getByInetAddress(bind_addr); if(nic == null) throw new BindException("bind_addr " + bind_addr + " is not a valid interface: " + bind_ex); } start_port++; } } }
public void init() throws Exception { super.init(); if (timer == null) throw new Exception("timer cannot be retrieved from protocol stack"); if(gossip_router_hosts.isEmpty()) throw new IllegalStateException("gossip_router_hosts needs to contain at least one address of a GossipRouter"); log.debug("GossipRouters are:" + gossip_router_hosts.toString()); stubManager = RouterStubManager.emptyGossipClientStubManager(this).useNio(this.use_nio); sock = getSocketFactory().createDatagramSocket("jgroups.tunnel.ucast_sock", bind_port, bind_addr); }
default ServerSocketChannel createServerSocketChannel(String service_name, int port) throws IOException { return createServerSocketChannel(service_name).bind(new InetSocketAddress(port)); }
protected void closeUnicastSocket() { getSocketFactory().close(sock); }
protected MulticastSocket createMulticastSocket(String service_name, int port) throws Exception { // Creates an *unbound* multicast socket (because SocketAddress is null) MulticastSocket retval=getSocketFactory().createMulticastSocket(service_name, null); // causes *no* binding ! if(bind_addr != null) setInterface(bind_addr, retval); retval.setReuseAddress(false); // so we get a conflict if binding to the same port and increment the port retval.bind(new InetSocketAddress(bind_addr, port)); return retval; }
private void createSocket(String serviceName, String bindingName) throws IOException { ManagedSocketFactory factory = mock(ManagedSocketFactory.class); Socket socket1 = mock(Socket.class); Socket socket2 = mock(Socket.class); Socket socket3 = mock(Socket.class); Socket socket4 = mock(Socket.class); Socket socket5 = mock(Socket.class); InetAddress localhost = InetAddress.getLocalHost(); when(this.manager.getSocketFactory()).thenReturn(factory); when(factory.createSocket(bindingName)).thenReturn(socket1); when(factory.createSocket(bindingName, localhost, 1)).thenReturn(socket2); when(factory.createSocket(bindingName, "host", 1)).thenReturn(socket3); when(factory.createSocket(bindingName, localhost, 1, localhost, 2)).thenReturn(socket4); when(factory.createSocket(bindingName, "host", 1, localhost, 2)).thenReturn(socket5); Socket result1 = this.subject.createSocket(serviceName); Socket result2 = this.subject.createSocket(serviceName, localhost, 1); Socket result3 = this.subject.createSocket(serviceName, "host", 1); Socket result4 = this.subject.createSocket(serviceName, localhost, 1, localhost, 2); Socket result5 = this.subject.createSocket(serviceName, "host", 1, localhost, 2); assertSame(socket1, result1); assertSame(socket2, result2); assertSame(socket3, result3); assertSame(socket4, result4); assertSame(socket5, result5); }