libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0065.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	be6d91572633
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 assert isinstance(jid_, jid.JID)
 self.host, self.port, self.type, self.jid = (host, int(port), type_, jid_)
 self.id = id_ if id_ is not None else str(uuid.uuid4())
 if priority_local:
 self._local_priority = int(priority)
-self._priority = self.calculatePriority()
+self._priority = self.calculate_priority()
 else:
 self._local_priority = 0
 self._priority = int(priority)
 self.factory = factory
 return False
 def __ne__(self, other):
 return not self.__eq__(other)
-def calculatePriority(self):
+def calculate_priority(self):
 """Calculate candidate priority according to XEP-0260 §2.2
 @return (int): priority
 """
 def activate(self, client, sid, peer_jid, local_jid):
 """Activate the proxy candidate
 Send activation request as explained in XEP-0065 § 6.3.5
 Must only be used with proxy candidates
-@param sid(unicode): session id (same as for getSessionHash)
+@param sid(unicode): session id (same as for get_session_hash)
 @param peer_jid(jid.JID): jid of the other peer
 @return (D(domish.Element)): IQ result (or error)
 """
 assert self.type == XEP_0065.TYPE_PROXY
 iq_elt = client.IQ()
 query_elt = iq_elt.addElement((NS_BS, "query"))
 query_elt["sid"] = sid
 query_elt.addElement("activate", content=peer_jid.full())
 return iq_elt.send()
-def startTransfer(self, session_hash=None):
+def start_transfer(self, session_hash=None):
 if self.type == XEP_0065.TYPE_PROXY:
 chunk_size = 4096  # Prosody's proxy reject bigger chunks by default
 else:
 chunk_size = None
