replaced <code></code> with more concise {@code}
[idea/community.git] / plugins / hg4idea / src / org / zmlx / hg4idea / execution / SocketServer.java
1 // Copyright 2008-2010 Victor Iacoban
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software distributed under
10 // the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
11 // either express or implied. See the License for the specific language governing permissions and
12 // limitations under the License.
13 package org.zmlx.hg4idea.execution;
14
15 import com.intellij.openapi.application.ApplicationManager;
16 import com.intellij.openapi.diagnostic.Logger;
17
18 import java.io.DataInputStream;
19 import java.io.DataOutputStream;
20 import java.io.IOException;
21 import java.net.ServerSocket;
22 import java.net.Socket;
23 import java.net.SocketException;
24
25 /**
26  * Common server class that contains the boiler-plate code to set up a server socket.
27  * The actual logic is delegated to the Protocol instance.
28  */
29 public class SocketServer {
30   protected ServerSocket myServerSocket;
31   private final Protocol myProtocol;
32
33   public SocketServer(Protocol protocol) {
34     myProtocol = protocol;
35   }
36
37   public int start() throws IOException {
38     myServerSocket = new ServerSocket(0);
39     int port = myServerSocket.getLocalPort();
40
41     ApplicationManager.getApplication().executeOnPooledThread(() -> {
42       try {
43         boolean _continue = true;
44         while (_continue) {
45           Socket socket = myServerSocket.accept();
46           try {
47             _continue = myProtocol.handleConnection(socket);
48           }
49           finally {
50             socket.close();
51           }
52         }
53       }
54       catch (SocketException e) {
55         //socket was closed, that's OK
56       }
57       catch (IOException e) {
58         throw new RuntimeException(e); //TODO implement catch clause
59       }
60     });
61
62     return port;
63   }
64
65   public void stop() {
66     try {
67       if (myServerSocket != null) {
68         myServerSocket.close();
69       }
70     } catch (IOException e) {
71       throw new RuntimeException(e); //TODO implement catch clause
72     }
73   }
74
75   public static abstract class Protocol {
76
77     private static final int MAX_INPUT_LENGTH = 10 * 1000 * 1000;
78     private static final Logger LOG = Logger.getInstance(Protocol.class);
79
80     /**
81      * Override this method to implement the actual logic of the protocol.
82      *
83      * @param socket The connected socket
84      * @return {@code true} if the server should keep listening for new incoming requests,
85      *         {@code false} if the server handling the protocol can be shutdown.
86      * 
87      * @throws IOException when the communication over the socket gives errors.
88      */
89     public abstract boolean handleConnection(Socket socket) throws IOException;
90
91     protected static byte[] readDataBlock(DataInputStream inputStream) throws IOException {
92       final int origLength = inputStream.readInt();
93       final int length;
94       if (origLength > MAX_INPUT_LENGTH) {
95         length = MAX_INPUT_LENGTH;
96         LOG.info(String.format("Too large input: %d bytes. Reading %s bytes and skipping all other.", origLength, length));
97       } else {
98         length = origLength;
99       }
100       byte[] data = new byte[length];
101
102       readAsMuchAsAvailable(inputStream, data, length);
103
104       int skipped = inputStream.skipBytes(origLength - length);
105       if (skipped > 0) {
106         LOG.info(String.format("Skipped %s bytes", skipped));
107       }
108       return data;
109     }
110
111     //if mercurial already sent number of bytes, but there was no data yet, this method read '\u0000' len times instead of data bytes.
112     private static void readAsMuchAsAvailable(DataInputStream inputStream, byte[] data, int maxLength) throws IOException {
113       int offset = 0;
114       int available;
115       while ((available = inputStream.available()) > 0) {
116         if (available + offset > maxLength) {
117           // read no more than maxLength
118           inputStream.readFully(data, offset, maxLength - offset);
119           return;
120         }
121         inputStream.readFully(data, offset, available);
122         offset += available;
123       }
124     }
125
126     protected static void sendDataBlock(DataOutputStream out, byte[] data) throws IOException {
127       out.writeInt(data.length);
128       out.write(data);
129     }
130   }
131
132 }