Resume a kvm domain by uuid
        :param uuid: uuid of the kvm container (same as the used in create)
        :return:
547066
def resume(self, uuid):
        
        args = {
            'uuid': uuid,
        }
        self._domain_action_chk.check(args)

        self._client.sync('kvm.resume', args)
122832
def make_uuid(cls, app_id=None):
        
        try:
            if app_id and isinstance(uuid.UUID(str(app_id), version=4), uuid.UUID):
                return str(app_id)
        except (ValueError, AssertionError):
            pass
        return str(uuid.UUID(int=random.getrandbits(128)))
959819
def uuid(self):
        '''
        '''
        pk = self.pkvalue()
        if not pk:
            raise self.DoesNotExist(
                'Object not saved. Cannot obtain universally unique id')
        return self.get_uuid(pk)
926883
def get_server(self, UUID):
        
        server, IPAddresses, storages = self.get_server_data(UUID)

        return Server(
            server,
            ip_addresses=IPAddresses,
            storage_devices=storages,
            populated=True,
            cloud_manager=self
        )
730411
def pause(self):
        
        if self.instance_id is None:
            raise ValueError("Trying to stop unstarted node.")
        resp = self._cloud_provider.pause_instance(self.instance_id)
        self.preferred_ip = None
        return resp
1156548
def start(self):
        

        if self.status == "started":
            return

        # resume the VM if it is paused
        vm_state = yield from self._get_vm_state()
        if vm_state == "paused":
            yield from self.resume()
            return

        # VM must be powered off to start it
        if vm_state != "poweroff":
            raise VirtualBoxError("VirtualBox VM not powered off")

        yield from self._set_network_options()
        yield from self._set_serial_console()

        # check if there is enough RAM to run
        self.check_available_ram(self.ram)

        args = [self._vmname]
        if self._headless:
            args.extend(["--type", "headless"])
        result = yield from self.manager.execute("startvm", args)
        self.status = "started"
        log.info("VirtualBox VM '{name}' [{id}] started".format(name=self.name, id=self.id))
        log.debug("Start result: {}".format(result))

        # add a guest property to let the VM know about the GNS3 name
        yield from self.manager.execute("guestproperty", ["set", self._vmname, "NameInGNS3", self.name])
        # add a guest property to let the VM know about the GNS3 project directory
        yield from self.manager.execute("guestproperty", ["set", self._vmname, "ProjectDirInGNS3", self.working_dir])

        yield from self._start_ubridge()
        for adapter_number in range(0, self._adapters):
            nio = self._ethernet_adapters[adapter_number].get_nio(0)
            if nio:
                yield from self.add_ubridge_udp_connection("VBOX-{}-{}".format(self._id, adapter_number),
                                                           self._local_udp_tunnels[adapter_number][1],
                                                           nio)

        yield from self._start_console()

        if (yield from self.check_hw_virtualization()):
            self._hw_virtualization = True
1099922
@POST
    @Path("{uuid}/repair")
    public Result repair(@PathParam("uuid") String uuid) {
        MigrationFeature.checkMigrationId(uuid);
        if (failMigrations.isEmpty()) {
            throw new NotFoundException();
        }
        for (String dbName : failMigrations.keySet()) {
            MigrationFail fail = failMigrations.get(dbName);
            fail.flyway.repair();
            fail.migration.persist();
            fail.migration.reset();
        }
        failMigrations.clear();
        return Result.success();
    }
118099
def reset_tag(self, name):
        
        id_ = str(uuid.uuid4()).replace('-', '')

        self._store.forever(self.tag_key(name), id_)

        return id_
300662
def docker_to_uuid(uuid):
    '''
    
    '''
    if _is_uuid(uuid):
        return uuid
    if _is_docker_uuid(uuid):
        images = list_installed(verbose=True)
        for image_uuid in images:
            if 'name' not in images[image_uuid]:
                continue
            if images[image_uuid]['name'] == uuid:
                return image_uuid
    return None
984439
def get(self, uuid):
        
        args = {'uuid':uuid}
        self._get_chk.check(args)
        return self._client.json('kvm.get', args)
1055613
def resume(env, identifier):
    """"""

    vsi = SoftLayer.VSManager(env.client)
    vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
    env.client['Virtual_Guest'].resume(id=vs_id)
1126952
def get_instance_for_uuid(self, uuid, project_id):
        
        instance_name = self._inst_info_cache.get((uuid, project_id))
        if instance_name:
            return instance_name
        instances = self._get_instances_for_project(project_id)
        for inst in instances:
            if inst.id.replace('-', '') == uuid:
                LOG.debug('get_instance_for_uuid: name=%s', inst.name)
                instance_name = inst.name
                self._inst_info_cache[(uuid, project_id)] = instance_name
                return instance_name
        return instance_name
1042151
def reset_key(self):
        
        new_key = self.client.reset_app_key(self.get('uuid'))
        self.data['key'] = new_key
        return new_key
14698
def uuid(self, name=None, pad_length=22):
        
        # If no name is given, generate a random UUID.
        if name is None:
            uuid = _uu.uuid4()
        elif "http" not in name.lower():
            uuid = _uu.uuid5(_uu.NAMESPACE_DNS, name)
        else:
            uuid = _uu.uuid5(_uu.NAMESPACE_URL, name)
        return self.encode(uuid, pad_length)
1240631
def getbyuuid(self, uuid):
        
        if uuid not in self._schbyuuid:
            raise KeyError('uuid {0} not registered'.format(uuid))

        return self._schbyuuid[uuid]
93583
def uuid(cls):
        """"""
        if hasattr(cls, '__uuid_primary_key__') and cls.__uuid_primary_key__:
            return synonym('id')
        else:
            return immutable(Column(UUIDType(binary=False), default=uuid_.uuid4, unique=True, nullable=False))
1288975
private void append2slowUUID() {
    if(_id != null)
      cancel_sparse();
    if( _ds==null && _ms!=null ) { // This can happen for columns with all NAs and then a UUID
      _xs=null;
      _ms.switchToLongs();
      _ds = MemoryManager.malloc8d(_sparseLen);
      Arrays.fill(_ms._vals8,C16Chunk._LO_NA);
      Arrays.fill(_ds,Double.longBitsToDouble(C16Chunk._HI_NA));
    }
    if( _ms != null && _sparseLen > 0 ) {
      _ds = MemoryManager.arrayCopyOf(_ds, _sparseLen * 2);
      _ms.resize(_sparseLen*2);
      if(_id != null) _id = Arrays.copyOf(_id,_sparseLen*2);
    } else {
      _ms = new Mantissas(4);
      _xs = null;
      _ms.switchToLongs();
      _ds = new double[4];
    }
  }