source: rc/puzzlebox_brainstorms_server.py @ 5

Last change on this file since 5 was 5, checked in by sc, 13 years ago

rc:

  • modified to use configuration module

server:

  • test_drive function added

configuration:

  • initial checkin

client:

  • initial checkin
File size: 24.0 KB
Line 
1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3#
4# Puzzlebox - Brainstorms - Server
5#
6# Copyright Puzzlebox Productions, LLC (2010)
7#
8# Portions of this code have been previously
9# released under the GNU Pulic License (GPL) version 2
10# and is Copyright Steven M. Castellotti (2010)
11# For more information please refer to http://www.gnu.org/copyleft/gpl.htm
12#
13# Last Update: 2010.01.28
14#
15#####################################################################
16
17import os, signal, sys, time
18import cPickle as pickle
19
20from twisted.internet import reactor, protocol, defer
21
22import puzzlebox_brainstorms_configuration as configuration
23import puzzlebox_brainstorms_client
24#import puzzlebox_logger
25
26#####################################################################
27# Globals
28#####################################################################
29
30DEBUG = 1
31
32SERVER_HOST = configuration.SERVER_HOST
33SERVER_PORT = configuration.SERVER_PORT
34
35#MAX_COMPONENTS = puzzlebox_configuration.MAX_COMPONENTS
36#GTKMOZ_PROFILE_DIR = puzzlebox_configuration.GTKMOZ_PROFILE_DIR
37#AUTOBIT_TIMEOUT = puzzlebox_configuration.AUTOBIT_TIMEOUT
38
39
40#####################################################################
41# Classes
42#####################################################################
43
44class puzzlebox_master_control(protocol.ServerFactory):
45
46        def __init__(self, log, DEBUG=DEBUG):
47
48                self.protocol = puzzlebox_master_control_server_protocol
49
50                self.log = log
51                self.DEBUG = DEBUG
52
53                self.registry = {}
54                #self.registry['components'] = {}
55                #self.registry['windows'] = {}
56
57                #self.csc = puzzlebox_master_control_client.puzzlebox_master_control_client( \
58                                #self.log, \
59                                #puzzlebox_configuration.CONTENT_SET_HOST, \
60                                #puzzlebox_configuration.CONTENT_SET_PORT, \
61                                #service_name = 'MCP', \
62                                #target_name = 'CS')
63
64
65        ##################################################################
66
67        def process_instruction(self, instruction):
68
69                #self.log.debug("Received instruction: %s" % instruction)
70                #if self.DEBUG:
71                        #print "Received instruction: %s" % instruction
72
73                d = defer.Deferred()
74                response = 'instruction received'
75
76                if 'command' in instruction:
77                        response = '%s instruction received' % instruction['command']
78
79
80                        if 'information' in instruction:
81                                information = instruction['information']
82
83
84                        if instruction['command'] == 'test_drive':
85                               
86                                command = 'python puzzlebox_brainstorms_rc.py'
87                               
88                                os.system(command)
89
90
91                        #if instruction['command'] == 'register_component':
92
93                                #if information['pid'] in self.registry['components']:
94                                        #self.log.error("Duplicate component registering - replacing old component (assumed dead).")
95                                        #self.log.error("Old component: %s" % self.registry['components'][information['pid']])
96                                        #self.log.error("New Component: %s" % information)
97                                       
98                                        #if self.DEBUG:
99                                                #print "Duplicate component registering - replacing old component (assumed dead)."
100                                                #print "Old component: %s" % self.registry['components'][information['pid']]
101                                                #print "New Component: %s" % information
102
103                                #self.registry['components'][information['pid']] = information
104
105
106                        #elif instruction['command'] == 'unregister_component':
107
108                                #if information['pid'] in self.registry['components']:
109                                        #self.log.debug("Removing component from registry: %s" % self.registry['components'][information['pid']])
110                                       
111                                        #if self.DEBUG:
112                                                #print "Removing component from registry: %s" % \
113                                                   #self.registry['components'][information['pid']]
114                                       
115                                        #del(self.registry['components'][information['pid']])
116
117                                #else:
118                                        #self.log.error("Unknown component attempted to unregister")
119                                        #if self.DEBUG:
120                                                #print "Unknown component attempted to unregister"
121
122
123                        #elif instruction['command'] == 'update_component':
124
125                                #if information['pid'] in self.registry['components']:
126
127                                        #component = self.registry['components'][information['pid']]
128
129                                        #for key in information:
130                                                #component[key] = information[key]
131
132                                #else:
133                                        #self.log.error("Unknown component attempted to update: %s" % information)
134                                        #if self.DEBUG:
135                                                #print "Unknown component attempted to update: %s" % information
136
137
138                        #elif instruction['command'] == 'restart_component':
139                               
140                                #self.restart_component(information['pid'])
141
142
143                        #elif instruction['command'] == 'load_url':
144
145                                #found_component = False
146
147                                #for each in self.registry['components']:
148
149                                        #component = self.registry['components'][each]
150
151                                        #if component['type'] == information['type'] and \
152                                                #component['display_pos_x'] == information['display_pos_x'] and \
153                                                #component['display_pos_y'] == information['display_pos_y'] and \
154                                                #component['window_size_x'] == information['window_size_x'] and \
155                                                #component['window_size_y'] == information['window_size_y']:
156
157                                                #found_component = True
158
159                                                #if component['active']:
160                                                        #self.log.debug("Matched an active component, activating callback.")
161                                                        #if self.DEBUG:
162                                                                #print "Matched an active component, activating callback."
163                                                        #component['callback'].callback("browser exit")
164
165                                                #component['callback'] = d
166
167                                                #try:
168                                                        #component['autobit'].cancel()
169                                                #except:
170                                                        #pass
171
172                                                #if int(information['enable_autobit']) == 1:
173                                                        #self.log.debug("Window %i loading with autobit enabled." % information['window_id'])
174                                                       
175                                                        #if self.DEBUG:
176                                                                #print "Window %i loading with autobit enabled." % \
177                                                                        #information['window_id']
178                                                       
179                                                        #component['autobit'] = \
180                                                                #reactor.callLater(AUTOBIT_TIMEOUT, self.restart_component, each)
181
182                                                #component['active'] = True
183
184                                                #for key in information:
185                                                        #component[key] = information[key]
186
187                                                #component['source'] = 'MCP'
188                                                #component['target'] = component['type']
189
190                                                #dw = self.csc.send_instruction(instruction, component=component)
191
192                                                #dw.addCallback(self.process_component_response, instruction)
193                                               
194                                                #break
195                               
196                                #if not found_component:
197                                       
198                                        #self.log.debug("No component found matching load_url information, spawning new.")
199                                        #if self.DEBUG:
200                                                #print "No component found matching load_url information, spawning new."
201                                        #self.spawn_new_component(instruction, d)
202
203                                #response = None
204
205
206                        #elif instruction['command'] == 'animation_started':
207
208                                #window_id = information['window_id']
209
210                                #self.log.debug("Got animation started for window id %i" % window_id)
211                                #if self.DEBUG:
212                                        #print "Got animation started for window id %i" % window_id
213
214                                #for each in self.registry['components']:
215                                        #if 'window_id' in self.registry['components'][each] and \
216                                                        #int(self.registry['components'][each]['window_id']) == int(window_id):
217
218                                                #self.log.debug("Found window %i" % window_id)
219                                                #if self.DEBUG:
220                                                        #print "Found window %i" % window_id
221                                               
222                                                #if 'autobit' in self.registry['components'][each]:
223                                                        #self.log.debug("Window %i cancelling autobit restart." % window_id)
224                                                        #if self.DEBUG:
225                                                                #print "Window %i cancelling autobit restart." % window_id
226
227                                                        #try:
228                                                                #self.registry['components'][each]['autobit'].cancel()
229                                                        #except:
230                                                                #self.log.error("Window %i error trying to cancel autobit restart" % window_id)
231                                                                #if self.DEBUG:
232                                                                        #print "Window %i error trying to cancel autobit restart" % window_id
233
234                                                #self.log.debug("Window %i white flash fix unhiding browser." % window_id)
235                                                #tinstr = {'command': 'unhide'}
236                                                #self.csc.send_instruction(tinstr, component=self.registry['components'][each])
237
238
239                        #elif instruction['command'] == 'hide_all_components':
240
241                                #dlist = []
242
243                                #for each in self.registry['components']:
244
245                                        #component = self.safe_component(self.registry['components'][each])
246
247                                        #tinstr = {'command': 'hide'}
248
249                                        #dlist.append(self.csc.send_instruction(tinstr, component))
250
251                                #if dlist:
252                                        #response = None
253                                        #dl = defer.DeferredList(dlist)
254                                        #dl.addCallback(d.callback)
255
256
257                        #elif instruction['command'] == 'register_window':
258
259                                #if information['window_id'] in self.registry['windows']:
260                                        #self.log.error("Duplicate window attempted to register: %s" % information)
261                                        #if self.DEBUG:
262                                                #print "Duplicate window attempted to register: %s" % information
263
264                                #else:
265                                        #self.registry['windows'][information['window_id']] = information
266
267
268                        #elif instruction['command'] == 'get_window_data':
269
270                                #if information['window_id'] == 'all':
271
272                                        #response = self.registry['windows']
273
274                                #elif information['window_id'] in self.registry['windows']:
275
276                                        #response = self.registry['windows'][information['window_id']]
277
278                                #else:
279                                        #self.log.error("Attempt to request data for unknown window: %s" % information)
280                                        #if self.DEBUG:
281                                                #print "Attempt to request data for unknown window: %s" % information
282
283
284                        #elif instruction['command'] == 'unregister_all_windows':
285
286                                #self.registry['windows'] = {}
287
288
289                        #elif instruction['command'] == 'exit_content_set':
290
291                                #self.log.debug("Requesting current content set to exit.")
292                                #if self.DEBUG:
293                                        #print "Requesting current content set to exit."
294                                #self.csc.exit_content_set()
295
296
297                        #elif instruction['command'] == 'change_content_set':
298
299                                #self.log.debug("Requesting to change content set to content_set_id %i" % information['content_set_id'])
300                                #if self.DEBUG:
301                                        #print "Requesting to change content set to content_set_id %i" % \
302                                           #information['content_set_id']
303                                #self.csc.change_content_set(information)
304
305
306                        #elif instruction['command'] == 'end_current_entry':
307
308                                #self.log.debug("Requesting to end content in window_id %i" % information['window_id'])
309                                #if self.DEBUG:
310                                        #print "Requesting to end content in window_id %i" % \
311                                           #information['window_id']
312                                #self.csc.end_current_entry(information)
313
314
315                        #elif instruction['command'] == 'request_screenshot':
316
317                                #self.log.debug("Requesting content set to take screenshot")
318                                #if self.DEBUG:
319                                        #print "Requesting content set to take screenshot"
320                                #self.csc.request_screenshot()
321
322
323                        #elif instruction['command'] == 'upload_screenshot':
324
325                                #self.log.debug("Requesting content set to upload system screenshot")
326                                #if self.DEBUG:
327                                        #print "Requesting content set to upload system screenshot"
328                                #self.csc.upload_screenshot()
329
330
331                        #elif instruction['command'] == 'export_schedule':
332
333                                #self.log.debug("Requesting content set to export content_set_sequence_schedule_id %i" % \
334                                                #information['content_set_sequence_schedule_id'])
335                                #if self.DEBUG:
336                                        #print "Requesting content set to export content_set_sequence_schedule_id %i" % \
337                                                #information['content_set_sequence_schedule_id']
338                                #self.csc.export_schedule(information)
339
340
341                        #elif instruction['command'] == 'check_health':
342
343                                #response = 'health_okay'
344
345
346                        #elif instruction['command'] == 'get_registry':
347
348                                # unfortunately registry needs to have volatile components removed
349                                # before it can be passed via pickle, e.g. the deferred objects in callback.
350                                # may end up changing the structure around so it's less hassle to pass
351
352                                #safe_registry = {}
353                                #safe_registry['components'] = {}
354                                #safe_registry['windows'] = {}
355                               
356                                #for each in self.registry['components']:
357                                        #safe_registry['components'][each] = \
358                                                        #self.safe_component(self.registry['components'][each])
359
360                                #for each in self.registry['windows']:
361                                        #safe_registry['windows'][each] = self.registry['windows'][each].copy()
362
363                                #response = safe_registry
364
365
366                        #elif instruction['command'] == '/usr/bin/puzzlebox_xorg_reset.py':
367
368                                #response = "EXECUTE OK"
369
370
371                        else:
372
373                                #self.log.error("Unrecognized command received: %s" % instruction)
374                                if self.DEBUG:
375                                        print "Unrecognized command received: %s" % instruction
376                                reponse = 'unrecognized instruction'
377
378
379                if response:
380                        d.callback(response)
381
382                return d
383
384
385        ##################################################################
386
387        #def process_component_response(self, result, instruction):
388
389                #result, component = result[0], result[1]
390
391                #if result == 'OK':
392
393                        #self.log.debug('%s responded OK' % component['type'])
394                        #if self.DEBUG:
395                                #print '%s responded OK' % component['type']
396
397
398                #elif result == 'FAILED_TO_CONNECT' or result == 'NO_REPLY':
399
400                        #self.log.error('%s responded %s' % (component['type'], result))
401                        #if self.DEBUG:
402                                #print '%s responded %s' % (component['type'], result)
403
404                        #if instruction['command'] == 'duration_expire':
405                                ## not sure what else to do here, since duration expire is meant to make the browser go away
406                                ## if it is already gone, no real point in bringing it back?
407                                #self.log.debug("Failed to connect for duration_expire... well whatever then.")
408                                #if self.DEBUG:
409                                        #print "Failed to connect for duration_expire... well whatever then."
410
411                        #elif instruction['command'] == 'load_url':
412                                #self.log.error("Failed to connect for load_url, restarting the web_browser.")
413                                #if self.DEBUG:
414                                        #print "Failed to connect for load_url, restarting the web_browser."
415                                #self.restart_component(component[pid])
416
417                #else:
418                        #self.log.error("%s" % result)
419                        #if self.DEBUG:
420                                #print "%s" % result
421
422
423        ##################################################################
424
425        #def safe_component(self, component):
426
427                ## remove volatile data from a component so it can be safely passed through pickle
428               
429                #tcomp = component.copy()
430                #tcomp['callback'] = None
431                #tcomp['autobit'] = None
432               
433                #return tcomp
434
435
436        ##################################################################
437
438        #def restart_component(self, pid):
439
440                #if pid in self.registry['components']:
441                        #try:
442                                #os.kill(pid, signal.SIGKILL)
443                                #self.log.debug("Killed component %s" % pid)
444                                #if self.DEBUG:
445                                        #print "Killed component %s" % pid
446                                #return True
447                        #except:
448                                #self.log.error("Failed to kill component %s" % pid)
449                                #if self.DEBUG:
450                                        #print "Failed to kill component %s" % pid
451                                #return False
452
453
454        ##################################################################
455
456        def process_connection_lost(self, instruction):
457
458                if not instruction:
459
460                        self.log.debug("Connection lost with no instruction?")
461                        if self.DEBUG:
462                                print "Connection lost with no instruction?"
463                        return
464
465                #else:
466               
467                        #if instruction['command'] == 'load_url':
468                       
469                                #found_component = False
470                                #information = instruction['information']
471
472                                #for each in self.registry['components']:
473
474                                        #component = self.registry['components'][each]
475
476                                        ## should only ever be 1 of each type of component per window_id
477                                        #if component['type'] == information['type'] and \
478                                           #component['window_id'] == information['window_id']:
479
480                                                #found_component = True
481
482                                                #component['active'] = False
483                                                #component['last_active'] = time.time()
484
485                                                #component['source'] = 'MCP'
486                                                #component['target'] = component['type']
487
488                                                #instruction['command'] = 'duration_expire'
489                                                #instruction['information'] = None
490
491                                                #dw = self.csc.send_instruction(instruction, component=component)
492
493                                                #dw.addCallback(self.process_component_response, instruction)
494                                               
495                                                #break
496
497                                #if not found_component:
498
499                                        #self.log.debug("Connection lost for a non-existent component? Weird.")
500                                        #if self.DEBUG:
501                                                #print "Connection lost for a non-existent component? Weird."
502
503
504        ##################################################################
505
506        #def stop_oldest_component(self):
507                ## return True if a component can be stopped
508                #oldest = {'last_active': time.time()}
509                #for each in self.registry['components']:
510                        #component = self.registry['components'][each]
511                       
512                        #if not component['active'] and \
513                                        #component['last_active'] < oldest['last_active']:
514                                #oldest = component
515
516                #if 'pid' in oldest:
517                        ## in this case restart just means kill since the component is not currently active
518                        #return self.restart_component(oldest['pid'])
519
520                #return False
521
522
523        ##################################################################
524
525        #def spawn_new_component(self, instruction, d):
526
527                #if len(self.registry['components']) >= MAX_COMPONENTS and \
528                                #not self.stop_oldest_component():
529                        #self.log.error("Max components exceeded, not spawning any new ones.")
530                        #if self.DEBUG:
531                                #print "Max components exceeded, not spawning any new ones."
532                        #return
533
534                #if instruction['command'] == 'load_url':
535
536                        #information = instruction['information']
537
538##                      command = '/usr/bin/screen -S web_browser ' + \
539##                                              '%s %i %i %i %i %i %i %i %i %i %s' % \
540                        #command = '%s %i %i %i %i %i %i %i %i %i %i %s' % \
541                                                #('/usr/bin/puzzlebox_web_browser.py', \
542                                                #information['window_id'], \
543                                                #information['display_pos_x'], \
544                                                #information['display_pos_y'], \
545                                                #information['window_size_x'], \
546                                                #information['window_size_y'], \
547                                                #information['display_fullscreen'], \
548                                                #information['refresh_interval'], \
549                                                #information['duration'], \
550                                                #information['hide_on_duration_expire'], \
551                                                #information['autobit_white_flash_fix'], \
552                                                #information['url'])
553
554                        #args = command.strip().split()
555                        #file = args[0]
556
557                        #self.log.debug("Spawning process from command: [%s]" % command)
558                        #if self.DEBUG:
559                                #print "Spawning process from command: [%s]" % command
560
561                        #pp = puzzlebox_mcp_browser_pp(self.log, instruction, self.registry, \
562                                                #self.spawn_new_component, self.restart_component, d, self.DEBUG)
563                        #process = reactor.spawnProcess(pp, file, args, os.environ, usePTY=True)
564
565                #else:
566                        #self.log.debug("Not spawning process because command is '%s'" % instruction['command'])
567                        #if self.DEBUG:
568                                #print "Not spawning process because command is '%s'" % instruction['command']
569
570
571        ##################################################################
572
573        #def spawn_new_process(self, instruction, d):
574
575                #process = reactor.spawnProcess(pp, file, args, os.environ, usePTY=True)
576
577                #if len(self.registry['components']) >= MAX_COMPONENTS and \
578                                #not self.stop_oldest_component():
579                        #self.log.error("Max components exceeded, not spawning any new ones.")
580                        #if self.DEBUG:
581                                #print "Max components exceeded, not spawning any new ones."
582                        #return
583
584                #if instruction['command'] == 'load_url':
585
586                        #information = instruction['information']
587
588##                      command = '/usr/bin/screen -S web_browser ' + \
589##                                              '%s %i %i %i %i %i %i %i %i %i %s' % \
590                        #command = '%s %i %i %i %i %i %i %i %i %i %i %s' % \
591                                                #('/usr/bin/puzzlebox_web_browser.py', \
592                                                #information['window_id'], \
593                                                #information['display_pos_x'], \
594                                                #information['display_pos_y'], \
595                                                #information['window_size_x'], \
596                                                #information['window_size_y'], \
597                                                #information['display_fullscreen'], \
598                                                #information['refresh_interval'], \
599                                                #information['duration'], \
600                                                #information['hide_on_duration_expire'], \
601                                                #information['autobit_white_flash_fix'], \
602                                                #information['url'])
603
604                        #args = command.strip().split()
605                        #file = args[0]
606
607                        #self.log.debug("Spawning process from command: [%s]" % command)
608                        #if self.DEBUG:
609                                #print "Spawning process from command: [%s]" % command
610
611                        #pp = puzzlebox_mcp_browser_pp(self.log, instruction, self.registry, \
612                                                #self.spawn_new_component, self.restart_component, d, self.DEBUG)
613                        #process = reactor.spawnProcess(pp, file, args, os.environ, usePTY=True)
614
615                #else:
616                        #self.log.debug("Not spawning process because command is '%s'" % instruction['command'])
617                        #if self.DEBUG:
618                                #print "Not spawning process because command is '%s'" % instruction['command'
619
620
621#####################################################################
622# Process Protocol
623#####################################################################
624
625#class puzzlebox_mcp_browser_pp(protocol.ProcessProtocol):
626
627        #def __init__(self, log, \
628                          #instruction, \
629                          #registry, \
630                          #spawn_new_component, \
631                          #restart_component, \
632                          #d, \
633                          #DEBUG=DEBUG):
634               
635                #self.log = log
636                #self.instruction = instruction
637                #self.information = self.instruction['information']
638                #self.registry = registry
639                #self.spawn_new_component = spawn_new_component
640                #self.restart_component = restart_component
641                #self.d = d
642                #self.DEBUG = DEBUG
643
644
645        ##################################################################
646
647        #def connectionMade(self):
648                #self.pid = self.transport.pid
649                #self.registry['components'][self.pid] = self.instruction['information']
650                #self.registry['components'][self.pid]['pid'] = self.pid
651                #self.registry['components'][self.pid]['active'] = True
652                #self.registry['components'][self.pid]['callback'] = self.d
653
654                #if int(self.information['enable_autobit']) == 1:
655                        #self.log.debug("Window %i started with autobit enabled." % self.information['window_id'])
656                        #if self.DEBUG:
657                                #print "Window %i started with autobit enabled." % self.information['window_id']
658                        #self.registry['components'][self.pid]['autobit'] = \
659                                #reactor.callLater(AUTOBIT_TIMEOUT, self.restart_component, self.pid)
660
661                #self.log.debug("Sub-process started with pid %i" % self.pid)
662                #if self.DEBUG:
663                        #print "Sub-process started with pid %i" % self.pid
664
665
666        ##################################################################
667
668        #def childDataReceived(self, childFD, data):
669       
670                ## attempt to log any errors... might not work for exceptions
671                #self.log.error(data)
672               
673                #if self.DEBUG:
674                        #print data
675
676
677        ##################################################################
678
679        #def processEnded(self, status_object):
680
681                #self.log.debug("Sub-process with pid %i ended" % self.pid)
682                #if self.DEBUG:
683                        #print "Sub-process with pid %i ended" % self.pid
684
685                ## this is kind of unnecessary as i could just use
686                ## component = self.instruction['information']
687                ## but for now i want to make sure it still exists in registry too
688                #if self.pid in self.registry['components']:
689
690                        #component = self.registry['components'][self.pid]
691
692                        #if component['active']:
693                                #self.log.debug("Component is still active, respawning...")
694                                #if self.DEBUG:
695                                        #print "Component is still active, respawning..."
696##                              for key in self.instruction['information']:
697##                                      self.instruction['information'][key] = component[key]
698                                #self.spawn_new_component(self.instruction, component['callback'])
699                        #else:
700                                #self.log.debug("Component inactive, not respawning.")
701                                #if self.DEBUG:
702                                        #print "Component inactive, not respawning."
703
704                        ## clean up the old component data in either case
705                        ## and remove gtkmoz profile
706                        #del(self.registry['components'][self.pid])
707                        #profile_dir = os.path.join(GTKMOZ_PROFILE_DIR, "%s" % self.pid)
708                        #if os.path.exists(profile_dir):
709                                #command = 'rm -rf %s' % profile_dir
710                                #self.log.debug("Executing command: [%s]" % command)
711                                #if self.DEBUG:
712                                        #print "Executing command: [%s]" % command
713                                #os.system(command)
714
715                #else:
716                        #self.log.error("Could not find component associated with this sub-process. Odd.")
717                        #if self.DEBUG:
718                                #print "Could not find component associated with this sub-process. Odd."
719
720
721#####################################################################
722# Protocol
723#####################################################################
724
725class puzzlebox_master_control_server_protocol(protocol.Protocol):
726
727        def __init__(self):
728                self.instruction = {}
729                self.data_chunk = ""
730
731
732        ##################################################################
733
734        def dataReceived(self, data):
735
736                self.data_chunk += data
737                try:
738                        self.instruction = pickle.loads(self.data_chunk)
739                except Exception, e:
740                        self.factory.log.error("Partial data received (or error: %s)." % e)
741                else:
742                        self.data_chunk = ""
743
744                        d = self.factory.process_instruction(self.instruction.copy())
745                        d.addCallback(self.send_response)
746
747
748        ##################################################################
749
750        def send_response(self, response):
751
752                #if response == "browser exit":
753                        #self.instruction['command'] = response
754
755                response = pickle.dumps(response)
756
757                self.transport.write(response)
758
759
760        ##################################################################
761
762        def connectionLost(self, reason):
763       
764                self.factory.process_connection_lost(self.instruction)
765
766
767#####################################################################
768# Main
769#####################################################################
770
771if __name__ == '__main__':
772
773        #log = puzzlebox_logger.puzzlebox_logger(logfile='master_control')
774        log = None
775
776        # Collect default settings and command line parameters
777        server_host = SERVER_HOST
778        server_port = SERVER_PORT
779       
780        for each in sys.argv:
781               
782                if each.startswith("--host="):
783                        server_host = each[ len("--host="): ]
784                if each.startswith("--port="):
785                        server_port = each[ len("--port="): ]
786
787        mcp = puzzlebox_master_control(log, DEBUG)
788        reactor.listenTCP(port=server_port, factory=mcp, interface=server_host)
789        reactor.run()
790
Note: See TracBrowser for help on using the repository browser.