def connect(self):
"""
Connects to the server.
"""
try:
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
# once connected, get the GNS3 server version (over classic HTTP)
url = "http://{host}:{port}/version".format(host=self.host, port=self.port)
content = urllib.request.urlopen(url).read()
try:
json_data = json.loads(content.decode("utf-8"))
self._version = json_data.get("version")
except ValueError as e:
log.error("could not get the server version: {}".format(e))
#FIXME: temporary version check
if (self._version != __version__):
self.close_connection()
raise OSError("GUI version {} differs with the server version {}".format(__version__, self._version))
def test_connect_and_close(self, sock):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [(socket.AF_INET, socket.SOCK_STREAM, 0, "",
("127.0.0.1", 80, 0, 0))]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
s.recv.return_value = b"\r\n".join([
b"HTTP/1.1 101 Switching Protocols",
b"Connection: Upgrade",
b"Sec-Websocket-Version: 13",
b"Content-Type: text/plain;charset=utf-8",
b"Sec-Websocket-Accept: " + b64encode(sha1(c.key + WS_KEY).digest()),
b"Upgrade: websocket",
b"Date: Sun, 26 Jul 2015 12:32:55 GMT",
b"Server: ws4py/test",
b"\r\n"
])
c.connect()
s.connect.assert_called_once_with(("127.0.0.1", 80))
s.reset_mock()
c.close(code=1006, reason="boom")
args = s.sendall.call_args_list[0]
f = Frame()
f.parser.send(args[0][0])
f.parser.close()
self.assertIn(b'boom', f.unmask(f.body))
def test_connect_and_close(self, sock):
s = MagicMock()
sock.socket.return_value = s
sock.getaddrinfo.return_value = [(socket.AF_INET, socket.SOCK_STREAM,
0, "", ("127.0.0.1", 80, 0, 0))]
c = WebSocketBaseClient(url="ws://127.0.0.1/?token=value")
s.recv.return_value = b"\r\n".join([
b"HTTP/1.1 101 Switching Protocols", b"Connection: Upgrade",
b"Sec-Websocket-Version: 13",
b"Content-Type: text/plain;charset=utf-8",
b"Sec-Websocket-Accept: " +
b64encode(sha1(c.key + WS_KEY).digest()), b"Upgrade: websocket",
b"Date: Sun, 26 Jul 2015 12:32:55 GMT", b"Server: ws4py/test",
b"\r\n"
])
c.connect()
s.connect.assert_called_once_with(("127.0.0.1", 80))
s.reset_mock()
c.close(code=1006, reason="boom")
args = s.sendall.call_args_list[0]
f = Frame()
f.parser.send(args[0][0])
f.parser.close()
self.assertIn(b'boom', f.unmask(f.body))
def connect(self):
"""
Connects to the server.
"""
try:
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
# once connected, get the GNS3 server version (over classic HTTP)
url = "http://{host}:{port}/version".format(host=self.host,
port=self.port)
content = urllib.request.urlopen(url).read()
try:
json_data = json.loads(content.decode("utf-8"))
self._version = json_data.get("version")
except ValueError as e:
log.error("could not get the server version: {}".format(e))
#FIXME: temporary version check
if (self._version != __version__):
self.close_connection()
raise OSError(
"GUI version {} differs with the server version {}".format(
__version__, self._version))
def connect(self):
"""
Connects to the server.
"""
try:
WebSocketBaseClient.connect(self)
except HandshakeError as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError(str(e))
def _connect(self):
"""
Connect to the server.
"""
try:
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
def _connect(self):
"""
Connect to the server.
"""
try:
if self._local is True:
self.connection.settimeout(5)
WebSocketBaseClient.connect(self)
except OSError:
raise
except Exception as e:
log.error("could not to connect {}: {}".format(self.url, e))
raise OSError("Websocket exception {}: {}".format(type(e), e))
from ws4py.client import WebSocketBaseClient
import json
import ssl
ws = WebSocketBaseClient(url='wss://localhost:8888/websocket',
ssl_options={
"cert_reqs": ssl.CERT_NONE,
"ssl_version": ssl.PROTOCOL_TLSv1_2
})
info = {'Type': 'Client', 'Request': 'EnvironmentInfo'}
print("trying to connect")
ws.connect()
ws.send(json.dumps(info))
def _new_ws(self, ws_url):
con = WebSocketBaseClient(ws_url)
con.connect()
return con
class WsClientSocket(ClientSocket):
# TODO: this shares a lot with zmq...
def send(self, msg):
"""Send the message to the socket"""
self.sock.send(msg)
def received_message(self, msg):
assert self.msg is None, \
"Already got non-zero msg {}".format(self.msg)
self.msg = str(msg)
def recv(self, timeout=None):
"""Co-operatively block until received"""
start = time.time()
self.msg = None
if timeout is None:
timeout = self.timeout
while True:
if timeout:
t = start + timeout - time.time()
else:
t = None
self.sock.sock.settimeout(t)
if self.sock.once() is False:
# Failed
raise StopIteration
elif self.msg is not None:
# sys.stdout.write("Got message {}\n".format(self.msg))
# sys.stdout.flush()
return self.msg
def serialize(self, typ, kwargs):
"""Serialize the arguments to a string that can be sent to the socket
"""
_id = kwargs.pop("id")
assert type(_id) == int, "Need an integer ID, got {}".format(_id)
assert typ in SType, \
"Expected type in {}, got {}".format(list(SType.__members__), typ)
d = OrderedDict(type=typ.name)
d.update(id=_id)
if kwargs is not None:
d.update(kwargs)
s = presenter.serialize(d)
return s
def deserialize(self, msg):
"""Deserialize the string to
(typ, kwargs)"""
d = presenter.deserialize(msg)
typ = d.pop("type")
assert typ in SType.__members__, \
"Expected type in {}, got {}".format(list(SType.__members__), typ)
typ = SType.__members__[typ]
assert "id" in d, "No id in {}".format(d)
return typ, d
def open(self, address):
"""Open the socket on the given address"""
from cothread.cosocket import socket as cosocket
import socket
from ws4py.client import WebSocketBaseClient
_socket = socket.socket
socket.socket = cosocket
self.sock = WebSocketBaseClient(address)
self.sock.handshake_ok = lambda: None
socket.socket = _socket
self.sock.received_message = weak_method(self.received_message)
self.sock.connect()
def close(self):
"""Close the socket"""
self.sock.close()
def request(self, response, typ, kwargs):
"""Make a new request and send it out, storing a suitable id so that
any returns can be mapped to the response function using do_response"""
# lazily make request map
if not hasattr(self, "request_id"):
self.request_id = {}
self.last_id = -1
self.last_id += 1
assert self.last_id not in self.request_id, \
"Already have a request {} in {}".format(self.last_id,
self.request_id)
self.request_id[self.last_id] = response
self = weakref.proxy(self)
def do_request(typ, kwargs=None, _id=self.last_id):
if kwargs is None:
kwargs = OrderedDict()
kwargs.update(id=_id)
self.send(self.serialize(typ, kwargs))
do_request(typ, kwargs)
return do_request
def lookup_response(self, kwargs, remove_response=False):
"""Return the reponse function given the id stored in the args. If
remove, then remove it from the list"""
_id = kwargs.pop("id")
if remove_response:
return self.request_id.pop(_id)
else:
return self.request_id[_id]
