Python utils.utcnow函数代码示例

    def setUp(self):
        super(BackupQueryTest, self).setUp()
        self.context = _prep_conf(utils.utcnow())
        current_time = str(utils.utcnow())
        self.instance_id = 'INSTANCE-' + current_time

        self.snapshot = models.DBBackup.create(tenant_id=self.context.tenant,
                                             name=BACKUP_NAME,
                                             state=BACKUP_STATE,
                                             instance_id=self.instance_id,
                                             deleted=False,
                                             size=2.0,
                                             location=BACKUP_LOCATION,
                                             group_id=GROUP_ID,
                                             type= TYPE)
        import time
        time.sleep(2)
        expire_at = int(time.time()) - (2 * 24 * 60 * 60)
        self.backup = models.DBBackup.create(tenant_id=self.context.tenant,
                                             name=BACKUP_NAME,
                                             state=BACKUP_STATE,
                                             instance_id=self.instance_id,
                                             deleted=False,
                                             size=2.0,
                                             location=BACKUP_LOCATION,
                                             group_id=GROUP_ID,
                                             type= BACKUP_TYPE,
                                             expire_at = expire_at
                                             )
        self.deleted = False

 def __init__(self, tenant_id, resource, hard_limit,
              id=utils.generate_uuid(), created=utils.utcnow(),
              update=utils.utcnow()):
     self.tenant_id = tenant_id
     self.resource = resource
     self.hard_limit = hard_limit
     self.id = id
     self.created = created
     self.update = update

    def delete(self):
        self['updated'] = utils.utcnow()
        LOG.debug(_("Deleting %s: %s") %
                  (self.__class__.__name__, self.__dict__))

        if self.preserve_on_delete:
            self['deleted_at'] = utils.utcnow()
            self['deleted'] = True
            return self.db_api.save(self)
        else:
            return self.db_api.delete(self)

    def delete(self):
        self['updated'] = utils.utcnow()
        LOG.debug(_("Deleting %(name)s: %(dict)s") %
                  {'name': self.__class__.__name__, 'dict': self.__dict__})

        if self.preserve_on_delete:
            self['deleted_at'] = utils.utcnow()
            self['deleted'] = True
            return self.db_api.save(self)
        else:
            return self.db_api.delete(self)

 def setUp(self):
     super(OrderingTests, self).setUp()
     util.init_db()
     now = utils.utcnow()
     self.context, self.instance_id = _prep_conf(now)
     info = {
         'tenant_id': self.context.tenant,
         'state': BACKUP_STATE,
         'instance_id': self.instance_id,
         'size': 2.0,
         'deleted': False
     }
     four = now - datetime.timedelta(days=4)
     one = now - datetime.timedelta(days=1)
     three = now - datetime.timedelta(days=3)
     two = now - datetime.timedelta(days=2)
     # Create backups out of order, save/create set the 'updated' field,
     # so we need to use the db_api directly.
     models.DBBackup().db_api.save(
         models.DBBackup(name='four', updated=four,
                         id=utils.generate_uuid(), **info))
     models.DBBackup().db_api.save(
         models.DBBackup(name='one', updated=one,
                         id=utils.generate_uuid(), **info))
     models.DBBackup().db_api.save(
         models.DBBackup(name='three', updated=three,
                         id=utils.generate_uuid(), **info))
     models.DBBackup().db_api.save(
         models.DBBackup(name='two', updated=two,
                         id=utils.generate_uuid(), **info))

 def _datastore_version_metadata_add(cls, datastore_version_id,
                                     key, value, exception_class):
     """Create an entry in the Datastore Version Metadata table."""
     # Do we have a mapping in the db?
     # yes: and its deleted then modify the association
     # yes: and its not deleted then error on create
     # no: then just create the new association
     try:
         db_record = DBDatastoreVersionMetadata.find_by(
             datastore_version_id=datastore_version_id,
             key=key, value=value)
         if db_record.deleted == 1:
             db_record.deleted = 0
             db_record.updated_at = utils.utcnow()
             db_record.save()
             return
         else:
             raise exception_class(
                 datastore_version_id=datastore_version_id,
                 flavor_id=value)
     except exception.NotFound:
         pass
     DBDatastoreVersionMetadata.create(
         datastore_version_id=datastore_version_id,
         key=key, value=value)

 def save(self):
     if not self.is_valid():
         raise exception.InvalidModelError(errors=self.errors)
     self['updated'] = utils.utcnow()
     LOG.debug(_("Saving %(name)s: %(dict)s") %
               {'name': self.__class__.__name__, 'dict': self.__dict__})
     return self.db_api.save(self)

    def _datastore_version_metadata_add(cls, datastore_name,
                                        datastore_version_name,
                                        datastore_version_id,
                                        key, value, exception_class):
        """
        Create a record of the specified key and value in the
        metadata table.
        """
        # if an association does not exist, create a new one.
        # if a deleted association exists, undelete it.
        # if an un-deleted association exists, raise an exception.

        try:
            db_record = DBDatastoreVersionMetadata.find_by(
                datastore_version_id=datastore_version_id,
                key=key, value=value)
            if db_record.deleted == 1:
                db_record.deleted = 0
                db_record.updated_at = utils.utcnow()
                db_record.save()
                return
            else:
                raise exception_class(
                    datastore=datastore_name,
                    datastore_version=datastore_version_name,
                    id=value)
        except exception.NotFound:
            pass

        # the record in the database only contains the datastore_verion_id
        DBDatastoreVersionMetadata.create(
            datastore_version_id=datastore_version_id,
            key=key, value=value)

 def save(self):
     if not self.is_valid():
         raise exception.InvalidModelError(errors=self.errors)
     self['updated_at'] = utils.utcnow()
     LOG.debug(_("Saving %s: %s") %
               (self.__class__.__name__, self.__dict__))
     return get_db_api().save(self)

    def delete_async(self, fake):
        LOG.debug("prepare delete instance %s, fake: %s " % (self.id, fake))
        modified_group_id = self.group_id
        self._delete_resources(fake)
        # Delete guest queue.
        _item = InstanceGroupItem.get_by_instance_id(self.context, self.id)
        group_id = _item.group_id
        del_instance_type = _item.type

        # if size of item_list equal 1,then we will delete last instance in group
        item_list = InstanceGroupItem.list_by_gid(self.context, modified_group_id)
        if len(item_list) == 1:
            if CONF.trove_security_groups_support:
                if fake is True:
                    LOG.debug("fake is True, %s skip delete secgroup rules", self.group_id)
                else:
                    # Delete associated security group
                    self.update_db(task_status=InstanceTasks.DELETEING_SECURITY_GROUP)
                    try:
                        SecurityGroup.delete_for_group(modified_group_id, self.context)
                    except Exception as e:
                        LOG.error(utils.get_traceback_stack())

        self.set_servicestatus_deleted()

        # zs: configuration is needed for restore deleted instance, DO NOT DELETE!
        # self._delete_instance_config()

        LOG.info("Delete instance_group_item for instance %s" % self.id)
        _type = self.type
        InstanceGroupItem.delete(self.context, self.id)
        deleted_at = utils.utcnow()
        if fake is True and _type == DBInstanceType.MASTER:
            LOG.debug("fake is True, %s is MASTER, set task_status :%s ", self.id, InstanceTasks.FAKE_DELETED)
            self.update_db(deleted=True, deleted_at=deleted_at, task_status=InstanceTasks.FAKE_DELETED)
        else:
            self.update_db(deleted=True, deleted_at=deleted_at, task_status=InstanceTasks.NONE)

        LOG.info("send notify to monitor when delete instance %s" % self.id)
        group_rpcapi.API(self.context).group_update(group_id, notify_when_delete=True)

        if len(item_list) == 1:
            LOG.info("Delete group %s" % group_id)
            InstanceGroup.delete(self.context, group_id)

        self._send_usage_event(self.server, utils.utcnow())

 def create(cls, **values):
     if 'id' not in values:
         values['id'] = utils.generate_uuid()
     if hasattr(cls, 'deleted') and 'deleted' not in values:
         values['deleted'] = False
     values['created'] = utils.utcnow()
     instance = cls(**values).save()
     if not instance.is_valid():
         raise exception.InvalidModelError(errors=instance.errors)
     return instance

 def setUp(self):
     super(BackupORMTest, self).setUp()
     util.init_db()
     self.context, self.instance_id = _prep_conf(utils.utcnow())
     self.backup = models.DBBackup.create(tenant_id=self.context.tenant,
                                          name=BACKUP_NAME,
                                          state=BACKUP_STATE,
                                          instance_id=self.instance_id,
                                          deleted=False,
                                          location=BACKUP_LOCATION)
     self.deleted = False

 def create(cls, **values):
     init_vals = {
         'id': utils.generate_uuid(),
         'created': utils.utcnow(),
     }
     if hasattr(cls, 'deleted'):
         init_vals['deleted'] = False
     init_vals.update(values)
     instance = cls(**init_vals)
     if not instance.is_valid():
         raise exception.InvalidModelError(errors=instance.errors)
     return instance.save()

 def default_config_items_update(self, id, value_file, config_name = None, description = None):
     try:
         self.db_api.configure_db(CONF)
         context = TroveContext(tenant = CONF.default_template_tenant_id)
         context.is_admin = True
         group = config_models.KSC_Configuration.load(context, id)
         '''
         instances = instances_models.DBInstance.find_all(
             tenant_id=context.tenant,
             configuration_id=id,
             deleted=False).all()
         '''
         # if name/description are provided in the request body, update the
         # model with these values as well.
         if  config_name is not None:
             group.name = config_name
 
         if description is not None:
             group.description = description
         
         fmt_values = {}
         if value_file is not None and os.path.isfile(value_file):
             config = open(value_file).read()
             cfg_parser = configurations.MySQLConfParser(config)
             parsed = cfg_parser.parse()
             values = dict(parsed)
             
             rules = configurations.get_validation_rules(datastore_manager='mysql')
             
             fmt_values = {}
             for k, v in values.iteritems():
                 # get the validation rule dictionary, which will ensure there is a
                 # rule for the given key name. An exception will be thrown if no
                 # valid rule is located.
                 rule = config_service.ConfigurationsController._get_item(k, rules['configuration-parameters'])
                 valueType = rule.get('type')
                 if "integer" == valueType:
                     fmt_values[k] = int(v)
                 elif "boolean" == valueType:
                     fmt_values[k] = bool(v)
                 else:
                     fmt_values[k] = v
                     
         if len(fmt_values) > 0:
             config_service.ConfigurationsController._validate_configuration(fmt_values, datastore_manager='mysql')
             config_models.KSC_Configuration.remove_all_items(context,id, utils.utcnow())
             items = config_models.KSC_Configuration.get_items_by_overrides(context,id, fmt_values)
             config_models.KSC_Configuration.save(context, group, items, [])
     except exception as e:
         print(e)

 def setUp(self):
     super(PaginationTests, self).setUp()
     util.init_db()
     self.context, self.instance_id = _prep_conf(utils.utcnow())
     # Create a bunch of backups
     bkup_info = {
         "tenant_id": self.context.tenant,
         "state": BACKUP_STATE,
         "instance_id": self.instance_id,
         "size": 2.0,
         "deleted": False,
     }
     for backup in xrange(50):
         bkup_info.update({"name": "Backup-%s" % backup})
         models.DBBackup.create(**bkup_info)