-self.factory.startTransfer(session_hash, chunk_size=chunk_size)
+self.factory.start_transfer(session_hash, chunk_size=chunk_size)
-def getSessionHash(requester_jid, target_jid, sid):
+def get_session_hash(requester_jid, target_jid, sid):
 """Calculate SHA1 Hash according to XEP-0065 §5.3.2
 @param requester_jid(jid.JID): jid of the requester (the one which activate the proxy)
 @param target_jid(jid.JID): jid of the target
 @param sid(unicode): session id
 if self.server_mode:
 return self.factory.getSession(self._session_hash)
 else:
 return self.factory.getSession()
-def _startNegotiation(self):
+def _start_negotiation(self):
 log.debug("starting negotiation (client mode)")
 self.state = STATE_CLIENT_AUTH
 self.transport.write(struct.pack("!3B", SOCKS5_VER, 1, AUTHMECH_ANON))
-def _parseNegotiation(self):
+def _parse_negotiation(self):
 try:
 # Parse out data
 ver, nmethod = struct.unpack("!BB", self.buf[:2])
 methods = struct.unpack("%dB" % nmethod, self.buf[2 : nmethod + 2])
 self.transport.write(struct.pack("!BB", SOCKS5_VER, AUTHMECH_INVALID))
 self.transport.loseConnection()
 except struct.error:
 pass
-def _parseUserPass(self):
+def _parse_user_pass(self):
 try:
 # Parse out data
 ver, ulen = struct.unpack("BB", self.buf[:2])
 uname, = struct.unpack("%ds" % ulen, self.buf[2 : ulen + 2])
 plen, = struct.unpack("B", self.buf[ulen + 2])
 password, = struct.unpack("%ds" % plen, self.buf[ulen + 3 : ulen + 3 + plen])
 # Trim off fron of the buffer
 self.buf = self.buf[3 + ulen + plen :]
 # Fire event to authenticate user
-if self.authenticateUserPass(uname, password):
+if self.authenticate_user_pass(uname, password):
 # Signal success
 self.state = STATE_REQUEST
 self.transport.write(struct.pack("!BB", SOCKS5_VER, 0x00))
 else:
 # Signal failure
 self.transport.write(struct.pack("!BB", SOCKS5_VER, 0x01))
 self.transport.loseConnection()
 except struct.error:
 pass
-def sendErrorReply(self, errorcode):
+def send_error_reply(self, errorcode):
 # Any other address types are not supported
 result = struct.pack("!BBBBIH", SOCKS5_VER, errorcode, 0, 1, 0, 0)
 self.transport.write(result)
 self.transport.loseConnection()
 # Parse out data and trim buffer accordingly
 ver, cmd, rsvd, self.addressType = struct.unpack("!BBBB", self.buf[:4])
 # Ensure we actually support the requested address type
 if self.addressType not in self.supportedAddrs:
-self.sendErrorReply(REPLY_ADDR_NOT_SUPPORTED)
+self.send_error_reply(REPLY_ADDR_NOT_SUPPORTED)
 return
 # Deal with addresses
 if self.addressType == ADDR_IPV4:
 addr, port = struct.unpack("!IH", self.buf[4:10])
 nlen = self.buf[4]
 addr, port = struct.unpack("!%dsH" % nlen, self.buf[5:])
 self.buf = self.buf[7 + len(addr) :]
 else:
 # Any other address types are not supported
-self.sendErrorReply(REPLY_ADDR_NOT_SUPPORTED)
+self.send_error_reply(REPLY_ADDR_NOT_SUPPORTED)
 return
 # Ensure command is supported
 if cmd not in self.enabledCommands:
 # Send a not supported error
-self.sendErrorReply(REPLY_CMD_NOT_SUPPORTED)
+self.send_error_reply(REPLY_CMD_NOT_SUPPORTED)
 return
 # Process the command
 if cmd == CMD_CONNECT:
-self.connectRequested(addr, port)
+self.connect_requested(addr, port)
 elif cmd == CMD_BIND:
-self.bindRequested(addr, port)
+self.bind_requested(addr, port)
 else:
 # Any other command is not supported
-self.sendErrorReply(REPLY_CMD_NOT_SUPPORTED)
+self.send_error_reply(REPLY_CMD_NOT_SUPPORTED)
 except struct.error:
 # The buffer is probably not complete, we need to wait more
 return None
-def _makeRequest(self):
+def _make_request(self):
 hash_ = self._session_hash.encode('utf-8')
 request = struct.pack(
 "!5B%dsH" % len(hash_),
 SOCKS5_VER,
 CMD_CONNECT,
 0,
 )
 self.transport.write(request)
 self.state = STATE_CLIENT_REQUEST
-def _parseRequestReply(self):
+def _parse_request_reply(self):
 try:
 ver, rep, rsvd, self.addressType = struct.unpack("!BBBB", self.buf[:4])
 # Ensure we actually support the requested address type
 if self.addressType not in self.supportedAddrs:
-self.sendErrorReply(REPLY_ADDR_NOT_SUPPORTED)
+self.send_error_reply(REPLY_ADDR_NOT_SUPPORTED)
 return
 # Deal with addresses
 if self.addressType == ADDR_IPV4:
 addr, port = struct.unpack("!IH", self.buf[4:10])
 nlen = self.buf[4]
 addr, port = struct.unpack("!%dsH" % nlen, self.buf[5:])
 self.buf = self.buf[7 + len(addr) :]
 else:
 # Any other address types are not supported
-self.sendErrorReply(REPLY_ADDR_NOT_SUPPORTED)
+self.send_error_reply(REPLY_ADDR_NOT_SUPPORTED)
 return
 # Ensure reply is OK
 if rep != REPLY_SUCCESS:
 self.loseConnection()
 "Socks5 connectionMade (mode = {})".format(
 "server" if self.state == STATE_INITIAL else "client"
 )
 )
 if self.state == STATE_CLIENT_INITIAL:
-self._startNegotiation()
+self._start_negotiation()
-def connectRequested(self, addr, port):
+def connect_requested(self, addr, port):
 # Check that this session is expected
-if not self.factory.addToSession(addr.decode('utf-8'), self):
+if not self.factory.add_to_session(addr.decode('utf-8'), self):
 log.warning(
 "Unexpected connection request received from {host}".format(
 host=self.transport.getPeer().host
 )
 )
-self.sendErrorReply(REPLY_CONN_REFUSED)
+self.send_error_reply(REPLY_CONN_REFUSED)
 return
 self._session_hash = addr.decode('utf-8')
-self.connectCompleted(addr, 0)
+self.connect_completed(addr, 0)
-def startTransfer(self, chunk_size):
+def start_transfer(self, chunk_size):
 """Callback called when the result iq is received
 @param chunk_size(None, int): size of the buffer, or None for default
 """
 self.active = True
 if chunk_size is not None:
 self.CHUNK_SIZE = chunk_size
 log.debug("Starting file transfer")
-d = self.stream_object.startStream(self.transport)
+d = self.stream_object.start_stream(self.transport)
-d.addCallback(self.streamFinished)
+d.addCallback(self.stream_finished)
-def streamFinished(self, d):
+def stream_finished(self, d):
 log.info(_("File transfer completed, closing connection"))
 self.transport.loseConnection()
-def connectCompleted(self, remotehost, remoteport):
+def connect_completed(self, remotehost, remoteport):
 if self.addressType == ADDR_IPV4:
 result = struct.pack(
 "!BBBBIH", SOCKS5_VER, REPLY_SUCCESS, 0, 1, remotehost, remoteport
 )
 elif self.addressType == ADDR_DOMAINNAME:
 remoteport,
 )
 self.transport.write(result)
 self.state = STATE_READY
-def bindRequested(self, addr, port):
+def bind_requested(self, addr, port):
 pass
-def authenticateUserPass(self, user, passwd):
+def authenticate_user_pass(self, user, passwd):
 # FIXME: implement authentication and remove the debug printing a password
 log.debug("User/pass: %s/%s" % (user, passwd))
 return True
 def dataReceived(self, buf):
 self.getSession()[TIMER_KEY].cancel()
 return
 self.buf = self.buf + buf
 if self.state == STATE_INITIAL:
-self._parseNegotiation()
+self._parse_negotiation()
 if self.state == STATE_AUTH_USERPASS:
-self._parseUserPass()
+self._parse_user_pass()
 if self.state == STATE_REQUEST:
 self._parseRequest()
 if self.state == STATE_CLIENT_REQUEST:
-self._parseRequestReply()
+self._parse_request_reply()
 if self.state == STATE_CLIENT_AUTH:
 ver, method = struct.unpack("!BB", buf)
 self.buf = self.buf[2:]
 if ver != SOCKS5_VER or method != AUTHMECH_ANON:
 self.transport.loseConnection()
 else:
-self._makeRequest()
+self._make_request()
 def connectionLost(self, reason):
 log.debug("Socks5 connection lost: {}".format(reason.value))
 if self.state != STATE_READY:
 self.connection.errback(reason)
 try:
 session_hash = self._session_hash
 except AttributeError:
 log.debug("no session has been received yet")
 else:
-self.factory.removeFromSession(session_hash, self, reason)
+self.factory.remove_from_session(session_hash, self, reason)
 class Socks5ServerFactory(protocol.ServerFactory):
 protocol = SOCKSv5
 self.parent = parent
 def getSession(self, session_hash):
 return self.parent.getSession(None, session_hash)
-def startTransfer(self, session_hash, chunk_size=None):
+def start_transfer(self, session_hash, chunk_size=None):
 session = self.getSession(session_hash)
 try:
 protocol = session["protocols"][0]
 except (KeyError, IndexError):
 log.error("Can't start file transfer, can't find protocol")
 else:
 session[TIMER_KEY].cancel()
-protocol.startTransfer(chunk_size)
+protocol.start_transfer(chunk_size)
-def addToSession(self, session_hash, protocol):
+def add_to_session(self, session_hash, protocol):
 """Check is session_hash is valid, and associate protocol with it
 the session will be associated to the corresponding candidate
 @param session_hash(str): hash of the session
 @param protocol(SOCKSv5): protocol instance
 return False
 else:
 session_data.setdefault("protocols", []).append(protocol)
 return True
