Пример #1
0
 def connect(self):
     """Open a connection to dAmn!"""
     if self.sock and self.sock.sock:
         return
     self.sock = Connection(self.CONST.SERVER, self.CONST.CLIENT, self.CONST.PORT)
     self.sock.connect()
     self.flag.connecting = self.sock.connected()
     return self.flag.connecting
Пример #2
0
class dAmnSock:
    """ dAmnSock class.
        This is a base class for managing a connection
        to a dAmn server.
    """
    
    class platform:
        """Information about the dAmn Viper platform."""
        name = 'dAmn Viper'
        version = 2
        state = 'RC'
        build = 52
        stamp = '20022011-002000'
        series = 'Swift'
        author = 'photofroggy'
            
    class user:
        """User login data."""
        username = None
        password = None
        cookie = None
        token = None

    class flag:
        """Status flags are stored here"""
        connecting = False
        shaking = False
        loggingin = False
        connected = False
    
    class CONST:
        """dAmnSock style 'constants'."""
        SERVER = 'chat.deviantart.com'
        CLIENT = 'dAmnClient 0.3'
        PORT = 3900
    
    class session:
        status = False
        cookie = None
        token = None

    extras = {'remember_me':'1'}
    agent = 'dAmnViper (python 3.x) dAmnSock/1.1'
    sock = None
    
    def nullflags(self):
        self.flag.connecting = False
        self.flag.shaking = False
        self.flag.loggingin = False
        self.flag.connected = False
    
    def logger(self, ns, msg, showns=True, mute=False, pkt=None):
        if mute: return
        stamp = time.strftime('%H:%M:%S|')
        sys.stdout.write('>> {0}{1} {2}\n'.format(stamp, (ns + '|' if showns else ''), msg))
        sys.stdout.flush()
    
    def get_token(self):
        self.on_get_token()
        if not self.user.password:
            return
        self.session = Login(self.user.username, self.user.password, self.extras, self.agent)
        if self.session.status[0] == 1:
            self.user.cookie = self.session.cookie
            self.user.token = self.session.token
            self.user.password = None
        self.on_token()

    def on_get_token(self):
        """Overwrite this method to do shit when get_token is called."""
        pass
    
    def on_token(self):
        """Overwrite this method to do stuff after get_token is finished."""
        pass
    
    def connect(self):
        """Open a connection to dAmn!"""
        if self.sock and self.sock.sock:
            return
        self.sock = Connection(self.CONST.SERVER, self.CONST.CLIENT, self.CONST.PORT)
        self.sock.connect()
        self.flag.connecting = self.sock.connected()
        return self.flag.connecting
    
    def handshake(self, vals=None):
        # Should be able to define values sent in the handshake packet.
        if not self.flag.connecting:
            return False
        self.flag.shaking = True # Raise the flag, hoe.
        shake = self.CONST.CLIENT
        shake+= '\nagent='+self.agent
        if vals == None:
            shake+= '\n'
        else:
            shake+= "\n{0}\n".format("\n".join(['='.join([key, vals[key]]) for key in vals]))
        if len(shake+'\0') == self.send(shake):
            return True
        return False
    
    def login(self):
        # Send our login packet. Set the loggingin flag to true.
        self.flag.loggingin = True
        return bool(self.send('login {0}\npk={1}\n'.format(self.user.username, self.user.token)))
    
    def send(self, data):
        # Send data to dAmn!
        if self.sock == None or not self.sock.connected():
            return 0
        return self.sock.send(data)
    
    def get_packet(self):
        # Return a single packet from the queue.
        if not self.sock.connected():
            self.nullflags()
            return None
        return self.sock.get_packet()
    
    def close(self):
        # This is how we close our connection!
        if self.sock and self.sock.connected():
            self.sock.close()
    
    # PROTOCOL!
    # The methods below pretty much define the protocol for outgoing packets.

    def raw(self, data):
        # Send a raw dAmn packet.
        return self.send(data)
        
    def pong(self):
        # dAmn likes to play ping pong...
        return self.send('pong\n')
        
    def join(self, ns):
        # Send a join packet to dAmn.
        return self.send('join {0}\n'.format(ns))
        
    def part(self, ns):
        # Send a part packet to dAmn
        return self.send('part {0}\n'.format(ns))
        
    def say(self, ns, message):
        # Send a message to a dAmn channel namespace.
        return self.send('send {0}\n\nmsg main\n\n{1}'.format(ns, str(message)))
    
    def action(self, ns, message):
        # Send an action to a dAmn channel namespace.
        return self.send('send {0}\n\naction main\n\n{1}'.format(ns, str(message)))
    
    def me(self, ns, message):
        # This is just another way to do an action.
        return self.action(ns, message)
        
    def npmsg(self, ns, message):
        # Send a non-parsed message to a dAmn channel namespace.
        return self.send('send {0}\n\nnpmsg main\n\n{1}'.format(ns, str(message)))
    
    def promote(self, ns, user, pc=None):
        # Promote a user in a dAmn channel.
        return self.send('send {0}\n\npromote {1}\n{2}'.format(ns, user, '' if pc == None else '\n'+str(pc)))
    
    def demote(self, ns, user, pc=None):
        # Demote a user in a dAmn channel.
        return self.send('send {0}\n\ndemote {1}\n{2}'.format(ns, user, '' if pc == None else '\n'+str(pc)))
    
    def kick(self, ns, user, r=None):
        # Kick a user out of a dAmn channel.
        return self.send('kick {0}\nu={1}\n{2}'.format(ns, user, '' if r == None else '\n'+str(r)))
    
    def ban(self, ns, user):
        # Ban a user from a dAmn channel.
        return self.send('send {0}\n\nban {1}\n'.format(ns, user))
    
    def unban(self, ns, user):
        # Unban someone from a dAmn channel.
        return self.send('send {0}\n\nunban {1}\n'.format(ns, user))
    
    def get(self, ns, p):
        # Get a property for a dAmn channel.
        return self.send('get {0}\np={1}\n'.format(ns, p))
    
    def set(self, ns, p, val):
        # Set a property for a dAmn channel.
        return self.send('set {0}\np={1}\n\n{2}'.format(ns, p, val))
    
    def admin(self, ns, command):
        # Send an admin command to a dAmn channel. No need for multiple methods here.
        return self.send('send {0}\n\nadmin\n\n{1}'.format(ns, command))
    
    def disconnect(self):
        # Send a disconnect packet to the dAmn server.
        return self.send('disconnect\n')
        
    def kill(self, ns, r=None):
        # Send a kill packet to the dAmn server.
        return self.send('kill {0}\n{1}'.format(ns, '' if r == None else '\n'+str(r)))
    
    # END PROTOCOL METHODS
    
    def parser(self):
        # Just a shortcut for getting the Packet class.
        return Packet