Ignore:
Timestamp:
06/21/10 16:02:12 (11 years ago)
Author:
sc
Message:

client_thinkgear:

  • ThinkGear? authorization added
  • response processing added

configuration:

  • comment/whitespace cleanup

server_thinkgear:

File:
1 edited

Legend:

Unmodified
Added
Removed
  • remote_control/puzzlebox_brainstorms_client_thinkgear.py

    r56 r57  
    4949         
    5050        def __init__(self, log, \ 
    51                           authorization_request, \ 
    52                           server_host=SERVER_HOST, \ 
    53                           server_port=SERVER_PORT, \ 
    54                           DEBUG=DEBUG): 
     51                          server_host=SERVER_HOST, \ 
     52                          server_port=SERVER_PORT, \ 
     53                          DEBUG=DEBUG): 
    5554                 
    5655                self.log = log 
    5756                self.DEBUG=DEBUG 
    5857                 
    59                 self.authorization_request = authorization_request 
    6058                self.server_host = server_host 
    6159                self.server_port = server_port 
    6260                self.max_connection_attempts = MAX_CONNECTION_ATTEMPTS 
    6361 
    64          
    65         ################################################################## 
    66          
    67         def send_command(self, \ 
    68                          command, \ 
    69                          max_connection_attempts=MAX_CONNECTION_ATTEMPTS): 
    70                  
    71                 factory = puzzlebox_brainstorms_client_thinkgear_factory(self.log, \ 
    72                                                        command, \ 
    73                                                        self.server_host, \ 
    74                                                        self.server_port, \ 
    75                                                        max_connection_attempts, \ 
    76                                                        self.DEBUG) 
    77                  
    78                 reactor.connectTCP(self.server_host, self.server_port, factory) 
    79                  
    80 ##              return factory.replyDefer 
    81          
    82          
    83         ################################################################## 
    84          
    85         def send_command_and_print_response(self, command): 
    86  
    87                 if self.DEBUG: 
    88                         print "---> [Client] Sending:", 
    89                         print command 
    90  
    91                          
    92                 d = self.send_command(command) 
     62                self.is_authorized = True 
     63                 
     64 
     65        ################################################################## 
     66 
     67        def authorize_and_send_parameters(self,\ 
     68                                          thinkgear_parameters, \ 
     69                                          authorization_request): 
     70 
     71                if self.DEBUG: 
     72                        print "----> [ThinkGear Client] Sending Authorization Request:", 
     73                        print authorization_request 
     74 
     75                         
     76                d = self.send_parameters(thinkgear_parameters, authorization_request) 
     77                d.addCallback(self.update_authorization) 
     78 
     79 
     80        ################################################################## 
     81 
     82        def update_authorization(self, authorization): 
     83 
     84                if self.DEBUG: 
     85                        print "--> [ThinkGear Client] Authorization:", 
     86                        print authorization 
     87                         
     88                self.is_authorized = authorization 
     89 
     90                 
     91        ################################################################## 
     92 
     93        def send_parameters(self, \ 
     94                         parameters, \ 
     95                         authentication=None, \ 
     96                         max_connection_attempts=MAX_CONNECTION_ATTEMPTS): 
     97                 
     98                self.factory = puzzlebox_brainstorms_client_thinkgear_factory(self.log, \ 
     99                             parameters, \ 
     100                             authentication, \ 
     101                             self.server_host, \ 
     102                             self.server_port, \ 
     103                             max_connection_attempts, \ 
     104                             self.DEBUG) 
     105                 
     106                reactor.connectTCP(self.server_host, self.server_port, self.factory) 
     107 
     108                return self.factory.replyDefer 
     109 
     110 
     111        ################################################################## 
     112 
     113        def send_parameters_and_print_response(self, parameters): 
     114 
     115                if self.DEBUG: 
     116                        print "----> [ThinkGear Client] Sending:", 
     117                        print parameters 
     118 
     119                         
     120                d = self.send_parameters(parameters) 
    93121                d.addCallback(self.print_response) 
    94          
    95          
    96         ################################################################## 
    97          
     122 
     123 
     124        ################################################################## 
     125 
    98126        def print_response(self, response): 
    99127                 
    100128                if self.DEBUG: 
    101                         print "---> [Client] Server Response:", 
     129                        print "--> [ThinkGear Client] Server Response:", 
    102130                        print response 
    103131                 
     
    120148         
    121149        def connectionMade(self): 
    122                  
    123                 data = json.dumps(self.factory.command) 
    124                 self.sendLine(data) 
     150 
     151                if self.DEBUG: 
     152                        print "----> [ThinkGear Client] Connected to %s:%i" % \ 
     153                              (self.factory.server_host, \ 
     154                               self.factory.server_port) 
     155 
     156 
     157                if (self.factory.authentication != None): 
     158                        self.send_data(self.factory.authentication) 
     159 
     160                else: 
     161                        self.send_data(self.factory.parameters) 
     162 
     163 
     164        ################################################################## 
     165 
     166        def send_data(self, data): 
     167 
     168                packet = json.dumps(data) 
     169 
     170                if self.DEBUG: 
     171                        print "----> [ThinkGear Client] Sending:", 
     172                        print packet 
     173 
     174                 
     175                self.sendLine(packet) 
    125176                 
    126177##              self.factory.noReply = reactor.callLater(NO_REPLY_WAIT, self.noReply) 
     
    136187                        if self.DEBUG: 
    137188                                print "noReply failed to call callback" 
    138          
    139          
    140         ################################################################## 
    141  
    142         def lineReceived(self, line): 
    143  
    144                 # Ignore blank lines 
    145                 if not line: 
    146                         return 
    147  
    148                 try: 
    149                         data = json.loads(line) 
    150                 except Exception, e: 
    151                         if DEBUG: 
     189 
     190 
     191        ################################################################## 
     192 
     193        def lineReceived(self, line): 
     194 
     195                # Ignore blank lines 
     196                if not line: 
     197                        return 
     198 
     199                try: 
     200                        data = json.loads(line) 
     201                except Exception, e: 
     202                        if SELF.DEBUG: 
    152203                                print "Partial data received (or error:", 
    153204                                print e 
     
    157208                                print line 
    158209                                 
    159                 else: 
    160                         if self.DEBUG: 
    161                                 if ('rawEeg' in data.keys()): 
    162                                         if self.DEBUG > 1: 
    163                                                 print "data:", 
    164                                                 print data 
    165                                 else: 
    166                                         print "data:", 
    167                                         print data 
    168  
    169  
    170         ################################################################## 
    171  
    172         def connectionLost(self, reason): 
     210                else: 
     211 
     212                        if (type(data) == type({})): 
     213 
     214                                self.factory.process_response(data) 
     215##                              self.factory.replyDefer.callback(data) 
     216 
     217                        else: 
     218                                if self.DEBUG: 
     219                                        print "data:", 
     220                                        print data 
     221 
     222 
     223        ################################################################## 
     224 
     225        def connectionLost(self, reason): 
    173226 
    174227                if self.DEBUG > 1: 
     
    194247         
    195248        def __init__(self, log, \ 
    196                      command, \ 
    197                      server_host=SERVER_HOST, \ 
    198                      server_port=SERVER_PORT, \ 
    199                      max_connection_attempts=MAX_CONNECTION_ATTEMPTS, \ 
    200                      DEBUG=DEBUG): 
     249                     parameters, \ 
     250                     authentication, \ 
     251                     server_host=SERVER_HOST, \ 
     252                     server_port=SERVER_PORT, \ 
     253                     max_connection_attempts=MAX_CONNECTION_ATTEMPTS, \ 
     254                     DEBUG=DEBUG): 
    201255                 
    202256                self.log = log 
     
    204258                self.server_host = server_host 
    205259                self.server_port = server_port 
    206                 self.command = command 
     260                self.parameters = parameters 
     261                self.authentication = authentication 
    207262                 
    208263                self.max_connection_attempts = max_connection_attempts 
     
    215270 
    216271 
     272        ################################################################## 
     273 
     274        def process_response(self, response): 
     275 
     276                if self.DEBUG: 
     277                        if (('rawEeg' not in response.keys()) or \ 
     278                            (self.DEBUG > 1)): 
     279                                print "<-- [ThinkGear Client] Received:", 
     280                                print response 
     281 
     282 
     283                if response.has_key('isAuthorized'): 
     284 
     285                        if (response['isAuthorized'] == True): 
     286                                self.replyDefer.callback(True) 
     287                        else: 
     288                                self.replyDefer.callback(False) 
     289 
     290 
    217291##################################################################### 
    218292# Main 
     
    224298        log = None 
    225299         
    226         #authorization_request = AUTHORIZATION_REQUEST 
    227         authorization_request = None # ThinkGear authentication not working 
     300        authorization_request = AUTHORIZATION_REQUEST 
    228301        thinkgear_parameters = THINKGEAR_PARAMETERS 
    229302         
    230303        thinkgear_client = puzzlebox_brainstorms_client_thinkgear( \ 
    231304                    log, \ 
    232                     authorization_request, \ 
    233305                    server_host=SERVER_HOST, \ 
    234306                    server_port=SERVER_PORT, \ 
    235307                    DEBUG=DEBUG) 
    236308 
     309        # Use ThinkGear authentication 
    237310        reactor.callWhenRunning( \ 
    238                 thinkgear_client.send_command, \ 
    239                 thinkgear_parameters) 
     311                thinkgear_client.authorize_and_send_parameters, \ 
     312                thinkgear_parameters, \ 
     313                authorization_request) 
     314         
     315        # Do not use ThinkGear authentication 
     316##      authorization_request = None 
     317##      reactor.callWhenRunning( \ 
     318##              thinkgear_client.send_parameters, \ 
     319##              thinkgear_parameters, \ 
     320##              authorization_request) 
     321 
     322 
    240323 
    241324 
Note: See TracChangeset for help on using the changeset viewer.