home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / yahoo / YahooSocket.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  6.4 KB  |  200 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. DEFAULT_YMSG_VERSION = 15
  6. from yahoo.yahooutil import *
  7. import yahoo.yahoolookup as ylookup
  8. from util import to_storage, unpack_named, dictargcall, traceguard
  9. import common
  10. from pprint import pformat
  11. import sys
  12. import traceback
  13. from logging import getLogger
  14. log = getLogger('yahoo')
  15. loginlog = getLogger('yahoo.login')
  16. packets_log = getLogger('yahoo.packets')
  17.  
  18. class YahooSocket(common.socket):
  19.     
  20.     def __init__(self, yahoo, server):
  21.         common.socket.__init__(self)
  22.         self.yahoo = yahoo
  23.         self.session_id = 0
  24.         self.active_gens = { }
  25.         self.set_terminator(header_size)
  26.         self.getting_header = True
  27.         self.data = []
  28.         self.byte_count = 0
  29.         self.server = server
  30.  
  31.     
  32.     def __str__(self):
  33.         return 'YahooSocket(%s:%d, %d bytes in)' % (self.server[0], self.server[1], self.byte_count)
  34.  
  35.     
  36.     def make_ypacket(self, service, status, version = DEFAULT_YMSG_VERSION, data = ''):
  37.         if not isinstance(service, (int, long)):
  38.             raise TypeError('service is', service, 'but should be an int!')
  39.         
  40.         if not isinstance(status, (int, long)):
  41.             raise TypeError('status is', status, 'but should be an int!')
  42.         
  43.         return pack(header_pack, 'YMSG', version, 0, len(data), service, status, self.session_id) + data
  44.  
  45.     
  46.     def ysend(self, service, status, version = DEFAULT_YMSG_VERSION, data = ''):
  47.         packet = self.make_ypacket(service, status, version, data)
  48.         self.push(packet)
  49.  
  50.     
  51.     def handle_packet(self, header, data):
  52.         self.session_id = header.session_id
  53.         if (header.service, header.status) in self.active_gens:
  54.             gen = self.active_gens.pop((header.service, header.status))
  55.             self.async_proc(gen, header, data)
  56.             return None
  57.         
  58.         sv_str = ylookup.services.get(header.service, '')
  59.         st_str = ylookup.statuses.get(header.status, '')
  60.         target = self.yahoo
  61.         fnname = '%s_%s' % (sv_str, st_str)
  62.         traceguard.__enter__()
  63.         
  64.         try:
  65.             packet_str = format_packet(data, sensitive = not getattr(sys, 'DEV', True))
  66.             packets_log.debug('~~> %s\n%s', fnname, packet_str)
  67.         finally:
  68.             pass
  69.  
  70.         raw_fn = '%s_raw' % fnname
  71.         if hasattr(target, raw_fn):
  72.             
  73.             try:
  74.                 return getattr(target, raw_fn)(from_ydict_iter(data))
  75.             except Exception:
  76.                 traceguard
  77.                 traceguard
  78.                 traceback.print_exc()
  79.             except:
  80.                 traceguard
  81.             finally:
  82.                 return None
  83.  
  84.         
  85.         if sv_str and st_str:
  86.             fn = '%s_%s' % (sv_str, st_str)
  87.             if hasattr(target, fn):
  88.                 func = getattr(target, fn)
  89.                 
  90.                 try:
  91.                     return dictargcall(func, from_ydict(data), ykeys)
  92.                 except Exception:
  93.                     traceback.print_exc()
  94.                     print >>sys.stderr, '  File "%s", line %d, in %s' % (func.func_code.co_filename, func.func_code.co_firstlineno, func.func_name)
  95.                     return None
  96.                 except:
  97.                     None<EXCEPTION MATCH>Exception
  98.                 
  99.  
  100.             None<EXCEPTION MATCH>Exception
  101.         
  102.         unhandled_text = None([
  103.             None,
  104.             ''.join,
  105.             'unhandled packet: ' if sv_str else str(header.service),
  106.             '_' if st_str else str(header.status)])
  107.         log.warning('%s:::%r', unhandled_text, data)
  108.  
  109.     
  110.     def async_proc(self, gen, header = None, data = None):
  111.         
  112.         try:
  113.             args = None if not header else (header, data)
  114.             (cmd, wait_on, packet) = gen.send(args)
  115.             while cmd == 'send':
  116.                 self.push(packet)
  117.                 (cmd, wait_on, packet) = gen.next()
  118.             if cmd == 'wait':
  119.                 self.active_gens[wait_on] = gen
  120.         except StopIteration:
  121.             pass
  122.         except YahooLoginError:
  123.             self.yahoo.set_disconnected(self.yahoo.Reasons.BAD_PASSWORD)
  124.  
  125.  
  126.     
  127.     def gsend(self, sv, st, data = '', **kwargs):
  128.         if 'v' not in kwargs:
  129.             v = DEFAULT_YMSG_VERSION
  130.         else:
  131.             v = kwargs['v']
  132.         if isinstance(sv, str):
  133.             sv = ylookup.services[sv]
  134.         
  135.         if isinstance(st, str):
  136.             st = ylookup.statuses[st]
  137.         
  138.         if isinstance(data, (dict, list)):
  139.             data = to_ydict(data)
  140.         
  141.         packet = self.make_ypacket(sv, st, v, data)
  142.         return ('send', None, packet)
  143.  
  144.     
  145.     def gwait(self, sv, st, err_fn):
  146.         sv = ylookup.services[sv]
  147.         st = ylookup.statuses[st]
  148.         return ('wait', (sv, st), err_fn)
  149.  
  150.     
  151.     def __repr__(self):
  152.         return '<%s(%s:%d) - sId: %s, bytes in: %d>' % (self.__class__.__name__, self.server[0], self.server[1], self.session_id, self.byte_count)
  153.  
  154.     
  155.     def handle_connect(self):
  156.         raise NotImplementedError
  157.  
  158.     
  159.     def handle_close(self):
  160.         raise NotImplementedError
  161.  
  162.     
  163.     def collect_incoming_data(self, data):
  164.         self.data.append(data)
  165.         self.byte_count += len(data)
  166.  
  167.     
  168.     def handle_error(self, *a, **k):
  169.         traceback.print_exc()
  170.         raise NotImplementedError
  171.  
  172.     
  173.     def handle_expt(self):
  174.         raise NotImplementedError
  175.  
  176.     
  177.     def found_terminator(self):
  178.         datastr = ''.join(self.data)
  179.         if self.getting_header:
  180.             self.getting_header = False
  181.             self.header = to_storage(unpack_named(*header_desc + tuple([
  182.                 datastr])))
  183.             if self.header.ymsg != 'YMSG' or self.header.size < 0:
  184.                 return log.warning('invalid packet')
  185.             
  186.             if self.header.size > 0:
  187.                 self.set_terminator(self.header.size)
  188.             else:
  189.                 self.getting_header = True
  190.                 self.set_terminator(header_size)
  191.                 self.handle_packet(self.header, datastr)
  192.                 self.data = []
  193.         else:
  194.             self.getting_header = True
  195.             self.set_terminator(header_size)
  196.             self.handle_packet(self.header, datastr[header_size:])
  197.             self.data = []
  198.  
  199.  
  200.