@Override protected Long getId(Object obj) { if (obj instanceof StoragePool) { return ((StoragePool) obj).getId(); } return null; }
public DockerStoragePoolVolumeCreateLock(StoragePool storagePool, String externalId) { super(String.format("DOCKER.STORAGE_POOL.VOLUME.CREATE.%s.%s", storagePool.getId(), externalId == null ? 0 : externalId.hashCode())); } }
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); } } }
@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()); }
protected void removeOldMaps(StoragePool storagePool, Map<Long, StoragePoolHostMap> newMaps) { List<? extends StoragePoolHostMap> existingMaps = storagePoolDao.findMapsToRemove(storagePool.getId()); List<StoragePoolHostMap> toRemove = new ArrayList<StoragePoolHostMap>(); for (StoragePoolHostMap m : existingMaps) { if (!newMaps.containsKey(m.getHostId())) { toRemove.add(m); } } for (StoragePoolHostMap m : toRemove) { StoragePoolHostMap remove = storagePoolDao.findNonremovedMap(m.getStoragePoolId(), m.getHostId()); if (remove != null) { objectProcessManager.scheduleStandardProcess(StandardProcess.REMOVE, remove, null); } } }
@Override public void doWithLockNoResult() { Volume volume = volumeDao.findVolumeByExternalId(storagePool.getId(), event.getExternalId()); switch (event.getEventType()) { case ExternalEventConstants.TYPE_VOLUME_CREATE: if (volume == null) { Map<String, Object> volumeData = CollectionUtils.toMap(DataUtils.getFields(event).get(FIELD_VOLUME)); if (volumeData.isEmpty()) { log.warn("Empty volume for externalVolumeEvent: {}. StoragePool: {}", event, volumeData); return; } volumeData.put(ObjectMetaDataManager.ACCOUNT_FIELD, event.getAccountId()); volumeData.put(FIELD_ATTACHED_STATE, CommonStatesConstants.INACTIVE); volumeData.put(FIELD_ALLOC_STATE, CommonStatesConstants.ACTIVE); volumeData.put(FIELD_ZONE_ID, 1L); volumeData.put(FIELD_DEV_NUM, -1); try { volumeDao.createVolumeInStoragePool(volumeData, name.toString(), storagePool); } catch (ProcessCancelException e) { log.info("Create process cancelled for volumeData {}. ProcessCancelException message: {}", volumeData, e.getMessage()); } } break; default: log.error("Unknown event type: {} for event {}", event.getEventType(), event); return; } } });
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; } }
StoragePool sp = pools.get(0); VolumeStoragePoolMap vspm = getObjectManager().newRecord(VolumeStoragePoolMap.class); vspm.setStoragePoolId(sp.getId()); Long volumeId = (Long)ObjectUtils.getId(v); vspm.setVolumeId(volumeId);
@Override public List<? extends Host> getHosts(Collection<? extends StoragePool> pools) { if (pools == null || pools.isEmpty()) { return new ArrayList<>(); } Collection<Long> poolIds = new HashSet<>(); for (StoragePool p : pools) { poolIds.add(p.getId()); } return create() .select(HOST.fields()) .from(HOST) .join(STORAGE_POOL_HOST_MAP) .on(STORAGE_POOL_HOST_MAP.HOST_ID.eq(HOST.ID)) .where(STORAGE_POOL_HOST_MAP.REMOVED.isNull() .and(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID.in(poolIds))) .fetchInto(HostRecord.class); }
@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; } }
protected void setupPoolsWithLock(StorageDriver storageDriver) { boolean localScope = StorageDriverConstants.SCOPE_LOCAL.equals(DataAccessor.fieldString(storageDriver, StorageDriverConstants.FIELD_SCOPE)); StoragePool globalPool = objectManager.findAny(StoragePool.class, STORAGE_POOL.STORAGE_DRIVER_ID, storageDriver.getId(), STORAGE_POOL.REMOVED, null); Map<Long, Long> hostToPool = storagePoolDao.findStoragePoolHostsByDriver(storageDriver.getAccountId(), storageDriver.getId()); for (Map.Entry<Long, Long> entry : hostToPool.entrySet()) { Long hostId = entry.getKey(); Long storagePoolId = entry.getValue(); if (storagePoolId != null) { continue; } if (localScope) { storagePoolDao.mapNewPool(hostId, getStoragePoolProperties(storageDriver)); } else { if (globalPool == null) { globalPool = storagePoolDao.mapNewPool(hostId, getStoragePoolProperties(storageDriver)); } else { genericResourceDao.createAndSchedule(StoragePoolHostMap.class, STORAGE_POOL_HOST_MAP.HOST_ID, hostId, STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID, globalPool.getId()); } } } } }
action = "Using existing"; log.debug("{} volume [{}] in storage pool [{}].", action, volume.getId(), pool.getId());
@Override public Volume getDockerVolumeInPool(String volumeUri, String externalId, StoragePool storagePool) { if ( StringUtils.isEmpty(volumeUri) || storagePool == null ) throw new IllegalArgumentException("Volume URI and storage pool must have values."); Condition condition = VOLUME.URI.eq(volumeUri); if (externalId != null) { condition = condition.or(VOLUME.EXTERNAL_ID.eq(externalId).or(VOLUME.NAME.eq(externalId)).or(VOLUME.EXTERNAL_ID.eq(VolumeUtils.externalId(externalId)))); } List<VolumeRecord> volumes = create() .select(VolumeTable.VOLUME.fields()) .from(VOLUME_STORAGE_POOL_MAP) .join(VOLUME) .on(VOLUME_STORAGE_POOL_MAP.VOLUME_ID.eq(VOLUME.ID)) .where(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(storagePool.getId()) .and(VOLUME.REMOVED.isNull()) .and(VOLUME.STATE.ne(CommonStatesConstants.REMOVING)) .and(condition) .and(VOLUME_STORAGE_POOL_MAP.REMOVED.isNull())) .fetchInto(VolumeRecord.class); if ( volumes.isEmpty() ) return null; else if ( volumes.size() == 1 ) return volumes.get(0); else throw new IllegalStateException(String.format( "More than one volume exists for volume URI [%s] or name/externalId [%s] and storage pool [%s].", volumeUri, externalId, storagePool.getId())); }
@Override public StoragePool associateVolumeToPool(Long volumeId, Long storageDriverId, Long hostId) { Record record = create().select(STORAGE_POOL.fields()) .from(STORAGE_POOL) .join(STORAGE_POOL_HOST_MAP) .on(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID.eq(STORAGE_POOL.ID)) .where(STORAGE_POOL.STORAGE_DRIVER_ID.eq(storageDriverId) .and(STORAGE_POOL_HOST_MAP.HOST_ID.eq(hostId))) .fetchAny(); if (record == null) { return null; } StoragePool storagePool = record.into(StoragePoolRecord.class); VolumeStoragePoolMap map = genericMapDao.findNonRemoved(VolumeStoragePoolMap.class, StoragePool.class, storagePool.getId(), Volume.class, volumeId); if (map == null) { resourceDao.createAndSchedule(VolumeStoragePoolMap.class, VOLUME_STORAGE_POOL_MAP.VOLUME_ID, volumeId, VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID, storagePool.getId()); } return storagePool; }
@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 Volume createDockerVolumeInPool(Long accountId, String name, String volumeUri, String externalId, String driver, StoragePool storagePool, boolean isHostPath, boolean isNative) { Volume volume = getDockerVolumeInPool(volumeUri, externalId, storagePool); if (volume != null) { return volume; } volume = objectManager.create(Volume.class, VOLUME.ACCOUNT_ID, accountId, VOLUME.NAME, name, VOLUME.ATTACHED_STATE, CommonStatesConstants.INACTIVE, VOLUME.DEVICE_NUMBER, -1, VOLUME.ALLOCATION_STATE, CommonStatesConstants.ACTIVE, VOLUME.URI, volumeUri, VOLUME.EXTERNAL_ID, VolumeUtils.externalId(externalId)); DataAccessor.fields(volume).withKey(VolumeConstants.FIELD_DOCKER_IS_NATIVE).set(isNative); DataAccessor.fields(volume).withKey(VolumeConstants.FIELD_DOCKER_IS_HOST_PATH).set(isHostPath); DataAccessor.fields(volume).withKey(VolumeConstants.FIELD_VOLUME_DRIVER).set(driver); objectManager.persist(volume); objectManager.create(VolumeStoragePoolMap.class, VOLUME_STORAGE_POOL_MAP.VOLUME_ID, volume.getId(), VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID, storagePool.getId()); return volume; }
for(StoragePool registry: storagePools){ if (serverAddress.equalsIgnoreCase((String) CollectionUtils.getNestedValue(registry.getData(), "fields", StoragePoolConstants.SERVER_ADDRESS))) { registryId = registry.getId(); break;
/** * {@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()); }