Python logger.info函数代码示例

def groupModify_user(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/groupModify/")
    G_lockmgr.acquire('__quotafile')
    result = G_usermgr.groupModify(newValue = form, cur_user = cur_user)
    G_lockmgr.release('__quotafile')
    return json.dumps(result)

def cleanup_vm(vm_name, provider_key, provider_mgmt):
    try:
        logger.info('Cleaning up VM %s on provider %s' % (vm_name, provider_key))
        provider_mgmt.delete_vm(vm_name + "_0001")
    except:
        # The mgmt_sys classes raise Exception :\
        logger.warning('Failed to clean up VM %s on provider %s' % (vm_name, provider_key))

    def _provisioner(template, provisioning_data, delayed=None):
        pytest.sel.force_navigate('infrastructure_provision_vms', context={
            'provider': provider,
            'template_name': template,
        })

        vm_name = provisioning_data["vm_name"]
        fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button)
        flash.assert_no_errors()

        request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
        if delayed is not None:
            total_seconds = (delayed - datetime.utcnow()).total_seconds()
            row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
            cells = {'Description': row_description}
            try:
                row, __ = wait_for(requests.wait_for_request, [cells],
                                   fail_func=requests.reload, num_sec=total_seconds, delay=5)
                pytest.fail("The provisioning was not postponed")
            except TimedOutError:
                pass
        logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
        wait_for(provider.mgmt.does_vm_exist, [vm_name], handle_exception=True, num_sec=600)

        # nav to requests page happens on successful provision
        logger.info('Waiting for cfme provision request for vm %s', vm_name)
        row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
        cells = {'Description': row_description}
        row, __ = wait_for(requests.wait_for_request, [cells],
                           fail_func=requests.reload, num_sec=900, delay=20)
        assert row.last_message.text == 'Vm Provisioned Successfully'
        return VM.factory(vm_name, provider)

def cleanup_vm(vm_name, provider):
    try:
        logger.info('Cleaning up VM %s on provider %s', vm_name, provider.key)
        provider.mgmt.delete_vm(vm_name)
    except:
        # The mgmt_sys classes raise Exception :\
        logger.warning('Failed to clean up VM %s on provider %s', vm_name, provider.key)

 def send_ctrl_alt_delete(self):
     """Press the ctrl-alt-delete button in the console tab."""
     self.switch_to_console()
     ctrl_alt_del_btn = self.provider.get_console_ctrl_alt_del_btn()
     logger.info("Sending following Keys to Console CTRL+ALT+DEL")
     ctrl_alt_del_btn.click()
     self.switch_to_appliance()

    def _do_stats_match(self, client, stats_to_match=None):
        """ A private function to match a set of statistics, with a Provider.

        This function checks if the list of stats match, if not, the page is refreshed.

        Note: Provider mgmt_system uses the same key names as this Provider class to avoid
            having to map keyname/attributes e.g. ``num_template``, ``num_vm``.

        Args:
            client: A provider mgmt_system instance.
            stats_to_match: A list of key/attribute names to match.

        Raises:
            KeyError: If the host stats does not contain the specified key.
            ProviderHasNoProperty: If the provider does not have the property defined.
        """
        host_stats = client.stats(*stats_to_match)

        for stat in stats_to_match:
            try:
                cfme_stat = getattr(self, stat)
                logger.info(' Matching stat [%s], Host(%s), CFME(%s)' %
                    (stat, host_stats[stat], cfme_stat))
                if host_stats[stat] != cfme_stat:
                    return False
            except KeyError:
                raise HostStatsNotContains("Host stats information does not contain '%s'" % stat)
            except AttributeError:
                raise ProviderHasNoProperty("Provider does not know how to get '%s'" % stat)
        else:
            return True

