Ejemplo n.º 1
0
    def test_replace_vm_ip(self):
        ctxt_agent = CtxtAgent("/tmp/gen_data.json", "")
        vm_data = self.gen_vm_data()

        with open("/tmp/gen_data.json", "w+") as f:
            json.dump(self.gen_general_conf(), f)
        with open("/tmp/hosts", "w+") as f:
            f.write("%s_%s " % (vm_data['ip'], vm_data['id']))
            f.write(" ansible_host=%s " % vm_data['ip'])
            f.write(" ansible_ssh_host=%s \n" % vm_data['ip'])

        vm_data['ctxt_ip'] = "10.0.0.2"
        vm_data['ctxt_port'] = 22
        ctxt_agent.replace_vm_ip(vm_data, True)

        with open("/tmp/gen_data.json.rep", "r") as f:
            general_conf_data = json.load(f)
        for vm in general_conf_data['vms']:
            if vm['id'] == vm_data['id']:
                self.assertEqual(vm['ctxt_ip'], vm_data['ctxt_ip'])

        with open("/tmp/hosts", "r") as f:
            data = f.read()
        self.assertIn(" ansible_host=%s " % vm_data['ctxt_ip'], data)
        self.assertIn(" ansible_ssh_host=%s \n" % vm_data['ctxt_ip'], data)
Ejemplo n.º 2
0
    def test_copy_playbooks(self, sftp_put_dir, sftp_chmod, test_connectivity,
                            execute):
        ctxt_agent = CtxtAgent("", "")
        ctxt_agent.logger = self.logger
        execute.return_value = "out", "err", 0

        general_conf_data = self.gen_general_conf()
        vm = self.gen_vm_data()
        lock = threading.Lock()
        errors = []
        ctxt_agent.copy_playbooks(vm, general_conf_data, errors, lock)
        self.assertEqual(errors, [])
Ejemplo n.º 3
0
    def test_50_launch_ansible_thread(self, test_connectivity, queue,
                                      ansible_thread):
        CtxtAgent.logger = self.logger
        vm = self.gen_vm_data()
        queue_mock = MagicMock()
        queue.return_value = queue_mock
        queue_mock.get.return_value = None, (0, []), None
        thread = CtxtAgent.LaunchAnsiblePlaybook(self.logger, "/tmp",
                                                 "play.yml", vm, 1, "/tmp/inv",
                                                 "/tmp/pk.pem", 3, True, None)
        res = CtxtAgent.wait_thread(thread, self.gen_general_conf(), False)
        self.assertEqual(res, (True, []))

        CtxtAgent.VM_CONF_DATA_FILENAME = "/tmp/conf.dat"
        thread[0].is_alive.return_value = False
        res = CtxtAgent.wait_thread(thread, self.gen_general_conf(), True)
        self.assertEqual(res, (True, []))
Ejemplo n.º 4
0
    def test_80_run(self, sftp_put):
        CtxtAgent.logger = self.logger
        CtxtAgent.contextualize_vm = MagicMock()
        CtxtAgent.contextualize_vm.return_value = {
            'SSH_WAIT': True,
            'OK': True,
            'CHANGE_CREDS': True,
            'basic': True
        }

        with open("/tmp/gen_data.json", "w+") as f:
            json.dump(self.gen_general_conf(), f)
        with open("/tmp/vm_data.json", "w+") as f:
            json.dump(self.gen_vm_conf(["basic"]), f)

        res = CtxtAgent.run("/tmp/gen_data.json", "/tmp/vm_data.json", 0)
        self.assertTrue(res)

        open("/tmp/ctxt_agent.log", 'a').close()
        res = CtxtAgent.run("/tmp/gen_data.json", "/tmp/vm_data.json", 1)
        self.assertTrue(res)
Ejemplo n.º 5
0
    def test_90_replace_vm_ip(self):
        CtxtAgent.logger = self.logger
        vm_data = self.gen_vm_data()
        CtxtAgent.CONF_DATA_FILENAME = "/tmp/gen_data.json"
        with open("/tmp/gen_data.json", "w+") as f:
            json.dump(self.gen_general_conf(), f)
        with open("/tmp/hosts", "w+") as f:
            f.write(" ansible_host=%s \n" % vm_data['ip'])
            f.write(" ansible_ssh_host=%s \n" % vm_data['ip'])

        vm_data['ctxt_ip'] = "10.0.0.2"
        CtxtAgent.replace_vm_ip(vm_data)

        with open("/tmp/gen_data.json.rep", "r") as f:
            general_conf_data = json.load(f)
        for vm in general_conf_data['vms']:
            if vm['id'] == vm_data['id']:
                self.assertEqual(vm['ctxt_ip'], vm_data['ctxt_ip'])

        with open("/tmp/hosts", "r") as f:
            data = f.read()
        self.assertIn(" ansible_host=%s \n" % vm_data['ctxt_ip'], data)
        self.assertIn(" ansible_ssh_host=%s \n" % vm_data['ctxt_ip'], data)
