Пример #1
0
 def setUp(self):
     self.config = Config('config',
                          'esx',
                          server='localhost',
                          username='******',
                          password='******',
                          owner='owner',
                          env='env',
                          log_dir='',
                          log_file='')
     self.second_config = Config('second_config',
                                 'esx',
                                 server='localhost',
                                 username='******',
                                 password='******',
                                 owner='owner',
                                 env='env',
                                 log_dir='',
                                 log_file='')
     fake_virt = Mock()
     fake_virt.CONFIG_TYPE = 'esx'
     guests = [Guest('guest1', fake_virt, 1)]
     test_hypervisor = Hypervisor('test',
                                  guestIds=[Guest('guest1', fake_virt, 1)])
     assoc = {'hypervisors': [test_hypervisor]}
     self.fake_domain_list = DomainListReport(self.second_config, guests)
     self.fake_report = HostGuestAssociationReport(self.config, assoc)
Пример #2
0
 def test_sm_config_cmd(self):
     os.environ = {}
     sys.argv = ["virt-who", "--sam", "--libvirt"]
     logger, options = parseOptions()
     config = Config("env/cmdline", options.virtType, defaults={}, **options)
     config.checkOptions(logger)
     manager = Manager.fromOptions(logger, options, config)
     self.assertTrue(isinstance(manager, SubscriptionManager))
Пример #3
0
 def test_sendVirtGuests(self, create_from_file, connection):
     self.prepare(create_from_file, connection)
     config = Config('test', 'libvirt')
     config.smType = 'sam'
     manager = Manager.fromOptions(self.logger, self.options, config)
     manager.sendVirtGuests(self.domain_report, self.options)
     manager.connection.updateConsumer.assert_called_with(
         ANY,
         guest_uuids=[guest.toDict() for guest in self.guestInfo],
         hypervisor_id=self.hypervisor_id)
Пример #4
0
 def test_sm_config_env(self):
     os.environ = {
         "VIRTWHO_SAM": '1',
         "VIRTWHO_LIBVIRT": '1'
     }
     sys.argv = ["virt-who"]
     logger, options = parseOptions()
     config = Config("env/cmdline", options.virtType, defaults={}, **options)
     config.checkOptions(logger)
     manager = Manager.fromOptions(logger, options, config)
     self.assertTrue(isinstance(manager, SubscriptionManager))
Пример #5
0
 def test_satellite_config_cmd(self):
     os.environ = {}
     sys.argv = ["virt-who", "--satellite",
                 "--satellite-server=sat.example.com",
                 "--satellite-username=username",
                 "--satellite-password=password",
                 "--libvirt"]
     logger, options = parseOptions()
     config = Config("env/cmdline", options.virtType, defaults={}, **options)
     config.checkOptions(logger)
     manager = Manager.fromOptions(logger, options, config)
     self.assertTrue(isinstance(manager, Satellite))
Пример #6
0
 def test_satellite_config_env(self):
     os.environ = {
         "VIRTWHO_SATELLITE": '1',
         "VIRTWHO_SATELLITE_SERVER": 'sat.example.com',
         "VIRTWHO_SATELLITE_USERNAME": '******',
         "VIRTWHO_SATELLITE_PASSWORD": '******',
         "VIRTWHO_LIBVIRT": '1'
     }
     sys.argv = ["virt-who"]
     logger, options = parseOptions()
     config = Config("env/cmdline", options.virtType, defaults={}, **options)
     config.checkOptions(logger)
     manager = Manager.fromOptions(logger, options, config)
     self.assertTrue(isinstance(manager, Satellite))
Пример #7
0
 def test_satellite_config_cmd(self):
     os.environ = {}
     sys.argv = [
         "virt-who", "--satellite", "--satellite-server=sat.example.com",
         "--satellite-username=username", "--satellite-password=password",
         "--libvirt"
     ]
     logger, options = parseOptions()
     config = Config("env/cmdline",
                     options.virtType,
                     defaults={},
                     **options)
     config.checkOptions(logger)
     manager = Manager.fromOptions(logger, options, config)
     self.assertTrue(isinstance(manager, Satellite))