-def removeFromSession(self, session_hash, protocol, reason):
+def remove_from_session(self, session_hash, protocol, reason):
 """Remove a protocol from session_data
 There can be several protocol instances while candidates are tried, they
 have removed when candidate connection is closed
 @param session_hash(str): hash of the session
 self.connector.disconnect()
 def getSession(self):
 return self.session
-def startTransfer(self, __=None, chunk_size=None):
+def start_transfer(self, __=None, chunk_size=None):
 self.session[TIMER_KEY].cancel()
-self._protocol_instance.startTransfer(chunk_size)
+self._protocol_instance.start_transfer(chunk_size)
 def clientConnectionFailed(self, connector, reason):
 log.debug("Connection failed")
 self.connection.errback(reason)
 log.debug("NAT Port plugin not available")
 self._np = None
 # parameters
 # XXX: params are not used for now, but they may be used in the futur to force proxy/IP
-# host.memory.updateParams(PARAMS)
+# host.memory.update_params(PARAMS)
-def getHandler(self, client):
+def get_handler(self, client):
 return XEP_0065_handler(self)
-def profileConnected(self, client):
+def profile_connected(self, client):
 client.xep_0065_sid_session = {}  # key: stream_id, value: session_data(dict)
 client._s5b_sessions = {}
-def getSessionHash(self, from_jid, to_jid, sid):
+def get_session_hash(self, from_jid, to_jid, sid):
-return getSessionHash(from_jid, to_jid, sid)
+return get_session_hash(from_jid, to_jid, sid)
-def getSocks5ServerFactory(self):
+def get_socks_5_server_factory(self):
 """Return server factory
 The server is created if it doesn't exists yet
 self._server_factory_port is set on server creation
 """
 )
 )
 return self._server_factory
 @defer.inlineCallbacks
-def getProxy(self, client, local_jid):
+def get_proxy(self, client, local_jid):
 """Return the proxy available for this profile
 cache is used between clients using the same server
