home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / jabber / filetransfer / initiateStream.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  14.4 KB  |  374 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from jabber.filetransfer.s5b_proxy_sender import S5B_proxyConnect
  5. from jabber.objects.bytestreams import ByteStreams, BYTESTREAMS_NS
  6. from jabber.objects.si_filetransfer import Feature
  7. from jabber.objects.si_filetransfer import SI_FileTransfer, SI_NS
  8. from jabber.objects.si_filetransfer import File
  9. from jabber.filetransfer.S5BFileXferHandler import ByteStream
  10. import functools
  11. import random
  12. from jabber.filetransfer import supported_streams
  13. from pyxmpp.all import Iq
  14. from util.net import NoneFileChunker
  15. from logging import getLogger
  16. log = getLogger('jabber.file.send')
  17. from common import pref
  18. from common.filetransfer import OutgoingFileTransfer, FileTransfer
  19. from path import path
  20. from util import lock
  21. done_states = FileTransfer.states.CompleteStates | FileTransfer.states.FailStates
  22.  
  23. def if_not_done(f):
  24.     
  25.     def wrapper1(self, *args, **kw):
  26.         if self.state not in done_states:
  27.             return f(self, *args, **kw)
  28.  
  29.     wrapper1 = (functools.wraps(f),)(wrapper1)
  30.     return wrapper1
  31.  
  32.  
  33. class SIsender(OutgoingFileTransfer):
  34.     
  35.     def __init__(self, jabber_protocol, jid, filestorage, message = None):
  36.         OutgoingFileTransfer.__init__(self)
  37.         self.j = jabber_protocol
  38.         self.jid = jid
  39.         self.filestor = filestorage
  40.         self.message = message
  41.         self.sid = 'si_' + str(id(self)) + str(random.randint(0, 100))
  42.         log.info('SIsender created for %r', jid)
  43.         self.completed = 0
  44.         self.size = filestorage.size
  45.         self.filepath = path(self.filestor.path)
  46.         self.buddy = self.j.buddies[jid]
  47.         self.name = self.filestor.name
  48.         self.on_get_buddy(self.buddy)
  49.  
  50.     
  51.     def protocol(self):
  52.         return self.j
  53.  
  54.     protocol = property(protocol)
  55.     
  56.     def send_offer(self):
  57.         self.state = self.states.WAITING_FOR_BUDDY
  58.         i = Iq(to_jid = self.jid, stanza_type = 'set')
  59.         si = SI_FileTransfer(self.sid)
  60.         si.file = File(self.filestor.name, self.filestor.size)
  61.         si.feature = Feature(possible_streams = supported_streams)
  62.         si.as_xml(i.get_node())
  63.         self.j.send_cb(i, success = self.handle_response, error = self.handle_error, timeout = self.timed_out)
  64.  
  65.     
  66.     def handle_response(self, stanza):
  67.         self.state = self.states.CONNECTING
  68.         si = SI_FileTransfer.from_iq(stanza)
  69.         self.stream = b = stream_connectors[si.feature.selected_stream](self)
  70.         b.bind_event('stream_connected', self.transferring)
  71.         b.bind_event('stream_connect_failed', self.stream_connect_failed)
  72.         b.bind_event('stream_error', self.stream_error)
  73.         b.bind_event('stream_closed', self.stream_closed)
  74.         b.connect_stream()
  75.  
  76.     handle_response = lock(if_not_done(handle_response))
  77.     
  78.     def stream_connect_failed(self):
  79.         self.unbind_all()
  80.         self.state = self.states.CONN_FAIL
  81.         self.on_error()
  82.  
  83.     stream_connect_failed = lock(if_not_done(stream_connect_failed))
  84.     
  85.     def handle_error(self, stanza):
  86.         e = stanza.get_error()
  87.         SI_NS_error = e.get_condition(SI_NS)
  88.         if SI_NS_error is not None:
  89.             SI_NS_error = SI_NS_error.name
  90.         
  91.         error = e.get_condition()
  92.         if error is not None:
  93.             error = error.name
  94.         
  95.         if SI_NS_error == 'no-valid-streams':
  96.             self.state = self.states.CONN_FAIL
  97.         elif SI_NS_error == 'bad-profile':
  98.             self.state = self.states.CONN_FAIL
  99.         elif error == 'forbidden':
  100.             reason = e.get_text()
  101.             log.info('%r: handle_error. Setting state to CANCELLED_BY_BUDDY')
  102.             self.state = self.states.CANCELLED_BY_BUDDY
  103.         else:
  104.             self.state = self.states.CONN_FAIL
  105.         if self.state == self.states.CONN_FAIL:
  106.             self.on_error()
  107.         
  108.  
  109.     handle_error = lock(if_not_done(handle_error))
  110.     
  111.     def timed_out(self):
  112.         log.info('%r: Timed out. Setting state to CONN_FAIL, calling on_error')
  113.         self.unbind_all()
  114.         self.state = self.states.CONN_FAIL
  115.         self.on_error()
  116.  
  117.     timed_out = lock(if_not_done(timed_out))
  118.     
  119.     def stream_error(self):
  120.         log.info('%r: Stream error. Setting state to CONN_FAIL_XFER, calling on_error')
  121.         self.unbind_all()
  122.         self.close_file()
  123.         self.state = self.states.CONN_FAIL_XFER
  124.         self.on_error()
  125.  
  126.     stream_error = lock(if_not_done(stream_error))
  127.     
  128.     def stream_closed(self):
  129.         log.info('%r: Stream closed. Setting state to CANCELLED_BY_BUDDY')
  130.         self.unbind_all()
  131.         self.close_file()
  132.         self.state = self.states.CANCELLED_BY_BUDDY
  133.  
  134.     stream_closed = lock(if_not_done(stream_closed))
  135.     
  136.     def unbind_all(self):
  137.         if hasattr(self, 'stream'):
  138.             b = self.stream
  139.             b.unbind('stream_connected', self.transferring)
  140.             b.unbind('stream_connect_failed', self.stream_connect_failed)
  141.             b.unbind('stream_error', self.stream_error)
  142.             b.unbind('stream_closed', self.stream_closed)
  143.         
  144.  
  145.     unbind_all = lock(unbind_all)
  146.     
  147.     def transferring(self):
  148.         self.stream.unbind('stream_connected', self.transferring)
  149.         self.state = self.states.TRANSFERRING
  150.         self.chunker = NoneFileChunker(self.filestor.obj, close_when_done = True, progress_cb = self.on_progress)
  151.         self.stream.conn.push_with_producer(self.chunker)
  152.         self.stream.conn.close_when_done()
  153.  
  154.     transferring = lock(if_not_done(transferring))
  155.     
  156.     def cancel(self, state = None):
  157.         self.unbind_all()
  158.         if hasattr(self, 'stream'):
  159.             self.stream.cancel()
  160.             if hasattr(self, 'chunker'):
  161.                 self.chunker.cancelled = True
  162.             
  163.         
  164.         self.close_file()
  165.         if state is None:
  166.             state = self.states.CANCELLED_BY_YOU
  167.         
  168.         self.state = state
  169.  
  170.     cancel = lock(if_not_done(cancel))
  171.     
  172.     def on_progress(self, bytes):
  173.         self._setcompleted(bytes)
  174.         if self.completed == self.size:
  175.             self.unbind_all()
  176.             self.stream.close()
  177.             self.state = self.states.FINISHED
  178.             self._ondone()
  179.         
  180.  
  181.     on_progress = lock(if_not_done(on_progress))
  182.     
  183.     def close_file(self):
  184.         
  185.         try:
  186.             self.chunker.fileobj.close()
  187.         except Exception:
  188.             pass
  189.  
  190.         
  191.         try:
  192.             self.filestor.obj.close()
  193.         except Exception:
  194.             pass
  195.  
  196.  
  197.  
  198.  
  199. class SOCKS5OutBytestream(ByteStream):
  200.     
  201.     def __init__(self, sender):
  202.         ByteStream.__init__(self)
  203.         self.j = sender.j
  204.         self.jid = sender.jid
  205.         self.sid = sender.sid
  206.         self.conn = None
  207.  
  208.     
  209.     def connect_stream(self):
  210.         
  211.         try:
  212.             self.hash = self.j.s5bserver.conn_id(self.sid, self.j.stream.me, self.jid)
  213.         except AttributeError:
  214.             self.event('stream_connect_failed')
  215.             return None
  216.  
  217.         self.j.s5bserver.add_hash(self.hash)
  218.         i = Iq(to_jid = self.jid, stanza_type = 'set')
  219.         b = ByteStreams(sid = self.sid)
  220.         if pref('jabber.use_proxy_ft'):
  221.             b.hosts.extend(set((lambda .0: for hosts in .0:
  222. for h in hosts:
  223. h)(self.j.known_s5b_proxies.values())))
  224.             if pref('jabber.use_jabber_org_proxy', True):
  225.                 b.add_host('proxy.jabber.org', '208.245.212.98', 7777)
  226.             
  227.         
  228.         b.as_xml(i.get_node())
  229.         self.j.send_cb(i, success = self.handle_ready, error = self.handle_error, timeout = self.timed_out)
  230.  
  231.     
  232.     def kill_socket_hash(self):
  233.         c = self.j.s5bserver.retrieve_hash(self.hash)
  234.         if c not in (False, None):
  235.             
  236.             try:
  237.                 c.close()
  238.  
  239.         
  240.  
  241.     
  242.     def timed_out(self):
  243.         self.kill_socket_hash()
  244.         self.event('stream_connect_failed')
  245.  
  246.     
  247.     def handle_error(self, stanza):
  248.         import traceback
  249.         traceback.print_exc()
  250.         self.kill_socket_hash()
  251.         self.event('stream_connect_failed')
  252.         log.info(stanza.serialize())
  253.  
  254.     
  255.     def handle_ready(self, stanza):
  256.         log.info(stanza.serialize())
  257.         
  258.         try:
  259.             b = ByteStreams(stanza.get_query())
  260.             used_jid = b.host_used
  261.         except:
  262.             self.kill_socket_hash()
  263.             self.event('stream_connect_failed')
  264.             return None
  265.  
  266.         if not pref('jabber.use_proxy_ft'):
  267.             pass
  268.         
  269.         if not pref('jabber.use_direct_ft'):
  270.             pass
  271.         
  272.         log.info('handle_ready done')
  273.  
  274.     
  275.     def socket_failed(self):
  276.         self.unbind_all()
  277.         self.event('stream_connect_failed')
  278.  
  279.     
  280.     def socket_connected(self):
  281.         self.conn.unbind('connection_failed', self.socket_failed)
  282.         self.conn.unbind('connected', self.handle_proxy_connect)
  283.         self.conn.bind_event('socket_error', self.stream_error)
  284.         self.conn.bind_event('socket_closed', self.stream_closed)
  285.  
  286.     
  287.     def stream_closed(self):
  288.         self.unbind_all()
  289.         self.event('stream_closed')
  290.  
  291.     
  292.     def stream_error(self):
  293.         self.unbind_all()
  294.         self.event('stream_error')
  295.  
  296.     
  297.     def unbind_all(self):
  298.         self.conn.unbind('connection_failed', self.socket_failed)
  299.         self.conn.unbind('connected', self.handle_proxy_connect)
  300.         self.conn.unbind('socket_error', self.stream_error)
  301.         self.conn.unbind('socket_closed', self.stream_closed)
  302.  
  303.     
  304.     def handle_proxy_failure(self):
  305.         log.info('handle proxy failure')
  306.         self.unbind_all()
  307.         self.event('stream_connect_failed')
  308.  
  309.     
  310.     def handle_proxy_failure2(self):
  311.         log.info('handle proxy failure2')
  312.         
  313.         try:
  314.             self.conn.close()
  315.         except:
  316.             import traceback
  317.             traceback.print_exc()
  318.  
  319.         self.event('stream_connect_failed')
  320.  
  321.     
  322.     def handle_proxy_connect(self):
  323.         log.info('handle_proxy_connect called')
  324.         self.conn.set_terminator(0)
  325.         streamhost = self.streamhost
  326.         sh_jid = streamhost.jid
  327.         targ_jid = self.jid
  328.         b = ByteStreams(None, self.sid)
  329.         b.activate = targ_jid
  330.         i = Iq(to_jid = sh_jid, stanza_type = 'set')
  331.         b.as_xml(i.get_node())
  332.         self.j.send_cb(i, success = self.handle_proxy_activate, error = self.handle_proxy_failure2, timeout = self.proxy_activate_timeout)
  333.  
  334.     
  335.     def proxy_activate_timeout(self):
  336.         self.unbind_all()
  337.         
  338.         try:
  339.             self.conn.close()
  340.         except:
  341.             import traceback
  342.             traceback.print_exc()
  343.  
  344.         self.event('stream_connect_failed')
  345.  
  346.     
  347.     def handle_proxy_activate(self, stanza):
  348.         log.info('handle_proxy_activate called')
  349.         self.socket_connected()
  350.         self.event('stream_connected')
  351.  
  352.     
  353.     def close(self):
  354.         self.conn.close_when_done()
  355.  
  356.     
  357.     def cancel(self):
  358.         
  359.         try:
  360.             self.conn.close()
  361.         except:
  362.             pass
  363.  
  364.  
  365.  
  366.  
  367. def dumpfile(conn, filestor, progress_cb):
  368.     log.info('dumpfile called')
  369.     conn.push_with_producer()
  370.     conn.close_when_done()
  371.  
  372. stream_connectors = {
  373.     BYTESTREAMS_NS: SOCKS5OutBytestream }
  374.