Пример #8
0
    def test_hypervisorCheckIn(self, server):
        options = MagicMock()
        server.return_value.registration.new_system_user_pass.return_value = {
            'system_id': '123'
        }

        config = Config('test', 'libvirt', sat_server='localhost')
        manager = Manager.fromOptions(self.logger, options, config)
        options.env = "ENV"
        options.owner = "OWNER"
        manager.hypervisorCheckIn(self.host_guest_report, options)
        manager.server_xmlrpc.registration.virt_notify.assert_called_with(ANY, [
            [0, "exists", "system", {"identity": "host", "uuid": "0000000000000000"}],
            [0, "crawl_began", "system", {}],
            [0, "exists", "domain", {
                "memory_size": 0,
                "name": "VM 9c927368-e888-43b4-9cdb-91b10431b258 from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670",
                "state": "running",
                "uuid": "9c927368e88843b49cdb91b10431b258",
                "vcpus": 1,
                "virt_type": "fully_virtualized"
            }],
            [0, "exists", "domain", {
                "memory_size": 0,
                "name": "VM d5ffceb5-f79d-41be-a4c1-204f836e144a from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670",
                "state": "shutoff",
                "uuid": "d5ffceb5f79d41bea4c1204f836e144a",
                "vcpus": 1,
                "virt_type": "fully_virtualized"
            }],
            [0, "crawl_ended", "system", {}]
        ])
Пример #9
0
    def test_sending_guests(self, parseFile, fromOptions, fromConfig,
                            getLogger):
        self.setUpParseFile(parseFile)
        options = Mock()
        options.oneshot = True
        options.interval = 0
        options.print_ = False
        fake_virt = Mock()
        fake_virt.CONFIG_TYPE = 'esx'
        test_hypervisor = Hypervisor('test',
                                     guestIds=[Guest('guest1', fake_virt, 1)])
        association = {'hypervisors': [test_hypervisor]}
        options.log_dir = ''
        options.log_file = ''
        getLogger.return_value = sentinel.logger
        fromConfig.return_value.config.name = 'test'
        virtwho = Executor(self.logger, options, config_dir="/nonexistant")
        config = Config("test",
                        "esx",
                        server="localhost",
                        username="******",
                        password="******",
                        owner="owner",
                        env="env")
        virtwho.configManager.addConfig(config)
        virtwho.queue = Queue()
        virtwho.queue.put(HostGuestAssociationReport(config, association))
        virtwho.run()

        fromConfig.assert_called_with(sentinel.logger, config)
        self.assertTrue(fromConfig.return_value.start.called)
        fromOptions.assert_called_with(self.logger, options, ANY)
Пример #10
0
 def test_remote_hostname_with_username(self, virt):
     config = Config('test', 'libvirt', server='server', username='******')
     virt.return_value.getCapabilities.return_value = LIBVIRT_CAPABILITIES_XML
     virt.return_value.getType.return_value = "LIBVIRT_TYPE"
     virt.return_value.getVersion.return_value = "VERSION 1337"
     self.run_virt(config)
     virt.assert_called_with('qemu+ssh://user@server/system?no_tty=1')
Пример #11
0
 def test_read(self, virt):
     config = Config('test', 'libvirt')
     virt.return_value.getCapabilities.return_value = LIBVIRT_CAPABILITIES_XML
     virt.return_value.getType.return_value = "LIBVIRT_TYPE"
     virt.return_value.getVersion.return_value = "VERSION 1337"
     self.run_virt(config)
     virt.assert_called_with("")
Пример #12
0
 def test_remote_url(self, virt):
     config = Config('test', 'libvirt', server='abc://server/test')
     virt.return_value.getCapabilities.return_value = LIBVIRT_CAPABILITIES_XML
     virt.return_value.getType.return_value = "LIBVIRT_TYPE"
     virt.return_value.getVersion.return_value = "VERSION 1337"
     self.run_virt(config)
     virt.assert_called_with('abc://server/test?no_tty=1')
Пример #13
0
 def test_sendVirtGuests(self, rhsmconnection):
     config = Config('test', 'libvirt')
     report = DomainListReport(config, self.guestList, self.hypervisor_id)
     self.sm.sendVirtGuests(report)
     self.sm.connection.updateConsumer.assert_called_with(
         123,
         guest_uuids=[g.toDict() for g in self.guestList],
         hypervisor_id=self.hypervisor_id)
Пример #14
0
 def test_satellite_config_env(self):
     os.environ = {
         "VIRTWHO_SATELLITE": '1',
         "VIRTWHO_SATELLITE_SERVER": 'sat.example.com',
         "VIRTWHO_SATELLITE_USERNAME": '******',
         "VIRTWHO_SATELLITE_PASSWORD": '******',
         "VIRTWHO_LIBVIRT": '1'
     }
     sys.argv = ["virt-who"]
     logger, options = parseOptions()
     config = Config("env/cmdline",
                     options.virtType,
                     defaults={},
                     **options)
     config.checkOptions(logger)
     manager = Manager.fromOptions(logger, options, config)
     self.assertTrue(isinstance(manager, Satellite))
