← Back to branch summary

~ubuntu-branches/ubuntu/saucy/restlet/saucy

« back to all changes in this revision

Viewing changes to org.restlet/src/org/restlet/engine/http/connector/Acceptor.java

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2012-06-11 16:25:45 UTC
  • Revision ID: package-import@ubuntu.com-20120611162545-5w2o0resi5y3pybc
Tags: upstream-2.0.14
Import upstream version 2.0.14

Show diffs side-by-side

added added

removed removed

Lines of Context:
org.restlet/src/org/restlet/engine/http/connector/Acceptor.java
 
1
/**
 
2
 * Copyright 2005-2012 Restlet S.A.S.
 
3
 * 
 
4
 * The contents of this file are subject to the terms of one of the following
 
5
 * open source licenses: Apache 2.0 or LGPL 3.0 or LGPL 2.1 or CDDL 1.0 or EPL
 
6
 * 1.0 (the "Licenses"). You can select the license that you prefer but you may
 
7
 * not use this file except in compliance with one of these Licenses.
 
8
 * 
 
9
 * You can obtain a copy of the Apache 2.0 license at
 
10
 * http://www.opensource.org/licenses/apache-2.0
 
11
 * 
 
12
 * You can obtain a copy of the LGPL 3.0 license at
 
13
 * http://www.opensource.org/licenses/lgpl-3.0
 
14
 * 
 
15
 * You can obtain a copy of the LGPL 2.1 license at
 
16
 * http://www.opensource.org/licenses/lgpl-2.1
 
17
 * 
 
18
 * You can obtain a copy of the CDDL 1.0 license at
 
19
 * http://www.opensource.org/licenses/cddl1
 
20
 * 
 
21
 * You can obtain a copy of the EPL 1.0 license at
 
22
 * http://www.opensource.org/licenses/eclipse-1.0
 
23
 * 
 
24
 * See the Licenses for the specific language governing permissions and
 
25
 * limitations under the Licenses.
 
26
 * 
 
27
 * Alternatively, you can obtain a royalty free commercial license with less
 
28
 * limitations, transferable or non-transferable, directly at
 
29
 * http://www.restlet.com/products/restlet-framework
 
30
 * 
 
31
 * Restlet is a registered trademark of Restlet S.A.S.
 
32
 */
 
33
 
 
34
package org.restlet.engine.http.connector;
 
35
 
 
36
import java.io.IOException;
 
37
import java.net.Socket;
 
38
import java.net.SocketException;
 
39
import java.nio.channels.AsynchronousCloseException;
 
40
import java.nio.channels.ClosedByInterruptException;
 
41
import java.util.concurrent.CountDownLatch;
 
42
import java.util.logging.Level;
 
43
 
 
44
import org.restlet.Server;
 
45
 
 
46
/**
 
47
 * Listens on the given socket channel for incoming connections and dispatches
 
48
 * them to the given handler pool
 
49
 * 
 
50
 * @author Jerome Louvel
 
51
 */
 
52
public class Acceptor extends BaseTask {
 
53
 
 
54
    /** The parent server helper. */
 
55
    private final BaseServerHelper helper;
 
56
 
 
57
    /**
 
58
     * The latch to countdown when the socket is ready to accept connections.
 
59
     */
 
60
    private final CountDownLatch latch;
 
61
 
 
62
    /**
 
63
     * Constructor.
 
64
     * 
 
65
     * @param helper
 
66
     *            The target server helper.
 
67
     * @param latch
 
68
     *            The latch to countdown when the socket is ready to accept
 
69
     *            connections.
 
70
     */
 
71
    public Acceptor(BaseServerHelper helper, CountDownLatch latch) {
 
72
        this.helper = helper;
 
73
        this.latch = latch;
 
74
    }
 
75
 
 
76
    /**
 
77
     * Returns the parent server helper.
 
78
     * 
 
79
     * @return The parent server helper.
 
80
     */
 
81
    protected BaseServerHelper getHelper() {
 
82
        return helper;
 
83
    }
 
84
 
 
85
    /**
 
86
     * Listens on the given server socket for incoming connections.
 
87
     */
 
88
    public void run() {
 
89
        this.latch.countDown();
 
90
        setRunning(true);
 
91
 
 
92
        while (isRunning()) {
 
93
            try {
 
94
                Socket socket = getHelper().getServerSocket().accept();
 
95
                int connectionsCount = getHelper().getConnections().size();
 
96
 
 
97
                if ((getHelper().getMaxTotalConnections() == -1)
 
98
                        || (connectionsCount <= getHelper()
 
99
                                .getMaxTotalConnections())) {
 
100
                    Connection<Server> connection = getHelper()
 
101
                            .createConnection(getHelper(), socket, null);
 
102
                    connection.open();
 
103
                    getHelper().getConnections().add(connection);
 
104
                } else {
 
105
                    // Rejection connection
 
106
                    socket.close();
 
107
                    getHelper()
 
108
                            .getLogger()
 
109
                            .info(
 
110
                                    "Maximum number of concurrent connections reached. New connection rejected.");
 
111
                }
 
112
            } catch (ClosedByInterruptException ex) {
 
113
                this.helper.getLogger().log(Level.FINE,
 
114
                        "ServerSocket channel was closed by interrupt", ex);
 
115
                break;
 
116
            } catch (AsynchronousCloseException ace) {
 
117
                this.helper.getLogger().log(Level.FINE,
 
118
                        "The server socket was closed", ace);
 
119
            } catch (SocketException se) {
 
120
                this.helper.getLogger().log(Level.FINE,
 
121
                        "The server socket was closed", se);
 
122
            } catch (IOException ex) {
 
123
                this.helper.getLogger().log(Level.WARNING,
 
124
                        "Unexpected error while accepting new connection", ex);
 
125
            }
 
126
        }
 
127
    }
 
128
}