-@param local_jid(jid.JID): same as for [getCandidates]
+@param local_jid(jid.JID): same as for [get_candidates]
 @return ((D)(ProxyInfos, None)): Found proxy infos,
 or None if not acceptable proxy is found
 @raise exceptions.NotFound: no Proxy found
 """
 defer.returnValue(self._cache_proxies[server])
 except KeyError:
 pass
 try:
 proxy = (
-yield self.host.findServiceEntities(client, "proxy", "bytestreams")
+yield self.host.find_service_entities(client, "proxy", "bytestreams")
 ).pop()
 except (defer.CancelledError, StopIteration, KeyError):
 notFound(server)
 iq_elt = client.IQ("get")
 iq_elt["from"] = local_jid.full()
 proxy_infos = self._cache_proxies[server] = ProxyInfos(host, jid_, port)
 log.info("Proxy found: {}".format(proxy_infos))
 defer.returnValue(proxy_infos)
 @defer.inlineCallbacks
-def _getNetworkData(self, client):
+def _get_network_data(self, client):
 """Retrieve information about network
 @param client: %(doc_client)s
 @return (D(tuple[local_port, external_port, local_ips, external_ip])): network data
 """
-self.getSocks5ServerFactory()
+self.get_socks_5_server_factory()
 local_port = self._server_factory_port
-external_ip = yield self._ip.getExternalIP(client)
+external_ip = yield self._ip.get_external_ip(client)
-local_ips = yield self._ip.getLocalIPs(client)
+local_ips = yield self._ip.get_local_i_ps(client)
 if external_ip is not None and self._external_port is None:
 if external_ip != local_ips[0]:
 log.info("We are probably behind a NAT")
 if self._np is None:
 log.warning("NAT port plugin not available, we can't map port")
 else:
-ext_port = yield self._np.mapPort(
+ext_port = yield self._np.map_port(
 local_port, desc="SaT socks5 stream"
 )
 if ext_port is None:
 log.warning("Can't map NAT port")
 else:
 self._external_port = ext_port
 defer.returnValue((local_port, self._external_port, local_ips, external_ip))
 @defer.inlineCallbacks
-def getCandidates(self, client, local_jid):
+def get_candidates(self, client, local_jid):
 """Return a list of our stream candidates
 @param local_jid(jid.JID): jid to use as local jid
 This is needed for client which can be addressed with a different jid than
 client.jid if a local part is used (e.g. piotr@file.example.net where
 client.jid would be file.example.net)
 @return (D(list[Candidate])): list of candidates, ordered by priority
 """
-server_factory = yield self.getSocks5ServerFactory()
+server_factory = yield self.get_socks_5_server_factory()
-local_port, ext_port, local_ips, external_ip = yield self._getNetworkData(client)
+local_port, ext_port, local_ips, external_ip = yield self._get_network_data(client)
 try:
-proxy = yield self.getProxy(client, local_jid)
+proxy = yield self.get_proxy(client, local_jid)
 except exceptions.NotFound:
 proxy = None
 # its time to gather the candidates
 candidates = []
 # should be already sorted, but just in case the priorities get weird
 candidates.sort(key=lambda c: c.priority, reverse=True)
 defer.returnValue(candidates)
-def _addConnector(self, connector, candidate):
+def _add_connector(self, connector, candidate):
 """Add connector used to connect to candidate, and return client factory's connection Deferred
 the connector can be used to disconnect the candidate, and returning the factory's connection Deferred allow to wait for connection completion
 @param connector: a connector implementing IConnector
 @param candidate(Candidate): candidate linked to the connector
 @return (D): Deferred fired when factory connection is done or has failed
 """
 candidate.factory.connector = connector
 return candidate.factory.connection
-def connectCandidate(
+def connect_candidate(
 self, client, candidate, session_hash, peer_session_hash=None, delay=None
 ):
 """Connect to a candidate
 Connection will be done with a Socks5ClientFactory
 @param peer_session_hash(unicode, None): hash used with the peer
 None to use session_hash.
 None must be used in 2 cases:
 - when XEP-0065 is used with XEP-0096
 - when a peer connect to a proxy *he proposed himself*