Ejemplo n.º 6
0
    def test_60_changeVMCredentials(self, winrm_session, execute,
                                    execute_timeout):
        CtxtAgent.logger = self.logger
        execute.return_value = "", "", 0
        execute_timeout.return_value = "", "", 0
        vm = self.gen_vm_data()
        res = CtxtAgent.changeVMCredentials(vm, None)
        self.assertTrue(res)

        vm = self.gen_vm_data()
        del vm['new_passwd']
        vm['new_public_key'] = "new_public_key"
        vm['new_private_key'] = "new_private_key"
        res = CtxtAgent.changeVMCredentials(vm, None)
        self.assertTrue(res)

        session = MagicMock()
        req = MagicMock
        req.status_code = 0
        session.run_cmd.return_value = req
        winrm_session.return_value = session
        vm = self.gen_vm_data("windows")
        res = CtxtAgent.changeVMCredentials(vm, None)
        self.assertTrue(res)
Ejemplo n.º 7
0
    def test_launch_ansible_remote(self, sftp_put, execute):
        ctxt_agent = CtxtAgent("", "")
        ctxt_agent.logger = self.logger
        execute.return_value = ("pid", "", "")

        with open("/tmp/gen_data.json", "w+") as f:
            json.dump(self.gen_general_conf(), f)
        with open("/tmp/vm_data.json", "w+") as f:
            json.dump(self.gen_vm_conf(["basic"]), f)
        ctxt_agent.vm_conf_data_filename = "/tmp/gen_data.json"
        ctxt_agent.conf_data_filename = "/tmp/vm_data.json"

        vm = self.gen_vm_data()
        res = ctxt_agent.LaunchRemoteInstallAnsible(vm, None, False)
        self.assertEqual(res[1], "pid")
Ejemplo n.º 8
0
    def test_launch_ansible_thread(self, test_connectivity, queue,
                                   ansible_thread):
        ctxt_agent = CtxtAgent("", "/tmp/conf.dat")
        ctxt_agent.logger = self.logger
        vm = self.gen_vm_data()
        queue_mock = MagicMock()
        queue.return_value = queue_mock
        queue_mock.get.return_value = None, 0, None
        thread = ctxt_agent.LaunchAnsiblePlaybook(self.logger, "/tmp",
                                                  "play.yml", vm, 1,
                                                  "/tmp/inv", "/tmp/pk.pem", 3,
                                                  True, None)
        res = ctxt_agent.wait_thread(thread, self.gen_general_conf(), False)
        self.assertEqual(res, True)

        thread[0].is_alive.return_value = False
        res = ctxt_agent.wait_thread(thread, self.gen_general_conf(), True)
        self.assertEqual(res, True)
Ejemplo n.º 9
0
    def test_70_contextualize_vm(self, sftp_put, execute, test_connectivity):
        CtxtAgent.logger = self.logger
        CtxtAgent.changeVMCredentials = MagicMock()
        CtxtAgent.changeVMCredentials.return_value = True
        CtxtAgent.LaunchAnsiblePlaybook = MagicMock()
        queue = MagicMock()
        queue.get.return_value = None, (0, []), None
        thread = MagicMock()
        thread.is_alive.return_value = False
        CtxtAgent.LaunchAnsiblePlaybook.return_value = (thread, queue)
        CtxtAgent.wait_winrm_access = MagicMock()
        CtxtAgent.wait_winrm_access.return_value = True
        CtxtAgent.wait_ssh_access = MagicMock()
        CtxtAgent.wait_ssh_access.return_value = True
        CtxtAgent.removeRequiretty = MagicMock()
        CtxtAgent.removeRequiretty.return_value = True
        CtxtAgent.VM_CONF_DATA_FILENAME = "/tmp/conf.dat"
        CtxtAgent.CONF_DATA_FILENAME = "/tmp/gconf.dat"
        execute.return_value = "1", 1, 1

        ctxt_vm = None
        for vm in self.gen_general_conf()['vms']:
            if vm['id'] == self.gen_vm_conf(["basic"])['id']:
                ctxt_vm = vm

        with open("/tmp/ctxt_agent.out", 'w+') as f:
            f.write('{"OK": true}')
        res = CtxtAgent.contextualize_vm(self.gen_general_conf(),
                                         self.gen_vm_conf(["basic"]), ctxt_vm,
                                         0)
        expected_res = {
            'SSH_WAIT': True,
            'OK': True,
            'CHANGE_CREDS': True,
            'basic': True
        }
        self.assertEqual(res, expected_res)

        res = CtxtAgent.contextualize_vm(self.gen_general_conf(),
                                         self.gen_vm_conf(["basic"]), ctxt_vm,
                                         1)
        expected_res = {
            'SSH_WAIT': True,
            'OK': True,
            'CHANGE_CREDS': True,
            'basic': True
        }
        self.assertEqual(res, expected_res)

        ctxt_vm = None
        for vm in self.gen_general_conf()['vms']:
            if vm['id'] == self.gen_vm_conf(["main", "front"])['id']:
                ctxt_vm = vm

        res = CtxtAgent.contextualize_vm(self.gen_general_conf(),
                                         self.gen_vm_conf(["main", "front"]),
                                         ctxt_vm, 0)
        expected_res = {'OK': True, 'front': True, 'main': True}
        self.assertEqual(res, expected_res)

        res = CtxtAgent.contextualize_vm(self.gen_general_conf(),
                                         self.gen_vm_conf(["main", "front"]),
                                         ctxt_vm, 1)
        expected_res = {'OK': True, 'front': True, 'main': True}
        self.assertEqual(res, expected_res)
