def _translator_update(self, filename):
log_debug("filename - {}".format(filename))
input_ = open(filename, 'rb')
self.parser = Parser(input_)
base_name = os.path.basename(filename[:-3]) # \c\xxx.vm -> xxx or /c/c/xxx.vm -> xxx
self.code_writer.set_filename(base_name)
def handle_event(self, event):
log_debug("handle_event: ", event)
evtype = event.type
if evtype == 'sync':
self.sync_changes()
elif evtype == 'file_change':
self.on_file_change(event.content)
def pv_retrieve_with_segs(device=None):
d = []
columns = ['pv_name', 'pv_uuid', 'pv_fmt', 'pv_size', 'pv_free',
'pv_used', 'dev_size', 'pv_mda_size', 'pv_mda_free',
'pv_ba_start', 'pv_ba_size', 'pe_start', 'pv_pe_count',
'pv_pe_alloc_count', 'pv_attr', 'pv_tags', 'vg_name',
'vg_uuid', 'pv_seg_start', 'pvseg_size', 'segtype']
# Lvm has some issues where it returns failure when querying pvs when other
# operations are in process, see:
# https://bugzilla.redhat.com/show_bug.cgi?id=1274085
while True:
cmd = _dc('pvs', ['-o', ','.join(columns)])
if device:
cmd.extend(device)
rc, out, err = call(cmd)
if rc == 0:
d = parse_column_names(out, columns)
break
else:
time.sleep(0.2)
log_debug("LVM Bug workaround, retrying pvs command...")
return d
def filename_by_path(path):
sep = '/' if '/' in path else '\\'
log_debug("sep - {}".format(sep))
dir_list = path.split(sep)
log_debug("dir_list - {}".format(dir_list))
filename = dir_list[-1] if dir_list[-1] != '' else dir_list[-2]
return "{}{}".format(filename, ASM_SUFFIX)
def write_arithmetic(self, command):
log_debug("command - {}".format(command))
handle_func = getattr(self, "_handle_{}".format(command))
handle_func()
self._write_empty_line()
def handle_single_vm_file(filename):
log_debug('handle_single_vm_file')
output = filename.replace(".vm", ".asm")
code_writer = CodeWriter(output)
translate_vm_to_asm(code_writer, filename)
code_writer.write_end() # 写入asm文件标准结尾
def start_profiling(self, target_args):
"""Start simpleperf reocrd process on device."""
args = ['/data/local/tmp/simpleperf', 'record', '-o', '/data/local/tmp/perf.data',
self.args.record_options]
if self.adb.run(['shell', 'ls', NATIVE_LIBS_DIR_ON_DEVICE]):
args += ['--symfs', NATIVE_LIBS_DIR_ON_DEVICE]
args += target_args
adb_args = [self.adb.adb_path, 'shell'] + args
log_debug('run adb cmd: %s' % adb_args)
self.record_subproc = subprocess.Popen(adb_args)
def translate_single_vm_file(filename):
log_debug('handle_single_vm_file')
output = filename.replace(VM_SUFFIX, ASM_SUFFIX)
code_writer = CodeWriter(output)
translator = Translator(code_writer)
translator.translate(filename)
code_writer.close()
def set_execution(shell):
global _t_call
with cmd_lock:
_t_call = None
if shell:
log_debug('Using lvm shell!')
lvm_shell = LVMShellProxy()
_t_call = lvm_shell.call_lvm
else:
_t_call = call_lvm
def start_profiling(self, target_args):
"""Start simpleperf reocrd process on device."""
args = ['/data/local/tmp/simpleperf', 'record', '-o', '/data/local/tmp/perf.data',
self.args.record_options]
if self.adb.run(['shell', 'ls', NATIVE_LIBS_DIR_ON_DEVICE]):
args += ['--symfs', NATIVE_LIBS_DIR_ON_DEVICE]
args += target_args
adb_args = [self.adb.adb_path, 'shell'] + args
log_debug('run adb cmd: %s' % adb_args)
self.record_subproc = subprocess.Popen(adb_args)
def write_push_or_pop(self, command, segment, index):
log_debug("command_type - {}, segment - {}, index - {}".format(
command, segment, index))
if command == COMMAND.C_PUSH:
self._handle_push(segment, index)
elif command == COMMAND.C_POP:
self._handle_pop(segment, index)
else:
raise Exception("Unexpected command type - {}".format(command))
self._write_empty_line()
def handle_multi_vm_file(path):
log_debug('handle_multi_vm_file')
output = os.path.join(path, 'out.asm')
code_writer = CodeWriter(output)
for f in os.listdir(path):
filename = os.path.join(path, f)
if os.path.isfile(filename) and filename.endswith(".vm"):
translate_vm_to_asm(code_writer, filename)
code_writer.write_end() # 写入asm文件标准结尾
def handle_request(self):
data = self.peer_socket.recv(1024)
zeng_request = pickle.loads(data)
request_id = zeng_request['task']
log_debug("Received message " + str(zeng_request))
if request_id == 'update':
self.on_get_file_update(zeng_request)
elif request_id == 'list':
self.on_get_file_ls()
elif request_id == 'dw':
self.on_get_file_download(zeng_request)
def wait_profiling(self):
"""Wait until profiling finishes, or stop profiling when user presses Ctrl-C."""
returncode = None
try:
returncode = self.record_subproc.wait()
except KeyboardInterrupt:
self.stop_profiling()
self.record_subproc = None
# Don't check return value of record_subproc. Because record_subproc also
# receives Ctrl-C, and always returns non-zero.
returncode = 0
log_debug('profiling result [%s]' % (returncode == 0))
if returncode != 0:
log_exit('Failed to record profiling data.')
def wait_profiling(self):
"""Wait until profiling finishes, or stop profiling when user presses Ctrl-C."""
returncode = None
try:
returncode = self.record_subproc.wait()
except KeyboardInterrupt:
self.stop_profiling()
self.record_subproc = None
# Don't check return value of record_subproc. Because record_subproc also
# receives Ctrl-C, and always returns non-zero.
returncode = 0
log_debug('profiling result [%s]' % (returncode == 0))
if returncode != 0:
log_exit('Failed to record profiling data.')
def refresh(self, log=True):
"""
Go out and query lvm for the latest data in as few trips as possible
:param log Add debug log entry/exit messages
:return: None
"""
self.num_refreshes += 1
if log:
log_debug("lvmdb - refresh entry")
# Grab everything first then parse it
if self.json:
# Do a single lvm retrieve for everything in json
a = cmdhandler.lvm_full_report_json()
_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs_json(a)
_vgs, _vgs_lookup = self._parse_vgs_json(a)
_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs_json(
a)
else:
_raw_pvs = cmdhandler.pv_retrieve_with_segs()
_raw_vgs = cmdhandler.vg_retrieve(None)
_raw_lvs = cmdhandler.lv_retrieve_with_segments()
_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs(_raw_pvs)
_vgs, _vgs_lookup = self._parse_vgs(_raw_vgs)
_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs(
_raw_lvs)
# Set all
self.pvs = _pvs
self.pv_path_to_uuid = _pvs_lookup
self.vg_name_to_uuid = _vgs_lookup
self.lv_full_name_to_uuid = _lvs_lookup
self.vgs = _vgs
self.lvs = _lvs
self.lvs_in_vgs = _lvs_in_vgs
self.pvs_in_vgs = _pvs_in_vgs
self.lvs_hidden = _lvs_hidden
# Create lookup table for which LV and segments are on each PV
self.pv_lvs, self.lv_pvs = self._parse_pv_in_lvs()
if log:
log_debug("lvmdb - refresh exit")
def translate_multi_vm_file(path):
log_debug('handle_multi_vm_file')
filename = filename_by_path(path)
output = os.path.join(path, filename)
log_debug("output - {}".format(output))
code_writer = CodeWriter(output)
translator = Translator(code_writer)
code_writer.bootstrap()
for f in os.listdir(path):
filename = os.path.join(path, f)
if os.path.isfile(filename) and filename.endswith(VM_SUFFIX):
translator.translate(filename)
# code_writer.write_end() # 写入asm文件标准结尾
code_writer.close()
def refresh(self, log=True):
"""
Go out and query lvm for the latest data in as few trips as possible
:param log Add debug log entry/exit messages
:return: None
"""
self.num_refreshes += 1
if log:
log_debug("lvmdb - refresh entry")
# Grab everything first then parse it
if self.json:
# Do a single lvm retrieve for everything in json
a = cmdhandler.lvm_full_report_json()
_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs_json(a)
_vgs, _vgs_lookup = self._parse_vgs_json(a)
_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs_json(a)
else:
_raw_pvs = cmdhandler.pv_retrieve_with_segs()
_raw_vgs = cmdhandler.vg_retrieve(None)
_raw_lvs = cmdhandler.lv_retrieve_with_segments()
_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs(_raw_pvs)
_vgs, _vgs_lookup = self._parse_vgs(_raw_vgs)
_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs(_raw_lvs)
# Set all
self.pvs = _pvs
self.pv_path_to_uuid = _pvs_lookup
self.vg_name_to_uuid = _vgs_lookup
self.lv_full_name_to_uuid = _lvs_lookup
self.vgs = _vgs
self.lvs = _lvs
self.lvs_in_vgs = _lvs_in_vgs
self.pvs_in_vgs = _pvs_in_vgs
self.lvs_hidden = _lvs_hidden
# Create lookup table for which LV and segments are on each PV
self.pv_lvs, self.lv_pvs = self._parse_pv_in_lvs()
if log:
log_debug("lvmdb - refresh exit")
def translate_vm_to_asm(code_writer, filename):
log_debug("filename - {}".format(filename))
input_ = open(filename, 'rb')
parser = Parser(input_)
base_name = os.path.basename(
filename[:-3]) # \c\xxx.vm -> xxx or /c/c/xxx.vm -> xxx
code_writer.set_filename(base_name)
while parser.has_more_commands():
parser.advance()
command_type = parser.command_type()
if command_type in (COMMAND.C_PUSH, COMMAND.C_POP):
segment, index = parser.arg1(), parser.arg2()
code_writer.write_push_or_pop(command_type, segment, index)
elif command_type == COMMAND.C_ARITHMETIC:
command = parser.arg1()
code_writer.write_arithmetic(command)
else:
Exception("Unexpected command - {}".format(command_type))
def pv_retrieve_with_segs(device=None):
d = []
err = ""
out = ""
rc = 0
columns = ['pv_name', 'pv_uuid', 'pv_fmt', 'pv_size', 'pv_free',
'pv_used', 'dev_size', 'pv_mda_size', 'pv_mda_free',
'pv_ba_start', 'pv_ba_size', 'pe_start', 'pv_pe_count',
'pv_pe_alloc_count', 'pv_attr', 'pv_tags', 'vg_name',
'vg_uuid', 'pv_seg_start', 'pvseg_size', 'segtype']
# Lvm has some issues where it returns failure when querying pvs when other
# operations are in process, see:
# https://bugzilla.redhat.com/show_bug.cgi?id=1274085
for i in range(0, 10):
cmd = _dc('pvs', ['-o', ','.join(columns)])
if device:
cmd.extend(device)
rc, out, err = call(cmd)
if rc == 0:
d = parse_column_names(out, columns)
break
else:
time.sleep(0.2)
log_debug("LVM Bug workaround, retrying pvs command...")
if rc != 0:
msg = "We were unable to get pvs to return without error after " \
"trying 10 times, RC=%d, STDERR=(%s), STDOUT=(%s)" % \
(rc, err, out)
log_error(msg)
raise RuntimeError(msg)
return d
def pv_retrieve_with_segs(device=None):
d = []
err = ""
out = ""
rc = 0
columns = ['pv_name', 'pv_uuid', 'pv_fmt', 'pv_size', 'pv_free',
'pv_used', 'dev_size', 'pv_mda_size', 'pv_mda_free',
'pv_ba_start', 'pv_ba_size', 'pe_start', 'pv_pe_count',
'pv_pe_alloc_count', 'pv_attr', 'pv_tags', 'vg_name',
'vg_uuid', 'pvseg_start', 'pvseg_size', 'segtype']
# Lvm has some issues where it returns failure when querying pvs when other
# operations are in process, see:
# https://bugzilla.redhat.com/show_bug.cgi?id=1274085
for i in range(0, 10):
cmd = _dc('pvs', ['-o', ','.join(columns)])
if device:
cmd.extend(device)
rc, out, err = call(cmd)
if rc == 0:
d = parse_column_names(out, columns)
break
else:
time.sleep(0.2)
log_debug("LVM Bug workaround, retrying pvs command...")
if rc != 0:
msg = "We were unable to get pvs to return without error after " \
"trying 10 times, RC=%d, STDERR=(%s), STDOUT=(%s)" % \
(rc, err, out)
log_error(msg)
raise RuntimeError(msg)
return d
if rc == 0:
d = parse_column_names(out, columns)
return d
def lv_retrieve_with_segments():
columns = ['lv_uuid', 'lv_name', 'lv_path', 'lv_size',
'vg_name', 'pool_lv_uuid', 'pool_lv', 'origin_uuid',
'origin', 'data_percent',
'lv_attr', 'lv_tags', 'vg_uuid', 'lv_active', 'data_lv',
'metadata_lv', 'seg_pe_ranges', 'segtype', 'lv_parent',
'lv_role', 'lv_layout']
cmd = _dc('lvs', ['-a', '-o', ','.join(columns)])
rc, out, err = call(cmd)
d = []
if rc == 0:
d = parse_column_names(out, columns)
return d
if __name__ == '__main__':
pv_data = pv_retrieve_with_segs()
for p in pv_data:
log_debug(str(p))
import Crossfire
import utils
map_ = Crossfire.WhoAmI()
utils.log_debug('%s %s' % ('free_objects', map_.Path))
import Crossfire
import utils
map_ = Crossfire.WhoAmI()
utils.log_debug('%s %s' % ('mapunload', map_.Path))
def on_file_change(self, file_evt):
changed_file = file_evt.file
log_debug("on_file_change: ", changed_file)
self.post_file_changes([changed_file])
def cast(self):
''' Действия при касте заклинания.
'''
utils.log_debug(self.id + " has no effect!")
def _shell_cfg():
global _t_call
log_debug('Using lvm shell!')
lvm_shell = LVMShellProxy()
_t_call = lvm_shell.call_lvm
for f in os.listdir(path):
filename = os.path.join(path, f)
if os.path.isfile(filename) and filename.endswith(".vm"):
translate_vm_to_asm(code_writer, filename)
code_writer.write_end() # 写入asm文件标准结尾
# 解析命令行参数
def parse_sys_arg(sys_argv):
path = sys_argv[1]
if os.path.isfile(path):
if path.endswith(".vm"):
handle_single_vm_file(path)
else:
log_error("{} is not a vm file".format(path))
elif os.path.isdir(path):
handle_multi_vm_file(path)
else:
abspath = os.path.abspath(path)
log_error("{} is not exists".format(abspath))
log(help_msg)
if __name__ == '__main__':
log_debug("sys.argv - {}".format(sys.argv))
if len(sys.argv) == 2:
parse_sys_arg(sys.argv)
else:
log(help_msg)
if rc == 0:
d = parse_column_names(out, columns)
return d
def lv_retrieve_with_segments():
columns = ['lv_uuid', 'lv_name', 'lv_path', 'lv_size',
'vg_name', 'pool_lv_uuid', 'pool_lv', 'origin_uuid',
'origin', 'data_percent',
'lv_attr', 'lv_tags', 'vg_uuid', 'lv_active', 'data_lv',
'metadata_lv', 'seg_pe_ranges', 'segtype', 'lv_parent',
'lv_role', 'lv_layout']
cmd = _dc('lvs', ['-a', '-o', ','.join(columns)])
rc, out, err = call(cmd)
d = []
if rc == 0:
d = parse_column_names(out, columns)
return d
if __name__ == '__main__':
pv_data = pv_retrieve_with_segs()
for p in pv_data:
log_debug(str(p))
import Crossfire
import utils
map_ = Crossfire.WhoAmI()
utils.log_debug('%s %s' % ('mapreset', map_.Path))
Parse the command line arguments
"""
p = ap.ArgumentParser()
p.add_argument('action',
help='\'start\' | \'stop\' the donuts process (or \'shutdown\' donuts process handler)',
choices=['start', 'stop', 'shutdown'])
p.add_argument('--nodebug',
help='Enable debugging mode',
action='store_true')
return p.parse_args()
if __name__ == "__main__":
args = arg_parse()
# do some debug logging
if args.nodebug:
log_debug(args)
try:
ag = Pyro4.Proxy('PYRO:donuts@localhost:9234')
except (Pyro4.errors.CommunicationError, ConnectionRefusedError):
if args.nodebug:
log_debug("Pyro communications error, exiting with status = {}".format(ag_status.pyro_connection_error))
ag = None
sys.exit(ag_status.pyro_connection_error)
if args.action == 'start' and ag:
status = ag.start_ag()
if args.nodebug:
log_debug("AG start called, returning status = {}".format(status))
sys.exit(status)
elif args.action == 'stop' and ag:
status = ag.stop_ag()
if args.nodebug:
