def test_write_str(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_context()
@socket.data_handler
def data_handler(data):
tu.check_context()
socket.write_buffer(data) # Just echo it back
server.listen(8080)
client = vertx.create_net_client()
def client_connect_handler(socket):
tu.check_context()
sent = 'some-string'
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_context()
received.append_buffer(data)
if received.length == len(sent):
tu.azzert(sent == received.to_string())
tu.test_complete()
socket.write_str(sent)
client.connect(8080, "localhost", client_connect_handler)
def test_write_str(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_context()
@socket.data_handler
def data_handler(data):
tu.check_context()
socket.write_buffer(data) # Just echo it back
server.listen(8080)
client = vertx.create_net_client()
def client_connect_handler(socket):
tu.check_context()
sent = 'some-string'
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_context()
received.append_buffer(data)
if received.length == len(sent):
tu.azzert(sent == received.to_string())
tu.test_complete()
socket.write_str(sent)
client.connect(8080, "localhost", client_connect_handler)
def test_echo(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_context()
@socket.data_handler
def data_handler(data):
tu.check_context()
socket.write_buffer(data) # Just echo it back
server.listen(8080)
client = vertx.create_net_client()
def client_connect_handler(socket):
tu.check_context()
sends = 10
size = 100
sent = Buffer.create()
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_context()
received.append_buffer(data)
if received.length == sends * size:
tu.azzert(TestUtils.buffers_equal(sent, received))
tu.test_complete()
@socket.drain_handler
def drain_handler(stream):
tu.check_context()
#print "drained\n"
@socket.end_handler
def end_handler(stream):
tu.check_context()
#print "end\n"
socket.pause()
socket.resume()
socket.write_queue_full
socket.write_queue_max_size = 100000
for i in range(0, sends):
data = TestUtils.gen_buffer(size)
sent.append_buffer(data)
socket.write_buffer(data)
client.connect(8080, "localhost", client_connect_handler)
def test_echo(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_context()
@socket.data_handler
def data_handler(data):
tu.check_context()
socket.write_buffer(data) # Just echo it back
server.listen(8080)
client = vertx.create_net_client()
def client_connect_handler(socket):
tu.check_context()
sends = 10
size = 100
sent = Buffer.create()
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_context()
received.append_buffer(data)
if received.length == sends * size:
tu.azzert(TestUtils.buffers_equal(sent, received))
tu.test_complete()
@socket.drain_handler
def drain_handler(stream):
tu.check_context()
#print "drained\n"
@socket.end_handler
def end_handler(stream):
tu.check_context()
#print "end\n"
socket.pause()
socket.resume()
socket.write_queue_full
socket.write_queue_max_size = 100000
for i in range(0, sends):
data = TestUtils.gen_buffer(size)
sent.append_buffer(data)
socket.write_buffer(data)
client.connect(8080, "localhost", client_connect_handler)
def test_write_str(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
@socket.data_handler
def data_handler(data):
tu.check_thread()
socket.write(data) # Just echo it back
client = vertx.create_net_client()
def client_connect_handler(err, socket):
tu.azzert(err == None)
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
sent = 'some-string'
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_thread()
received.append_buffer(data)
if received.length == len(sent):
tu.azzert(sent == received.to_string())
tu.test_complete()
socket.write_str(sent)
def listen_handler(err, serv):
tu.azzert(err == None)
tu.azzert(serv == server)
client.connect(8080, "localhost", client_connect_handler)
server.listen(8080, "0.0.0.0", listen_handler)
def test_write_str(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
@socket.data_handler
def data_handler(data):
tu.check_thread()
socket.write(data) # Just echo it back
client = vertx.create_net_client()
def client_connect_handler(err, socket):
tu.azzert(err == None)
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
sent = 'some-string'
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_thread()
received.append_buffer(data)
if received.length == len(sent):
tu.azzert(sent == received.to_string())
tu.test_complete()
socket.write_str(sent)
def listen_handler(err, serv):
tu.azzert(err == None)
tu.azzert(serv == server)
client.connect(8080, "localhost", client_connect_handler)
server.listen(8080, "0.0.0.0", listen_handler)
def test_methods(self):
global server, client
server = vertx.create_net_server()
server.ssl = True
server.key_store_path = "foo.jks"
server.key_store_password = "******"
server.trust_store_path = "bar.jks"
server.trust_store_password = "******"
server.send_buffer_size = 123123
server.receive_buffer_size = 218123
server.tcp_keep_alive = True
server.reuse_address = True
server.so_linger = True
server.traffic_class = 123
@server.connect_handler
def connect_handler(sock):
pass
server.close()
client = vertx.create_net_client()
client.ssl = True
client.key_store_path = "foo.jks"
client.key_store_password = "******"
client.trust_store_path = "bar.jks"
client.trust_store_password = "******"
client.trust_all = True
client.send_buffer_size = 123123
client.receive_buffer_size = 218123
client.tcp_keep_alive = True
client.reuse_address = True
client.so_linger = True
client.traffic_class = 123
client.close()
tu.test_complete()
def test_methods(self):
global server, client
server = vertx.create_net_server()
server.ssl=True
server.key_store_path="foo.jks"
server.key_store_password="******"
server.trust_store_path="bar.jks"
server.trust_store_password="******"
server.send_buffer_size=123123
server.receive_buffer_size=218123
server.tcp_keep_alive=True
server.reuse_address=True
server.so_linger = True
server.traffic_class=123
@server.connect_handler
def connect_handler(sock): pass
server.close()
client = vertx.create_net_client()
client.ssl=True
client.key_store_path="foo.jks"
client.key_store_password="******"
client.trust_store_path="bar.jks"
client.trust_store_password="******"
client.trust_all=True
client.send_buffer_size=123123
client.receive_buffer_size=218123
client.tcp_keep_alive=True
client.reuse_address=True
client.so_linger = True
client.traffic_class=123
client.close()
tu.test_complete()
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import vertx
server = vertx.create_net_server()
server.ssl = True
server.key_store_path = "server-keystore.jks"
server.key_store_password = "******"
@server.connect_handler
def connect_handler(socket):
def data_handler(data):
socket.write_buffer(data)
socket.data_handler(data_handler)
server.listen(1234)
# Copyright 2011 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import vertx
server = vertx.create_net_server()
server.ssl = True
server.key_store_path="server-keystore.jks"
server.key_store_password="******"
@server.connect_handler
def connect_handler(socket):
def data_handler(data):
socket.write(data)
socket.data_handler(data_handler)
server.listen(1234)
def test_echo_ssl(self):
global server, client
# Let's do full SSL with client auth
server = vertx.create_net_server()
server.ssl = True
server.key_store_path = './src/test/keystores/server-keystore.jks'
server.key_store_password = '******'
server.trust_store_path = './src/test/keystores/server-truststore.jks'
server.trust_store_password = '******'
server.client_auth_required = True
@server.connect_handler
def connect_handler(socket):
tu.check_context()
@socket.data_handler
def data_handler(data):
tu.check_context()
socket.write_buffer(data) # Just echo it back
server.listen(8080)
client = vertx.create_net_client()
client.ssl = True
client.key_store_path = './src/test/keystores/client-keystore.jks'
client.key_store_password = '******'
client.trust_store_path = './src/test/keystores/client-truststore.jks'
client.trust_store_password = '******'
def client_connect_handler(socket):
tu.check_context()
sends = 10
size = 100
sent = Buffer.create()
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_context()
received.append_buffer(data)
if received.length == sends * size:
tu.azzert(TestUtils.buffers_equal(sent, received))
tu.test_complete()
#Just call the methods. Real testing is done in java tests
@socket.drain_handler
def drain_handler(stream):
tu.check_context()
#print "drained\n"
@socket.end_handler
def end_handler(stream):
tu.check_context()
#print "end\n"
@socket.closed_handler
def closed_handler():
tu.check_context()
#print "closed\n"
socket.pause()
socket.resume()
socket.write_queue_full
socket.write_queue_max_size = 100000
for i in range(0, sends):
data = TestUtils.gen_buffer(size)
sent.append_buffer(data)
socket.write_buffer(data)
client.connect(8080, "localhost", client_connect_handler)
def test_echo_ssl(self):
global server, client
# Let's do full SSL with client auth
server = vertx.create_net_server()
server.ssl = True
server.key_store_path = './src/test/keystores/server-keystore.jks'
server.key_store_password = '******'
server.trust_store_path = './src/test/keystores/server-truststore.jks'
server.trust_store_password = '******'
server.client_auth_required = True
@server.connect_handler
def connect_handler(socket):
tu.check_context()
@socket.data_handler
def data_handler(data):
tu.check_context()
socket.write_buffer(data) # Just echo it back
server.listen(8080)
client = vertx.create_net_client()
client.ssl = True
client.key_store_path = './src/test/keystores/client-keystore.jks'
client.key_store_password = '******'
client.trust_store_path = './src/test/keystores/client-truststore.jks'
client.trust_store_password = '******'
def client_connect_handler(socket):
tu.check_context()
sends = 10
size = 100
sent = Buffer.create()
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_context()
received.append_buffer(data)
if received.length == sends * size:
tu.azzert(TestUtils.buffers_equal(sent, received))
tu.test_complete()
#Just call the methods. Real testing is done in java tests
@socket.drain_handler
def drain_handler(stream):
tu.check_context()
#print "drained\n"
@socket.end_handler
def end_handler(stream):
tu.check_context()
#print "end\n"
@socket.closed_handler
def closed_handler():
tu.check_context()
#print "closed\n"
socket.pause()
socket.resume()
socket.write_queue_full
socket.write_queue_max_size = 100000
for i in range(0, sends):
data = TestUtils.gen_buffer(size)
sent.append_buffer(data)
socket.write_buffer(data)
client.connect(8080, "localhost", client_connect_handler)
def test_echo(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
@socket.data_handler
def data_handler(data):
tu.check_thread()
socket.write(data) # Just echo it back
client = vertx.create_net_client()
def client_connect_handler(err, socket):
tu.azzert(err == None)
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
sends = 10
size = 100
sent = Buffer.create()
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_thread()
received.append_buffer(data)
if received.length == sends * size:
tu.azzert(TestUtils.buffers_equal(sent, received))
tu.test_complete()
@socket.drain_handler
def drain_handler():
tu.check_thread()
@socket.end_handler
def end_handler():
tu.check_thread()
socket.pause()
socket.resume()
socket.write_queue_full
socket.write_queue_max_size = 100000
for i in range(0, sends):
data = TestUtils.gen_buffer(size)
sent.append_buffer(data)
socket.write(data)
def listen_handler(err, serv):
tu.azzert(err == None)
tu.azzert(serv == server)
client.connect(8080, "localhost", client_connect_handler)
server.listen(8080, "0.0.0.0", listen_handler)
def test_echo(self):
global server, client
server = vertx.create_net_server()
@server.connect_handler
def connect_handler(socket):
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
@socket.data_handler
def data_handler(data):
tu.check_thread()
socket.write(data) # Just echo it back
client = vertx.create_net_client()
def client_connect_handler(err, socket):
tu.azzert(err == None)
tu.check_thread()
tu.azzert(socket.local_address[0] is not None)
tu.azzert(socket.local_address[1] > -1)
tu.azzert(socket.remote_address[0] is not None)
tu.azzert(socket.remote_address[1] > -1)
sends = 10
size = 100
sent = Buffer.create()
received = Buffer.create()
@socket.data_handler
def data_handler(data):
tu.check_thread()
received.append_buffer(data)
if received.length == sends * size:
tu.azzert(TestUtils.buffers_equal(sent, received))
tu.test_complete()
@socket.drain_handler
def drain_handler():
tu.check_thread()
@socket.end_handler
def end_handler():
tu.check_thread()
socket.pause()
socket.resume()
socket.write_queue_full
socket.write_queue_max_size = 100000
for i in range(0, sends):
data = TestUtils.gen_buffer(size)
sent.append_buffer(data)
socket.write(data)
def listen_handler(err, serv):
tu.azzert(err == None)
tu.azzert(serv == server)
client.connect(8080, "localhost", client_connect_handler)
server.listen(8080, "0.0.0.0", listen_handler)