Ejemplo n.º 10
0
 def test_40_run_command(self):
     CtxtAgent.logger = self.logger
     res = CtxtAgent.run_command("ls -l", 2, 0.1)
     self.assertIn("total", str(res))
Ejemplo n.º 11
0
 def test_30_removeRequiretty(self, execute_timeout):
     CtxtAgent.logger = self.logger
     execute_timeout.return_value = "", "", 0
     vm = self.gen_vm_data()
     res = CtxtAgent.removeRequiretty(vm, False, None)
     self.assertTrue(res)
Ejemplo n.º 12
0
 def test_20_wait_winrm_access(self, socket_connect_ex):
     socket_connect_ex.return_value = 0
     CtxtAgent.logger = self.logger
     vm = self.gen_vm_data("windows")
     res = CtxtAgent.wait_winrm_access(vm)
     self.assertTrue(res)
Ejemplo n.º 13
0
 def test_10_wait_ssh_access(self, test_connectivity):
     CtxtAgent.logger = self.logger
     vm = self.gen_vm_data()
     res = CtxtAgent.wait_ssh_access(vm)
     self.assertEqual(res, "init")
Ejemplo n.º 14
0
    def test_contextualize_vm(self, from_private_key, sftp_put_dir, sftp_mkdir,
                              sftp_put, execute, test_connectivity):
        ctxt_agent = CtxtAgent("/tmp/gconf.dat", "/tmp/conf.dat")
        ctxt_agent.logger = self.logger
        ctxt_agent.changeVMCredentials = MagicMock()
        ctxt_agent.changeVMCredentials.return_value = True
        ctxt_agent.LaunchAnsiblePlaybook = MagicMock()
        queue = MagicMock()
        queue.get.return_value = None, 0, None
        thread = MagicMock()
        thread.is_alive.return_value = False
        ctxt_agent.LaunchAnsiblePlaybook.return_value = (thread, queue)
        ctxt_agent.wait_winrm_access = MagicMock()
        ctxt_agent.wait_winrm_access.return_value = True
        ctxt_agent.wait_ssh_access = MagicMock()
        ctxt_agent.wait_ssh_access.return_value = True
        ctxt_agent.removeRequiretty = MagicMock()
        ctxt_agent.removeRequiretty.return_value = True
        execute.return_value = "1", 1, 1

        ctxt_vm = None
        for vm in self.gen_general_conf()['vms']:
            if vm['id'] == self.gen_vm_conf(["basic"])['id']:
                ctxt_vm = vm

        with open("/tmp/ctxt_agent.out", 'w+') as f:
            f.write('{"OK": true}')
        res = ctxt_agent.contextualize_vm(self.gen_general_conf(),
                                          self.gen_vm_conf(["basic"]), ctxt_vm,
                                          0)
        expected_res = {
            'SSH_WAIT': True,
            'OK': True,
            'CHANGE_CREDS': True,
            'basic': True
        }
        self.assertEqual(res, expected_res)

        res = ctxt_agent.contextualize_vm(self.gen_general_conf(),
                                          self.gen_vm_conf(["basic"]), ctxt_vm,
                                          1)
        expected_res = {'SSH_WAIT': True, 'OK': True, 'basic': True}
        self.assertEqual(res, expected_res)

        ctxt_vm = None
        for vm in self.gen_general_conf()['vms']:
            if vm['id'] == self.gen_vm_conf(["main", "front"])['id']:
                ctxt_vm = vm

        res = ctxt_agent.contextualize_vm(self.gen_general_conf(),
                                          self.gen_vm_conf(["main", "front"]),
                                          ctxt_vm, 0)
        expected_res = {'OK': True, 'front': True, 'main': True}
        self.assertEqual(res, expected_res)

        res = ctxt_agent.contextualize_vm(self.gen_general_conf(),
                                          self.gen_vm_conf(["main", "front"]),
                                          ctxt_vm, 1)
        expected_res = {'OK': True, 'front': True, 'main': True}
        self.assertEqual(res, expected_res)

        res = ctxt_agent.contextualize_vm(
            self.gen_general_conf(), self.gen_vm_conf(["copy_facts_cache"]),
            ctxt_vm, 0)
        expected_res = {'OK': True, 'copy_facts_cache': True}
        self.assertEqual(res, expected_res)
Ejemplo n.º 15
0
 def test_gen_facts_cache(self, ansible_thread):
     ctxt_agent = CtxtAgent("", "")
     ctxt_agent.logger = self.logger
     ctxt_agent.gen_facts_cache('/tmp', '', None)