def test_reconfigure_service(provider, provisioning, create_template, catalog, request):
    """Tests stack provisioning

    Metadata:
        test_flag: provision
    """
    dialog_name, template = create_template
    item_name = fauxfactory.gen_alphanumeric()
    catalog_item = CatalogItem(item_type="Orchestration", name=item_name,
                  description="my catalog", display_in=True, catalog=catalog.name,
                  dialog=dialog_name, orch_template=template.template_name)
    catalog_item.create()
    stack_data = prepare_stack_data(provider, provisioning)

    @request.addfinalizer
    def _cleanup_vms():
        if provider.mgmt.stack_exist(stack_data['stack_name']):
            wait_for(lambda: provider.mgmt.delete_stack(stack_data['stack_name']),
             delay=10, num_sec=800, message="wait for stack delete")
        template.delete_all_templates()
        stack_data['vm_name'].delete_from_provider()

    service_catalogs = ServiceCatalogs("service_name", stack_data)
    service_catalogs.order_stack_item(catalog.name, catalog_item)
    logger.info('Waiting for cfme provision request for service %s', item_name)
    row_description = item_name
    cells = {'Description': row_description}
    row, __ = wait_for(requests.wait_for_request, [cells, True],
                       fail_func=requests.reload, num_sec=2000, delay=20)
    assert row.last_message.text == 'Service Provisioned Successfully'
    myservice = MyService(catalog_item.name)
    myservice.reconfigure_service()

def chlxcsetting_user(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/chlxcsetting/")
    G_lockmgr.acquire('__lxcsetting')
    result = G_usermgr.chlxcsetting(cur_user = cur_user, form = form)
    G_lockmgr.release('__lxcsetting')
    return json.dumps(result)

def delete_notification(cur_user, user, form):
    global G_notificationmgr
    logger.info("handle request: notification/delete/")
    G_lockmgr.acquire('__notification')
    result = G_notificationmgr.delete_notification(cur_user=cur_user, form=form)
    G_lockmgr.release('__notification')
    return json.dumps(result)

def usageRelease_user(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/usageInc/")
    G_lockmgr.acquire('__usage_'+str(user))
    result = G_usermgr.usageRelease(cur_user = cur_user, cpu = form.get('cpu'), memory = form.get('memory'), disk = form.get('disk'))
    G_lockmgr.release('__usage_'+str(user))
    return json.dumps(result)

def usageRecover_user(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/usageInc/")
    G_lockmgr.acquire('__usage_'+str(user))
    result = G_usermgr.usageRecover(cur_user = cur_user, modification = json.loads(form.get('setting')))
    G_lockmgr.release('__usage_'+str(user))
    return json.dumps(result)

def groupdel_user(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/groupdel/")
    G_lockmgr.acquire('__quotafile')
    result = G_usermgr.groupdel(name = form.get('name', None), cur_user = cur_user)
    G_lockmgr.release('__quotafile')
    return json.dumps(result)

def quotaadd_user(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/quotaadd/")
    G_lockmgr.acquire('__quotafile')
    result = G_usermgr.quotaadd(form = form, cur_user = cur_user)
    G_lockmgr.release('__quotafile')
    return json.dumps(result)

def chdefault(cur_user, user, form):
    global G_usermgr
    logger.info("handle request: user/chdefault/")
    G_lockmgr.acquire('__quotafile')
    result = G_usermgr.change_default_group(form = form, cur_user = cur_user)
    G_lockmgr.release('__quotafile')
    return json.dumps(result)

    def _filter_required_flags(self, provider):
        """ Filters by required yaml flags """
        if self.required_flags is None:
            return None
        if self.required_flags:
            test_flags = [flag.strip() for flag in self.required_flags]

            defined_flags = conf.cfme_data.get('test_flags', '')
            if isinstance(defined_flags, six.string_types):
                defined_flags = defined_flags.split(',')
            defined_flags = [flag.strip() for flag in defined_flags]

            excluded_flags = provider.data.get('excluded_test_flags', '')
            if isinstance(excluded_flags, six.string_types):
                excluded_flags = excluded_flags.split(',')
            excluded_flags = [flag.strip() for flag in excluded_flags]

            allowed_flags = set(defined_flags) - set(excluded_flags)

            if set(test_flags) - allowed_flags:
                logger.info("Filtering Provider %s out because it does not have the right flags, "
                            "%s does not contain %s",
                            provider.name, list(allowed_flags),
                            list(set(test_flags) - allowed_flags))
                return False
        return True