def connect(self, url, **kwargs):
self.parse_url(url)
if not self.scheme:
self.scheme = kwargs.get('scheme',"ws")
else:
if 'scheme' in kwargs:
raise ValueError('Connection scheme cannot be delared in both url and arguments.')
if self.scheme is "http":
self.scheme = "ws"
builder = ClientTransportBuilder()
self.transport = builder.create(self.scheme)
self.transport.connect(self.parsed_url, self, **kwargs)
debug_log('Connection opened, local address {0}', self.transport.address)
if self.use_bursts:
self.event_thread = spawn_thread(target=self.__event_emitter, args=())
self.event_thread.start()
def connect(self, url, parent, **kwargs):
self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.fd = self.sock.makefile('rwb')
self.parent = parent
if not self.parent:
raise RuntimeError('ClientTransportSock can be only created inside of a class')
if url.path:
self.path = url.path
try:
self.sock.connect(self.path)
debug_log('Connected to {0}', self.path)
recv_t = spawn_thread(target=self.recv)
recv_t.setDaemon(True)
recv_t.start()
except socket.error as err:
self.terminated = True
debug_log('Socket connection exception: {0}', err)
raise
def connect(self, url, parent, **kwargs):
self.url = url
self.parent = parent
self.username = url.username
self.port = url.port
if not self.parent:
raise RuntimeError('ClientTransportSSH can be only created inside of a class')
if url.hostname:
self.hostname = url.hostname
elif url.netloc:
self.hostname = url.netloc
if '@' in self.hostname:
temp, self.hostname = self.hostname.split('@')
elif url.path:
self.hostname = url.path
if not self.username:
self.username = kwargs.get('username', None)
else:
if 'username' in kwargs:
raise ValueError('Username cannot be delared in both url and arguments.')
if not self.username:
raise ValueError('Username is not declared.')
if not self.hostname:
self.hostname = kwargs.get('hostname', None)
else:
if 'hostname' in kwargs:
raise ValueError('Hostname cannot be delared in both url and arguments.')
if not self.hostname:
raise ValueError('Hostname is not declared.')
if not self.port:
self.port = kwargs.get('port', 22)
else:
if 'port' in kwargs:
raise ValueError('Port cannot be delared in both url and arguments.')
self.password = kwargs.get('password', None)
self.pkey = kwargs.get('pkey', None)
self.key_filename = kwargs.get('key_filename', None)
if not self.pkey and not self.password and not self.key_filename:
raise ValueError('No password, key_filename nor pkey for authentication declared.')
self.host_key = kwargs.get('host_key', None)
self.host_key_file = kwargs.get('host_key_file', None)
if self.host_key and self.host_key_file:
raise ValueError('Both host_key and host_key_file parameters cannot be specified simultaneously.')
debug_log('Trying to connect to {0}', self.hostname)
try:
self.ssh = paramiko.SSHClient()
if self.host_key_file:
try:
self.ssh.load_host_keys(self.host_key_file)
self.look_for_keys = False
except IOError:
debug_log('Cannot read host key file: {0}. SSH transport is closing.', self.host_key_file)
self.close()
raise
elif self.host_key:
key_hostname, key_type, key = self.host_key.split(' ')
if not key_hostname:
raise ValueError('Hostname field of host key is not specified.')
if not key:
raise ValueError('Key field of host key is not specified.')
if key_type is not "ssh-rsa" or key_type is not "ssh-dss":
raise ValueError('Key_type field of host key must be either ssh-rsa or ssh-dss.')
self.ssh._host_keys.add(key_hostname, key_type, key)
else:
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.ssh.connect(
self.hostname,
port=self.port,
username=self.username,
password=self.password,
pkey=self.pkey,
look_for_keys=self.look_for_keys,
key_filename=self.key_filename
)
debug_log('Connected to {0}', self.hostname)
except paramiko.AuthenticationException as err:
debug_log('Authentication exception: {0}', err)
raise
except paramiko.BadHostKeyException as err:
debug_log('Bad host key exception: {0}', err)
raise
except paramiko.SSHException as err:
debug_log('SSH exception: {0}', err)
raise
except socket.error as err:
debug_log('Socket exception: {0}', err)
raise
self.stdin, self.stdout, self.stderr = self.ssh.exec_command(
"sh /usr/local/libexec/dispatcher/ssh_transport_catcher",
bufsize=0
)
self.channel = self.ssh.get_transport().open_session()
recv_t = spawn_thread(target=self.recv)
recv_t.setDaemon(True)
recv_t.start()
closed_t = spawn_thread(target=self.closed)
closed_t.setDaemon(True)
closed_t.start()
def decode(self, msg):
if 'namespace' not in msg:
self.error_callback(ClientError.INVALID_JSON_RESPONSE)
return
if 'name' not in msg:
self.error_callback(ClientError.INVALID_JSON_RESPONSE)
return
if msg['namespace'] == 'events' and msg['name'] == 'event':
args = msg['args']
t = spawn_thread(target=self.__process_event, args=(args['name'], args['args']))
t.start()
return
if msg['namespace'] == 'events' and msg['name'] == 'event_burst':
args = msg['args']
for i in args['events']:
t = spawn_thread(target=self.__process_event, args=(i['name'], i['args']))
t.start()
return
if msg['namespace'] == 'events' and msg['name'] == 'logout':
self.error_callback(ClientError.LOGOUT)
return
if msg['namespace'] == 'rpc':
if msg['name'] == 'call':
if self.rpc is None:
self.__send_error(msg['id'], errno.EINVAL, 'Server functionality is not supported')
return
if 'args' not in msg:
self.__send_error(msg['id'], errno.EINVAL, 'Malformed request')
return
args = msg['args']
if 'method' not in args or 'args' not in args:
self.__send_error(msg['id'], errno.EINVAL, 'Malformed request')
return
def run_async(msg, args):
try:
result = self.rpc.dispatch_call(args['method'], args['args'], sender=self)
except rpc.RpcException as err:
self.__send_error(msg['id'], err.code, err.message)
else:
self.__send_response(msg['id'], result)
t = spawn_thread(target=run_async, args=(msg, args))
t.start()
return
if msg['name'] == 'response':
if msg['id'] in self.pending_calls.keys():
call = self.pending_calls[msg['id']]
call.result = msg['args']
call.completed.set()
if call.callback is not None:
call.callback(msg['args'])
del self.pending_calls[str(call.id)]
else:
if self.error_callback is not None:
self.error_callback(ClientError.SPURIOUS_RPC_RESPONSE, msg['id'])
if msg['name'] == 'error':
if msg['id'] in self.pending_calls.keys():
call = self.pending_calls[msg['id']]
call.result = None
call.error = msg['args']
call.completed.set()
del self.pending_calls[str(call.id)]
if self.error_callback is not None:
self.error_callback(ClientError.RPC_CALL_ERROR)
