/** * {@inheritDoc} */ @Override public void from(io.cattle.platform.core.model.StoragePool from) { setId(from.getId()); setName(from.getName()); setAccountId(from.getAccountId()); setKind(from.getKind()); setUuid(from.getUuid()); setDescription(from.getDescription()); setState(from.getState()); setCreated(from.getCreated()); setRemoved(from.getRemoved()); setRemoveTime(from.getRemoveTime()); setData(from.getData()); setPhysicalTotalSizeMb(from.getPhysicalTotalSizeMb()); setVirtualTotalSizeMb(from.getVirtualTotalSizeMb()); setExternal(from.getExternal()); setAgentId(from.getAgentId()); setZoneId(from.getZoneId()); setExternalId(from.getExternalId()); setDriverName(from.getDriverName()); setVolumeAccessMode(from.getVolumeAccessMode()); setStorageDriverId(from.getStorageDriverId()); }
protected Map<Long, StoragePoolHostMap> constructStoragePoolMaps(StoragePool storagePool, List<String> hostUuids) { List<? extends Host> hosts = hostDao.getHosts(storagePool.getAccountId(), hostUuids); Map<Long, StoragePoolHostMap> maps = new HashMap<Long, StoragePoolHostMap>(); for (Host h : hosts) { StoragePoolHostMap sphm = objectManager.newRecord(StoragePoolHostMap.class); sphm.setHostId(h.getId()); sphm.setStoragePoolId(storagePool.getId()); maps.put(h.getId(), sphm); } return maps; } }
@Override protected Long getId(Object obj) { if (obj instanceof StoragePool) { return ((StoragePool) obj).getId(); } return null; }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { StoragePool registry = (StoragePool) state.getResource(); if (registry.getKind().equalsIgnoreCase(StoragePoolConstants.KIND_REGISTRY)){ for (Credential cred : getObjectManager().find(Credential.class, CredentialTable.CREDENTIAL.REGISTRY_ID, registry.getId(), CredentialTable.CREDENTIAL.REMOVED, null)) { try { deactivateThenScheduleRemove(cred, state.getData()); } catch (ProcessCancelException e) { //Ignore } } return null; } for (Volume v : volumeDao.findNonRemovedVolumesOnPool(registry.getId())) { deactivateThenRemove(v, null); } for (StoragePoolHostMap map : objectManager.children(registry, StoragePoolHostMap.class)) { deactivateThenRemove(map, null); } return null; } }
for (StoragePool pool : objectManager.mappedChildren(host, StoragePool.class)) { if (DockerStoragePoolDriver.isDockerPool(pool) && (VolumeConstants.LOCAL_DRIVER.equals(pool.getDriverName()) || StringUtils.isEmpty(pool.getDriverName()))) { dockerLocalStoragePool = pool; if (StringUtils.isNotEmpty(pool.getDriverName())) { pools.put(pool.getDriverName(), pool); action = "Using existing"; log.debug("{} volume [{}] in storage pool [{}].", action, volume.getId(), pool.getId());
.and(STORAGE_POOL.KIND.eq(StoragePoolConstants.KIND_REGISTRY)))).fetchInto(StoragePool.class); for(StoragePool registry: storagePools){ if (serverAddress.equalsIgnoreCase((String) CollectionUtils.getNestedValue(registry.getData(), "fields", StoragePoolConstants.SERVER_ADDRESS))) { registryId = registry.getId(); break;
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { final StoragePool pool = (StoragePool) state.getResource(); if (!KIND.equals(pool.getKind()) || EXT_UUID.equals(pool.getUuid())) { return null; } StoragePool extPool = getExtPool(); if (extPool == null) { lockManager.lock(new SimExtPoolCreateLock(), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() { StoragePool extPool = getExtPool(); if (extPool == null) { extPool = getObjectManager().create(StoragePool.class, ObjectMetaDataManager.UUID_FIELD, EXT_UUID, ObjectMetaDataManager.KIND_FIELD, KIND, STORAGE_POOL.ACCOUNT_ID, pool.getAccountId(), STORAGE_POOL.EXTERNAL, true); getObjectProcessManager().executeStandardProcess(StandardProcess.CREATE, extPool, null); } } }); } else { getObjectProcessManager().executeStandardProcess(StandardProcess.CREATE, extPool, null); } return null; }
protected void removePools(Host host) { for (StoragePoolHostMap map : objectManager.children(host, StoragePoolHostMap.class)) { StoragePool pool = objectManager.loadResource(StoragePool.class, map.getStoragePoolId()); if (DockerHostConstants.KIND_DOCKER.equals(pool.getKind())) { deactivateThenRemove(pool, null); } StorageDriver driver = objectManager.loadResource(StorageDriver.class, pool.getStorageDriverId()); if (driver != null) { String scope = DataAccessor.fieldString(driver, StorageDriverConstants.FIELD_SCOPE); if (StringUtils.equals(scope, StorageDriverConstants.SCOPE_LOCAL)) { deactivateThenRemove(pool, null); } } deactivateThenRemove(map, null); } }
public static boolean isDockerPool(StoragePool pool) { return pool == null ? false : DockerStoragePoolConstants.DOCKER_KIND.equals(pool.getKind()); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Map<String, Object> requestObject = CollectionUtils.toMap(request.getRequestObject()); String serverAddress = (String) requestObject.get(StoragePoolConstants.SERVER_ADDRESS); long accountId = ((Policy) ApiContext.getContext().getPolicy()).getAccountId(); List<StoragePool> registries = objectManager.find(StoragePool.class, ObjectMetaDataManager.KIND_FIELD, StoragePoolConstants.KIND_REGISTRY, ObjectMetaDataManager.ACCOUNT_FIELD, accountId, ObjectMetaDataManager.REMOVED_FIELD, null); for (StoragePool registry: registries){ if (!CommonStatesConstants.PURGED.equalsIgnoreCase(registry.getState())) { if (serverAddress.equalsIgnoreCase( (String) CollectionUtils.getNestedValue(registry.getData(), "fields", StoragePoolConstants.SERVER_ADDRESS))) { throw new ClientVisibleException(ResponseCodes.BAD_REQUEST, "ServerAddressUsed"); } } } return super.create(type, request, next); }
@Override public void doWithLockNoResult() { StoragePool extPool = getExtPool(); if (extPool == null) { extPool = getObjectManager().create(StoragePool.class, ObjectMetaDataManager.UUID_FIELD, EXT_UUID, ObjectMetaDataManager.KIND_FIELD, KIND, STORAGE_POOL.ACCOUNT_ID, pool.getAccountId(), STORAGE_POOL.EXTERNAL, true); getObjectProcessManager().executeStandardProcess(StandardProcess.CREATE, extPool, null); } } });
if (pool.getRemoved() != null) { continue;
public DockerStoragePoolVolumeCreateLock(StoragePool storagePool, String externalId) { super(String.format("DOCKER.STORAGE_POOL.VOLUME.CREATE.%s.%s", storagePool.getId(), externalId == null ? 0 : externalId.hashCode())); } }
@Override public void createVolumeInStoragePool(Map<String, Object> volumeData, String volumeName, StoragePool storagePool) { Record record = create() .select(VOLUME.fields()) .from(VOLUME) .join(VOLUME_STORAGE_POOL_MAP) .on(VOLUME_STORAGE_POOL_MAP.VOLUME_ID.eq(VOLUME.ID) .and(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(storagePool.getId()))) .join(STORAGE_POOL) .on(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(STORAGE_POOL.ID)) .and(STORAGE_POOL.REMOVED.isNull()) .where(VOLUME.NAME.eq(volumeName) .and((VOLUME.REMOVED.isNull().or(VOLUME.STATE.eq(CommonStatesConstants.REMOVING))))) .and(VOLUME.ACCOUNT_ID.eq(storagePool.getAccountId())) .fetchAny(); if (record != null) { return; } Volume volume = resourceDao.createAndSchedule(Volume.class, volumeData); Map<String, Object> vspm = new HashMap<String, Object>(); vspm.put("volumeId", volume.getId()); vspm.put("storagePoolId", storagePool.getId()); resourceDao.createAndSchedule(VolumeStoragePoolMap.class, vspm); }
@Override public boolean matches(AllocationCandidate candidate) { Set<Long> poolIds = candidate.getPools().get(volume.getId()); for (Long id : poolIds) { StoragePool pool = candidate.loadResource(StoragePool.class, id); if (!AllocatorUtils.UNMANGED_STORAGE_POOLS.contains(pool.getKind())) { return false; } } return true; }
public AllocationAttempt(long accountId, List<Instance> instances, Long hostId, Long requestedHostId, Set<Volume> volumes, Map<Volume, Set<StoragePool>> pools) { super(); this.accountId = accountId; this.instances = instances; this.hostId = hostId; this.requestedHostId = requestedHostId; this.pools = pools; this.volumes = volumes == null ? new HashSet<Volume>(): volumes; this.poolIds = new HashMap<Long, Set<Long>>(); for (Volume v : volumes) { Set<StoragePool> storagePools = pools.get(v); if (storagePools != null) { Set<Long> poolIds = new HashSet<Long>(storagePools.size()); for (StoragePool pool : storagePools) { poolIds.add(pool.getId()); } this.poolIds.put(v.getId(), poolIds); } } }
if (obj instanceof StoragePool) { StoragePool sp = (StoragePool)obj; if (StoragePoolConstants.TYPE.equals(sp.getKind())) {
@Override public StoragePool mapNewPool(Long hostId, Map<String, Object> properties) { StoragePool pool = resourceDao.createAndSchedule(StoragePool.class, properties); resourceDao.createAndSchedule(StoragePoolHostMap.class, STORAGE_POOL_HOST_MAP.HOST_ID, hostId, STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID, pool.getId()); return pool; }
@Override public Resource filter(ApiRequest request, Object original, Resource converted) { if (request != null && "v1".equals(request.getVersion())) { return converted; } if (original instanceof StoragePool) { Map<Long, Map<String, Object>> data = getCached(request); if (data == null) { return converted; } Map<String, Object> fields = data.get(((StoragePool) original).getId()); if (fields != null) { converted.getFields().putAll(fields); } } return converted; }
protected void logStart(AllocationAttempt attempt) { String id = attempt.getId(); StringBuilder candidateLog = new StringBuilder(String.format("[%s] Attempting allocation for:\n", id)); if (attempt.getInstances() != null) { List<Long>instanceIds = new ArrayList<Long>(); for (Instance i : attempt.getInstances()) { instanceIds.add(i.getId()); } candidateLog.append(String.format(" [%s] instance [%s]\n", id, instanceIds)); } for (Map.Entry<Volume, Set<StoragePool>> entry : attempt.getPools().entrySet()) { long volumeId = entry.getKey().getId(); candidateLog.append(String.format(" [%s] volume [%s]\n", id, volumeId)); for (StoragePool pool : entry.getValue()) { candidateLog.append(String.format(" [%s] pool [%s]\n", id, pool.getId())); } } candidateLog.append(String.format(" [%s] constraints:\n", id)); for (Constraint constraint : attempt.getConstraints()) { candidateLog.append(String.format(" [%s] %s\n", id, constraint)); } candidateLog.deleteCharAt(candidateLog.length() - 1); // Remove trailing newline log.info(candidateLog.toString()); }