def load_from_json(cluster_name): """ load the cluster information from json file :param cluster_name: the name of the cluster :return: a Cluster instance or None if no such cluster """ data = Data() json_data = data.read_cluster_json(cluster_name) if json_data is None: return None ambari_server_vm = [] service_server_vm_list = [] ambari_agent_vm_list = [] for vm_json in json_data["ambari_server_vm"]: ambari_server_vm.append(VM.load_from_json(vm_json)) for vm_json in json_data["service_server_vm_list"]: service_server_vm_list.append(VM.load_from_json(vm_json)) for vm_json in json_data["ambari_agent_vm_list"]: ambari_agent_vm_list.append(VM.load_from_json(vm_json)) cluster = Cluster() cluster.cluster_name = cluster_name cluster.state = json_data["state"] cluster.create_time = json_data["create_time"] cluster.ambari_server_vm = ambari_server_vm cluster.service_server_vm_list = service_server_vm_list cluster.ambari_agent_vm_list = ambari_agent_vm_list return cluster
def generate_cluster_info(self, VM_IP_list, cluster_name, docker_num): config = Config() config.load() Docker_IP_base = config.ATTRIBUTES["Docker_IP_base"].split(".") Docker_IP_mask = config.ATTRIBUTES["Docker_IP_mask"] VM_index = 0 for VM_IP in VM_IP_list: vm = VM(VM_IP) for Docker_index in range(0, docker_num): total_Docker_index = VM_index * docker_num + Docker_index docker_IP = self.__increase_IP__(Docker_IP_base, total_Docker_index) docker_IP_str = str(docker_IP[0]) + "." + str(docker_IP[1]) + "." + \ str(docker_IP[2]) + "." + str(docker_IP[3]) docker_hostname = cluster_name + "-" + str( VM_index) + "-" + str(Docker_index) docker = Docker(docker_IP_str, str(Docker_IP_mask), docker_hostname) # print docker vm.add_docker(docker) VM_index = VM_index + 1 self.VM_list.append(vm) self.VMs_num = len(VM_IP_list) self.cluster_name = cluster_name
def put(self): logging.info('put all vms received') data_string = self.request.body decoded = json.loads(data_string) decoded2 = json.dumps(decoded, indent=2) logging.info(decoded2) if decoded.has_key('vms'): count_vms = len(decoded['vms']) logging.info('count vms: '+str(count_vms)) vms = [] for vm in decoded['vms']: temp = VM(key_name=vm['ip']) temp.set(vm) temp.ip = vm['ip'] vms.append(temp) for vm in vms: vm.put() logging.info('put vm['+vm.ip+'] into datastore') else: logging.info('no key vms defined') self.error(500) return
def put(self): logging.info('put single vm received') data_string = self.request.body decoded = json.loads(data_string) decoded2 = json.dumps(decoded, indent=2) logging.info(decoded2) if decoded.has_key('vms'): count_vms = len(decoded['vms']) logging.info('count vms: '+str(count_vms)) if count_vms > 1: logging.info("more than 1 vm, abort") self.error(500) return vms = [] for vm in decoded['vms']: ip = self.request.remote_addr temp = VM(key_name=ip) temp.set(vm) temp.ip = ip vms.append(temp) for vm in vms: vm.put() logging.info('put vm['+vm.ip+'] into datastore') else: logging.info('no key vms defined') self.error(500) return
def run(fp): program_contents = "" while True: read = os.read(fp, 4096) if len(read) == 0: break program_contents += read os.close(fp) program = parse(program_contents) i = 0 functions = [None] * 1024 while i < len(program): ops = program[i] opcode = int(ops[0]) if opcode == OpCode.MAKE_FUNCTION: name = int(ops[1]) params = int(ops[2]) func, bytecodes_length = make_function(name, params, program, i + 1) functions[name] = func i += bytecodes_length i += 1 functions = [func for func in functions if func is not None] main_func = functions[0] init_frame = Frame(None, main_func, main_func.num_locals, main_func.literals, main_func.stack_size) vm = VM(functions) vm.run(init_frame)
def verify_tx(tx: Tx) -> None: compiler = Compiler() input_sum = sum( sum(outpoint.amount for outpoint in tx_input.outpoints) for tx_input in tx.inputs) output_sum = sum(output.amount for output in tx.outputs) if output_sum > input_sum: raise ValueError('Output amounts exceeds input amounts') for input_idx, tx_input in enumerate(tx.inputs): witness = tx.witnesses[input_idx] loop_trees = parse_loop_trees(io.BytesIO(witness.loop_trees)) loop_stack = LoopStack(loop_trees) src = tx_input.bytecode.decode('ascii') compile_result = compiler.compile(src) vm = VM(loop_stack, compile_result.num_locals, witness.ram_size) instructions = Block(compile_result.instructions) instructions.run(vm) for preamble_idx, preamble in enumerate(tx.preambles): witness = tx.witnesses[len(tx.inputs) + preamble_idx] loop_trees = parse_loop_trees(io.BytesIO(witness.loop_trees)) loop_stack = LoopStack(loop_trees) src = preamble.decode('ascii') compile_result = compiler.compile(src) vm = VM(loop_stack, compile_result.num_locals, witness.ram_size) instructions = Block(compile_result.instructions) instructions.run(vm)
def get_vm(self, vmid=None, **kwargs): '''Retrieve specific vm or all''' if vmid is not None: req = self.get_request('v1/vms/{0}'.format(vmid)) return VM(**req.json()) req = self.get_request('v1/vms', params=(kwargs or None)) return list([VM(**res) for res in req.json()])
def test_nested_loop(): vm = VM( LoopStack([ LoopTree.CARTESIAN(3, [ LoopTree.LEAF(3), LoopTree.LEAF(5), ]), ]), num_locals=0, ram_size=0, ) ins = InsLoopSpecified( Block([ InsLoopSpecified( Block([ InsArith([0], True, ArithMode.CHECKED, lambda n: n - 1), ])), InsLoopSpecified( Block([ InsArith([0], True, ArithMode.CHECKED, lambda n: n + 1), ])), InsArith([0], True, ArithMode.CHECKED, lambda n: n * 2), ])) ins.run(vm) result = vm.belt().get_num(0).value.expect_int() assert result == 28
def validateBuild(args): available_build_actions = ("branch", "patch", "origin") action = args.build[0] if args.install and (args.install[1] == "repo" or args.install[1] == "develrepo"): raise Exception( "First building IPA from sources and then " "installing it from repo makes no sense. " "Think about it." ) if action not in available_build_actions: raise ValueError("Unknown build action: {s}. Choose either branch " "or patch.".format(s=action)) if action == "patch": show("Checking whether all given patches exist.") vm = VM(locals.NFS_VM, locals.DOMAIN, None, None) patches_exist = True for patch_id in args.build[1:]: num = vm.cmd("bash labtool/ipa-fun-get-patch-name.sh %s" % patch_id, allow_failure=True, silent=True) if num != 0: show("Inappropriate number of patches matching %s" % patch_id) patches_exist = False if not patches_exist: raise ValueError("One of the given patches could not be " "determined.") show("Patch check successful.") vm.close() elif action == "branch": pass # check that such branch indeed exists
def vm_addons(): data = {} payload = request.get_json() logging.debug(payload) field = {'Address', 'Username', 'Passwd', 'Port', 'Addons'} if field - set(payload.keys()): error_msg = "Input json missing some field! " + "It must include " + str( field) logging.error(error_msg) return jsonify({"error": error_msg}), 400 else: try: vm = VM(payload['Address'], payload['Username'], payload['Passwd'], "", port=payload['Port'], addons=payload['Addons']) logging.info("VM install addons " + str(vm.addons)) vm.install_addons() logging.info("VM install addons done") except Exception as e: logging.error(str(e)) return jsonify({"error": str(e)}), 500 return jsonify(data), 200
def test_input(self): ops =[9, 32768, 32769, 4, 19, 32768] # - Store into register 0 the sum of 4 and the value contained in register 1. # - Output to the terminal the character with the ascii code contained in register 0. vm = VM(ops) vm.r[1] = 65 vm.run() self.assertEqual(vm.r[0], vm.r[1] + 4)
def get_vm(self, vmid=None, **kwargs): '''Retrieve specific vm or all''' if vmid is not None: req = self.get_request('v1/vms/{0}'.format(vmid)) return VM(**req.json()) # Get protected VMs prot_vms = self.get_request('v1/vms', params=(kwargs or None)) return [VM(**vm_resp) for vm_resp in prot_vms.json()]
def _api_call(sm: VM): _b = get_next_byte(sm) _args = get_next_byte(sm, 2) args = [sm.pop() for _ in range(_args)] fun = sm.get_data_at(_b) f = FUNCTIONS[fun] f(*args) [sm.push(i) for i in args]
def do_pt1(): with open('input') as f: intcode = f.read() intcode = VM.sanitise_memory(intcode) intcode[1] = 12 intcode[2] = 2 vm = VM() print(vm.compute(intcode))
def __init__(self, sql_string): self.sql_string_array = sql_string.split() self.statement_type = self.sql_string_array[0] self.command_executions = { 'insert': self.handle_insert_command, 'select': self.handle_select_command } self.vm = VM()
def generate_cluster_info(self, cluster_name, ambari_server_fqdn_ip_pairs, service_server_fqdn_ip_pairs, ambari_agent_fqdn_ip_pairs, docker_num): """ generate VM and docker info for this cluster set up parameter of the class instance as this info :param cluster_name: the name of the cluster :param ambari_server_fqdn_ip_pairs: the domain name and IP pairs for Ambari-server :param service_server_fqdn_ip_pairs: the domain name and IP pairs for VMs with Ambari-agent installed :param ambari_agent_fqdn_ip_pairs: the domain name and IP pairs for VM with Docker containers :param docker_num: the number of Dockers inside each VMs :return: None """ weave_ip_base = Config.ATTRIBUTES["weave_ip_base"] weave_ip_mask = Config.ATTRIBUTES["weave_ip_mask"] current_ip = weave_ip_base for vm_domain_name, vm_ip in ambari_server_fqdn_ip_pairs: current_ip = self._increase_ip(current_ip, 1) weave_dns_ip = current_ip vm = VM(vm_ip, vm_domain_name, weave_dns_ip, weave_ip_mask) current_ip = self._increase_ip(current_ip, 1) vm.weave_internal_ip = current_ip self.ambari_server_vm.append(vm) for vm_domain_name, vm_ip in service_server_fqdn_ip_pairs: current_ip = self._increase_ip(current_ip, 1) weave_dns_ip = current_ip vm = VM(vm_ip, vm_domain_name, weave_dns_ip, weave_ip_mask) current_ip = self._increase_ip(current_ip, 1) vm.weave_internal_ip = current_ip self.service_server_vm_list.append(vm) vm_index = 0 for vm_domain_name, vm_ip in ambari_agent_fqdn_ip_pairs: current_ip = self._increase_ip(current_ip, 1) weave_dns_ip = current_ip vm = VM(vm_ip, vm_domain_name, weave_dns_ip, weave_ip_mask) for docker_index in range(0, docker_num): current_ip = self._increase_ip(current_ip, 1) docker_ip_str = current_ip total_docker_index = vm_index * docker_num + docker_index docker_domain_name = Docker.get_weave_domain_name(cluster_name, total_docker_index) docker = Docker(docker_ip_str, str(weave_ip_mask), docker_domain_name) vm.add_docker(docker) vm_index += 1 self.ambari_agent_vm_list.append(vm) self.cluster_name = cluster_name self.create_time = str(datetime.datetime.now()) self.state = Cluster.STATE_FREE # update config file. # This step makes the user avoid reconfiguring the IP for next cluster creation Config.update("weave", "weave_ip_base", current_ip)
def run(self): #wrong operation if(RM.PI == 1): print("wrong operation in ", RM.current_vm.PAGE) Interrupt.kill_vm() #division by zero elif(RM.PI == 2): print("division by zero in ", RM.current_vm.PAGE) Interrupt.kill_vm() #error while loading user's program elif(RM.PI == 3): print("error while trying to load ", Load.filename) #success loading user's program elif(RM.PI == 4): Process.find_by_name("Main").state = State.READY #test elif(RM.PI == 5): Process.find_by_name("Load").state = State.READY #perhaps those two will be optional if(RM.SI == 1): pass #read elif(RM.SI == 2): pass #halt elif(RM.SI == 3): RM.current_vm.state = State.FINISHED RM.current_vm = None RM.TI = 0 #watchdog elif(RM.SI == 4): Interrupt.kill_vm() #timer if(RM.TI == 0): #get all active vms vms = VM.get_active() #for vm in vms: # print(vm, " ", vm.PAGE) if vms != []: #this vm already worked vms[0].state = State.BLOCKED #rotate vms list VM.rotate() #make first ready vms[0].state = State.READY #set timer for vm RM.TI = TIMER_PERIOD #turn on watchdog Process.find_by_name("Watchdog").state = State.READY else: #no need to use watchdog if there is no user's programs Process.find_by_name("Watchdog").state = State.BLOCKED #clear RM.PI = 0 RM.SI = 0 self.state = State.READY
def run(self, vm: VM) -> Optional[Break]: for _ in range(self._num_loops): br = self._block.run(vm) if br is not None: if br.depth == 0 and br.is_continue: vm.loop_stack().continue_loop() continue vm.loop_stack().break_loop() return br
def get_vm(self, vmname): """Return the VM instance corresponding to the given vmname.""" try: uuid=self.server.xenapi.VM.get_by_name_label(vmname)[0] except IndexError: raise NotRunningVmError(self.get_hostname(),vmname) vm_rec=self.server.xenapi.VM.get_record(uuid) vm=VM(vm_rec['name_label'],vm_rec['domid']) vm.metrics=self.server.xenapi.VM_metrics.get_record(vm_rec['metrics']) return vm
class Eval: def __init__(self): self.vm = VM() def eval(self, expr): compiled_expr = compile(expr) print("compiled_expr:", compiled_expr) self.vm.reg.x = compiled_expr self.vm.run() return self.vm.reg.a
def run(self, vm: VM) -> Optional['Break']: a_num = vm.belt().get_num(self._a_idx) b_num = vm.belt().get_num(self._b_idx) a = a_num.to_signed(self._is_signed).to_int() b = b_num.to_signed(self._is_signed).to_int() if a is None or b is None: vm.belt().push(BeltNum(DataType.I8, Integer(None))) else: result = self._op(a, b) vm.belt().push(BeltNum(DataType.I8, Integer(int(result)))) return None
def get_vm(self, vmname): """Return the VM instance corresponding to the given vmname.""" try: uuid = self.server.xenapi.VM.get_by_name_label(vmname)[0] except IndexError: raise NotRunningVmError(self.get_hostname(), vmname) vm_rec = self.server.xenapi.VM.get_record(uuid) vm = VM(vm_rec['name_label'], vm_rec['domid']) vm.metrics = self.server.xenapi.VM_metrics.get_record( vm_rec['metrics']) return vm
def test_vm_starts(): """ starts vm creates folder on it with ssh and checks """ vm = VM("oneiric") with vm.start(): cmd = SSHCMDExecutor(vm.ip, vmuser, vmpass) cmd.exec_simple("mkdir /%s" % some_dir) tdirname = os.path.join(vm.fs.mpoint, some_dir) ok_(os.path.exists(tdirname))
def main(): vm = VM() try: opts, args = getopt.getopt( sys.argv[1:], "c:i:o:gh", ["codefile=", "inputfile=", "outputfile=", "debug", "help"] ) except getopt.GetoptError as error: print(error) exit() # Go through the options, initializing and configuring the vm. for opt, arg in opts: if opt in ("-h", "--help"): exit() elif opt in ("-c", "--codefile"): try: codeFile = open(arg, mode="rt", encoding="utf-8") header = codeFile.readline() if not vm.setLoader(header, codeFile): print("The header of the file {} is not recognized:".format(arg)) print(header) sys.exit(2) transferHeader = codeFile.readline() vm.setTransferStage(transferHeader) except IOError as ioe: print(ioe) sys.exit(2) elif opt in ("-i", "--inputfile"): try: vm.input = open(arg, mode="rt", encoding="utf-8") except IOError as ioe: print(ioe) sys.exit(2) elif opt in ("-o", "--outputfile"): try: vm.output = open(arg, mode="wb") except IOError as ioe: print(ioe) sys.exit(2) elif opt in ("-g", "--debug"): vm.setDebugMode() # If a code file isn't supplied, there won't be any loader so we end. if vm.loader is None: exit() vm.run() sys.exit(0)
def test_simple_loop(): vm = VM( LoopStack([ LoopTree.LEAF(8), ]), num_locals=0, ram_size=0, ) ins = InsLoopSpecified( Block([ InsArith([0], False, ArithMode.CHECKED, lambda n: n + 1), ])) ins.run(vm) result = vm.belt().get_num(0).value.expect_int() assert result == 8
def compile_from_string(string, allowed_opcodes=None): """ :param allowed_opcodes: from opcode_pack """ allowed_opcodes = allowed_opcodes or \ OPCode.get_all_opcodes() vm = VM() print_opcodes = filter(lambda op: issubclass(op, PrintOPCode), allowed_opcodes) jump_opcodes = filter(lambda op: issubclass(op, JumpOPCodes), allowed_opcodes) nc = string_to_prt_opcodes(string, print_opcodes, vm) atoms = break_to_atoms(nc) if NOP in allowed_opcodes: add_random_nops(atoms) atoms.append(NodeChain(HLT())) if jump_opcodes: atoms = add_jmp_opcodes(atoms, jmp_opcode_classes=jump_opcodes) atoms = shuffle(atoms) nc = make_chain_from_atoms(atoms) link_to_real_address(nc) return nc
def check_missing_lvs(self): """ Perform a check on logicals volumes used by VMs. Return False if some are missing. """ log.info("Checking for missing LV...") safe = True # Get all LVs used by VMs used_lvs = list() for vm in self.get_possible_vm_names(): used_lvs.extend(VM(vm).get_lvs()) # Get all existent LVs existent_lvs = list() for line in self.run("lvs -o vg_name,name --noheading").readlines(): (vg, lv) = line.strip().split() existent_lvs.append("/dev/" + vg + "/" + lv) # Compute missing LVs missing_lvs = list(Set(used_lvs) - Set(existent_lvs)) if len(missing_lvs): log.info(" ** WARNING : Found missing LV :\n\t", "\n\t".join(missing_lvs)) safe = False return safe
def do_pt2(): with open('input') as f: clean_intcode_str = f.read() # intcode = VM.sanitise_memory(intcode) vm = VM() for i in range(0, 100): # noun # print('trying noun = {0}, verb = '.format(i), end='') for j in range(0, 100): # verb # print("{0}, ".format(j), end='') intcode = VM.sanitise_memory(clean_intcode_str) intcode[1] = i intcode[2] = j if vm.compute(intcode) == 19690720: print('found! noun: {0}, verb: {1}'.format(i, j)) print('answer: 100 * noun + verb = {0}'.format(100 * i + j)) break
def identical_hosts(num_hosts=10, max_vms=None, min_vm_ram=None, max_vm_ram=None): VM.reset() VMhost.reset() stateA = VMPoolState() vmhosts = testcases.utils.create_vmhosts(num_hosts, 'x86_64', 4096, 280) for vmhost in vmhosts: stateA.init_vmhost(vmhost.name) randomly_populate_hosts(stateA, max_vms, min_vm_ram=min_vm_ram, max_vm_ram=max_vm_ram) stateB = randomly_shuffle(copy.copy(stateA)) return (stateA, stateB, "no idea what path to expect!")
def info(user, password, machine, mongo, dt_string): server= machine["name"] owner = machine["owner"] print("working on server " + server) resource = Resources(server, owner, dt_string) conn = Connection(server, user, password) try: pythoncom.CoInitialize() conn.register_physical() except Exception as e: print("connection issues with physical namespace " + server) print(e) mongo.update("systems", {"server": server}, json.loads(str(resource))) return resource.physical_properties = PhysicalProperties(conn.physical_connection, get_login=True) print("got physical info of " + server) try: conn.register_virtual() resource.virtual_properties = VirtualProperties(conn.virtual_connection) for vm in resource.virtual_properties.vms_list: v = VM(conn.virtual_connection, vm) resource.virtual_properties.register_vm(v) print("got virtual info of " + server) resource.physical_properties.virtualization = resource.virtual_properties.virtualization except Exception as e: resource.physical_properties.virtualization = "disabled" print("Did not find virtual namespace on " + server) print(e) #print(resource) mongo.update("systems", {"server": server}, json.loads(str(resource)))
def solve(): prev_first_x = 0 rows = [] for y in count(500): first_x = None if prev_first_x == None: prev_first_x = 0 x = prev_first_x while True: inputs = deque([x, y]) vm = VM(ns, inputs) output = next(vm) if output: if first_x == None: first_x = x if rows: x = rows[-1][1] - 1 else: if first_x != None: rows.append((first_x, x)) if len(rows) > 100: smallest_x = rows[-1][0] biggest_x = rows[-100][1] if biggest_x - smallest_x >= 100: return smallest_x * 10000 + y - 100 + 1 break x += 1 prev_first_x = first_x
def load_vm(self, name): show('Loading VM %s' % name) self.get_domain(name) # this fails if VM does not exist # TODO: check that it started, if not, wait self.start(name) # TODO: need a proper retry function ip = None timeout = 0 while ip is None: ip = self.get_ip(name) sleep(2) timeout += 2 if timeout > 20: raise RuntimeError("Could not determine IP of VM %s" % name) hostname = util.normalize_hostname(ip) show('IP determined: %s' % ip) return VM(name=name, backend=self, hostname=hostname, domain=locals.DOMAIN, ip=ip)
class Interpreter: def __init__(self): #The VM is the only thing that persists throughout running chunks of code #The lexer and parser are better off refershing line numbers and such when #made to run on a new chunk of code self.vm = VM() def run(self, code): #First we scan for tokens scanner = lexer.Scanner(code.upper()) tokens = scanner.scanTokens() #We use None as a way to return Errors if (tokens == None): print("Lexical error encountered. Not executing") return #Next we parse the tokens we've generated into trees parser = parsing.Parser(tokens) trees = parser.parse() if (trees == None): print("Parsing error encountered. Not executing") return #The next section forms a middle end, that changes the not so assembly code so far #into proper assembly code that the actual transputer would be able to handle #We should check for any prefix errors that may come up and be undetecable #at run time after we expand out illegal operands in the expansion step prefixChanger = prefixChecking.PrefixPreparer(trees) trees = prefixChanger.prepare() if (trees == None): print("Illegal prefix sequence encountered. Not executing") return #Then we use an expander to expand out double length instructions #And operands longer than 4 bits #We also check if there is any overflow when expanding out jumps expander = expanding.Expander(trees) trees = expander.expand() if (trees == None): print("Ran into a problem while correcting Jumps. Not executing") return #After this we're ready to interpret! self.vm.run(trees)
def get_vm(self, vmname): """Return the VM instance corresponding to the given vmname.""" if core.cfg['USESSH']: line=self.run("xm list | grep " + vmname + " | awk '{print $1,$2,$3,$4;}'").read() if len(line)<1: raise ClusterNodeError(self.get_hostname(),ClusterNodeError.VM_NOT_RUNNING,vmname) (name, id, ram, vcpu)=line.strip().split() return VM(name, id, ram, vcpu) else: try: uuid=self.server.xenapi.VM.get_by_name_label(vmname)[0] except IndexError: raise ClusterNodeError(self.get_hostname(),ClusterNodeError.VM_NOT_RUNNING,vmname) vm_rec=self.server.xenapi.VM.get_record(uuid) vm=VM(vm_rec['name_label'],vm_rec['domid']) vm.metrics=self.server.xenapi.VM_metrics.get_record(vm_rec['metrics']) return vm
def run(self, vm: VM) -> Optional['Break']: param_nums = [vm.belt().get_num(idx) for idx in self._param_indices] params = [ num.to_signed(self._is_signed).to_int() for num in param_nums ] data_type = functools.reduce(DataType.promote, (param.data_type for param in param_nums)) if any(param is None for param in params): vm.belt().push(BeltNum(data_type, Integer(None))) else: results = self._op(data_type, *params) for result in reversed(results): vm.belt().push( BeltNum.from_signed(Integer(result), data_type, is_signed=self._is_signed)) return None
def run(self, vm: VM) -> Optional['Break']: a_num = vm.belt().get_num(self._a_idx) b_num = vm.belt().get_num(self._b_idx) a = a_num.to_signed(self._is_signed).to_int() b = b_num.to_signed(self._is_signed).to_int() if a is None or b is None or not self._op(a, b): raise ValueError('Verify failed') return None
def execute(filename): try: f = open(filename) except: print_msg("open file error\n", abort=True) text = f.read() f.close() token = tokenizer(text) parser = Parser(token) instruction = parser.parse() #print repr(text) #print instruction vm = VM(instruction) vm.run() return text
def __init__(self, _id, _label, _isHost=False): Component.__init__(self, _id, _label) self.compType = CompType.DEVICE self.isHost = _isHost self.VMs = [] if _isHost: self.VMs = [VM(self.id) for x in range(cfg.VMsInHost)] self.links = []
def test_simple_loop_break(): vm = VM( LoopStack([ LoopTree.LEAF(8), ]), num_locals=0, ram_size=0, ) ins = InsLoopSpecified( Block([ InsBrIf(condition_idx=0, br_depth=1), InsArith([2], False, ArithMode.CHECKED, lambda n: n + 1), InsConst(BeltNum(DataType.I8, Integer(3))), InsRel(a_idx=0, b_idx=1, is_signed=False, op=lambda a, b: a < b), ])) ins.run(vm) belt = [vm.belt().get_num(i).value.expect_int() for i in range(Belt.SIZE)] assert belt == [1, 3, 4, 0, 3, 3, 0, 3, 2, 0, 3, 1, 0, 0, 0, 0]
def run(self, vm: VM) -> Optional['Break']: if vm.belt().get_num(self._condition_idx).value.expect_int(): block = self._then_block else: block = self._else_block br = block.run(vm) if br is not None and br.depth == 0 and br.is_continue: raise ValueError('Cannot continue if/else/end block') return br
def get_vms(self): """Return the list of VM instance for each running vm.""" vms=list() if core.cfg['USESSH']: for line in self.run("xm list | awk '{print $1,$2,$3,$4;}' | tail -n +3").readlines(): (name, id, ram, vcpu)=line.strip().split() vms.append(VM(name, id, ram, vcpu)) else: dom_recs = self.server.xenapi.VM.get_all_records() dom_metrics_recs = self.server.xenapi.VM_metrics.get_all_records() if core.cfg['DEBUG']: print "DEBUG Xen-Api: ", dom_recs for dom_rec in dom_recs.values(): if dom_rec['name_label'] != "Domain-0": vm=VM(dom_rec['name_label'],dom_rec['domid']) vm.metrics=dom_metrics_recs[dom_rec['metrics']] vms.append(vm) return vms
def _get_vms(): vms=list() dom_recs = self.server.xenapi.VM.get_all_records() dom_metrics_recs = self.server.xenapi.VM_metrics.get_all_records() log.debug("[API]", self.hostname, "dom_recs=", dom_recs) log.debug("[API]", self.hostname, "dom_metrics_recs=", dom_metrics_recs) for dom_rec in dom_recs.values(): if dom_rec['name_label'] == "Domain-0": continue # Discard Dom0 if dom_rec['name_label'].startswith("migrating-"): continue # Discard migration temporary vm if dom_rec['power_state'] == "Halted": # power_state could be: Halted, Paused, Running, Suspended, Crashed, Unknown continue # Discard non instantiated vm vm=VM(dom_rec['name_label'],dom_rec['domid']) vm.metrics=dom_metrics_recs[dom_rec['metrics']] vms.append(vm) return vms
class Interpreter: def __init__(self, initial_class, classpath): self.initial_class_name = initial_class self.vm = VM(classpath) def start(self): self.vm.class_loader.load_jar('klasses/rt.jar') self.vm.warmup() # initialise klass klass = self.vm.load_class(self.initial_class_name) self.vm.frame_stack[0].push('java') # run initial method self.vm.run_method(klass, klass.get_method('main', '([Ljava/lang/String;)V')[1]) self.vm.run_bytecode()
def get(self): self.response.headers['Content-Type'] = 'application/json' logging.info("get single vm received") # GET VM with same request.remote_addr q = VM.all() q.filter("ip =", self.request.remote_addr) vm = q.get() if vm == None: logging.info('no vm found for this ip: '+str(self.request.remote_addr)+', abort') self.error(204) return l = { 'vms': [vm.getJSON()]} content = json.dumps(l, indent=2) # logging.info(content) self.response.out.write(content)
def test_halt_after_poweroff(self): # Bring up a VM and test power off by call poweroff on instance self.vm = self._vm_factory('halt_test') self.vm.poweroff() # test that you can't halt a powered off machine self.vm.halt() #clean up the machine self.vm.unregistervm() # Bring up a VM and test poweroff with command line parameters self.vm = self._vm_factory('halt_test') kwargs = { 'subparser_name': 'destroy', 'force': False, 'TEST': self.TEST } self.vm = VM(**kwargs)
def test_barebones_init(self): project_name='virtual_machine_1' self.kwargs.update({ 'subparser_name':'init', 'force':True, 'project-name':project_name, }) vm = VM(**self.kwargs) self.assertEqual(vm.RET['STATUS'], 'SUCCESS') self.assertTrue(os.path.isdir(project_name)) # Check that we have to be in correct directory self.assertRaises(IOError, vm.readVagabond) hold_dir = os.getcwd() os.chdir(project_name) vm.readVagabond() config = vm.config self.assertEqual(vm.config_version, API_VERSION) # confirm that that config has a vm section self.assertTrue(config.get('vm')) # Confirm that the defaults are correct vm = config.get('vm') self.assertEqual('hashicopy/precise64', vm.get('box')) self.assertEqual(None, vm.get('iso')) self.assertEqual(project_name, vm.get('hostname')) # Now go back to parent directory and try again to see errors os.chdir(hold_dir) # Now test that trying to create the project again without --force throws errors self.kwargs.update({'force':False}) self.assertRaises(VagabondError, VM, **self.kwargs) self.kwargs.update({'force':True}) vm = VM(**self.kwargs) project_path=os.path.abspath(project_name) shutil.rmtree(project_path) self.assertFalse(os.path.isdir(project_path))
def test_halt(self): # Test halt by calling the halt() method on an instantiated vm self.vm = self._vm_factory('halt_test') self.vm.halt() # Test calling halt on a halted vm. self.vm.halt() # Test that you can't poweroff a halted machine self.vm.poweroff() # Bring the vm back up. # and call halt with command line parameters self.vm.up() kwargs = { 'subparser_name': 'halt', 'force': False, 'TEST': self.TEST } self.vm = VM(**kwargs)
def run(bytes, mode): data = Data(bytes[16:]) isdump = mode == MODE_DUMP offset = 0 text_bytes = bytes[16:] # テキストデータ vm = VM(text_bytes) # TODO:dumpとrunは分ける。 while data.has_more_elements(): pc = vm.pc() op = (text_bytes[pc+1] << 8) | text_bytes[pc] print("pc:", pc, hex(pc), "op:", op, oct(op), hex(op)) # ダンプ用 d = opcode.dispatch(op, data, MODE_DUMP, vm) print("dump:", d) # ダンプするとpcが書き換わるので、元に戻す vm.set_pc(pc) d = opcode.dispatch(op, data, mode, vm) vm.dump_reg()
reference = None cpu = CY16() data = [[0x1e,0x7a],[0xfe,0x146],[0x8a8,0xa6e]] for opt,param in opts[0]: if opt in ("-h","--help"): usage(0) elif opt in ("-t","--test"): test = True elif opt in ("-c","--cpu"): if param == "cy16": cpu = CY16() # information that should be considered as data and not opcode data = [[0x1e,0x7a],[0xfe,0x146],[0x8a8,0xa6e]] elif param == "vm": cpu = VM() data = [] else: print "Unknown cpu" usage(1) elif opt in ("-g","--graphic"): graphic = param elif opt in ("-b","--graphic-bloc"): block_graphic = param elif opt in ("-o","--offset"): offset = int(param) elif opt in ("-x","--disassemble"): disassemble = True elif opt in ("-d","--debuguer"): debugguer = True elif opt in ("-r","--reference"):
def test_vm_rollbacks_after_test1(): vm = VM("oneiric") with vm.start(): tdirname = os.path.join(vm.fs.mpoint, some_dir) SSHCMDExecutor(vm.ip, vmuser, vmpass) ok_(not os.path.exists(tdirname))
def test_show_valid_os_types(self): ostypes = VM.show_valid_os_types() self.assertEqual(ostypes, OSTYPES)
class TestVMActions(unittest.TestCase): def setUp(self): self.TEST=True self.kwargs = { 'TEST': self.TEST, } # Make sure the previous test directory is removed if os.path.isdir(TEST_ROOT): shutil.rmtree(TEST_ROOT) # Create a new test directory os.mkdir(TEST_ROOT) self.vm = None def tearDown(self): print "\n** tearDown ** " if self.vm: self.vm.halt() self.vm.unregistervm() # Now remove the root testing directory shutil.rmtree(TEST_ROOT) def _vm_factory(self, project_name): # Return to the root test directory os.chdir(TEST_ROOT) self.kwargs.update({ 'subparser_name':'init', 'force':True, 'project-name':project_name, 'iso':os.path.expanduser('~/Downloads/ubuntu-14.04.1-server-i386.iso') }) VM(**self.kwargs) os.chdir(project_name) kwargs = { 'subparser_name': 'up', 'force': True, 'hard_force': False, 'TEST': self.TEST } vm = VM(**kwargs) time.sleep(3) return vm def test_startvm(self): self.vm = self._vm_factory('start_test') #Should be warning self.vm.up() def test_halt(self): # Test halt by calling the halt() method on an instantiated vm self.vm = self._vm_factory('halt_test') self.vm.halt() # Test calling halt on a halted vm. self.vm.halt() # Test that you can't poweroff a halted machine self.vm.poweroff() # Bring the vm back up. # and call halt with command line parameters self.vm.up() kwargs = { 'subparser_name': 'halt', 'force': False, 'TEST': self.TEST } self.vm = VM(**kwargs) def test_barebones_init(self): project_name='virtual_machine_1' self.kwargs.update({ 'subparser_name':'init', 'force':True, 'project-name':project_name, }) vm = VM(**self.kwargs) self.assertEqual(vm.RET['STATUS'], 'SUCCESS') self.assertTrue(os.path.isdir(project_name)) # Check that we have to be in correct directory self.assertRaises(IOError, vm.readVagabond) hold_dir = os.getcwd() os.chdir(project_name) vm.readVagabond() config = vm.config self.assertEqual(vm.config_version, API_VERSION) # confirm that that config has a vm section self.assertTrue(config.get('vm')) # Confirm that the defaults are correct vm = config.get('vm') self.assertEqual('hashicopy/precise64', vm.get('box')) self.assertEqual(None, vm.get('iso')) self.assertEqual(project_name, vm.get('hostname')) # Now go back to parent directory and try again to see errors os.chdir(hold_dir) # Now test that trying to create the project again without --force throws errors self.kwargs.update({'force':False}) self.assertRaises(VagabondError, VM, **self.kwargs) self.kwargs.update({'force':True}) vm = VM(**self.kwargs) project_path=os.path.abspath(project_name) shutil.rmtree(project_path) self.assertFalse(os.path.isdir(project_path)) unittest.skip("showing class skipping") def test_iso_box(self): print "ENTERING test_iso_box" self.vm = self._vm_factory('Ubuntu_1404') self.vm.halt() self.vm.up() self.vm.halt() self.vm.unregistervm() def test_halt_after_poweroff(self): # Bring up a VM and test power off by call poweroff on instance self.vm = self._vm_factory('halt_test') self.vm.poweroff() # test that you can't halt a powered off machine self.vm.halt() #clean up the machine self.vm.unregistervm() # Bring up a VM and test poweroff with command line parameters self.vm = self._vm_factory('halt_test') kwargs = { 'subparser_name': 'destroy', 'force': False, 'TEST': self.TEST } self.vm = VM(**kwargs) def test_action_not_defined(self): kwargs = { 'subparser_name': 'noaction', 'force': False, 'TEST': self.TEST } self.assertRaises(VagabondActionUndefined, VM, **self.kwargs) def test_box_subaction_not_defined(self): self.kwargs.update({ 'subparser_name': 'box', 'box_subparser_name': 'noaction', 'name': 'ubuntu_1404', 'loc': 'http://hashicorp-files.vagrantup.com/precise32.box', }) self.assertRaises(VagabondError, VM, **self.kwargs) unittest.skip("showing class skipping") def test_add_vagrant_box(self): self.kwargs.update({ 'subparser_name': 'box', 'box_subparser_name': 'add', 'name': 'ubuntu_1404', 'loc': 'http://hashicorp-files.vagrantup.com/precise32.box', }) vm = VM(**self.kwargs) self.assertEqual(vm.RET['STATUS'], 'SUCCESS') # Test that all the typicaly vagrant files are there. VAGABOND_PROJECT_ROOT = vm.RET['VAGABOND_PROJECT_ROOT'] for _file in ['box-disk1.vmdk', 'box.ovf', 'Vagrantfile']: vfile = os.path.join(VAGABOND_PROJECT_ROOT, _file) self.assertTrue(os.path.isfile(vfile)) """ x box-disk1.vmdk x box.ovf x Vagrantfile """ def test_show_valid_os_types(self): ostypes = VM.show_valid_os_types() self.assertEqual(ostypes, OSTYPES)
from vdi import VDI from vm import VM from pif import get_network, get_public_pif XENAPI_URL = 'http://65.183.54.10' IMAGE_PATH = '/Users/jarrod/Dev/ipcloud/ubuntu.10-04.x86-64.20100927.img.gz' import XenAPI session = XenAPI.Session('https://65.183.54.10/') session.login_with_password('root','') xenapi = session.xenapi i = Instance(name='Ubuntu 10.04', instance_type='level2') v = VM(session) vm_ref = v.create(i, '', '') print "vm_ref - %s" % vm_ref di = VDI(session) vdi_ref = di.create('%s-vdi' % i._name, i._storage_gb) print "vdi_ref - %s" % vdi_ref # This is where the img should be attached to disk? c = pycurl.Curl() c.setopt(c.POST, True) c.setopt(c.ENCODING, 'gzip') c.setopt(c.HTTPAUTH, c.HTTPAUTH_BASIC) c.setopt(c.USERPWD, "%s:%s" % ('root', '')) c.setopt(c.URL, "%s/import_raw_vdi?vdi=%s" % (XENAPI_URL, vdi_ref)) c.setopt(c.HTTPPOST, [ ("filename", (c.FORM_FILE, IMAGE_PATH)),
def main(): print "---" print "Simple test" print vm = VM(code_test) vm.run() print "---" print "GCD" print vm = VM(code_gcd) vm.greg[0] = 9 vm.greg[1] = 12 vm.run() print "---" print "Concurrent fibonacci" print vm = VM(code_fib_concurrent, 4) vm.greg[0] = 17 vm.run()
def setUp(self): VM.reset() VMhost.reset()
import sys import os from vm import VM if __name__ == '__main__': assert len(sys.argv) == 2 print os.getcwd() with open(sys.argv[1],"rb") as fin: data = fin.read() vm = VM(data) vm.inPort[0x3E80] = 1001.0 while vm.outPort[0] == 0.0: vm.printStats() print 'step' vm.execute() vm.memDump() break vm.printStats() print 'ok'
from __future__ import with_statement import sys import os from vm import VM if __name__ == '__main__': assert len(sys.argv) == 2, "specify .obf file" with open(sys.argv[1],"rb") as fin: data = fin.read() vm = VM(data) vm.setScenario(1001) while vm.stats.score == 0.0: print 'step' vm.execute() vm.changeSpeed(10,12) vm.changeSpeed(10,12) # overwrite previous #vm.memDump() vm.printStats() if True: vm.execute() break # to finish after first iteration with open('solution','wb') as fout: fout.write(vm.getSolution()) print 'finished'
def __init__(self, initial_class, classpath): self.initial_class_name = initial_class self.vm = VM(classpath)