def start(self): self.running = True conn_listener = Listener(self.index, self.port, self.clock) conn_listener.start() for i in range(constants.EVENTS_COUNT): if not self.running: break sleep(min(random.random() + 0.5, 1)) self.clock.increment() if random.random() > self.chance: # local self.logger.info(f"{perf_counter_ns() // 1000} {self.index} {self.clock.get()}{self.index} l") else: # remote idx, node = self.get_node() try: self.send_message(idx, node) except SocketTimeout: print( f"""Error: Timeout sending message to node {idx} ({node["host"]}:{node["port"]})""" ) break conn_listener.stop()
class Accompanist: def __init__(self): self.queue_in = Queue() self.queue_out = Queue() self.predictor_queue = Queue() self.running = Value('i', False) self.tempo = Value('f', default_tempo) self.deadline = Value('f', 0) self.player = Player(self.queue_out, self.running, self.tempo, self.deadline) self.predictor = ChordPredictor(self.queue_in, self.queue_out) self.listener = Listener(self.queue_in, self.running, self.tempo, self.deadline) def run(self): self.running.value = True self.listener.run() self.player.run() self.predictor.run() def stop(self): self.running.value = False self.player.stop() self.listener.stop() self.predictor.stop() self.queue_in = Queue() self.queue_out = Queue() def set_tempo(self, tempo=default_tempo): self.tempo.value = tempo def set_deadline(self, deadline=0): self.deadline.value = deadline player = None listener = None predictor = None queue_in = None queue_out = None running = None tempo = None deadline = None process = None
def EmonHub(): # Load settings settings = ConfigObj("emonhub.conf", file_error=True) # Create queue for node packets queue = Queue.Queue(0) # Create and start serial listener a = Listener(queue, settings) a.start() # Create and start http dispatcher b = Dispatcher(queue, settings) b.start() while 1: try: time.sleep(0.1) except KeyboardInterrupt: print "Stopping threads" a.stop = True b.stop = True break
def EmonHub(): # Load settings settings = ConfigObj("emonhub.conf", file_error=True) # Create queue for node packets queue = Queue.Queue(0) # Create and start serial listener a = Listener(queue,settings) a.start() # Create and start http dispatcher b = Dispatcher(queue,settings) b.start() while 1: try: time.sleep(0.1) except KeyboardInterrupt: print "Stopping threads" a.stop = True b.stop = True break
import os import time import logging from listener import Listener, worker if __name__ == '__main__': logging.basicConfig(filename="log.txt", level=logging.DEBUG, format='%(asctime)s: %(message)s') os.makedirs('screenshots', exist_ok=True) listener = Listener() listener.start() time.sleep(5) listener.stop() worker.stop()
class MessageHandler(threading.Thread): def __init__(self, peer, messages, isVerbose=True, listening_mode=False, msgs_freq=1, wait_time=20, port=2123): threading.Thread.__init__(self) self.sock = None self.TAG_NAME = 'GTPV2 SERVER_LISTENER' self.peer = peer self.is_verbose = isVerbose self.messages = messages self.is_listening = listening_mode self.gtp_port = port self.sock = socket(AF_INET, SOCK_DGRAM) self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.sock.bind(('0.0.0.0', self.gtp_port)) self.msgs_freq = msgs_freq self.wait_time = wait_time self.listener = None self.sender = None signal.signal(signal.SIGQUIT, self.stop) signal.signal(signal.SIGINT, self.stop) signal.signal(signal.SIGTERM, self.stop) ## ## @brief Determines if the thread is running ## ## @param self refers to the class itself ## ## @return True if running, False otherwise. ## def isRunning(self): return self.is_running ## ## @brief Starts the execution of the thread ## ## @param self refers to the class itself ## def run(self): self.is_running = True if self.is_listening: if self.is_verbose: print "\033[34m[*]\033[0m starting the listener ...." ''' START Listener ''' self.listener = Listener(open_sock=self.sock, isVerbose=self.is_verbose) self.listener.daemon = True self.listener.start() if self.is_verbose: print "\033[34m[*]\033[0m starting the sender ...." ''' START Sender''' self.sender = Sender(sock=self.sock, messages=self.messages, peers=self.peer, isVerbose=self.is_verbose, msg_freq=self.msgs_freq, wait_time=self.wait_time, gtp_port=self.gtp_port) self.sender_daemon = True self.sender.start() self.sender.join() time.sleep(5) self.stop() ## ## @brief Stops the execution of the thread ## ## @param self refers to the class itself ## def stop(self): if self.sender: self.sender.stop() if self.listener: self.listener.stop() if self.sock: self.sock.close() self.is_running = False if self.is_verbose: print "%s: Stopped" % (self.TAG_NAME)
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys import logging.config from config import config from listener import Listener logging.filename = 'logs/{}_log'.format(config['server_name']) logging.config.fileConfig('logging.ini') if __name__ == '__main__': if '-h' in sys.argv or '--help' in sys.argv: print('Run this file and as the first argument send name of the config' 'file. For example: python main.py config.ini') if len(sys.argv) < 2: logging.error('Please specify config name.') sys.exit(1) listener = Listener() try: listener.start() except KeyboardInterrupt: logging.info('KeyboardInterrupt. Exiting...') listener.stop() listener.join()
current_path = garbage_3 elif (temp_job == "garbage" and temp_room == "four"): current_path = garbage_4 elif (temp_job == "medical" and temp_room == "one"): current_path = medical_1 elif (temp_job == "medical" and temp_room == "two"): current_path = medical_2 elif (temp_job == "medical" and temp_room == "three"): current_path = medical_3 elif (temp_job == "medical" and temp_room == "four"): current_path = medical_4 waypoint_x = current_path[path_counter][0] #assign waypoint waypoint_y = current_path[path_counter][1] listener.stop = True state = "Moving" dx = waypoint_x - translation[0] dy = waypoint_y - translation[1] xr = math.cos(robot_theta) * dx + math.sin(robot_theta) * dy yr = math.cos(robot_theta) * dy - math.sin(robot_theta) * dx p = math.hypot(xr, yr) q = math.atan2(yr, xr) if p < 0.1 and state == "Moving": ## arrived to waypoint path_counter = path_counter + 1 #select next waypoint from path waypoint_x = current_path[path_counter][0] waypoint_y = current_path[path_counter][1] if (state == "Moving"):
motor_command=Twist() temp_room = listener.room #voice mistake corrections temp_job=listener.job if temp_room == '1' or temp_room == 'wall': temp_room = 'one' if temp_room == '2' or temp_room == 'to': temp_room = 'two' if temp_room == '3'or temp_room == 'tree': temp_room = 'three' if temp_room == '4'or temp_room == 'for': temp_room = 'four' #print("Temp room:",temp_room," temp job",temp_job) if (temp_room=="one" or temp_room =="two" or temp_room =="three" or temp_room =="four") and (temp_job=="garbage" or temp_job=="medical") and (state =="Listening"): listener.stop = True if(temp_job=="garbage" and temp_room =="one"): current_path = garbage_1 elif(temp_job=="garbage" and temp_room =="two"): current_path = garbage_2 elif(temp_job=="garbage" and temp_room =="three"): current_path = garbage_3 elif(temp_job=="garbage" and temp_room =="four"): current_path = garbage_4 elif(temp_job=="medical" and temp_room =="one"): current_path = medical_1 elif(temp_job=="medical" and temp_room =="two"): current_path = medical_2 elif(temp_job=="medical" and temp_room =="three"): current_path = medical_3 elif(temp_job=="medical" and temp_room =="four"):
parser = argparse.ArgumentParser() parser.add_argument("--port", type=int, help="The port for the server run locally", default=8000) parser.add_argument("--sensitivity", type=float, help="Model sensitivity", default=0.35) parser.add_argument("--speed_factor", type=float, help="Keyboard speed factor playback", default=0) return parser.parse_args(argv) args = parse_argument(sys.argv[1:]) if (len(database.get_all()) > 0): listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor) listenter.start() app.run('0.0.0.0', args.port) sound_recorder.end() try: listenter.stop() except: pass database.close()
class Trollduction(object): '''Trollduction class for easy generation chain setup ''' def __init__(self, td_config_file=None): '''Init Trollduction instance ''' # configuration file for the Trollduction instance self.td_config_file = td_config_file # read everything from the Trollduction config file if td_config_file is not None: self.update_tdconfig() # otherwise set empty placeholders else: self.product_list_file = None self.area_def_names = None # product list is a dict with area def names as keys and # product names as value arrays # eg. {'euro4km': ['green_snow', 'overview']} self.product_list = None self.listener = None self.listener_thread = None self.listener_parent_conn = None self.listener_child_conn = None # self.publisher = None # self.logger = None self.image_output_dir = None # single swath or MSG disc: 'single' # multiple granules or GEO images: 'multi' self.production_type = None # self.pool = None # self.pool_size = None # self.loaded_channels = [] def update_tdconfig(self, fname=None): '''Read Trollduction master configuration file and update the class fields. ''' # TODO: add checks what has changed # TODO: restart relevant parts if fname is not None: self.td_config_file = fname td_config = read_config_file(fname) elif self.td_config_file is not None: td_config = read_config_file(self.td_config_file) else: return keys = td_config.keys() if 'listener' in keys: # TODO: check if changed self.init_listener(td_config['listener']['address_list'], td_config['listener']['msg_type_list']) self.restart_listener() # if 'parallel' in keys: # if 'num_processes' in keys: # # TODO: check if changed # self.init_pool(num_processes=td_config['num_processes']) # else: # self.init_pool() if '' in keys: # TODO: check if changed pass def update_product_config(self, fname=None): '''Read area definition names and associated product names from a file and update the class member values. ''' if fname is not None: self.product_config_file = fname product_config = read_config_file(fname) elif self.product_config_file is not None: product_config = read_config_file(self.product_config_file) else: product_config = None # add checks, or do we just assume the config to be valid at # this point? self.product_config = product_config def read_config_file(self, fname=None): '''Read config file to dictionary. ''' # TODO: check validity # TODO: read config, parse to dict, logging if fname is None: return None else: # TODO: read config pass def init_listener(self, address_list, msg_type_list): '''Initialise listener that receives messages about new files to be processed, etc. ''' # Create Pipe connection parent_conn, child_conn = Pipe() self.listener_parent_conn = parent_conn self.listener_child_conn = child_conn # Create a Listener instance self.listener = Listener(address_list=address_list, msg_type_list=msg_type_list, pipe=self.listener_child_conn) #self.listener.add_address_list(address_list) #self.listener.type_list = msg_type_list # Create subscriber #self.listener.create_subscriber() print "Listener initialised" def start_listener(self): '''Start Listener instance into a new daemonized thread. ''' self.listener_thread = Thread(target=self.listener.run) self.listener_thread.setDaemon(True) self.listener_thread.start() print "Listener started" def restart_listener(self): '''Restart listener ''' self.listener.stop() self.init_listener() self.start_listener() def cleanup(self): '''Cleanup everything before shutdown ''' # TODO: add cleanup, close threads, and stuff pass def shutdown(self): '''Shutdown trollduction ''' self.cleanup() sys.exit() def run_single(self): '''Run image production without threading. ''' # TODO: Get relevant preprocessing function for this # production chain type: single/multi, or # swath, geo, granule, global_polar, global_geo, global_mixed # That is, gatherer for the multi-image/multi-granule types # preproc_func = getattr(preprocessing, self.production_type) while True: # wait for new messages msg = self.listener_parent_conn.recv() print msg # shutdown trollduction if msg.subject == '/StopTrollduction': self.cleanup() break #self.shutdown() # update trollduction config elif msg.subject == '/NewTrollductionConfig': self.update_td_config(msg.data) # update product lists elif msg.subject == '/NewProductConfig': self.udpate_product_config(msg.data) # process new file elif '/NewFileArrived' in msg.subject: self.time_slot = dt.datetime(msg.data['year'], msg.data['month'], msg.data['day'], msg.data['hour'], msg.data['minute']) # orbit is empty string for meteosat, change it to None if msg.data['orbit'] == '': msg.data['orbit'] = None t1a = time.time() self.global_data = GF.create_scene(satname=str(msg.data['satellite']), satnumber=str(msg.data['satnumber']), instrument=str(msg.data['instrument']), time_slot=self.time_slot, orbit=str(msg.data['orbit'])) # Find maximum extent that is needed for all the # products to be made. self.get_maximum_extent() # Make images for each area for area_name in self.area_def_names: t1b = time.time() # Check which channels are needed. Unload # unnecessary channels and load those that are not # already available. self.load_unload_channels(self.product_list[area_name]) # TODO: or something # reproject to local domain self.local_data = self.global_data.project(area_name, mode='nearest') print "Data reprojected for area:", area_name # Draw requested images for this area. self.draw_images(area_name) print "Single area time elapsed time:", time.time()-t1b, 's' self.local_data = None self.global_data = None # self.loaded_channels = [] print "Full time elapsed time:", time.time()-t1a, 's' else: # Unhandled message types end up here # No need to log these? pass def get_maximum_extent(self): '''Get maximum extend needed to produce all defined areas. ''' self.maximum_area_extent = [None, None, None, None] for area in self.area_def_names: extent = get_area_def(area) if self.maximum_area_extent[0] is None: self.maximum_area_extent = list(extent.area_extent) else: if self.maximum_area_extent[0] > extent.area_extent[0]: self.maximum_area_extent[0] = extent.area_extent[0] if self.maximum_area_extent[1] > extent.area_extent[1]: self.maximum_area_extent[1] = extent.area_extent[1] if self.maximum_area_extent[2] < extent.area_extent[2]: self.maximum_area_extent[2] = extent.area_extent[2] if self.maximum_area_extent[3] < extent.area_extent[3]: self.maximum_area_extent[3] = extent.area_extent[3] def load_unload_channels(self, product_list): '''Load channels that are required for the given list of products. Unload channels that are unnecessary. ''' ch_names = [] wavelengths = [] for ch in self.global_data.channels: ch_names.append(ch.name) wavelengths.append(ch.wavelength_range) # loaded = self.global_data.loaded_channels() # for l in loaded: # print l.wavelength_range required = [] to_load = [] to_unload = [] for product in product_list: req = eval('self.global_data.image.'+product+'.prerequisites') for r in req: # get channel name for i in range(len(wavelengths)): if r >= wavelengths[i][0] and r <= wavelengths[i][-1]: n = ch_names[i] break if n not in required: required.append(n) self.global_data.load(required, self.maximum_area_extent) # At this time we only load all the required channels with # maximum extent. The code below could be tuned to also unload # extra channels. ''' if n not in to_load and n not in self.loaded_channels: to_load.append(n) for c in self.loaded_channels: if c not in required: to_unload.append(c) self.loaded_channels.remove(c) if len(to_load) > 0: print "load channels:", to_load self.global_data.load(to_load) if len(self.loaded_channels) == 0: self.loaded_channels = to_load if len(to_unload) > 0: print "unload channels:", to_unload self.global_data.unload(to_unload) ''' def draw_images(self, area_name): '''Generate images from local data using given area name and product definitions. ''' # Create images for each color composite for product in self.product_list[area_name]: # Parse image filename fname = self.image_output_dir + '/' + self.image_filename_template fname = fname.replace('%Y', '%04d' % self.time_slot.year) fname = fname.replace('%m', '%02d' % self.time_slot.month) fname = fname.replace('%d', '%02d' % self.time_slot.day) fname = fname.replace('%H', '%02d' % self.time_slot.hour) fname = fname.replace('%M', '%02d' % self.time_slot.minute) fname = fname.replace('%(area)', area_name) fname = fname.replace('%(composite)', product) fname = fname.replace('%(ending)', 'png') try: # Check if this combination is defined func = getattr(self.local_data.image, product) img = func() img.save(fname) print "Image", fname, "saved." # TODO: log succesful production # TODO: publish message except AttributeError: # TODO: log incorrect product name print "Incorrect product name:", product, "for area", area_name except KeyError: # TODO: log missing channel print "Missing channel on", product, "for area", area_name except: # TODO: log other errors print "Undefined error on", product, "for area", area_name
class Server: setup_cache_contents = {} def read_setup_cache(): """Static function to setup cache""" cache_file = '' try: cache_file = open(setup_cache, 'r') except IOError: cache_file = open(setup_cache, 'w') cache_file.close() cache_file = open(setup_cache, 'r') contents = cache_file.readlines() for server in contents: Server.setup_cache_contents[server.strip()] = True cache_file.close() def __init__(self, ip, binary, name="noname", port=22): self.name = name self.ip = ip self.port = port listener_port = random.randint(20000, 25000) self.listener = Listener(name, ip, listener_port, self) self.binary = Binary(binary, self) def __repr__(self): return '{} at {}:{}'.format(self.name, self.ip, self.port) def __str__(self): return self.__repr__() def run_proc(self, args): if self.ip in ["127.0.0.1", "0.0.0.0", "localhost"]: try: ex = subprocess.call(["bash", "-c", " ".join(args)]) return ex except KeyboardInterrupt: print("Process stopped by user") return 0 else: return subprocess.call(["ssh", self.ip, "-t", " ".join(args)]) def copy_file(self, file_path_local, file_path_server, file_name_server): return subprocess.call(["scp", file_path_local, "{}:{}/{}".format(self.ip, file_path_server, file_name_server)]) def copy_executable(self, file_path_local, file_location_server, file_name_server): ex = self.copy_file(file_path_local, file_location_server, file_name_server) if ex != 0: return ex return self.run_proc(["chmod", "+x", "{}/{}".format( file_location_server, file_name_server)]) def tail_file(self, file_path_server): try: self.run_proc(["tail", "-f", file_path_server]) finally: pass def setup_ssh(self): ex = subprocess.call(["ssh-copy-id", self.ip]) if ex != 0: sys.exit("Error while setting up SSH login on server {}" .format(self.ip)) def setup_folder(self): ex = self.run_proc(["mkdir", "-p", path_on_servers]) if ex != 0: sys.exit("Error while setting up main data folder on {}" .format(self.ip)) def clear_logs(self): ex = self.run_proc(["bash", "-c", "'rm {}/.*logs'".format(path_on_servers)]) if ex != 0: sys.exit("Error while clearing logs on {}" .format(self.ip)) def finish_setup(self): with open(setup_cache, "a") as f: f.write("{}\n".format(self.ip)) def setup_volatile(self): self.binary.setup() self.listener.setup() def setup(self, copy_anyway=False): if len(Server.setup_cache_contents) == 0: Server.read_setup_cache() if self.ip in Server.setup_cache_contents: if copy_anyway: self.setup_volatile() return print("Setting up server {}".format(self.ip)) self.setup_ssh() self.setup_folder() self.clear_logs() self.finish_setup() print("Finished setting up server {}".format(self.ip)) def run(self): self.setup_volatile() self.listener.run() def shutdown(self): self.listener.stop()
class Trollduction(object): '''Trollduction class for easy generation chain setup ''' def __init__(self, td_config_file=None): '''Init Trollduction instance ''' # configuration file for the Trollduction instance self.td_config_file = td_config_file # read everything from the Trollduction config file if td_config_file is not None: self.update_tdconfig() # otherwise set empty placeholders else: self.product_list_file = None self.area_def_names = None # product list is a dict with area def names as keys and # product names as value arrays # eg. {'euro4km': ['green_snow', 'overview']} self.product_list = None self.listener = None self.listener_thread = None self.listener_parent_conn = None self.listener_child_conn = None # self.publisher = None # self.logger = None self.image_output_dir = None # single swath or MSG disc: 'single' # multiple granules or GEO images: 'multi' self.production_type = None # self.pool = None # self.pool_size = None # self.loaded_channels = [] def update_tdconfig(self, fname=None): '''Read Trollduction master configuration file and update the class fields. ''' # TODO: add checks what has changed # TODO: restart relevant parts if fname is not None: self.td_config_file = fname td_config = read_config_file(fname) elif self.td_config_file is not None: td_config = read_config_file(self.td_config_file) else: return keys = td_config.keys() if 'listener' in keys: # TODO: check if changed self.init_listener(td_config['listener']['address_list'], td_config['listener']['msg_type_list']) self.restart_listener() # if 'parallel' in keys: # if 'num_processes' in keys: # # TODO: check if changed # self.init_pool(num_processes=td_config['num_processes']) # else: # self.init_pool() if '' in keys: # TODO: check if changed pass def update_product_config(self, fname=None): '''Read area definition names and associated product names from a file and update the class member values. ''' if fname is not None: self.product_config_file = fname product_config = read_config_file(fname) elif self.product_config_file is not None: product_config = read_config_file(self.product_config_file) else: product_config = None # add checks, or do we just assume the config to be valid at # this point? self.product_config = product_config def read_config_file(self, fname=None): '''Read config file to dictionary. ''' # TODO: check validity # TODO: read config, parse to dict, logging if fname is None: return None else: # TODO: read config pass def init_listener(self, address_list, msg_type_list): '''Initialise listener that receives messages about new files to be processed, etc. ''' # Create Pipe connection parent_conn, child_conn = Pipe() self.listener_parent_conn = parent_conn self.listener_child_conn = child_conn # Create a Listener instance self.listener = Listener(address_list=address_list, msg_type_list=msg_type_list, pipe=self.listener_child_conn) #self.listener.add_address_list(address_list) #self.listener.type_list = msg_type_list # Create subscriber #self.listener.create_subscriber() print "Listener initialised" def start_listener(self): '''Start Listener instance into a new daemonized thread. ''' self.listener_thread = Thread(target=self.listener.run) self.listener_thread.setDaemon(True) self.listener_thread.start() print "Listener started" def restart_listener(self): '''Restart listener ''' self.listener.stop() self.init_listener() self.start_listener() def cleanup(self): '''Cleanup everything before shutdown ''' # TODO: add cleanup, close threads, and stuff pass def shutdown(self): '''Shutdown trollduction ''' self.cleanup() sys.exit() def run_single(self): '''Run image production without threading. ''' # TODO: Get relevant preprocessing function for this # production chain type: single/multi, or # swath, geo, granule, global_polar, global_geo, global_mixed # That is, gatherer for the multi-image/multi-granule types # preproc_func = getattr(preprocessing, self.production_type) while True: # wait for new messages msg = self.listener_parent_conn.recv() print msg # shutdown trollduction if msg.subject == '/StopTrollduction': self.cleanup() break #self.shutdown() # update trollduction config elif msg.subject == '/NewTrollductionConfig': self.update_td_config(msg.data) # update product lists elif msg.subject == '/NewProductConfig': self.udpate_product_config(msg.data) # process new file elif '/NewFileArrived' in msg.subject: self.time_slot = dt.datetime(msg.data['year'], msg.data['month'], msg.data['day'], msg.data['hour'], msg.data['minute']) # orbit is empty string for meteosat, change it to None if msg.data['orbit'] == '': msg.data['orbit'] = None t1a = time.time() self.global_data = GF.create_scene( satname=str(msg.data['satellite']), satnumber=str(msg.data['satnumber']), instrument=str(msg.data['instrument']), time_slot=self.time_slot, orbit=str(msg.data['orbit'])) # Find maximum extent that is needed for all the # products to be made. self.get_maximum_extent() # Make images for each area for area_name in self.area_def_names: t1b = time.time() # Check which channels are needed. Unload # unnecessary channels and load those that are not # already available. self.load_unload_channels(self.product_list[area_name]) # TODO: or something # reproject to local domain self.local_data = self.global_data.project(area_name, mode='nearest') print "Data reprojected for area:", area_name # Draw requested images for this area. self.draw_images(area_name) print "Single area time elapsed time:", time.time( ) - t1b, 's' self.local_data = None self.global_data = None # self.loaded_channels = [] print "Full time elapsed time:", time.time() - t1a, 's' else: # Unhandled message types end up here # No need to log these? pass def get_maximum_extent(self): '''Get maximum extend needed to produce all defined areas. ''' self.maximum_area_extent = [None, None, None, None] for area in self.area_def_names: extent = get_area_def(area) if self.maximum_area_extent[0] is None: self.maximum_area_extent = list(extent.area_extent) else: if self.maximum_area_extent[0] > extent.area_extent[0]: self.maximum_area_extent[0] = extent.area_extent[0] if self.maximum_area_extent[1] > extent.area_extent[1]: self.maximum_area_extent[1] = extent.area_extent[1] if self.maximum_area_extent[2] < extent.area_extent[2]: self.maximum_area_extent[2] = extent.area_extent[2] if self.maximum_area_extent[3] < extent.area_extent[3]: self.maximum_area_extent[3] = extent.area_extent[3] def load_unload_channels(self, product_list): '''Load channels that are required for the given list of products. Unload channels that are unnecessary. ''' ch_names = [] wavelengths = [] for ch in self.global_data.channels: ch_names.append(ch.name) wavelengths.append(ch.wavelength_range) # loaded = self.global_data.loaded_channels() # for l in loaded: # print l.wavelength_range required = [] to_load = [] to_unload = [] for product in product_list: req = eval('self.global_data.image.' + product + '.prerequisites') for r in req: # get channel name for i in range(len(wavelengths)): if r >= wavelengths[i][0] and r <= wavelengths[i][-1]: n = ch_names[i] break if n not in required: required.append(n) self.global_data.load(required, self.maximum_area_extent) # At this time we only load all the required channels with # maximum extent. The code below could be tuned to also unload # extra channels. ''' if n not in to_load and n not in self.loaded_channels: to_load.append(n) for c in self.loaded_channels: if c not in required: to_unload.append(c) self.loaded_channels.remove(c) if len(to_load) > 0: print "load channels:", to_load self.global_data.load(to_load) if len(self.loaded_channels) == 0: self.loaded_channels = to_load if len(to_unload) > 0: print "unload channels:", to_unload self.global_data.unload(to_unload) ''' def draw_images(self, area_name): '''Generate images from local data using given area name and product definitions. ''' # Create images for each color composite for product in self.product_list[area_name]: # Parse image filename fname = self.image_output_dir + '/' + self.image_filename_template fname = fname.replace('%Y', '%04d' % self.time_slot.year) fname = fname.replace('%m', '%02d' % self.time_slot.month) fname = fname.replace('%d', '%02d' % self.time_slot.day) fname = fname.replace('%H', '%02d' % self.time_slot.hour) fname = fname.replace('%M', '%02d' % self.time_slot.minute) fname = fname.replace('%(area)', area_name) fname = fname.replace('%(composite)', product) fname = fname.replace('%(ending)', 'png') try: # Check if this combination is defined func = getattr(self.local_data.image, product) img = func() img.save(fname) print "Image", fname, "saved." # TODO: log succesful production # TODO: publish message except AttributeError: # TODO: log incorrect product name print "Incorrect product name:", product, "for area", area_name except KeyError: # TODO: log missing channel print "Missing channel on", product, "for area", area_name except: # TODO: log other errors print "Undefined error on", product, "for area", area_name
class NetMgr(Mgr): def __init__(self, engine,localOptions): Mgr.__init__(self, engine) self.engine = engine self.networkingEnabled = localOptions.enableNetworking if self.networkingEnabled: self.server = localOptions.server else: self.server = False self.ip = localOptions.ip self.remainingIDs = [] self.timeToWaitForPlayers = 10 def initialize(self): pass def loadLevel(self): if self.networkingEnabled: self.broadcaster = Broadcaster() self.listener = Listener() self.listener.start() self.broadcaster.start() if self.server or not self.networkingEnabled: self.remainingIDs.append([1,""]) self.remainingIDs.append([2,""]) def releaseLevel(self): if self.networkingEnabled: self.listener.stop() self.broadcaster.stop() self.listener.join() self.broadcaster.join() def tick(self, dtime): if self.networkingEnabled: if dtime < 1 and self.timeToWaitForPlayers > 0: self.timeToWaitForPlayers -= dtime # check to see if all players are ready to start the race if self.timeToWaitForPlayers > 0 and self.engine.gameMgr.allPlayersReady == False: allReady = True for ent in self.engine.entMgr.entities: if not ent.isReady: allReady = False if len(self.engine.entMgr.entities) > 1: self.engine.gameMgr.allPlayersReady = allReady elif self.timeToWaitForPlayers <= 0: self.engine.gameMgr.allPlayersReady = True # get messages incoming = self.listener.getMessages() outgoingMsgs = [] for msgs in incoming: msgType, msg = messages.unpack(msgs) if msgType == const.STATUS: found = False # check to see if the status message is regarding a ship that is already created for ent in self.engine.entMgr.entities: if ent.shipId == msg.shipId: found = True # if it is, send updates to entity if found and msg.shipId != self.engine.entMgr.playerIndex: self.engine.entMgr.entities[msg.shipId].updateQueue.append(msg) # if it isn't, create that entity elif not found: ent = Spaceship("Ship" + str(msg.shipId),msg.shipId, self.engine,const.MESHES[msg.shipId]) ent.pos = self.engine.entMgr.nextPos self.engine.entMgr.nextPos.x += 40 self.engine.entMgr.entities.append(ent) # only process requests before game has started elif msgType == const.REQUEST and self.timeToWaitForPlayers > 0: for ID in self.remainingIDs: # if the id has not been issued already, or if the ID corresponds to a user who has been given an ID (but did not recieve their ID), send the ID if ID[1] == "" or ID[1] == msg.userName: outgoingMsgs.append(messages.pack(messages.InfoMessage(msg.userName,ID[0]),const.INFO)) ID[1] = msg.userName # only process info messages when this player has not been handed a playerIndex elif msgType == const.INFO and not self.server and self.engine.entMgr.playerIndex == -1: self.engine.entMgr.playerIndex = msg.shipId found = False for ent in self.engine.entMgr.entities: if ent.shipId == msg.shipId: found = True if not found: ent = Spaceship("Ship" + str(msg.shipId),msg.shipId, self.engine,const.MESHES[msg.shipId]) ent.pos = self.engine.entMgr.nextPos self.engine.entMgr.nextPos.x += 40 self.engine.entMgr.entities.append(ent) # if this player has not been handed a playerIndex, request one. if self.engine.entMgr.playerIndex == -1: outgoingMsgs.append(messages.pack(messages.RequestMessage(str(socket.gethostname())),const.REQUEST)) # if the player has been handed a playerIndex, send the status of your ship else: myId = self.engine.entMgr.playerIndex myEnt = self.engine.entMgr.entities[myId] outgoingMsgs.append(messages.pack(messages.StatusMessage(myId,myEnt.pos,myEnt.dir,myEnt.colVel,myEnt.speed,myEnt.pitch, myEnt.roll,myEnt.isReady),const.STATUS)) # send outgoing messages for msg in outgoingMsgs: self.broadcaster.addMessage(msg)