Пример #15
0
 def test_wrong_password(self):
     options = Options("http://localhost:%s" % TEST_PORT, "username",
                       "wrong")
     options.force_register = True
     s = Satellite(self.logger, options)
     config = Config('test', 'libvirt')
     report = HostGuestAssociationReport(config, self.mapping)
     self.assertRaises(SatelliteError, s.hypervisorCheckIn, report, options)
Пример #16
0
    def test_send_data_batch_hypervisor_checkin(self):
        # This tests that reports of the right type are batched into one
        # and that the hypervisorCheckIn method of the destination is called
        # with the right parameters
        config1 = Config('source1', 'esx')
        config1.exclude_hosts = []
        config1.filter_hosts = []

        config2 = Config('source2', 'esx')
        config2.exclude_hosts = []
        config2.filter_hosts = []

        virt1 = Mock()
        virt1.CONFIG_TYPE = 'esx'
        virt2 = Mock()
        virt2.CONFIG_TYPE = 'esx'

        guest1 = Guest('GUUID1', virt1, Guest.STATE_RUNNING)
        guest2 = Guest('GUUID2', virt2, Guest.STATE_RUNNING)
        assoc1 = {'hypervisors': [Hypervisor('hypervisor_id_1', [guest1])]}
        assoc2 = {'hypervisors': [Hypervisor('hypervisor_id_2', [guest2])]}
        report1 = HostGuestAssociationReport(config1, assoc1)
        report2 = HostGuestAssociationReport(config2, assoc2)

        data_to_send = {'source1': report1, 'source2': report2}

        source_keys = ['source1', 'source2']
        report1 = Mock()
        report2 = Mock()
        report1.hash = "report1_hash"
        report2.hash = "report2_hash"
        datastore = {'source1': report1, 'source2': report2}
        manager = Mock()
        options = Mock()
        options.print_ = False

        def check_hypervisorCheckIn(report, options=None):
            self.assertEquals(report.association['hypervisors'],
                              data_to_send.values)

        manager.hypervisorCheckIn = Mock(side_effect=check_hypervisorCheckIn)
        logger = Mock()
        config = Mock()
        terminate_event = Mock()
        interval = 10  # Arbitrary for this test
        destination_thread = DestinationThread(logger,
                                               config,
                                               source_keys=source_keys,
                                               source=datastore,
                                               dest=manager,
                                               interval=interval,
                                               terminate_event=terminate_event,
                                               oneshot=True,
                                               options=options)
        destination_thread._send_data(data_to_send)
Пример #17
0
 def setUp(self):
     config = Config('test',
                     'hyperv',
                     server='localhost',
                     username='******',
                     password='******',
                     owner='owner',
                     env='env')
     self.hyperv = HyperV(self.logger, config)
Пример #18
0
    def setUp(self):
        config = Config('test', 'vdsm')

        def fakeSecureConnect(self):
            return MagicMock()

        Vdsm._secureConnect = fakeSecureConnect
        self.vdsm = Vdsm(self.logger, config)
        self.vdsm.prepare()
Пример #19
0
 def setUp(self):
     config = Config('test',
                     'xen',
                     server='localhost',
                     username='******',
                     password='******',
                     owner='owner',
                     env='env')
     self.xen = Xen(self.logger, config)
Пример #20
0
    def test_new_system(self):
        options = Options("http://localhost:%s" % TEST_PORT, "username",
                          "password")
        options.force_register = True
        s = Satellite(self.logger, options)

        config = Config('test', 'libvirt')
        report = HostGuestAssociationReport(config, self.mapping)
        s.hypervisorCheckIn(report, options)
Пример #21
0
 def setUp(self):
     config = Config('test',
                     'esx',
                     server='localhost',
                     username='******',
                     password='******',
                     owner='owner',
                     env='env')
     self.esx = Esx(self.logger, config, None)  #  No dest given here
Пример #22
0
 def setUp(self):
     config = Config('test',
                     'rhevm',
                     server='localhost',
                     username='******',
                     password='******',
                     owner='owner',
                     env='env')
     self.rhevm = RhevM(self.logger, config)
Пример #23
0
 def test_mapping_has_no_hostname_when_unavailible(self, virt):
     config = Config('test', 'libvirt', server='abc://server/test')
     datastore = Datastore()
     virt.return_value.getCapabilities.return_value = LIBVIRT_CAPABILITIES_NO_HOSTNAME_XML
     virt.return_value.getType.return_value = "LIBVIRT_TYPE"
     virt.return_value.getVersion.return_value = "VERSION 1337"
     self.run_virt(config, datastore)
     result = datastore.get(config.name)
     for host in result.association['hypervisors']:
         self.assertTrue(host.name is None)
