1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 """
16 Net support to the python vert.x platform
17 """
18
19 import org.vertx.java.core.Handler
20 import org.vertx.java.deploy.impl.VertxLocator
21 import core.tcp_support
22 import core.ssl_support
23 import core.buffer
24 import core.streams
25
26 from core.handlers import CloseHandler, DoneHandler, ClosedHandler
27 from core.event_bus import EventBus
28
29 __author__ = "Scott Horn"
30 __email__ = "scott@hornmicro.com"
31 __credits__ = "Based entirely on work by Tim Fox http://tfox.org"
32
33 -class NetServer(core.ssl_support.SSLSupport, core.tcp_support.TCPSupport):
34 """Represents a TCP or SSL Server
35
36 When connections are accepted by the server
37 they are supplied to the user in the form of a NetSocket instance that is passed via the handler
38 set using connect_handler.
39 """
41 self.java_obj = org.vertx.java.deploy.impl.VertxLocator.vertx.createNetServer()
42 for item in kwargs.keys():
43 setattr(self, item, kwargs[item])
44
46 """Client authentication is an extra level of security in SSL, and requires clients to provide client certificates.
47 Those certificates must be added to the server trust store.
48 @param val: If true then the server will request client authentication from any connecting clients, if they
49 do not authenticate then they will not make a connection.
50 """
51 self.java_obj.setClientAuthRequired(val)
52 return self
53 client_auth_required = property(fset=set_client_auth_required)
54
56 """Supply a connect handler for this server. The server can only have at most one connect handler at any one time.
57 As the server accepts TCP or SSL connections it creates an instance of NetSocket and passes it to the
58 connect handler.
59
60 Keyword arguments:
61 @param handler: connection handler
62
63 @return: a reference to self so invocations can be chained
64 """
65 self.java_obj.connectHandler(ConnectHandler(handler))
66 return self
67
68
69 - def listen(self, port, host="0.0.0.0"):
70 """Instruct the server to listen for incoming connections.
71
72 Keyword arguments:
73 @param port: The port to listen on.
74 @param host: The host name or ip address to listen on.
75
76 @return: a reference to self so invocations can be chained
77 """
78 self.java_obj.listen(port, host)
79 return self
80
81
82 - def close(self, handler=None):
83 """Close the server. The handler will be called when the close is complete."""
84 self.java_obj.close(CloseHandler(handler))
85
86
87
88 -class NetClient(core.ssl_support.SSLSupport, core.tcp_support.TCPSupport):
89 """NetClient is an asynchronous factory for TCP or SSL connections.
90
91 Multiple connections to different servers can be made using the same instance.
92 """
94 self.java_obj = org.vertx.java.deploy.impl.VertxLocator.vertx.createNetClient()
95 for item in kwargs.keys():
96 setattr(self, item, kwargs[item])
97
99 """Should the client trust ALL server certificates
100
101 Keyword arguments:
102 @param val: If val is set to true then the client will trust ALL server certificates and will not attempt to authenticate them
103 against it's local client trust store. The default value is false.
104
105 Use this method with caution!
106
107 @return: a reference to self so invocations can be chained
108 """
109 self.java_obj.setTrustAll(val)
110 return self
111
112 trust_all = property(fset=set_trust_all)
113
114 - def connect(self, port, host, handler):
115 """Attempt to open a connection to a server. The connection is opened asynchronously and the result returned in the
116 handler.
117
118 Keyword arguments:
119 @param port: The port to connect to.
120 @param host: The host or ip address to connect to.
121 @param handler: The connection handler
122
123 @return: a reference to self so invocations can be chained
124 """
125 self.java_obj.connect(port, host, ConnectHandler(handler))
126 return self
127
129 """Close the NetClient. Any open connections will be closed."""
130 self.java_obj.close()
131
132 -class NetSocket(core.streams.ReadStream, core.streams.WriteStream):
133 """NetSocket is a socket-like abstraction used for reading from or writing
134 to TCP connections.
135 """
137 self.java_obj = j_socket
138
139 def simple_handler(msg):
140 self.write_buffer(msg.body)
141
142 self.write_handler_id = EventBus.register_simple_handler(False, simple_handler)
143
144 def wrapped_closed_handler():
145 EventBus.unregister_handler(self.write_handler_id)
146 if hasattr(self, "_closed_handler"):
147 self._closed_handler()
148 self.java_obj.closedHandler(ClosedHandler(wrapped_closed_handler))
149
151 """Write a Buffer to the socket. The handler will be called when the buffer has actually been written to the wire.
152
153 Keyword arguments:
154 @param buffer: The buffer to write.
155 @param handler: The handler to call on completion.
156 """
157 java_buffer = buffer._to_java_buffer()
158 if handler is None:
159 self.java_obj.write(java_buffer)
160 else:
161 self.java_obj.write(java_buffer, DoneHandler(handler))
162
163 - def write_str(self, str, enc="UTF-8", handler=None):
164 """Write a String to the socket. The handler will be called when the string has actually been written to the wire.
165
166 Keyword arguments:
167 @param str: The string to write.
168 @param enc: The encoding to use.
169 @param handler: The handler to call on completion.
170 """
171 if handler is None:
172 self.java_obj.write(str, enc)
173 else:
174 self.java_obj.write(str, enc, DoneHandler(handler))
175
177 """Set a closed handler on the socket.
178
179 Keyword arguments:
180 @param handler: A block to be used as the handler
181 """
182 self._closed_handler = handler
183
185 """Tell the kernel to stream a file directly from disk to the outgoing connection, bypassing userspace altogether
186 (where supported by the underlying operating system. This is a very efficient way to stream files.
187
188 Keyword arguments:
189 @param file_path: Path to file to send.
190 """
191 self.java_obj.sendFile(file_path)
192
194 """Close the socket"""
195 self.java_obj.close()
196
198 """ Connection handler """
200 self.handler = handler
201
203 """ Call the handler after connection is established"""
204 self.handler(NetSocket(socket))
205