Changeset 25 for rc


Ignore:
Timestamp:
02/03/10 00:08:41 (12 years ago)
Author:
sc
Message:

server:

  • major cleanup, unecessary code pruned

client_interface_button:

  • whitespace cleanup

client:

  • major cleanup, unecessary code pruned

client_interface:

  • major cleanup, unecessary code pruned

client_interface_component:

  • whitespace cleanup
Location:
rc
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • rc/puzzlebox_brainstorms_client.py

    r21 r25  
    1111# For more information please refer to http://www.gnu.org/copyleft/gpl.htm 
    1212# 
    13 # Last Update: 2010.02.01 
     13# Last Update: 2010.02.02 
    1414# 
    1515##################################################################### 
     
    3535NO_REPLY_WAIT = configuration.NO_REPLY_WAIT 
    3636 
    37  
    3837##################################################################### 
    3938# Classes 
    4039##################################################################### 
    4140 
    42 ##################################################################### 
    43 # MCC Base class 
    44 ##################################################################### 
    45  
    4641class puzzlebox_brainstorms_client: 
    4742         
    48         def __init__(self, log, hostname, port, \ 
    49                           service_name = 'MCC', \ 
    50                           target_name = 'MCP', \ 
     43        def __init__(self, log, \ 
     44                          server_host, \ 
     45                          server_port, \ 
    5146                          max_connection_attempts = MAX_CONNECTION_ATTEMPTS): 
    5247                 
    5348                self.log = log 
    54                 self.hostname = hostname 
    55                 self.port = port 
    56                 self.service_name = service_name 
    57                 self.target_name = target_name 
     49                self.server_host = server_host 
     50                self.server_port = server_port 
     51                #self.service_name = service_name 
     52                #self.target_name = target_name 
    5853                self.max_connection_attempts = max_connection_attempts 
    5954         
     
    6156        ################################################################## 
    6257         
    63         def send_instruction(self, instruction, component=None, \ 
    64                                         max_connection_attempts=MAX_CONNECTION_ATTEMPTS): 
    65                  
    66                 if not component: 
    67                         component = {} 
    68                         component['hostname'] = self.hostname 
    69                         component['port'] = self.port 
    70                         component['source'] = self.service_name 
    71                         component['target'] = self.target_name 
    72                  
    73                 factory = puzzlebox_brainstorms_client_send_instruction_factory(self.log, \ 
    74                                                        component, \ 
    75                                                        instruction, \ 
    76                                                        max_connection_attempts) 
    77                  
    78                 reactor.connectTCP(component['hostname'], component['port'], factory) 
     58        def send_command(self, \ 
     59                         command, \ 
     60                         max_connection_attempts=MAX_CONNECTION_ATTEMPTS): 
     61                 
     62                factory = puzzlebox_brainstorms_client_send_command_factory(self.log, \ 
     63                                                       command, \ 
     64                                                       self.server_host, \ 
     65                                                       self.server_port, \ 
     66                                                       max_connection_attempts, \ 
     67                                                       self.DEBUG) 
     68                 
     69                reactor.connectTCP(self.server_host, self.server_port, factory) 
    7970                 
    8071                return factory.replyDefer 
     
    8273 
    8374##################################################################### 
    84 # MCC Protocol class 
    85 ##################################################################### 
    86  
    87 class mcc_send_instruction_protocol(protocol.Protocol): 
     75# Client Protocol class 
     76##################################################################### 
     77 
     78class puzzlebox_brainstorms_client_send_command_protocol(protocol.Protocol): 
    8879         
    8980        def __init__(self): 
     81                 
     82                self.DEBUG = DEBUG 
    9083                self.data_chunk = "" 
    9184         
     
    9487         
    9588        def connectionMade(self): 
    96                 data = pickle.dumps(self.factory.instruction) 
     89                 
     90                data = pickle.dumps(self.factory.command) 
    9791                self.transport.write(data) 
    9892                 
    99                 #self.factory.log.debug("%s sent '%s' to remote %s component at %s:%s " % \ 
    100                                 #(self.factory.component['source'], \ 
    101                                  #self.factory.instruction['command'], \ 
    102                                  #self.factory.component['target'], \ 
    103                                  #self.factory.component['hostname'], \ 
    104                                  #self.factory.component['port'])) 
    105                  
    10693                self.factory.noReply = reactor.callLater(NO_REPLY_WAIT, self.noReply) 
    10794         
     
    11198        def noReply(self): 
    11299                 
    113                 #self.factory.log.error('No reply from %s for instruction %s' % \ 
    114                         #(self.factory.component['target'], self.factory.instruction)) 
    115                  
    116                 try: 
    117                         self.factory.replyDefer.callback(('NO_REPLY', self.factory.component)) 
    118                 except: 
    119                         self.factory.log.error("noReply failed to call callback?") 
     100                try: 
     101                        self.factory.replyDefer.callback('NO_REPLY') 
     102                except: 
     103                        if self.DEBUG: 
     104                                print "noReply failed to call callback" 
     105                        #self.factory.log.error("noReply failed to call callback") 
    120106                 
    121107                self.transport.loseConnection() 
     
    129115                        self.factory.noReply.cancel() 
    130116                except: 
    131                         self.factory.log.error("dataReceived after noReply triggered (or cancelled)?!") 
     117                        self.factory.log.error("dataReceived after noReply triggered (or cancelled)") 
    132118                 
    133119                self.data_chunk += data 
     120                 
    134121                try: 
    135122                        reply = pickle.loads(self.data_chunk) 
     
    139126                        self.data_chunk = "" 
    140127                         
    141                         #self.factory.log.debug('%s received reply from %s: %s' % \ 
    142                                 #(self.factory.component['source'], \ 
    143                                  #self.factory.component['target'], \ 
    144                                  #reply)) 
    145                          
    146128                        try: 
    147                                 self.factory.replyDefer.callback((reply, self.factory.component)) 
     129                                self.factory.replyDefer.callback(reply) 
    148130                        except: 
    149                                 #self.factory.log.error("dataReceived failed to call callback?") 
     131                                if self.DEBUG: 
     132                                        print "dataReceived failed to call callback" 
     133                                #self.factory.log.error("dataReceived failed to call callback") 
    150134                                pass 
    151135                         
     
    154138 
    155139##################################################################### 
    156 # MCC Factory class 
    157 ##################################################################### 
    158  
    159 class puzzlebox_brainstorms_client_send_instruction_factory(protocol.ClientFactory): 
     140# Client Factory class 
     141##################################################################### 
     142 
     143class puzzlebox_brainstorms_client_send_command_factory(protocol.ClientFactory): 
    160144                 
    161145        def __init__(self, log, \ 
    162                      component, \ 
    163                      instruction, \ 
    164                      max_connection_attempts=MAX_CONNECTION_ATTEMPTS): 
    165                  
    166                 self.protocol = mcc_send_instruction_protocol 
     146                     command, \ 
     147                     server_host=SERVER_HOST, \ 
     148                     server_port=SERVER_PORT, \ 
     149                     max_connection_attempts=MAX_CONNECTION_ATTEMPTS, \ 
     150                     DEBUG=DEBUG): 
     151                 
    167152                self.log = log 
    168                 self.component = component 
    169                 self.instruction = instruction 
     153                self.DEBUG = DEBUG 
     154                self.server_host = server_host 
     155                self.server_port = server_port 
     156                self.command = command 
    170157                 
    171158                self.max_connection_attempts = max_connection_attempts 
    172159                self.connection_attempt = 1 
    173160                 
     161                self.protocol = \ 
     162                   puzzlebox_brainstorms_client_send_command_protocol 
     163                 
    174164                self.replyDefer = defer.Deferred() 
    175165         
     
    179169        def clientConnectionFailed(self, connector, reason): 
    180170                 
    181                 #self.log.error("%s failed to connect to remote %s compontent at %s:%i" % \ 
    182                                 #(self.component['source'], \ 
    183                                  #self.component['target'], \ 
    184                                  #self.component['hostname'], \ 
    185                                  #self.component['port'])) 
     171                if self.DEBUG: 
     172                        print "Client failed to connect to remote component at %s:%i" % \ 
     173                           (self.server_host, self.server_port) 
    186174                 
    187175                reply='FAILED_TO_CONNECT' 
     
    189177                self.connection_attempt = self.connection_attempt + 1 
    190178                 
    191                 if self.max_connection_attempts == None or \ 
    192                         self.connection_attempt <= self.max_connection_attempts: 
     179                if ((self.max_connection_attempts == None) or \ 
     180                         (self.connection_attempt <= self.max_connection_attempts)): 
    193181                 
    194182                        # If connection failed retry after one second 
     
    196184                 
    197185                else: 
    198                         #self.log.error("Maximum connection retries from %s to %s reached, aborting" % \ 
    199                                        #(self.component['source'], self.component['target'])) 
    200                         pass 
    201                          
    202                         self.replyDefer.callback((reply, self.component)) 
     186                        if self.DEBUG: 
     187                                print "Maximum connection retries reached, aborting" 
     188                         
     189                         
     190                        self.replyDefer.callback(reply) 
    203191         
    204192         
     
    208196                 
    209197                # Losing Connection is expected after data exchange is complete 
    210                 #self.log.debug("Connection to %s lost for instruction %s" % (self.component, self.instruction)) 
    211                 try: 
    212                         self.replyDefer.callback((reason, self.component)) 
     198                try: 
     199                        self.replyDefer.callback(reason) 
    213200                except: 
    214201                        pass 
     
    231218                 
    232219                self.command_parameters = command_parameters 
    233                 self.hostname = SERVER_HOST 
    234                 self.port = SERVER_PORT 
    235                 self.service_name = 'MCC-CL' 
    236                 self.target_name = 'MCP' 
     220                self.server_host = SERVER_HOST 
     221                self.server_port = SERVER_PORT 
    237222                self.max_connection_attempts = MAX_CONNECTION_ATTEMPTS 
    238223         
     
    242227        def execute_command_line(self): 
    243228                 
    244                 (command, information) = self.parse_command_list(self.command_parameters) 
    245                  
    246                 instruction = {} 
    247                 instruction['command'] = command 
    248                 instruction['information'] = information 
    249                  
    250                 d = self.send_instruction(instruction) 
     229                (command) = self.parse_command_line(self.command_parameters) 
     230                 
     231                d = self.send_command(command) 
    251232                d.addCallback(self.print_response_and_stop) 
    252233         
     
    256237        def print_response_and_stop(self, response): 
    257238                 
    258                 print response[0] 
    259                  
    260                 reactor.stop() 
    261          
    262          
    263         ################################################################## 
    264          
    265         def parse_command_list(self, command_parameters): 
    266                  
    267                 command = None 
    268                 data = {} 
    269                  
    270                 if (command_parameters[0] == 'test_drive'): 
    271                         command = 'test_drive' 
    272                 elif (command_parameters[0] == 'drive_forward'): 
    273                         command = 'drive_forward' 
    274                 elif (command_parameters[0] == 'drive_reverse'): 
    275                         command = 'drive_reverse' 
    276                 elif (command_parameters[0] == 'turn_left'): 
    277                         command = 'turn_left' 
    278                 elif (command_parameters[0] == 'turn_right'): 
    279                         command = 'turn_right' 
    280                 elif (command_parameters[0] == 'turn_left_in_reverse'): 
    281                         command = 'turn_in_reverse' 
    282                 elif (command_parameters[0] == 'turn_right_in_reverse'): 
    283                         command = 'turn_in_reverse' 
    284                  
    285                  
    286                 else: 
    287                         self.log.error("Unrecognized command received: %s" % command_parameters[0]) 
    288                  
    289                  
    290                 return (command, data) 
     239                if self.DEBUG: 
     240                        print "---> [Client] Server Response:", 
     241                        print response 
     242                 
     243                try: 
     244                        reactor.stop() 
     245                except: 
     246                        print "ERROR: Can't stop reactor that isn't running." 
     247         
     248         
     249        ################################################################## 
     250         
     251        def parse_command_line(self, command_parameters): 
     252                 
     253                try: 
     254                        command = command_parameters[0] 
     255                except: 
     256                        command = None 
     257                 
     258                 
     259                return(command) 
    291260 
    292261 
     
    297266if __name__ == '__main__': 
    298267         
    299         #log = puzzlebox_logger.puzzlebox_logger(logfile='mcc') 
     268        #log = puzzlebox_logger.puzzlebox_logger(logfile='client') 
    300269        log = None 
    301270         
  • rc/puzzlebox_brainstorms_client_interface.py

    r23 r25  
    1111# For more information please refer to http://www.gnu.org/copyleft/gpl.htm 
    1212# 
    13 # Last Update: 2010.02.01 
     13# Last Update: 2010.02.02 
    1414# 
    1515##################################################################### 
     
    2222import pygame.locals 
    2323 
     24from twisted.internet import reactor, protocol, defer 
     25 
    2426import puzzlebox_brainstorms_configuration as configuration 
    25 #import puzzlebox_brainstorms_client 
     27import puzzlebox_brainstorms_client 
    2628import puzzlebox_brainstorms_client_interface_component as component 
    2729import puzzlebox_brainstorms_client_interface_button as button 
     
    5557 
    5658class puzzlebox_brainstorms_client_interface( \ 
    57          component.puzzlebox_brainstorms_client_interface_component): 
     59         component.puzzlebox_brainstorms_client_interface_component, \ 
     60         protocol.ClientFactory): 
    5861         
    5962        def __init__(self, log, \ 
     
    9396                 
    9497                self.update_display() 
     98                 
     99                #self.client = \ 
     100                   #puzzlebox_brainstorms_client.puzzlebox_brainstorms_client( 
     101                         #self.log, \ 
     102                         #configuration.SERVER_HOST, \ 
     103                         #configuration.SERVER_PORT, \ 
     104                         #configuration.MAX_CONNECTION_ATTEMPTS) 
    95105         
    96106         
     
    99109        def initialize_pygame(self): 
    100110                 
    101                 os.environ['SDL_VIDEO_WINDOW_POS'] = "%i,%i" % (self.display_window_x_coordinate, \ 
    102                                                                 self.display_window_y_coordinate) 
     111                if (self.operating_system != "windows"): 
     112                        os.environ['SDL_VIDEO_WINDOW_POS'] = \ 
     113                           "%i,%i" % (self.display_window_x_coordinate, \ 
     114                                 self.display_window_y_coordinate) 
    103115                 
    104116                self.pygame.init() 
     
    217229        def send_commands_to_server(self, commands): 
    218230         
    219                 #client = \ 
    220                    #puzzlebox_brainstorms_client.puzzlebox_brainstorms_client_command_line( 
    221                          #self.log, \ 
    222                          #commands, \ 
    223                          #SERVER_HOST, \ 
    224                          #SERVER_PORT) 
    225                 #puzzlebox_brainstorms_client.reactor.callWhenRunning(client.execute_command_line) 
    226                 #puzzlebox_brainstorms_client.reactor.run() 
    227                  
    228                  
    229                 command = 'python puzzlebox_brainstorms_client.py' 
    230                  
    231                 for each in commands: 
    232                         command = '%s %s' % (command, each) 
    233                  
    234                 if self.DEBUG: 
    235                         print "executing: %s" % command 
    236                  
    237                 os.system(command) 
     231                for command in commands: 
     232                         
     233                        #Command Line Client version 
     234                        command_line = 'python puzzlebox_brainstorms_client.py %s' % command 
     235                         
     236                        if self.DEBUG: 
     237                                print "executing: %s" % command_line 
     238                         
     239                        os.system(command_line) 
    238240         
    239241         
     
    266268                                 
    267269                                if (event.type is self.pygame.locals.QUIT): 
     270                                        #reactor.stop() 
    268271                                        sys.exit() 
    269272                                 
     
    377380         
    378381        interface.start() 
    379  
    380  
     382         
     383        reactor.callWhenRunning(interface.start) 
     384        #print "bing" 
     385        reactor.run() 
     386 
  • rc/puzzlebox_brainstorms_client_interface_button.py

    r19 r25  
    9999 
    100100if __name__ == '__main__': 
    101  
     101         
    102102        pass 
    103103 
  • rc/puzzlebox_brainstorms_client_interface_component.py

    r19 r25  
    2020 
    2121class puzzlebox_brainstorms_client_interface_component: 
    22  
     22         
    2323        def __init__(self, DEBUG = 0): 
    2424                 
     
    108108 
    109109if __name__ == '__main__': 
    110  
     110         
    111111        pass 
    112112 
  • rc/puzzlebox_brainstorms_server.py

    r21 r25  
    1111# For more information please refer to http://www.gnu.org/copyleft/gpl.htm 
    1212# 
    13 # Last Update: 2010.02.01 
     13# Last Update: 2010.02.02 
    1414# 
    1515##################################################################### 
     
    5151        ################################################################## 
    5252         
    53         def process_instruction(self, instruction): 
    54                  
    55                 #self.log.debug("Received instruction: %s" % instruction) 
    56                 #if self.DEBUG: 
    57                         #print "Received instruction: %s" % instruction 
     53        def process_command(self, command): 
    5854                 
    5955                d = defer.Deferred() 
    60                 response = 'instruction received' 
    6156                 
    62                 if 'command' in instruction: 
    63                         response = '%s instruction received' % instruction['command'] 
    64                          
    65                         if self.DEBUG: 
    66                                 print response 
    67                          
    68                         if 'information' in instruction: 
    69                                 information = instruction['information'] 
    70                          
    71                          
    72                         if instruction['command'] == 'test_drive': 
    73                                 command = 'python puzzlebox_brainstorms_rc.py --command=test_drive' 
    74                                 os.system(command) 
    75                          
    76                          
    77                         elif instruction['command'] == 'drive_forward': 
    78                                 command = 'python puzzlebox_brainstorms_rc.py --command=drive_forward' 
    79                                 os.system(command) 
    80                          
    81                          
    82                         elif instruction['command'] == 'drive_reverse': 
    83                                 command = 'python puzzlebox_brainstorms_rc.py --command=drive_reverse' 
    84                                 os.system(command) 
    85                          
    86                          
    87                         elif instruction['command'] == 'turn_left': 
    88                                 command = 'python puzzlebox_brainstorms_rc.py --command=turn_left' 
    89                                 os.system(command) 
    90                          
    91                          
    92                         elif instruction['command'] == 'turn_right': 
    93                                 command = 'python puzzlebox_brainstorms_rc.py --command=turn_right' 
    94                                 os.system(command) 
    95                          
    96                          
    97                         elif instruction['command'] == 'turn_left_in_reverse': 
    98                                 command = 'python puzzlebox_brainstorms_rc.py --command=turn_left_in_reverse' 
    99                                 os.system(command) 
    100                          
    101                          
    102                         elif instruction['command'] == 'turn_right_in_reverse': 
    103                                 command = 'python puzzlebox_brainstorms_rc.py --command=turn_right_in_reverse' 
    104                                 os.system(command) 
    105                          
    106                          
    107                         else: 
    108                                  
    109                                 #self.log.error("Unrecognized command received: %s" % instruction) 
    110                                 if self.DEBUG: 
    111                                         print "Unrecognized command received: %s" % instruction 
    112                                 reponse = 'unrecognized instruction' 
     57                response = '%s command received' % command 
     58                 
     59                if self.DEBUG: 
     60                        print '--> [Server] %s command received' % command 
     61                 
     62                command = 'python puzzlebox_brainstorms_rc.py --command=%s' % command 
     63                os.system(command) 
    11364                 
    11465                 
     
    12273        ################################################################## 
    12374         
    124         def process_connection_lost(self, instruction): 
     75        def process_connection_lost(self, command): 
    12576                 
    126                 if not instruction: 
     77                if not command: 
    12778                         
    128                         #self.log.debug("Connection lost with no instruction") 
     79                        #self.log.debug("Connection lost with no command") 
    12980                         
    13081                        if self.DEBUG: 
    131                                 print "--> [Server] Connection lost with no instruction" 
     82                                print "--> [Server] Connection lost with no command" 
    13283                 
    13384                 
    13485                else: 
    13586                         
    136                         #self.log.debug("Connection lost with no instruction") 
     87                        #self.log.debug("Connection lost") 
    13788                         
    13889                        #if self.DEBUG: 
    13990                                #print "--> [Server] Connection lost" 
    140                                  
     91                         
    14192                        pass 
    14293 
     
    149100         
    150101        def __init__(self): 
    151                 self.instruction = {} 
     102                 
     103                self.command = None 
    152104                self.data_chunk = "" 
    153105         
     
    158110                 
    159111                self.data_chunk += data 
     112                 
    160113                try: 
    161                         self.instruction = pickle.loads(self.data_chunk) 
     114                        self.command = pickle.loads(self.data_chunk) 
     115                 
    162116                except Exception, e: 
    163117                        self.factory.log.error("Partial data received (or error: %s)." % e) 
     118                 
    164119                else: 
    165120                        self.data_chunk = "" 
    166121                         
    167                         d = self.factory.process_instruction(self.instruction.copy()) 
     122                        d = self.factory.process_command("%s" % self.command) 
    168123                        d.addCallback(self.send_response) 
    169124         
     
    172127         
    173128        def send_response(self, response): 
    174                  
    175129                 
    176130                response = pickle.dumps(response) 
     
    183137        def connectionLost(self, reason): 
    184138                 
    185                 self.factory.process_connection_lost(self.instruction) 
     139                self.factory.process_connection_lost(self.command) 
    186140 
    187141 
     
    191145 
    192146if __name__ == '__main__': 
    193  
     147         
    194148        #log = puzzlebox_logger.puzzlebox_logger(logfile='master_control') 
    195149        log = None 
Note: See TracChangeset for help on using the changeset viewer.