Пример #24
0
    def test_duplicate_reports_are_ignored(self):
        """
        Test that duplicate reports are filtered out when retrieving items
        from the data store
        """
        source_keys = ['source1', 'source2']
        interval = 1
        terminate_event = Mock()
        options = Mock()
        options.print_ = False
        config1 = Config('source1', 'esx')
        virt1 = Mock()
        virt1.CONFIG_TYPE = 'esx'
        config = Mock()
        manager = Mock()

        guest1 = Guest('GUUID1', virt1, Guest.STATE_RUNNING)
        report1 = DomainListReport(config1, [guest1],
                                   hypervisor_id='hypervisor_id_1')
        report2 = DomainListReport(config1, [guest1],
                                   hypervisor_id='hypervisor_id_2')
        report3 = DomainListReport(config1, [guest1],
                                   hypervisor_id='hypervisor_id_3')
        datastore = {
            'source1': report1,  # Not changing, should be excluded later
            'source2': report2,  # Will change the report sent for source2
        }
        data_to_send = {
            'source1': report1,
            'source2': report2,
        }
        logger = Mock()
        destination_thread = DestinationThread(logger,
                                               config,
                                               source_keys=source_keys,
                                               source=datastore,
                                               dest=manager,
                                               interval=interval,
                                               terminate_event=terminate_event,
                                               oneshot=False,
                                               options=options)
        destination_thread._send_data(data_to_send=data_to_send)

        expected_hashes = {}
        for source_key, report in data_to_send.iteritems():
            expected_hashes[source_key] = report.hash

        self.assertEqual(destination_thread.last_report_for_source,
                         expected_hashes)
        # Pretend there were updates to the datastore from elsewhere
        destination_thread.source['source2'] = report3

        next_data_to_send = destination_thread._get_data()
        expected_next_data_to_send = {'source2': report3}
        self.assertEqual(next_data_to_send, expected_next_data_to_send)
Пример #25
0
    def setUpClass(cls, rhsmcert, rhsmconfig):
        super(TestSubscriptionManager, cls).setUpClass()
        config = Config('test', 'libvirt')
        cls.tempdir = tempfile.mkdtemp()
        with open(os.path.join(cls.tempdir, 'cert.pem'), 'w') as f:
            f.write("\n")

        rhsmcert.return_value.subject = {'CN': 123}
        rhsmconfig.return_value.get.side_effect = lambda group, key: {'consumerCertDir': cls.tempdir}.get(key, DEFAULT)
        cls.sm = SubscriptionManager(cls.logger, config)
        cls.sm.cert_uuid = 123
Пример #26
0
 def mock_virtwho(self):
     options = Mock()
     options.interval = 6
     options.oneshot = False
     options.print_ = False
     virtwho = Executor(Mock(), options, config_dir="/nonexistant")
     config = Config("env/cmdline", 'libvirt')
     virtwho.configManager.addConfig(config)
     virtwho.queue = Mock()
     virtwho.send = Mock()
     return virtwho
Пример #27
0
 def test_remote_url_with_username_and_password(self, virt):
     config = Config('test',
                     'libvirt',
                     server='abc://server/test',
                     username='******',
                     password='******')
     virt.return_value.getCapabilities.return_value = LIBVIRT_CAPABILITIES_XML
     virt.return_value.getType.return_value = "LIBVIRT_TYPE"
     virt.return_value.getVersion.return_value = "VERSION 1337"
     self.run_virt(config)
     virt.assert_called_with('abc://user@server/test?no_tty=1', ANY, ANY)
Пример #28
0
    def test_hypervisorCheckIn(self):
        options = Options("http://localhost:%s" % TEST_PORT, "username",
                          "password")
        options.force_register = True
        s = Satellite(self.logger, options)

        config = Config('test', 'libvirt')
        report = HostGuestAssociationReport(config, self.mapping)
        result = s.hypervisorCheckIn(report, options)
        self.assertTrue("failedUpdate" in result)
        self.assertTrue("created" in result)
        self.assertTrue("updated" in result)
