def known_hosts(vagrant_root): vagrant_root = lookup_vagrant_root(vagrant_root) vagrant = Vagrant(vagrant_root) return { machine: vagrant.hostname(machine) for machine in list_machines(vagrant_root) }
def known_hosts(vagrant_root, name=None): vagrant_root = lookup_vagrant_root(vagrant_root) vagrant = Vagrant(vagrant_root) machines = list_machines(vagrant_root) name = name if name in machines else machines[0] return parse_content( vagrant._run_vagrant_command(('ssh', name, '-c', 'cat /etc/hosts')))
def execute_vagrant_command_on_minion(self, project_name, command): minion_path = self.parent.config['minions'][project_name] vagrant = Vagrant(minion_path, quiet_stdout=False, quiet_stderr=False) puts( colored.blue("Execute vagrant %s on minion %s" % (command, project_name))) getattr(vagrant, command)() puts(colored.blue("Done"))
def main(self): for minion_name, minion_path in self.parent.config.get('minions', {}).items(): vagrant = Vagrant(minion_path) vagrant_status = vagrant.status()[0].state salt_status = self.parent.client.get_minion_status(minion_name) puts("%s:" % minion_name) with indent(4): puts("vagrant status: %s" % vagrant_status) puts("saltstack status: %s" % salt_status)
def __init__(self, *args, **kwargs): """Check that the vagrant_boxes attribute is not left empty, and is populated by all boxes if left blank""" self.vagrant = Vagrant(self.vagrant_root) if not self.vagrant_boxes: boxes = self.vagrant.status().keys() if len(boxes) == 1: self.vagrant_boxes = ['default'] else: self.vagrant_boxes = boxes super(VagrantTestCase, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): """Check that the vagrant_boxes attribute is not left empty, and is populated by all boxes if left blank""" self.vagrant = Vagrant(self.vagrant_root, err_cm=stderr_cm) if not self.vagrant_boxes: boxes = [s.name for s in self.vagrant.status()] if len(boxes) == 1: self.vagrant_boxes = ["default"] else: self.vagrant_boxes = boxes super().__init__(*args, **kwargs)
def vagrant(): v = Vagrant(os.path.dirname(__file__)) # Start remote VM first so local VM can copy its SSH key to it afterwards v.up(vm_name="remote") v.up(vm_name="local") yield v v.halt()
def __init__(self, host='default', vagrantDir=None, controlVagrant=True): global _defaultVagrantDir self.host = host self._controlVagrant = controlVagrant if vagrantDir is None: vagrantDir = _defaultVagrantDir self._vagrant = Vagrant(root=vagrantDir) self._startedVagrant = False self._sshClient = None self._sshConfigStr = None self._sshConfig = None self._sshHostConfig = None
def __enter__(self): # We want to start with a clean environment every time. if os.path.exists(SINGULARITY_VM_INPUT_DIR): rmtree(SINGULARITY_VM_INPUT_DIR) if os.path.exists(SINGULARITY_VM_OUTPUT_DIR): rmtree(SINGULARITY_VM_OUTPUT_DIR) makedirs(SINGULARITY_VM_OUTPUT_DIR) copytree(self.path_to_build, SINGULARITY_VM_INPUT_DIR, symlinks=True) self.vm = Vagrant(root=SINGULARITY_VM, quiet_stdout=False, quiet_stderr=False) return self
def __init__(self, vagrantfile): """ Configure logging. """ # Use the logger object created by Client. self.p = logging.getLogger('qb') self.p.debug("Using Vagrant config:\n" " Vagrantfile: %s" % vagrantfile) # Create a Vagrant object. self.vagrant = Vagrant(vagrantfile) return
def do_clean(self, project_name): minion_path = self.parent.config['minions'][project_name] # Check if sahara is available minion_path = self.parent.config['minions'][project_name] try: plugins = Vagrant(minion_path).plugin_list() except Exception as e: raise sahara = bool([p for p in plugins if p.name == "sahara"]) # Check sandbox status sandbox_status = 'off' if sahara: sandbox = SandboxVagrant(minion_path) sandbox_status = sandbox.sandbox_status() # If sandbox is activated, rollback only if sandbox_status == 'on' and not self.force_clean: message = "Rollback snapshot, if you will delete snapshot, use "\ "--force-clean option" puts(colored.blue(message)) sandbox.sandbox_rollback() puts(colored.blue("Done")) command = "sudo /etc/init.d/salt-minion restart" result = get_output_cmd(command, minion_path) puts(colored.blue("Restarted salt-minion")) puts(colored.blue("Wait some time for salt-minion to connect")) sleep(10) # Else destroy and up else: # Destroy VagrantDestroy.parent = self.parent VagrantDestroy.run(['destroy', project_name], exit=False) # Up VagrantUp.parent = self.parent VagrantUp.run(['up', project_name], exit=False)
def __init__(self, root_dir, env): self.instance = Vagrant(root=root_dir) self.env = env self.target = GuestOS(env[:-2], env[-2:])
def main(self, project_name): minion_path = self.parent.config['minions'][project_name] self.execute_vagrant_command_on_minion(project_name, 'up') # Get back master IP puts(colored.blue("Check master ip")) command = "/sbin/ifconfig eth1 | grep 'inet addr:' | cut -d: -f2 | cut -d' ' -f 1" vm_ip = get_output_cmd(command, minion_path) vm_ip = vm_ip.split('.') vm_ip[-1] = '1' master_ip = ".".join(vm_ip) # Check declared master ip command = "grep master /etc/salt/minion" declared_master_ip = get_output_cmd(command, minion_path) declared_master_ip = declared_master_ip.split()[-1] change = False if declared_master_ip != master_ip: puts( colored.yellow( "Master ip on minion is invalid, {0} instead of {1}". format(declared_master_ip, master_ip))) # Replace master ip command = "sudo sed -i 's/{0}/{1}/g' /etc/salt/minion".format( declared_master_ip, master_ip) result = get_output_cmd(command, minion_path) # Reboot minion command = "sudo /etc/init.d/salt-minion restart" result = get_output_cmd(command, minion_path) # Change minion command = "sed -i 's/{0}/{1}/g' {2}".format( declared_master_ip, master_ip, join(minion_path, 'minion')) check_output(command, shell=True) # Wait for minion to connect sleep(10) puts( colored.blue( "Master ip has been updated from {0} to {1}".format( declared_master_ip, master_ip))) change = True else: puts(colored.blue("Master is good")) # Check if sahara is available minion_path = self.parent.config['minions'][project_name] try: plugins = Vagrant(minion_path).plugin_list() except Exception as e: raise sahara = bool([p for p in plugins if p.name == "sahara"]) if not sahara: message = "Sandbox support is not available, please install sahara"\ " plugin with 'vagrant plugin install sahara'" puts(colored.yellow(message)) else: sandbox = SandboxVagrant(minion_path, quiet_stdout=False, quiet_stderr=False) sandbox_status = sandbox.sandbox_status() if sandbox_status == 'on': puts(colored.blue("Snapshot is already enabled on VM")) if change: puts( colored.blue( "Minion config has changes, would you like to redo the snapshot? It will save the VM in its current state" )) choice = bool_choice("Yes/No: ") if choice: sandbox.sandbox_commit() else: puts(colored.blue("Would you like to enable snapshot on VM?")) choice = bool_choice("Yes/No: ") if choice: puts(colored.blue("Starting snapshot")) sandbox.sandbox_on() puts(colored.blue("Done"))
def test_vagrant(temp_repo_func, destroy=False): if os.environ.get("TRAVIS", False): pytest.skip("Vagrant doesn't work on Travis") backend = VagrantBackend(verbosity=2, use_registry_name="docker.io/mikicz/arca-test", keep_vm_running=True) arca = Arca(backend=backend, base_dir=BASE_DIR) if destroy: vagrant_location = backend.get_vm_location() if vagrant_location.exists(): vagrant = Vagrant(vagrant_location) vagrant.destroy() shutil.rmtree(vagrant_location) # master branch - return colorama version temp_repo_func.file_path.write_text(RETURN_COLORAMA_VERSION_FUNCTION) requirements_path = temp_repo_func.repo_path / backend.requirements_location requirements_path.write_text("colorama==0.3.9") temp_repo_func.repo.index.add( [str(temp_repo_func.file_path), str(requirements_path)]) temp_repo_func.repo.index.commit("Initial") # branch branch - return unicode temp_repo_func.repo.create_head("branch") temp_repo_func.repo.branches.branch.checkout() temp_repo_func.file_path.write_text(SECOND_RETURN_STR_FUNCTION) temp_repo_func.repo.index.add([str(temp_repo_func.file_path)]) temp_repo_func.repo.index.commit("Test unicode on a separate branch") task = Task("test_file:return_str_function") assert arca.run(temp_repo_func.url, temp_repo_func.branch, task).output == "0.3.9" # halt the VM, checks that the VM can be booted when stopped with the vagrant attribute set backend.stop_vm() assert arca.run(temp_repo_func.url, temp_repo_func.branch, task).output == "0.3.9" # halt the vm and create a new instance of the backend, to check that the vagrant attribute can be set from existing backend.stop_vm() backend = VagrantBackend(verbosity=2, use_registry_name="docker.io/mikicz/arca-test", keep_vm_running=True) arca = Arca(backend=backend, base_dir=BASE_DIR) assert arca.run(temp_repo_func.url, temp_repo_func.branch, task).output == "0.3.9" # test that two branches can work next to each other assert arca.run(temp_repo_func.url, temp_repo_func.branch, task).output == "0.3.9" assert arca.run(temp_repo_func.url, "branch", task).output == TEST_UNICODE # test timeout temp_repo_func.repo.branches.master.checkout() temp_repo_func.file_path.write_text(WAITING_FUNCTION) temp_repo_func.repo.index.add([str(temp_repo_func.file_path)]) temp_repo_func.repo.index.commit("Waiting function") task_1_second = Task("test_file:return_str_function", timeout=1) task_3_seconds = Task("test_file:return_str_function", timeout=3) with pytest.raises(BuildTimeoutError): assert arca.run(temp_repo_func.url, temp_repo_func.branch, task_1_second).output == "Some string" assert arca.run(temp_repo_func.url, temp_repo_func.branch, task_3_seconds).output == "Some string" backend.stop_vm() if destroy: backend.destroy = True backend.stop_vm()
from __future__ import print_function from vagrant import Vagrant v = Vagrant() def mock_create(config): try: if config: v.init(box_name=config['box_name'], box_url=config['box_url']) else: v.init() return "SUCCESS" except Exception as e: return "FAILED" def mock_vagrantfile(): with open('Vagrantfile', 'r') as myfile: vagrantfile = myfile.read() return vagrantfile def mock_deploy(config): with open('./src/mockdata/create_instance') as myfile: status_file = myfile.read() return status_file