def test_task(uuid, box):
ret = False
try:
folder = path.join(box["temp"], uuid)
virtual_machine = VirtualBox().find_machine(box["vm"])
with virtual_machine.create_session() as session:
session.unlock_machine()
proc = virtual_machine.launch_vm_process(session, "gui", "")
proc.wait_for_completion(timeout=-1)
with session.console.guest.create_session(box["user"],
box["pass"]) as gs:
if box["os"] == "Linux":
gs.environment_schedule_set("DISPLAY", ":0")
process, stdout, stderr = gs.execute("bin/ls")
if len(stdout) > 0:
ret = True
elif box["os"] == "Windows":
process, stdout, stderr = gs.execute(
"%WINDIR%\\system32\\cmd.exe", ["/C", "dir"])
if len(stdout) > 0:
ret = True
session.console.power_down()
except Exception as e:
log_string(uuid, "custom_task Failed {}".format(e), "Red")
return ret
def custom_task(uuid, box, actions_list):
ret = False
try:
folder = path.join(box["temp"], uuid)
file_recording(uuid, box["vm"],
path.join(folder, box["screen_recorder"]))
virtual_machine = VirtualBox().find_machine(box["vm"])
with virtual_machine.create_session() as session:
session.unlock_machine()
file_recording(uuid, box["vm"],
path.join(folder, box["screen_recorder"]))
proc = virtual_machine.launch_vm_process(session, "headless", "")
proc.wait_for_completion(timeout=-1)
#do not timeout the session.console.guest.create_session timeout_ms=5*1000 (some vms)
with session.console.guest.create_session(box["user"],
box["pass"]) as gs:
#fix issues with display
if box["os"] == "Linux":
gs.environment_schedule_set("DISPLAY", ":0")
sleep(1)
session.machine.recording_settings.enabled = True
sleep(1)
parse_actions(uuid, box, folder, session, gs, actions_list)
sleep(1)
session.machine.recording_settings.enabled = False
take_screenshot(uuid, box["vm"],
path.join(folder, box["screenshot"]))
sleep(1)
ret = True
session.console.power_down()
except Exception as e:
log_string(uuid, "custom_task Failed {}".format(e), "Red")
return ret
def turn_off(uuid, box, timeout):
ret = False
try:
log_string(
uuid, "{} Status {}".format(box["vm"],
show_status(uuid, box["vm"])),
"Yellow")
timeout_start = time()
virtual_machine = VirtualBox().find_machine(box["vm"])
if Session().state == SessionState(2):
Session().unlock_machine()
if virtual_machine.state != MachineState.aborted:
with virtual_machine.create_session() as session:
if virtual_machine.state == MachineState.saved:
session.machine.discard_saved_state(True)
elif virtual_machine.state != MachineState.powered_off:
session.console.power_down()
while virtual_machine.state != MachineState.powered_off and (
time() < timeout_start + timeout):
log_string(uuid, "Waiting on {}".format(box["vm"]),
"Yellow")
sleep(2)
if virtual_machine.state == MachineState.powered_off:
log_string(uuid, "VM is powered off {}".format(box["vm"]),
"Yellow")
ret = True
except Exception as e:
log_string(uuid, "turn_off Failed {}".format(e), "Red")
return ret
def init(self):
with open("run.json", "r") as file:
run = json.load(file)
for commands in run:
vbox = VirtualBox()
session = Session()
vm = vbox.find_machine(VBOX_MACHINE_NAME)
p = vm.launch_vm_process(session, 'gui', '')
p.wait_for_completion(60 * 1000)
session = vm.create_session()
gs = session.console.guest.create_session(VBOX_USER_NAME,
VBOX_PASSWORD,
timeout_ms=300 *
1000)
for command in commands:
print("Command: %s" % (command['command']))
print("Parameters: %s" % (command['parameters']))
print("Sleep: %s" % (command['sleep']))
try:
process, stdout, stderr = gs.execute(
command['command'],
command['parameters'],
timeout_ms=30 * 1000)
print(stdout)
time.sleep(int(command['sleep']))
except:
pass
self._power_down(session)
self._extract_victims(
VICTIMS_FOLDER_IN,
datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S"))
self._delete_victims(VICTIMS_FOLDER_IN)
def delete_machine(uuid, box):
try:
virtual_machine = VirtualBox().find_machine(box["vm"])
virtual_machine.remove(delete=True)
log_string(uuid, "{} was deleted".format(box["vm"]), "Red")
return True
except Exception as e:
log_string(uuid, "delete_machine Failed {}".format(e), "Red")
return False
def _power_down(self, session):
vbox = VirtualBox()
clone = vbox.find_machine(session.machine.name)
try:
p = session.console.power_down()
p.wait_for_completion(60*1000)
session.unlock_machine()
session = clone.create_session()
console = session.console
p = console.restore_snapshot()
p.wait_for_completion(60*1000)
return clone
finally:
if session.state == SessionState.locked:
session.unlock_machine()
def _power_down(self, session):
vbox = VirtualBox()
clone = vbox.find_machine(session.machine.name)
try:
p = session.console.power_down()
p.wait_for_completion(60 * 1000)
session.unlock_machine()
session = clone.create_session()
console = session.console
p = console.restore_snapshot()
p.wait_for_completion(60 * 1000)
return clone
finally:
if session.state == SessionState.locked:
session.unlock_machine()
def get_machines(base_name):
v_box = VirtualBox()
all_machines = v_box.machines
machines = []
for machine in all_machines:
if base_name in machine.name:
machines.append(machine)
return machines
def _new_instance(cls, docker_manager):
try:
from virtualbox import VirtualBox
from virtualbox.library import ISession, LockType
except ImportError:
return None
return VirtualBoxHypervisor(docker_manager, VirtualBox(), ISession,
LockType)
def get_machine_status(uuid, box):
try:
virtual_machine = VirtualBox().find_machine(box["vm"])
log_string(uuid, "machine status is {}".format(virtual_machine.state),
"Red")
return True
except:
log_string(uuid, "get_machine_status Failed {}".format(e), "Red")
return False
def create_dummy_machine(uuid, box):
try:
log_string(uuid, "Creating {}".format(box["vm"]), "Green")
machine = VirtualBox().create_machine(settings_file="",
name=box["vm"],
os_type_id="",
groups=['/'],
flags="")
VirtualBox().register_machine(machine)
virtual_machine = VirtualBox().find_machine(box["vm"])
with virtual_machine.create_session() as session:
process, x = session.machine.take_snapshot(
box["snapshot"],
datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), True)
process.wait_for_completion(timeout=-1)
return True
except Exception as e:
log_string(uuid, "create_dummy_machine Failed {}".format(e), "Red")
def _power_down(self, session):
vbox = VirtualBox()
clone = vbox.find_machine(session.machine.name)
try:
p = session.console.power_down()
p.wait_for_completion(60 * 1000)
try:
session.unlock_machine()
except OleErrorUnexpected:
# session seems to become unlocked automatically after
# wait_for_completion is called after the power_down?
pass
session = clone.create_session()
p = session.machine.restore_snapshot()
p.wait_for_completion(60 * 1000)
return clone
finally:
if session.state == SessionState.locked:
session.unlock_machine()
def check_if_exists_machines(uuid, box):
try:
for machine in VirtualBox().machines:
if box["vm"] == machine.name:
log_string(uuid, "{} exists".format(box["vm"]), "Green")
return True
log_string(uuid, "{} does not exist".format(box["vm"]), "Green")
return False
except Exception as e:
log_string(uuid, "check_if_exists_machines Failed {}".format(e), "Red")
def _power_down(self, session):
vbox = VirtualBox()
clone = vbox.find_machine(session.machine.name)
try:
p = session.console.power_down()
p.wait_for_completion(60 * 1000)
try:
session.unlock_machine()
except OleErrorUnexpected:
# session seems to become unlocked automatically after
# wait_for_completion is called after the power_down?
pass
session = clone.create_session()
p = session.machine.restore_snapshot()
p.wait_for_completion(60 * 1000)
return clone
finally:
if session.state == SessionState.locked:
session.unlock_machine()
def _clones(self):
"Yield all machines under this pool"
vbox = VirtualBox()
machines = []
for machine in vbox.machines:
if machine.name == self.machine_name:
continue
if machine.name.startswith(self.machine_name):
machines.append(machine)
return machines
def _lock(self, timeout_ms=-1):
"Exclusive lock over root machine"
vbox = VirtualBox()
machine = vbox.find_machine(self.machine_name)
wait_time = 0
while True:
session = Session()
try:
machine.lock_machine(session, LockType.write)
except Exception as exc:
if timeout_ms != -1 and wait_time > timeout_ms:
raise ValueError("Failed to acquire lock - %s" % exc)
time.sleep(1)
wait_time += 1000
else:
try:
yield session
finally:
session.unlock_machine()
break
def _lock(self, timeout_ms=-1):
"Exclusive lock over root machine"
vbox = VirtualBox()
machine = vbox.find_machine(self.machine_name)
wait_time = 0
while True:
session = Session()
try:
machine.lock_machine(session, LockType.write)
except Exception as exc:
if timeout_ms != -1 and wait_time > timeout_ms:
raise ValueError("Failed to acquire lock - %s" % exc)
time.sleep(1)
wait_time += 1000
else:
try:
yield session
finally:
session.unlock_machine()
break
def restore_machine(uuid, box):
restoring_machine = False
ret = False
try:
virtual_machine = VirtualBox().find_machine(box["vm"])
snap = virtual_machine.find_snapshot(box["snapshot"])
with virtual_machine.create_session() as session:
try:
restoring = session.machine.restore_snapshot(snap)
restoring.wait_for_completion(-1)
if restoring.completed == 1:
log_string(uuid,
"Restoring completed {}".format(box["vm"]),
"Green")
restoring_machine = True
except Exception as e:
log_string(uuid, "start_task Failed {}".format(e), "Red")
if restoring_machine:
ret = True
except Exception as e:
log_string(uuid, "start_task Failed {}".format(e), "Red")
return ret
def _new_instance(cls,
get_config_fn: GetConfigFunction,
docker_vm: str = DOCKER_VM_NAME) -> Hypervisor:
init_pythoncom()
try:
from virtualbox import VirtualBox
from virtualbox.library import ISession, LockType
except ImportError as err:
logger.error('Error importing VirtualBox libraries: %r', err)
raise
return VirtualBoxHypervisor(get_config_fn, VirtualBox(), ISession,
LockType, docker_vm)
def vms(self):
vbox = VirtualBox()
running_vms = len(
list(
filter(lambda m: m.state != MachineState.powered_off,
vbox.machines)))
full_text = self.py3.safe_format(self.format, {'number': running_vms})
#print(full_text)
if running_vms > 0:
color = self.py3.COLOR_BAD
else:
color = self.py3.COLOR_GOOD
return {
'full_text': full_text,
'color': color,
'cached_until': self.py3.time_in(seconds=120)
}
def vbox_remote_control(uuid, box):
ret = False
try:
queue = Redis.from_url(redis_settings_docker)
virtual_machine = VirtualBox().find_machine(box["vm"])
vm_name_lock = "{}_lock".format(box["vm"])
vm_name_frame = "{}_frame".format(box["vm"])
vm_name_action = "{}_action".format(box["vm"])
with virtual_machine.create_session() as session:
session.unlock_machine()
proc = virtual_machine.launch_vm_process(session, "headless", "")
proc.wait_for_completion(timeout=-1)
with session.console.guest.create_session(box["user"],
box["pass"]) as gs:
h, w, _, _, _, _ = session.console.display.get_screen_resolution(
0)
update_item(mongo_settings_docker["worker_db"],
mongo_settings_docker["worker_col_logs"], uuid, {
"status": "live",
"started_time": datetime.now()
})
queue.set(vm_name_lock, "False")
while queue.get(vm_name_lock) == b"False":
x, y, dz, dw, button_state, key = "false", "false", "false", "false", "false", "false"
try:
t = queue.get(vm_name_action)
if t and t != "None":
x, y, dz, dw, button_state, key = loads(t)
#log_string(uuid,">>>>>>>>>> {} {} {} {} {} {}".format(x,y,dz,dw,button_state,key),"Red")
except e:
pass
try:
if key != "false":
session.console.keyboard.put_scancodes(
list(scan_code_table[key]))
if "false" not in (x, y, dz, dw, button_state):
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 0)
if button_state == "leftclick":
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 1)
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 0)
elif button_state == "leftdoubleclick":
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 1)
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 0)
elif button_state == "rightclick":
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 2)
session.console.mouse.put_mouse_event_absolute(
x, y, dz, dw, 0)
queue.set(vm_name_action, "None")
png = session.console.display.take_screen_shot_to_array(
0, h, w, BitmapFormat.png)
queue.set(vm_name_frame, png)
except:
pass
sleep(.2)
ret = True
session.console.power_down()
except Exception as e:
log_string(uuid, "custom_task Failed {}".format(e), "Red")
return ret
def __init__(self):
try:
self.conn = VirtualBox()
except Exception:
self.conn = None
def initialize():
global vbox
vbox = VirtualBox()
from virtualbox import Session, VirtualBox
from virtualbox.library import MachineState
import time
import sys
poll_time = 30
try:
vbox = VirtualBox()
session = Session()
except ModuleNotFoundError as e:
if "vboxapi" in e.msg:
print("Module 'vboxapi' is missing. Installation steps:")
print("1. Download the VirtualBox SDK at https://www.virtualbox.org/wiki/Downloads")
print("2. Extract ZIP")
print("3. Navigate to installer directory")
print("4. Run python vboxapisetup.py install")
sys.exit(-1)
else:
raise e
# https://raw.githubusercontent.com/sethmlarson/virtualbox-python/984a6e2cb0e8996f4df40f4444c1528849f1c70d/virtualbox/library.py
while True:
machines = list(filter(lambda machine: machine.name.startswith("PIAV"), vbox.machines))
print("{} VMs found".format(len(machines)))
for machine in machines:
print("{}'s state: {}".format(machine.name, machine.state))
if machine.state == MachineState.powered_off:
def __init__(self):
try:
self.conn = VirtualBox()
except Exception as e:
print(e)
self.conn = None
def running_vagrant_boxes():
vbox = VirtualBox()
return [vm.name for vm in vbox.machines if vm.state == MachineState(5)]