-in practice, peer_session_hash is only used by tryCandidates
+in practice, peer_session_hash is only used by try_candidates
 @param delay(None, float): optional delay to wait before connection, in seconds
 @return (D): Deferred launched when TCP connection + Socks5 connection is done
 """
 if peer_session_hash is None:
 # for XEP-0065, only one hash is needed
 if delay is None:
 d = defer.succeed(candidate.host)
 else:
 d = sat_defer.DelayedDeferred(delay, candidate.host)
 d.addCallback(reactor.connectTCP, candidate.port, factory)
-d.addCallback(self._addConnector, candidate)
+d.addCallback(self._add_connector, candidate)
 return d
-def tryCandidates(
+def try_candidates(
 self,
 client,
 candidates,
 session_hash,
 peer_session_hash,
 for candidate in candidates:
 delay = CANDIDATE_DELAY * len(defers_list)
 if candidate.type == XEP_0065.TYPE_PROXY:
 delay += CANDIDATE_DELAY_PROXY
-d = self.connectCandidate(
+d = self.connect_candidate(
 client, candidate, session_hash, peer_session_hash, delay
 )
 if connection_cb is not None:
 d.addCallback(
 lambda __, candidate=candidate, client=client: connection_cb(
 d.addErrback(connection_eb, client, candidate)
 defers_list.append(d)
 return defers_list
-def getBestCandidate(self, client, candidates, session_hash, peer_session_hash=None):
+def get_best_candidate(self, client, candidates, session_hash, peer_session_hash=None):
 """Get best candidate (according to priority) which can connect
 @param candidates(iterable[Candidate]): candidates to test
 @param session_hash(unicode): hash of the session
 hash is the same as hostname computed in XEP-0065 § 5.3.2 #1
 only useful for XEP-0260, must be None for XEP-0065 streamhost candidates
 @return (D(None, Candidate)): best candidate or None if none can connect
 """
 defer_candidates = None
-def connectionCb(client, candidate):
+def connection_cb(client, candidate):
 log.info("Connection of {} successful".format(str(candidate)))
 for idx, other_candidate in enumerate(candidates):
 try:
 if other_candidate.priority < candidate.priority:
 log.debug("Cancelling {}".format(other_candidate))
 defer_candidates[idx].cancel()
 except AttributeError:
 assert other_candidate is None
-def connectionEb(failure, client, candidate):
+def connection_eb(failure, client, candidate):
 if failure.check(defer.CancelledError):
 log.debug("Connection of {} has been cancelled".format(candidate))
 else:
 log.info(
 "Connection of {candidate} Failed: {error}".format(
 candidate=candidate, error=failure.value
 )
 )
 candidates[candidates.index(candidate)] = None
-def allTested(__):
+def all_tested(__):
 log.debug("All candidates have been tested")
 good_candidates = [c for c in candidates if c]
 return good_candidates[0] if good_candidates else None
-defer_candidates = self.tryCandidates(
+defer_candidates = self.try_candidates(
 client,
 candidates,
 session_hash,
 peer_session_hash,
-connectionCb,
+connection_cb,
-connectionEb,
+connection_eb,
 )
 d_list = defer.DeferredList(defer_candidates)
-d_list.addCallback(allTested)
+d_list.addCallback(all_tested)
 return d_list
-def _timeOut(self, session_hash, client):
+def _time_out(self, session_hash, client):
 """Called when stream was not started quickly enough
-@param session_hash(str): hash as returned by getSessionHash
+@param session_hash(str): hash as returned by get_session_hash
 @param client: %(doc_client)s
 """
 log.info("Socks5 Bytestream: TimeOut reached")
 session = self.getSession(client, session_hash)
 session[DEFER_KEY].errback(exceptions.TimeOutError())
-def killSession(self, failure_, session_hash, sid, client):
+def kill_session(self, failure_, session_hash, sid, client):
 """Clean the current session
