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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 2000-2009. All Rights Reserved.
*
* The contents of this file are subject to the Erlang Public License,
* Version 1.1, (the "License"); you may not use this file except in
* compliance with the License. You should have received a copy of the
* Erlang Public License along with this software. If not, it can be
* retrieved online at http://www.erlang.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* %CopyrightEnd%
*/
package com.ericsson.otp.erlang;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* Represents an OTP node. It is used to connect to remote nodes or accept
* incoming connections from remote nodes.
*
* <p>
* When the Java node will be connecting to a remote Erlang, Java or C node, it
* must first identify itself as a node by creating an instance of this class,
* after which it may connect to the remote node.
*
* <p>
* When you create an instance of this class, it will bind a socket to a port so
* that incoming connections can be accepted. However the port number will not
* be made available to other nodes wishing to connect until you explicitely
* register with the port mapper daemon by calling {@link #publishPort()}.
* </p>
*
* <pre>
* OtpSelf self = new OtpSelf("client", "authcookie"); // identify self
* OtpPeer other = new OtpPeer("server"); // identify peer
*
* OtpConnection conn = self.connect(other); // connect to peer
* </pre>
*
*/
public class OtpSelf extends OtpLocalNode {
private final ServerSocket sock;
private final OtpErlangPid pid;
/**
* <p>
* Create a self node using the default cookie. The default cookie is found
* by reading the first line of the .erlang.cookie file in the user's home
* directory. The home directory is obtained from the System property
* "user.home".
* </p>
*
* <p>
* If the file does not exist, an empty string is used. This method makes no
* attempt to create the file.
* </p>
*
* @param node
* the name of this node.
*
*/
public OtpSelf(final String node) throws IOException {
this(node, defaultCookie, 0);
}
/**
* Create a self node.
*
* @param node
* the name of this node.
*
* @param cookie
* the authorization cookie that will be used by this node
* when it communicates with other nodes.
*/
public OtpSelf(final String node, final String cookie) throws IOException {
this(node, cookie, 0);
}
public OtpSelf(final String node, final String cookie, final int port)
throws IOException {
super(node, cookie);
sock = new ServerSocket(port);
if (port != 0) {
this.port = port;
} else {
this.port = sock.getLocalPort();
}
pid = createPid();
}
/**
* Get the Erlang PID that will be used as the sender id in all "anonymous"
* messages sent by this node. Anonymous messages are those sent via send
* methods in {@link OtpConnection OtpConnection} that do not specify a
* sender.
*
* @return the Erlang PID that will be used as the sender id in all
* anonymous messages sent by this node.
*/
public OtpErlangPid pid() {
return pid;
}
/**
* Make public the information needed by remote nodes that may wish to
* connect to this one. This method establishes a connection to the Erlang
* port mapper (Epmd) and registers the server node's name and port so that
* remote nodes are able to connect.
*
* <p>
* This method will fail if an Epmd process is not running on the localhost.
* See the Erlang documentation for information about starting Epmd.
*
* <p>
* Note that once this method has been called, the node is expected to be
* available to accept incoming connections. For that reason you should make
* sure that you call {@link #accept()} shortly after calling
* {@link #publishPort()}. When you no longer intend to accept connections
* you should call {@link #unPublishPort()}.
*
* @return true if the operation was successful, false if the node was
* already registered.
*
* @exception java.io.IOException
* if the port mapper could not be contacted.
*/
public boolean publishPort() throws IOException {
if (getEpmd() != null) {
return false; // already published
}
OtpEpmd.publishPort(this);
return getEpmd() != null;
}
/**
* Unregister the server node's name and port number from the Erlang port
* mapper, thus preventing any new connections from remote nodes.
*/
public void unPublishPort() {
// unregister with epmd
OtpEpmd.unPublishPort(this);
// close the local descriptor (if we have one)
try {
if (super.epmd != null) {
super.epmd.close();
}
} catch (final IOException e) {/* ignore close errors */
}
super.epmd = null;
}
/**
* Accept an incoming connection from a remote node. A call to this method
* will block until an incoming connection is at least attempted.
*
* @return a connection to a remote node.
*
* @exception java.io.IOException
* if a remote node attempted to connect but no common
* protocol was found.
*
* @exception OtpAuthException
* if a remote node attempted to connect, but was not
* authorized to connect.
*/
public OtpConnection accept() throws IOException, OtpAuthException {
Socket newsock = null;
while (true) {
try {
newsock = sock.accept();
return new OtpConnection(this, newsock);
} catch (final IOException e) {
try {
if (newsock != null) {
newsock.close();
}
} catch (final IOException f) {/* ignore close errors */
}
throw e;
}
}
}
/**
* Open a connection to a remote node.
*
* @param other
* the remote node to which you wish to connect.
*
* @return a connection to the remote node.
*
* @exception java.net.UnknownHostException
* if the remote host could not be found.
*
* @exception java.io.IOException
* if it was not possible to connect to the remote node.
*
* @exception OtpAuthException
* if the connection was refused by the remote node.
*/
public OtpConnection connect(final OtpPeer other) throws IOException,
UnknownHostException, OtpAuthException {
return new OtpConnection(this, other);
}
}
|
