forked from jooby-project/jooby
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathServer.java
More file actions
142 lines (127 loc) · 3.44 KB
/
Server.java
File metadata and controls
142 lines (127 loc) · 3.44 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/**
* Jooby https://jooby.io
* Apache License Version 2.0 https://jooby.io/LICENSE.txt
* Copyright 2014 Edgar Espina
*/
package io.jooby;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.EOFException;
import java.io.IOException;
import java.nio.channels.ClosedChannelException;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Web server contract. Defines operations to start, join and stop a web server. Jooby comes
* with three web server implementation: Jetty, Netty and Undertow.
*
* A web server is automatically discovered using the Java Service Loader API. All you need is to
* add the server dependency to your project classpath.
*
* When service loader is not an option or do you want to manually bootstrap a server:
*
* <pre>{@code
*
* Server server = new Netty(); // or Jetty or Utow
*
* App app = new App();
*
* server.start(app);
*
* ...
*
* server.stop();
*
* }</pre>
*
* @author edgar
* @since 2.0.0
*/
public interface Server {
/**
* Base class for server.
*/
abstract class Base implements Server {
private static final boolean useShutdownHook = Boolean
.parseBoolean(System.getProperty("jooby.useShutdownHook", "true"));
private AtomicBoolean stopping = new AtomicBoolean();
protected void fireStart(@Nonnull List<Jooby> applications, @Nonnull Executor defaultWorker) {
for (Jooby app : applications) {
app.setDefaultWorker(defaultWorker).start(this);
}
}
protected void fireReady(@Nonnull List<Jooby> applications) {
for (Jooby app : applications) {
app.ready(this);
}
}
protected void fireStop(@Nonnull List<Jooby> applications) {
if (stopping.compareAndSet(false, true)) {
if (applications != null) {
for (Jooby app : applications) {
app.stop();
}
}
}
}
protected void addShutdownHook() {
if (useShutdownHook) {
Runtime.getRuntime().addShutdownHook(new Thread(this::stop));
}
}
}
/**
* Set server options.
*
* @param options Server options.
* @return This server.
*/
@Nonnull Server setOptions(@Nonnull ServerOptions options);
/**
* Get server options.
*
* @return Server options.
*/
@Nonnull ServerOptions getOptions();
/**
* Start an application.
*
* @param application Application to start.
* @return This server.
*/
@Nonnull Server start(@Nonnull Jooby application);
/**
* Block current thread so JVM doesn't exit.
*/
@Nonnull default void join() {
try {
Thread.currentThread().join();
} catch (InterruptedException x) {
Thread.currentThread().interrupt();
}
}
/**
* Stop the server.
*
* @return Stop the server.
*/
@Nonnull Server stop();
/**
* Test whenever the given exception is a connection-lost. Connection-lost exceptions don't
* generate log.error statements.
*
* @param cause Exception to check.
* @return True for connection lost.
*/
static boolean connectionLost(@Nullable Throwable cause) {
if (cause instanceof IOException) {
String message = cause.getMessage();
if (message != null) {
String msg = message.toLowerCase();
return msg.contains("reset by peer") || msg.contains("broken pipe");
}
}
return (cause instanceof ClosedChannelException) || (cause instanceof EOFException);
}
}