Пример #29
0
 def test_hypervisorCheckIn(self, create_from_file, connection):
     self.prepare(create_from_file, connection)
     config = Config('test', 'libvirt')
     config.smType = 'sam'
     manager = Manager.fromOptions(self.logger, self.options, config)
     self.options.env = "ENV"
     self.options.owner = "OWNER"
     manager.hypervisorCheckIn(self.host_guest_report, self.options)
     manager.connection.hypervisorCheckIn.assert_called_with(
         self.options.owner,
         self.options.env,
         dict(
             (
                 host.hypervisorId,
                 [
                     guest.toDict()
                     for guest in host.guestIds
                 ]
             )
             for host in self.host_guest_report.association['hypervisors']),
         options=self.options)
Пример #30
0
    def test_creating_channel(self):
        options = Options("http://localhost:%s" % TEST_PORT, "username",
                          "password")
        options.force_register = True
        s = Satellite(self.logger, options)

        config = Config('test', 'libvirt')
        report = HostGuestAssociationReport(config, self.mapping)
        result = s.hypervisorCheckIn(report, options)
        self.assertTrue(self.fake_server.channel_created)
        self.assertIsNotNone(self.fake_server.created_system)
        self.assertTrue("created" in result)
Пример #31
0
    def test_hypervisorCheckIn(self, rhsmconnection):
        owner = "owner"
        env = "env"
        config = Config("test", "esx", owner=owner, env=env)
        # Ensure the data takes the proper for for the old API
        rhsmconnection.return_value.has_capability.return_value = False
        report = HostGuestAssociationReport(config, self.mapping)
        self.sm.hypervisorCheckIn(report)

        self.sm.connection.hypervisorCheckIn.assert_called_with(
            owner,
            env,
            dict((host.hypervisorId, [g.toDict() for g in host.guestIds]) for host in self.mapping['hypervisors']), options=None)
Пример #32
0
    def get_config(self):
        config = None
        parser = SafeConfigParser()
        parser.add_section(self.config_name)

        for field in self.all_fields:
            value = getattr(self, field)
            if value:
                parser.set(self.config_name, field, value)

        for section in parser.sections():
            config = Config.fromParser(section, parser)
        return config
Пример #33
0
def main():
    logger = options = None
    try:
        logger, options = parseOptions()
    except OptionError as e:
        print >>sys.stderr, str(e)
        exit(1, status="virt-who can't be started: %s" % str(e))

    lock = PIDLock(PIDFILE)
    if lock.is_locked():
        msg = "virt-who seems to be already running. If not, remove %s" % PIDFILE
        print >>sys.stderr, msg
        exit(1, status=msg)

    global executor
    try:
        executor = Executor(logger, options)
    except (InvalidKeyFile, InvalidPasswordFormat) as e:
        logger.error(str(e))
        exit(1, "virt-who can't be started: %s" % str(e))

    if options.virtType is not None:
        config = Config("env/cmdline", options.virtType, executor.configManager._defaults, **options)
        try:
            config.checkOptions(logger)
        except InvalidOption as e:
            err = "virt-who can't be started: %s" % str(e)
            logger.error(err)
            exit(1, err)
        executor.configManager.addConfig(config)
    has_error = False
    for conffile in options.configs:
        try:
            executor.configManager.readFile(conffile)
        except InvalidPasswordFormat as e:
            err = "virt-who can't be started: %s" % str(e)
            logger.error(err)
            exit(1, err)
        except Exception as e:
            logger.error('Config file "%s" skipped because of an error: %s', conffile, str(e))
            has_error = True

    if len(executor.configManager.configs) == 0:
        if has_error:
            err = "virt-who can't be started: no valid configuration found"
            logger.error(err)
            exit(1, err)
        # In order to keep compatibility with older releases of virt-who,
        # fallback to using libvirt as default virt backend
        logger.info("No configurations found, using libvirt as backend")
        executor.configManager.addConfig(Config("env/cmdline", "libvirt"))

    for config in executor.configManager.configs:
        if config.name is None:
            logger.info('Using commandline or sysconfig configuration ("%s" mode)', config.type)
        else:
            logger.info('Using configuration "%s" ("%s" mode)', config.name, config.type)

    logger.info("Using reporter_id='%s'", options.reporter_id)
    log.closeLogger(logger)
    if options.background:
        locker = lambda: daemon.DaemonContext(pidfile=lock)  # flake8: noqa
    else:
        locker = lambda: lock  # flake8: noqa

    with locker():
        signal.signal(signal.SIGHUP, reload)
        signal.signal(signal.SIGTERM, atexit_fn)

        executor.logger = logger = log.getLogger(name='main', config=None, queue=True)

        sd_notify("READY=1\nMAINPID=%d" % os.getpid())
        while True:
            try:
                return _main(executor)
            except ReloadRequest:
                logger.info("Reloading")
                continue