def bckg_return(self, d): self.paused = False out = d.out() if out is not None and os.path.isfile(out): robot.background = out env.init(self.ports) if robot.background is not "": env.cfg['others']['background'] = robot.background try: img = pygame.image.load(robot.background) if img.get_alpha() != None: img = img.convert_alpha() else: img = img.convert() img = pygame.transform.scale(img, (640, 480)) env.background.blit(img, (3, 3)) except: pass else: env.cfg['others']['background'] = "None" else: robot.background = None env.init(self.ports) self.writeit(d)
def dialogReturn(self, d): out = d.out() robot.inputs = out['inputs'] for i in out['inputs']: inp = out['inputs'][i] self.sensors[i] = sensor_generator(inp['type'], inp['slot']) if out['others'][0][1] == 'custom' and out['others'][1][1] != '': robot.background = out['others'][1][1] env.init() img = pygame.image.load(robot.background) if img.get_alpha() != None: img = img.convert_alpha() else: img = img.convert() env.background.blit(img, (3, 3)) else: robot.background = None env.init() self.imgUpdate() d.close()
def onConsole(self): if self.console.is_open(): if not self.console_clicked: self.console_clicked = True return return self.consoleQuit(self.console) width = env.w + env.WALL_HEIGHT * 2 + 378 height = env.h + env.WALL_HEIGHT * 2 + 200 env.window = pygame.display.set_mode((width, height)) env.screen = pygame.display.get_surface() env.background = pygame.Surface(env.screen.get_size()).convert() env.init(self.ports) ClearScreen() self.header() self.textCenterOut(LCD_LINE5 + 2, "Live Console") self.console.connect(gui.CHANGE, self.consoleQuit, self.console) self.console.connect(gui.CLOSE, self.consoleQuit, self.console) self.console.open() self.console.rect.y = env.h + env.WALL_HEIGHT * 2 + 5 # focusing the input x = int(self.console.rect.x) + 86 + 10 y = int(self.console.rect.y) + 86 + 38 + 50 self.console_clicked = False self.console.own_focus(x, y)
def measure(model, num_storages, output_dir): env.init() scheduler = "Fifo" num_nodes = 1 cluster_config_path = env.get_cluter_config_path( model, num_nodes, num_storages) node_config_path = env.get_node_config_path() setting = HadoopSetting( cluster_config_path, node_config_path, scheduler="Fifo", model=model, num_nodes=num_nodes, num_storages=num_storages, parameters={}) upload = True format = True job_list = ["nocomputation"] job_size_list = ["3GB"] #job_list = ["wordcount", "nocomputation"] #job_size_list = ["512MB", "1GB"] map_size = 1024 submit_times = 10 job_timeline = jobfactory.create_all_pair_jobs( job_list=job_list, job_size_list=job_size_list, map_size=map_size, submit_times=submit_times) experiment = ExperimentRun( job_timeline, output_dir, setting=setting, upload=upload, format=format, sync=True) experiment.init() experiment.run()
def onConsole(self): if self.console.is_open(): if not self.console_clicked: self.console_clicked = True return return self.consoleQuit(self.console) width = env.w + env.WALL_HEIGHT*2 + 378 height = env.h + env.WALL_HEIGHT*2 + 200 env.window = pygame.display.set_mode((width, height)) env.screen = pygame.display.get_surface() env.background = pygame.Surface(env.screen.get_size()).convert() env.init(self.ports) ClearScreen() self.header() self.textCenterOut(LCD_LINE5 + 2, "Live Console") self.console.connect(gui.CHANGE, self.consoleQuit, self.console) self.console.connect(gui.CLOSE, self.consoleQuit, self.console) self.console.open() self.console.rect.y = env.h + env.WALL_HEIGHT*2 + 5 # focusing the input x = int(self.console.rect.x) + 86 + 10 y = int(self.console.rect.y) + 86 + 38 + 50 self.console_clicked = False self.console.own_focus(x,y)
def __init__( self, import_name, static_url_path=None, static_folder="static", static_host=None, host_matching=False, subdomain_matching=False, template_folder="templates", instance_path=None, instance_relative_config=False, root_path=None, ): super().__init__( import_name, static_url_path, static_folder, static_host, host_matching, subdomain_matching, template_folder, instance_path, instance_relative_config, root_path ) json_logging.ENABLE_JSON_LOGGING = True json_logging.init_flask(enable_json=True) json_logging.init_request_instrument(self) self.logger = logging.getLogger(self.name) self.logger.setLevel(int(os.environ.get("LOGGING_LEVEL", logging.INFO))) self.logger.addHandler(logging.StreamHandler(sys.stdout)) self.logger.propagate = False self.logger_core = logging.getLogger("__core__") self.logger_core.setLevel(int(os.environ.get("CORE_LOGGING_LEVEL", logging.ERROR))) self.logger_core.addHandler(logging.StreamHandler(sys.stdout)) self.logger_core.propagate = False self.logger_router = logging.getLogger("__router__") self.logger_router.setLevel(int(os.environ.get("ROUTER_LOGGING_LEVEL", logging.ERROR))) self.logger_router.addHandler(logging.StreamHandler(sys.stdout)) self.logger_router.propagate = False self.req_logger = logging.getLogger("flask-request-logger") self.req_logger.setLevel(logging.ERROR) self.req_logger.propagate = False init() try: import env env.init() except ImportError: self.logger.warning("No app env defined!") subject_factory.override(providers.Factory(lambda *args, **kw: g_wrap(subject_factory.cls, *args, **kw))) self.router = event_router_factory()
def consoleQuit(self, d): env.window = pygame.display.set_mode((env.w + env.WALL_HEIGHT*2 + 378, env.h + env.WALL_HEIGHT*2)) env.screen = pygame.display.get_surface() env.background = pygame.Surface(env.screen.get_size()).convert() env.init(self.ports) ClearScreen() self.scrout() d.close()
def consoleQuit(self, d): env.window = pygame.display.set_mode( (env.w + env.WALL_HEIGHT * 2 + 378, env.h + env.WALL_HEIGHT * 2)) env.screen = pygame.display.get_surface() env.background = pygame.Surface(env.screen.get_size()).convert() env.init(self.ports) ClearScreen() self.scrout() d.close()
def add_sensor(self, d, i): self.paused = False out = d.out() env.cfg["inputs"][i]["type"] = out["type"] env.cfg["inputs"][i]["slot"] = out["slot"] self.sensors[i] = sensor_generator(out['type'], out['slot']) self.ports[i] = out['slot'] env.init(self.ports) self.writeit(d)
def load_config(self, filename): env.cfg = env.read_config(filename) for i, inp in env.cfg['inputs'].iteritems(): self.sensors[i] = sensor_generator(inp['type'], inp['slot']) self.ports[i] = inp['slot'] self.port_dialogs[i - 1].inp = inp self.port_dialogs[i - 1].build_slots() env.init(self.ports) robot.imgUpdate() self.save_config('./config.yml')
def init(): configs_factory.override(providers.Singleton(lambda: krules_settings)) proc_events_rx_factory.queue.clear() event_router_factory.override(providers.Singleton(lambda: EventRouter())) exceptions_dumpers = exceptions_dumpers_factory() exceptions_dumpers.set(ExceptionDumperBase) exceptions_dumpers.set(RequestsHTTPErrorDumper) # TODO: do it better source = None if "K_SERVICE" in os.environ: source = os.environ["K_SERVICE"] elif "SERVICE" in os.environ: source = os.environ["SERVICE"] else: source = socket.gethostname() from krules_cloudevents.route.dispatcher import CloudEventsDispatcher event_dispatcher_factory.override( providers.Singleton( lambda: CloudEventsDispatcher(_get_dispatch_url, source))) try: import env if "init" in dir(env) and callable(env.init): env.init() except ModuleNotFoundError: logger.warning("No application env.py found!") try: m_rules = importlib.import_module("ruleset") load_rules_from_rulesdata(m_rules.rulesdata) except ModuleNotFoundError as ex: if ex.name == "ruleset": logger.warning("No rules defined!") else: raise ex proc_events_filters = os.environ.get("PUBLISH_PROCEVENTS_MATCHING") if proc_events_filters: proc_events_rx_factory.subscribe( on_next=lambda x: publish_proc_events_filtered( x, proc_events_filters.split(";"), lambda match: match is not None)) else: proc_events_rx_factory.subscribe( on_next=lambda x: publish_proc_events_all(x))
def measure(model, schedulers, num_nodes, num_storages, job_list, num_jobs, output_dir, debug=False): env.init(debug=debug) from my.experiment.base import HadoopSetting from my.experiment.base import SchedulerExperiment from my.experiment import jobfactory parameters = { 'mapreduce.job.reduce.slowstart.completedmaps': '0.8', } cluster_config_path = env.get_cluter_config_path(model, num_nodes, num_storages) node_config_path = env.get_node_config_path() setting = HadoopSetting(cluster_config_path, node_config_path, scheduler="Fifo", model=model, num_nodes=num_nodes, num_storages=num_storages, parameters=parameters) #job_list = ["grep", "terasort", "wordcount", "nocomputation", "histogrammovies", "histogramratings", "custommap1"] #job_list = ["grep"] job_size_list = ["1GB"] job_timeline = jobfactory.create_jobs(job_list=job_list, job_size_list=job_size_list, num_jobs=num_jobs, period=10) experiment = SchedulerExperiment(setting, schedulers, job_timeline, output_dir) experiment.init() experiment.run()
def measure(model, scheduler, num_nodes, num_storages, output_dir): env.init() cluster_config_path = env.get_cluter_config_path(model, num_nodes, num_storages) node_config_path = env.get_node_config_path() setting = HadoopSetting(cluster_config_path, node_config_path, scheduler="Fifo", model=model, num_nodes=num_nodes, num_storages=num_storages, parameters={}) upload = True format = True job_list = [ "grep", "terasort", "wordcount", "nocomputation", "histogrammovies", "histogramratings", "custommap1" ] job_size_list = ["64MB", "128MB", "256MB", "512MB", "1GB", "2GB", "4GB"] #job_list = ["wordcount", "nocomputation"] #job_size_list = ["512MB", "1GB"] map_size = 512 submit_times = 1 job_timeline = jobfactory.create_all_pair_jobs(job_list=job_list, job_size_list=job_size_list, map_size=map_size, submit_times=submit_times) experiment = ExperimentRun(job_timeline, output_dir, setting=setting, upload=upload, format=format, sync=True) experiment.init() experiment.run()
from tornado.options import options import env from config import ConfigMgr from .entries import entries from logs import LoggerMgr tornado.options.define('port', default=11000, help='run server on specific port.', type=int ) tornado.options.parse_command_line() env.init() logger = LoggerMgr.getLogger() if __name__ == '__main__': settings = { 'cookie_secret': ConfigMgr.get("cookie_secret"), } application = tornado.web.Application(entries, **settings) logger.info("Start server at %d", options.port) application.listen(options.port) try: tornado.ioloop.IOLoop.current().start() except KeyboardInterrupt:
def init(exe, tap, m): if not os.path.isfile(exe): raise Execfile("[!] Invalid executable (%s)" % exe) # init env, syms, and prototypes symbol.init(exe) env.init(m.read_reg, m.write_reg, m.read_mem, m.write_mem) mac = platform.machine() if mac == 'i686': ptr_size = 4 elif mac == 'x86_64': ptr_size = 8 else: assert False, "[!] Unknown machine '%s'" % mac prototype.init(["/usr/include"], ptr_size) if not os.path.isfile(tap): raise Execfail("[!] Invalid tap (%s)" % tap) # run the scripts execfile(tap, { "exe" : exe, "tap" : tap, "argv" : [exe], # probes "function_entry" : probe.function_entry, "function_exit" : probe.function_exit, "syscall_entry" : probe.syscall_entry, "syscall_exit" : probe.syscall_exit, "memory_read" : probe.memory_read, "memory_write" : probe.memory_write, "memory_execute" : probe.memory_execute, # expressions "process_id" : probeexp.process_id, "process_name" : probeexp.process_name, "thread_id" : probeexp.thread_id, "module_name" : probeexp.module_name, "function_address" : probeexp.function_address, "function_name" : probeexp.function_name, "memory_address" : probeexp.memory_address, "memory_size" : probeexp.memory_size, "memory_value" : probeexp.memory_value, "syscall_num" : probeexp.syscall_num, "syscall_name" : probeexp.syscall_name, # symbols "module" : symbol.get_module, "symbol" : resolve, "syscall" : symbol.get_syscall, # prototypes "include" : prototype.parse_header, "prototype" : prototype.get_prototype, "declare" : prototype.set_prototype, # exceptions "MissingPrototype": prototype.MissingPrototype }) probe.show_probes() return probe.enabled_probes()
from robothread import * import env pygame.init() yspeed = 0 xspeed = 0 maxspeed = 4 minspeed = -4 stop = 0 accel = 0.1 yup = True xleft = True env.init() # env.background = pygame.Surface(env.screen.get_size()) # env.background = env.background.convert() # env.background.fill((255, 255, 255)) # pygame.display.set_caption("nxtemu") # #background.blit(pygame.image.load("./icons/brick.jpg").convert(), (640, 0)) # env.background.blit(imgs.brick.convert(), (640, 0)) # pygame.draw.rect(env.background, pygame.Color("gray"), ((0, 0), (646, 486))) # pygame.draw.rect(env.background, pygame.Color("white"), ((3, 3), (640, 480))) # background.blit(pygame.image.load("settings.png").convert_alpha(), (970, 400)) #background.blit(pygame.image.load("./line.jpg"), (3, 3))
logger_core.setLevel(int(os.environ.get("CORE_LOGGING_LEVEL", logging.ERROR))) logger_core.addHandler(logging.StreamHandler(sys.stdout)) logger_core.propagate = False logger_router = logging.getLogger("__router__") logger_router.setLevel( int(os.environ.get("ROUTER_LOGGING_LEVEL", logging.ERROR))) logger_router.addHandler(logging.StreamHandler(sys.stdout)) logger_router.propagate = False req_logger = logging.getLogger("flask-request-logger") req_logger.setLevel(logging.ERROR) req_logger.propagate = False krules_env.init() app_env.init() subject_factory.override( providers.Factory( lambda *args, **kw: g_wrap(subject_factory.cls, *args, **kw))) try: m_rules = importlib.import_module("ruleset") except ModuleNotFoundError: m_rules = importlib.import_module("rules") load_rules_from_rulesdata(m_rules.rulesdata) @app.route('/', methods=['POST']) def main(): start_time = datetime.now()
import env import signal import sys from entries import entries def exit_handler(signal, frame): # 清理工作 或者 设置退出标记 sys.exit(0) # 会抛出 SystemExit 异常 # kill -s INT (等价 Ctrl+C) signal.signal(signal.SIGINT, exit_handler) # kill -s TERM (supervisor) signal.signal(signal.SIGTERM, exit_handler) tornado.options.define("config", default=None, type=str, help="File for configuration.") tornado.options.parse_command_line() if __name__ == "__main__": env.init(tornado.options.options.config) try: port = env.configMgr.get("port") logging.info("Run with port %d", port) application = tornado.web.Application(entries) application.listen(port) tornado.ioloop.IOLoop.current().start() except (KeyboardInterrupt, SystemExit): logging.info("exit") finally: env.finish()