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 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 __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 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 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()
