public static void main(String[] args) { int port = 8080; if (args != null && args.length > 0) { try { port = Integer.parseInt(args[0], 10); } catch (NumberFormatException e) { e.printStackTrace(); } } ServerSocket servSocket = null; try { servSocket = new ServerSocket(port); System.out.println("The server start in port:" + port); Socket socket = null; TimeServerHandlerExecutePool singleExecutor = new TimeServerHandlerExecutePool(100, 10000); while (true) { socket = servSocket.accept(); singleExecutor.execute(new TimeServerHandler(socket)); } } catch (IOException e) { e.printStackTrace(); } finally { if (servSocket != null) { try { System.out.println("The time server close."); servSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } }
@Override public void run() { try { ServerSocket ss = new ServerSocket(port); while (!interrupted()) { try (Socket s = ss.accept(); ) { InputStream in = s.getInputStream(); OutputStream out = s.getOutputStream(); ChannelLevelInputStream cin = new ChannelLevelInputStream(in); ChannelLevelPacket clp = cin.readPacket(); PALInputStream pin = new PALInputStream(new ByteArrayInputStream(clp.getPacketData())); PALRequest req = pin.readRequest(); PALResponse resp = process(req); ByteArrayOutputStream bout = new ByteArrayOutputStream(); PALOutputStream pout = new PALOutputStream(bout); pout.writePALResponse(resp); ChannelLevelPacket packet = new ChannelLevelPacket( clp.getAddressS(), clp.getAddressD(), 0x48, bout.toByteArray()); ChannelLevelOutputStream cout = new ChannelLevelOutputStream(out); cout.writePacket(packet); cout.close(); cin.close(); pout.close(); pin.close(); } catch (IOException e) { e.printStackTrace(); } } ss.close(); } catch (IOException e1) { e1.printStackTrace(); return; } }
/** * creates a server socket listening on the port specified in the parameter of the constructor, * and waits for a single incoming client connection which it handles by invoking the <CODE> * addNewClientConnection(s)</CODE> method of the enclosing server, and then the thread exits. */ public void run() { try { ServerSocket ss = new ServerSocket(_port); System.out.println("Srv: Now Accepting Single Client Connection"); // while (true) { try { Socket s = ss.accept(); System.out.println("Srv: Client Added to the Network"); addNewClientConnection(s); System.out.println("Srv: finished adding client connection"); } catch (Exception e) { // e.printStackTrace(); System.err.println("Client Connection failed, exiting..."); System.exit(-1); } // } } catch (IOException e) { // e.printStackTrace(); utils.Messenger.getInstance() .msg( "PDBTExecSingleCltWrkInitSrv.C2Thread.run(): " + "Failed to create Server Socket, Server exiting.", 0); System.exit(-1); } }
public static void main(String[] args) throws IOException { String ip = "localhost"; int port = 4321; if (args.length == 2) { ip = args[0]; port = Integer.parseInt(args[1]); } ServerSocket ss = new ServerSocket(); ss.bind(new InetSocketAddress(ip, port)); Socket s; while (true) { s = ss.accept(); BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream())); PrintWriter out = new PrintWriter(s.getOutputStream(), true); // waits for data and reads it in until connection dies // readLine() blocks until the server receives a new line from client String str; while ((str = in.readLine()) != null) { if (str.equals("!!")) { System.exit(0); } out.println(str); } } }
public static void startServer(int port) { ServerSocket ssock; // Socket sock; // DezactiveazaBonus bonus= new DezactiveazaBonus(); // Thread b=new Thread(bonus); // b.start(); try { ssock = new ServerSocket(port); while (true) { Socket esock = null; try { esock = ssock.accept(); while (listEmpty()) yield(); // System.out.println("A intrat in bucla"); assignThread(esock); } catch (Exception e) { try { esock.close(); } catch (Exception ec) { } } // System.out.println("A iesit din bucla"); } } catch (IOException e) { } }
/** Creates the server. */ public static void main(String args[]) { client = null; ServerSocket server = null; try { System.out.print("\nCreating Server...\n"); // creates the server server = new ServerSocket(8008); System.out.print("Created\n"); // get the ip Address and the host name. InetAddress localAddr = InetAddress.getLocalHost(); System.out.println("IP address: " + localAddr.getHostAddress()); System.out.println("Hostname: " + localAddr.getHostName()); } catch (IOException e) { // sends a System.out.println("IO" + e); } // constantly checks for a new aocket trying to attach itself to the trhead while (true) { try { client = server.accept(); // create a new thread. FinalMultiThread thr = new FinalMultiThread(client); System.out.print(client.getInetAddress() + " : " + thr.getUserName() + "\n"); CliList.add(thr); current++; thr.start(); } catch (IOException e) { System.out.println(e); } } }
Server() throws IOException { if (useSerial) { ServerThread.initSerial(); ServerThread.writeSerial(true); try { Thread.sleep(200); } catch (InterruptedException e1) { } ServerThread.writeSerial(true); try { Thread.sleep(200); } catch (InterruptedException e1) { } ServerThread.writeSerial(true); } int port = 10055; ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(port); System.out.println("Soccer robots server active on port " + port + "."); } catch (IOException e) { System.err.println("Could not listen on port: " + port + "."); System.exit(-1); } while (true) { ServerThread tmp = new ServerThread(serverSocket.accept()); threads.add(tmp); } }
public void server() { try { ss = new ServerSocket(5000); socket = ss.accept(); System.out.println(socket); in = new BufferedReader(new InputStreamReader(socket.getInputStream())); out = new PrintWriter(socket.getOutputStream(), true); while (socket.isConnected()) { String line = in.readLine(); System.out.println(line); out.println("you input is :" + line); } out.close(); in.close(); socket.close(); } catch (IOException e) { } finally { try { ss.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
/** used for start of the thread */ public void run() { ServerSocket sServer = null; try { /* initialize the server socket*/ sServer = new ServerSocket(port); while (true) { /* wait for service */ Socket socket = sServer.accept(); /* fill in the receive queue*/ fillInReceiveQueue(socket); } } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } finally { try { /* close the service */ sServer.close(); } catch (IOException e) { e.printStackTrace(); } } }
public static void main(String[] args) throws Exception { ServerSocket server = new ServerSocket(4040); while (true) { Socket clientSocket = server.accept(); InputStream is = clientSocket.getInputStream(); OutputStream os = clientSocket.getOutputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(is)); PrintStream writer = new PrintStream(os, true); while (true) { String input = reader.readLine(); System.out.println("input " + input); if ("exit".equals(input)) { break; } System.out.println("send " + input); writer.println(input); } } }
private static boolean available(int port) { if (port <= 0) { throw new IllegalArgumentException("Invalid start port: " + port); } ServerSocket ss = null; DatagramSocket ds = null; try { ss = new ServerSocket(port); ss.setReuseAddress(true); ds = new DatagramSocket(port); ds.setReuseAddress(true); return true; } catch (IOException e) { LogKit.logNothing(e); } finally { if (ds != null) { ds.close(); } if (ss != null) { try { ss.close(); } catch (IOException e) { // should not be thrown, just detect port available. LogKit.logNothing(e); } } } return false; }
public String decodeUrl(final String path) throws Exception { ServerSocket serverSocket = new ServerSocket(0); final int port = serverSocket.getLocalPort(); serverSocket.close(); Server server = new Server(port); server.setStopAtShutdown(true); ServletContextHandler ctx = new ServletContextHandler(server, "/", true, false); ctx.addServlet(new ServletHolder(new DecodeServlet()), "/*"); server.start(); ThreadUtils.sleep(500); new Thread() { @Override public void run() { try { ThreadUtils.sleep(500); InputStream is = new URL("http://localhost:" + port + path).openStream(); } catch (IOException e) { throw new RuntimeException(e); } } }.start(); synchronized (this) { wait(); } return this.decodedPath; }
public static void main(String args[]) { String fileToSend = "C:\\test1.txt"; while (true) { // Maak lokale variabels eerst aan. // Dit is nodig om deze ook te gebruiken buiten de "try catch" blok. ServerSocket welcomeSocket = null; Socket connectionSocket = null; BufferedOutputStream outToClient = null; try { // poort waar gebruiker kan op connecteren welcomeSocket = new ServerSocket(3248); // Tot er een gebruiker gevonden is zal .accept() blijven wachten // Nadat er iemand geconnecteerd is zal er een nieuwe socket aangemaakt worden waarmee deze // met elkaar communiceren connectionSocket = welcomeSocket.accept(); // buffer voor data communicatie tussen server en client outToClient = new BufferedOutputStream(connectionSocket.getOutputStream()); } catch (IOException ex) { System.out.println("IOException1"); } // if an I/O error occurs when opening the socket. if (outToClient != null) // wanneer buffer correct is aangemaakt zal deze niet een null waarde hebben { // gemaakte variabele doorgeven aan thread Connection c = new Connection(connectionSocket, outToClient, fileToSend); // thread starten c.start(); } } }
public Server() { try { ServerSocket ss = new ServerSocket(SERVER_PORT); Socket s = ss.accept(); InputStream is = s.getInputStream(); OutputStream out = s.getOutputStream(); InputStreamReader isr = new InputStreamReader(is); BufferedReader br = new BufferedReader(isr); String sss = br.readLine(); System.out.println(sss); PrintWriter pw = new PrintWriter(out); pw.print("hello,我是服务器。"); pw.close(); br.close(); isr.close(); out.close(); is.close(); s.close(); ss.close(); } catch (UnknownHostException ue) { ue.printStackTrace(); } catch (IOException oe) { oe.printStackTrace(); } }
public void listenSocket() { try { server = new ServerSocket(4321, 1, new InetSocketAddress(0).getAddress()); System.out.println( "Server is listening on " + server.getInetAddress().getHostName() + ":" + 4321); } catch (IOException e) { System.out.println("Could not listen on port 4321"); System.exit(-1); } try { client = server.accept(); System.out.println("Client connected on port " + 4321); has_client = true; } catch (IOException e) { System.out.println("Accept failed: 4321"); System.exit(-1); } try { in = new BufferedReader(new InputStreamReader(client.getInputStream())); out = new PrintWriter(client.getOutputStream(), true); } catch (IOException e) { System.out.println("Read failed"); System.exit(-1); } }
/** * Checks to see if a specific port is available. * * @param port the port to check for availability * @return <tt>true</tt> if the port is available, <tt>false</tt> otherwise */ public boolean available(int port) { if (port < fromPort || port > toPort) { throw new IllegalArgumentException("Port outside port range: " + port); } ServerSocket ss = null; DatagramSocket ds = null; try { ss = new ServerSocket(port); ss.setReuseAddress(true); ds = new DatagramSocket(port); ds.setReuseAddress(true); return true; } catch (IOException ignored) { /* checkstyle drives me nuts */ } finally { if (ds != null) { ds.close(); } if (ss != null) { try { ss.close(); } catch (IOException ignored) { /* checkstyle drives me nuts */ } } } return false; }
private LauncherServer() throws IOException { this.refCount = new AtomicLong(0); ServerSocket server = new ServerSocket(); try { server.setReuseAddress(true); server.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); this.clients = new ArrayList<>(); this.threadIds = new AtomicLong(); this.factory = new NamedThreadFactory(THREAD_NAME_FMT); this.pending = new ConcurrentHashMap<>(); this.timeoutTimer = new Timer("LauncherServer-TimeoutTimer", true); this.server = server; this.running = true; this.serverThread = factory.newThread( new Runnable() { @Override public void run() { acceptConnections(); } }); serverThread.start(); } catch (IOException ioe) { close(); throw ioe; } catch (Exception e) { close(); throw new IOException(e); } }
public static void main(String[] args) throws IOException { // port number hard-coded if it's not given int portNumber = 6999; // command line input if (args.length > 0) { portNumber = Integer.parseInt(args[0]); if (args.length > 1) num_Students = Integer.parseInt(args[0]); if (args.length > 2) TableCapacity = Integer.parseInt(args[1]); } Event event = new Event(num_Students, TableCapacity); boolean listen = true; try (ServerSocket serverSocket = new ServerSocket(portNumber)) { System.out.println("The server is now running"); while (listen) { new ServerThread(serverSocket.accept(), event).start(); } } catch (IOException e) { System.err.println("Could not listen on port " + portNumber); System.exit(-1); } }
public static void main(String[] args) { try { ServerSocket socket = new ServerSocket(8606, 50, InetAddress.getByName("localhost")); Socket client = socket.accept(); OutputStream out = client.getOutputStream(); InputStream in = client.getInputStream(); DataOutputStream dout = new DataOutputStream(out); DataInputStream din = new DataInputStream(in); String line = null; while (true) { line = din.readUTF(); System.out.println(line); dout.writeUTF(line); } } catch (UnknownHostException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public void run() { try { isStarting = true; synchronized (this) { serverSocket = new ServerSocket(0); this.port = serverSocket.getLocalPort(); setRunning(true); isStarting = false; this.notifyAll(); } System.err.println("Child-process heartbeat server started on port: " + port); while (true) { Socket sock = serverSocket.accept(); log("Got heartbeat connection from client; starting heartbeat."); synchronized (heartBeatThreads) { HeartbeatThread hbt = new HeartbeatThread(sock); heartBeatThreads.add(hbt); hbt.start(); } } } catch (Exception e) { if (!running) log("Heartbeat server was shutdown."); else log("Got expcetion in heartbeat server: " + e.getMessage()); } finally { setRunning(false); log("Heartbeat server terminated."); } }
public static void main(String args[]) throws IOException { ServerSocket sSocket = new ServerSocket(sPort, 10); // Arguments Handling if (args.length != 1) { System.out.println("Must specify a file-path argument."); } else { String currentDir = System.getProperty("user.dir"); filePath = currentDir + "/src/srcFile/" + args[0]; filename = args[0]; } // Get list of chunks owned chunkOwned(); // Call FileSplitter FileSplitter fs = new FileSplitter(); fs.split(filePath); System.out.println("Waiting for connection"); while (true) { Socket connection = sSocket.accept(); System.out.println("Connection received from " + connection.getInetAddress().getHostName()); new Thread(new MultiThreadServer(connection)).start(); } }
public TCPConnectionMap( String service_name, ThreadFactory f, SocketFactory socket_factory, Receiver r, InetAddress bind_addr, InetAddress external_addr, int srv_port, int max_port, long reaper_interval, long conn_expire_time) throws Exception { this.mapper = new Mapper(f, reaper_interval); this.receiver = r; this.bind_addr = bind_addr; this.conn_expire_time = conn_expire_time; if (socket_factory != null) this.socket_factory = socket_factory; this.srv_sock = Util.createServerSocket(this.socket_factory, service_name, bind_addr, srv_port, max_port); if (external_addr != null) local_addr = new IpAddress(external_addr, srv_sock.getLocalPort()); else if (bind_addr != null) local_addr = new IpAddress(bind_addr, srv_sock.getLocalPort()); else local_addr = new IpAddress(srv_sock.getLocalPort()); acceptor = f.newThread(thread_group, new ConnectionAcceptor(), "ConnectionMap.Acceptor"); }
static void fun() { PrintStream toSoc; try { ServerSocket f = new ServerSocket(9090); while (true) { Socket t = f.accept(); BufferedReader fromSoc = new BufferedReader(new InputStreamReader(t.getInputStream())); String video = fromSoc.readLine(); System.out.println(video); searcher obj = new searcher(); boolean fs; fs = obj.search(video); if (fs == true) { System.out.println("stream will starts"); toSoc = new PrintStream(t.getOutputStream()); toSoc.println("stream starts"); } else { toSoc = new PrintStream(t.getOutputStream()); toSoc.println("sorry"); } } } catch (Exception e) { System.out.println(e); } }
public static void main(String[] args) throws IOException, ClassNotFoundException { ServerSocket serverSocket = null; boolean listening = true; Class.forName("org.sqlite.JDBC"); try { if (args.length == 1) { serverSocket = new ServerSocket(Integer.parseInt(args[0])); System.out.println( "Server up and running with:\nhostname: " + getLocalIpAddress() + "\nport: " + args[0]); System.out.println("Waiting to accept client..."); System.out.println("Remember to setup client hostname"); } else { System.err.println("ERROR: Invalid arguments!"); System.exit(-1); } } catch (IOException e) { System.err.println("ERROR: Could not listen on port!"); System.exit(-1); } while (listening) { new ServerHandlerThread(serverSocket.accept()).start(); } serverSocket.close(); }
public void run() { ServerSocket server = null; try { server = new ServerSocket(link.getSerPort()); System.out.println("System Online!"); } catch (Exception e) { e.printStackTrace(); return; } try { Socket remoteSocket = server.accept(); System.out.println("remoteSocket accpet!"); Socket localSocket = server.accept(); System.out.println("localSocket accpet!"); remoteSocket.setSoTimeout(0); localSocket.setSoTimeout(0); remoteSocket.setTcpNoDelay(true); localSocket.setTcpNoDelay(true); new TransferDown(remoteSocket, localSocket, "ToCZ"); new TransferUp(remoteSocket, localSocket, "ToYonYou"); } catch (Exception e) { e.printStackTrace(); } }
@Override public void run() { try { if (socket != null && !socket.isClosed()) { while (true) { Log.i("Server Started", "Server Started"); fileSocket = socket.accept(); Log.i("RF Sever Accepted", "accepted saving now"); saveFile(fileSocket); new Thread(new SendEndMsg(Home.current)).start(); /*to send free me msg*/ } } else Log.i("Error", "file Port Already Bind Close Reconnect"); } catch (IOException e) { Log.i("RFSever Accepted", "IO"); e.printStackTrace(); } catch (Exception e) { Log.i("RFSever Accepted", "EX"); e.printStackTrace(); } { Log.i("RF FAIL", "Is closed check"); if (socket != null && !socket.isClosed()) { try { Log.i("FAIL", "Closing"); socket.close(); } catch (IOException e) { Log.i("FAIL", "Fail to close socket"); e.printStackTrace(); } } } }
/** * creates a server socket listening on port specified in the object constructor, and then * enters an infinite loop waiting for incoming socket connection requests representing a worker * process attempting to connect to this server, which it handles via the enclosing server's * <CODE>addNewWorkerConnection(s)</CODE> method. */ public void run() { try { ServerSocket ss = new ServerSocket(_port); System.out.println("Srv: Now Accepting Worker Connections"); while (true) { try { Socket s = ss.accept(); System.out.println("Srv: Incoming New Worker Connection to the Network"); System.out.println( "Srv: Thread may have to wait if an init_cmd has not yet arrived from the client"); addNewWorkerConnection(s); System.out.println("Srv: finished adding new worker connection to the _workers"); } catch (Exception e) { utils.Messenger.getInstance() .msg( "PDBTExecSingleCltWrkInitSrv.W2Thread.run(): " + "An error occured while adding new worker connection", 2); // e.printStackTrace(); } } } catch (IOException e) { // e.printStackTrace(); utils.Messenger.getInstance() .msg( "PDBTExecSingleCltWrkInitSrv.W2Thread.run(): " + "Failed to create Server Socket, Server exiting.", 0); System.exit(-1); } }
public static void main(String[] args) { try { System.out.println("Creando socket servidor"); ServerSocket serverSocket = new ServerSocket(); System.out.println("Realizando el enlace"); InetSocketAddress addr = new InetSocketAddress("localhost", 5555); serverSocket.bind(addr); System.out.println("Aceptando conexiones"); Socket newSocket = serverSocket.accept(); System.out.println("Conexión recibida"); InputStream is = newSocket.getInputStream(); OutputStream os = newSocket.getOutputStream(); byte[] mensaje = new byte[25]; is.read(mensaje); System.out.println("Mensaje recibido: " + new String(mensaje)); System.out.println("Cerrando el nuevo socket"); newSocket.close(); System.out.println("Cerrando el socket servidor"); serverSocket.close(); System.out.println("Terminado"); } catch (IOException e) { e.printStackTrace(); } }
public static void main(String[] args) throws IOException { ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(10008); System.out.println("Enroll: 130050131071"); System.out.println("Connection Socket Created"); try { while (true) { System.out.println("Waiting for Connection"); new EchoServer2(serverSocket.accept()); } } catch (IOException e) { System.err.println("Accept failed."); System.exit(1); } } catch (IOException e) { System.err.println("Could not listen on port: 10008."); System.exit(1); } finally { try { serverSocket.close(); } catch (IOException e) { System.err.println("Could not close port: 10008."); System.exit(1); } } }
/** * Test of a large write on a socket to understand what happens when the write is greater than the * combined size of the client send buffer and the server receive buffer and the server side of * the socket is either not accepted or already shutdown. * * @throws IOException * @throws InterruptedException */ public void testDirectSockets_largeWrite_NotAccepted() throws IOException, InterruptedException { final Random r = new Random(); // Get a socket addresss for an unused port. final InetSocketAddress serverAddr = new InetSocketAddress(getPort(0)); // First our ServerSocket final ServerSocket ss = new ServerSocket(); try { // Size of the server socket receive buffer. final int receiveBufferSize = ss.getReceiveBufferSize(); // Allocate buffer twice as large as the receive buffer. final byte[] largeBuffer = new byte[receiveBufferSize * 10]; if (log.isInfoEnabled()) { log.info( "receiveBufferSize=" + receiveBufferSize + ", largeBufferSize=" + largeBuffer.length); } // fill buffer with random data. r.nextBytes(largeBuffer); // bind the ServerSocket to the specified port. ss.bind(serverAddr); // Now the first Client SocketChannel final SocketChannel cs = SocketChannel.open(); try { /* * Note: true if connection made. false if connection in * progress. */ final boolean immediate = cs.connect(serverAddr); if (!immediate) { // Did not connect immediately, so finish connect now. if (!cs.finishConnect()) { fail("Did not connect."); } } /* * Attempt to write data. The server socket is not yet accepted. * This should hit a timeout. */ assertTimeout(10L, TimeUnit.SECONDS, new WriteBufferTask(cs, ByteBuffer.wrap(largeBuffer))); accept(ss); } finally { cs.close(); } } finally { ss.close(); } }