-@param session_hash(str): hash as returned by getSessionHash
+@param session_hash(str): hash as returned by get_session_hash
 @param sid(None, unicode): session id
 or None if self.xep_0065_sid_session was not used
 @param client: %(doc_client)s
 @param failure_(None, failure.Failure): None if eveything was fine, a failure else
 @return (None, failure.Failure): failure_ is returned
 except (internet_error.AlreadyCalled, internet_error.AlreadyCancelled):
 pass
 return failure_
-def startStream(self, client, stream_object, local_jid, to_jid, sid):
+def start_stream(self, client, stream_object, local_jid, to_jid, sid):
 """Launch the stream workflow
 @param streamProducer: stream_object to use
-@param local_jid(jid.JID): same as for [getCandidates]
+@param local_jid(jid.JID): same as for [get_candidates]
 @param to_jid: JID of the recipient
 @param sid: Stream session id
 @param successCb: method to call when stream successfuly finished
 @param failureCb: method to call when something goes wrong
 @return (D): Deferred fired when session is finished
 """
-session_data = self._createSession(
+session_data = self._create_session(
 client, stream_object, local_jid, to_jid, sid, True)
 session_data[client] = client
-def gotCandidates(candidates):
+def got_candidates(candidates):
 session_data["candidates"] = candidates
 iq_elt = client.IQ()
 iq_elt["from"] = local_jid.full()
 iq_elt["to"] = to_jid.full()
 query_elt = iq_elt.addElement((NS_BS, "query"))
 streamhost["jid"] = candidate.jid.full()
 log.debug("Candidate proposed: {}".format(candidate))
 d = iq_elt.send()
 args = [client, session_data, local_jid]
-d.addCallbacks(self._IQNegotiationCb, self._IQNegotiationEb, args, None, args)
+d.addCallbacks(self._iq_negotiation_cb, self._iq_negotiation_eb, args, None, args)
-self.getCandidates(client, local_jid).addCallback(gotCandidates)
+self.get_candidates(client, local_jid).addCallback(got_candidates)
 return session_data[DEFER_KEY]
-def _IQNegotiationCb(self, iq_elt, client, session_data, local_jid):
+def _iq_negotiation_cb(self, iq_elt, client, session_data, local_jid):
 """Called when the result of open iq is received
 @param session_data(dict): data of the session
 @param client: %(doc_client)s
 @param iq_elt(domish.Element): <iq> result
 else:
 log.info("Candidate choosed by target: {}".format(candidate))
 if candidate.type == XEP_0065.TYPE_PROXY:
 log.info("A Socks5 proxy is used")
-d = self.connectCandidate(client, candidate, session_data["hash"])
+d = self.connect_candidate(client, candidate, session_data["hash"])
 d.addCallback(
 lambda __: candidate.activate(
 client, session_data["id"], session_data["peer_jid"], local_jid
 )
 )
-d.addErrback(self._activationEb)
+d.addErrback(self._activation_eb)
 else:
 d = defer.succeed(None)
-d.addCallback(lambda __: candidate.startTransfer(session_data["hash"]))
+d.addCallback(lambda __: candidate.start_transfer(session_data["hash"]))
-def _activationEb(self, failure):
+def _activation_eb(self, failure):
 log.warning("Proxy activation error: {}".format(failure.value))
-def _IQNegotiationEb(self, stanza_err, client, session_data, local_jid):
+def _iq_negotiation_eb(self, stanza_err, client, session_data, local_jid):
 log.warning("Socks5 transfer failed: {}".format(stanza_err.value))
 # FIXME: must clean session
-def createSession(self, *args, **kwargs):
+def create_session(self, *args, **kwargs):
-"""like [_createSession] but return the session deferred instead of the whole session
+"""like [_create_session] but return the session deferred instead of the whole session
 session deferred is fired when transfer is finished
 """
-return self._createSession(*args, **kwargs)[DEFER_KEY]
+return self._create_session(*args, **kwargs)[DEFER_KEY]
-def _createSession(self, client, stream_object, local_jid, to_jid, sid,
+def _create_session(self, client, stream_object, local_jid, to_jid, sid,
 requester=False):
 """Called when a bytestream is imminent
 @param stream_object(iface.IStreamProducer): File object where data will be
 written
 @return (dict): session data
 """
 if sid in client.xep_0065_sid_session:
 raise exceptions.ConflictError("A session with this id already exists !")
 if requester:
-session_hash = getSessionHash(local_jid, to_jid, sid)
+session_hash = get_session_hash(local_jid, to_jid, sid)
-session_data = self._registerHash(client, session_hash, stream_object)
+session_data = self._register_hash(client, session_hash, stream_object)
 else:
-session_hash = getSessionHash(to_jid, local_jid, sid)
+session_hash = get_session_hash(to_jid, local_jid, sid)
 session_d = defer.Deferred()
-session_d.addBoth(self.killSession, session_hash, sid, client)
+session_d.addBoth(self.kill_session, session_hash, sid, client)
 session_data = client._s5b_sessions[session_hash] = {
 DEFER_KEY: session_d,
 TIMER_KEY: reactor.callLater(
-TIMEOUT, self._timeOut, session_hash, client
+TIMEOUT, self._time_out, session_hash, client
 ),
 }
 client.xep_0065_sid_session[sid] = session_data
 session_data.update(
 {
 except KeyError as e:
 log.warning("The requested session doesn't exists !")
 raise e
 return client._s5b_sessions[session_hash]
-def registerHash(self, *args, **kwargs):
+def register_hash(self, *args, **kwargs):
-"""like [_registerHash] but return the session deferred instead of the whole session
+"""like [_register_hash] but return the session deferred instead of the whole session
 session deferred is fired when transfer is finished
 """
-return self._registerHash(*args, **kwargs)[DEFER_KEY]
+return self._register_hash(*args, **kwargs)[DEFER_KEY]
-def _registerHash(self, client, session_hash, stream_object):
+def _register_hash(self, client, session_hash, stream_object):
 """Create a session_data associated to hash
 @param session_hash(str): hash of the session
 @param stream_object(iface.IStreamProducer, IConsumer, None): file-like object
 None if it will be filled later
 return (dict): session data
 """
 assert session_hash not in client._s5b_sessions
 session_d = defer.Deferred()
-session_d.addBoth(self.killSession, session_hash, None, client)
+session_d.addBoth(self.kill_session, session_hash, None, client)
 session_data = client._s5b_sessions[session_hash] = {
 DEFER_KEY: session_d,
-TIMER_KEY: reactor.callLater(TIMEOUT, self._timeOut, session_hash, client),
+TIMER_KEY: reactor.callLater(TIMEOUT, self._time_out, session_hash, client),
 }
 if stream_object is not None:
 session_data["stream_object"] = stream_object
 assert session_hash not in self.hash_clients_map
 self.hash_clients_map[session_hash] = client
 return session_data
-def associateStreamObject(self, client, session_hash, stream_object):
+def associate_stream_object(self, client, session_hash, stream_object):
 """Associate a stream object with  a session"""
 session_data = self.getSession(client, session_hash)
 assert "stream_object" not in session_data
 session_data["stream_object"] = stream_object
-def streamQuery(self, iq_elt, client):
+def stream_query(self, iq_elt, client):
 log.debug("BS stream query")
 iq_elt.handled = True
 query_elt = next(iq_elt.elements(NS_BS, "query"))
 candidates.append(Candidate(host, port, type_, priority, jid_))
 for candidate in candidates:
 log.info("Candidate proposed: {}".format(candidate))
-d = self.getBestCandidate(client, candidates, session_data["hash"])
+d = self.get_best_candidate(client, candidates, session_data["hash"])
-d.addCallback(self._ackStream, iq_elt, session_data, client)
+d.addCallback(self._ack_stream, iq_elt, session_data, client)
-def _ackStream(self, candidate, iq_elt, session_data, client):
+def _ack_stream(self, candidate, iq_elt, session_data, client):
 if candidate is None:
 log.info("No streamhost candidate worked, we have to end negotiation")
 return client.sendError(iq_elt, "item-not-found")
 log.info("We choose: {}".format(candidate))
 result_elt = xmlstream.toResponse(iq_elt, "result")
 self.plugin_parent = plugin_parent
 self.host = plugin_parent.host
 def connectionInitialized(self):
 self.xmlstream.addObserver(
-BS_REQUEST, self.plugin_parent.streamQuery, client=self.parent
+BS_REQUEST, self.plugin_parent.stream_query, client=self.parent
 )
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return [disco.DiscoFeature(NS_BS)]

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0065.py @ 4037:524856bd7b19