.join(INSTANCE) .on(INSTANCE_HOST_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .leftOuterJoin(SERVICE_EXPOSE_MAP) .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .where(INSTANCE_HOST_MAP.HOST_ID.in(hostIds)
public List<ResourceAccessEntry> getAccessLevel(UUID projectId) { List<ResourceAccessEntry> resourceAccessList = new ArrayList<>(); try (DSLContext tx = DSL.using(cfg)) { Result<Record5<UUID, UUID, String, String, String>> teamsAccess = tx.select( PROJECT_TEAM_ACCESS.TEAM_ID, PROJECT_TEAM_ACCESS.PROJECT_ID, TEAMS.TEAM_NAME, ORGANIZATIONS.ORG_NAME, PROJECT_TEAM_ACCESS.ACCESS_LEVEL) .from(PROJECT_TEAM_ACCESS) .leftOuterJoin(TEAMS).on(TEAMS.TEAM_ID.eq(PROJECT_TEAM_ACCESS.TEAM_ID)) .leftOuterJoin(PROJECTS).on(PROJECTS.PROJECT_ID.eq(projectId)) .leftOuterJoin(ORGANIZATIONS).on(ORGANIZATIONS.ORG_ID.eq(PROJECTS.ORG_ID)) .where(PROJECT_TEAM_ACCESS.PROJECT_ID.eq(projectId)) .fetch(); for (Record5<UUID, UUID, String, String, String> t : teamsAccess) { resourceAccessList.add(new ResourceAccessEntry(t.get(PROJECT_TEAM_ACCESS.TEAM_ID), t.get(ORGANIZATIONS.ORG_NAME), t.get(TEAMS.TEAM_NAME), ResourceAccessLevel.valueOf(t.get(PROJECT_TEAM_ACCESS.ACCESS_LEVEL)))); } } return resourceAccessList; }
.leftOuterJoin(SERVICE) .on(SERVICE.ID.eq(SERVICE_CONSUME_MAP.CONSUMED_SERVICE_ID)) .leftOuterJoin(STACK) .on(STACK.ID.eq(SERVICE.STACK_ID)) .where(SERVICE_CONSUME_MAP.SERVICE_ID.in(ids)
.join(network) .on(network.ID.eq(nic.NETWORK_ID)) .leftOuterJoin(volume) .on(volume.INSTANCE_ID.eq(instance.ID) .and(volume.REMOVED.isNull())) .leftOuterJoin(CREDENTIAL_INSTANCE_MAP) .on(CREDENTIAL_INSTANCE_MAP.INSTANCE_ID.eq(instance.ID) .and(CREDENTIAL_INSTANCE_MAP.REMOVED.isNull())) .leftOuterJoin(credential) .on(CREDENTIAL_INSTANCE_MAP.CREDENTIAL_ID.eq(credential.ID) .and(credential.REMOVED.isNull()) .and(credential.KIND.eq(CredentialConstants.KIND_SSH_KEY))) .leftOuterJoin(IP_ADDRESS_NIC_MAP) .on(IP_ADDRESS_NIC_MAP.NIC_ID.eq(nic.ID) .and(IP_ADDRESS_NIC_MAP.REMOVED.isNull())) .leftOuterJoin(primaryIp) .on(IP_ADDRESS_NIC_MAP.IP_ADDRESS_ID.eq(primaryIp.ID) .and(primaryIp.ROLE.in(IpAddressConstants.ROLE_PRIMARY, IpAddressConstants.ROLE_SECONDARY)) .and(primaryIp.REMOVED.isNull())) .leftOuterJoin(subnet) .on(primaryIp.SUBNET_ID.eq(subnet.ID)) .where(nic.INSTANCE_ID.eq(agentInstance.getId()).and(nic.REMOVED.isNull()));
.from(LABEL) .leftOuterJoin(INSTANCE_LABEL_MAP).on(LABEL.ID.eq(INSTANCE_LABEL_MAP.LABEL_ID)) .leftOuterJoin(HOST_LABEL_MAP).on(LABEL.ID.eq(HOST_LABEL_MAP.LABEL_ID)) .where(INSTANCE_LABEL_MAP.ID.isNull()) .and(HOST_LABEL_MAP.ID.isNull())
protected SelectConditionStep<Record3<String, Long, Long>> getHostQuery(List<String> orderedHostUUIDs, QueryOptions options) { return create() .select(HOST.UUID, HOST.ID, STORAGE_POOL.ID) .from(HOST) .leftOuterJoin(STORAGE_POOL_HOST_MAP) .on(STORAGE_POOL_HOST_MAP.HOST_ID.eq(HOST.ID) .and(STORAGE_POOL_HOST_MAP.REMOVED.isNull())) .join(STORAGE_POOL) .on(STORAGE_POOL.ID.eq(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID)) .leftOuterJoin(AGENT) .on(AGENT.ID.eq(HOST.AGENT_ID)) .where(getQueryOptionCondition(options, orderedHostUUIDs)); }
@Override public boolean isScheulderIpsEnabled(long accountId) { return create() .select(HOST_LABEL_MAP.ID) .from(HOST_LABEL_MAP) .join(LABEL).on(HOST_LABEL_MAP.LABEL_ID.eq(LABEL.ID)) .join(HOST).on(HOST_LABEL_MAP.HOST_ID.eq(HOST.ID)) .leftOuterJoin(AGENT) .on(AGENT.ID.eq(HOST.AGENT_ID)) .leftOuterJoin(STORAGE_POOL_HOST_MAP) .on(STORAGE_POOL_HOST_MAP.HOST_ID.eq(HOST.ID) .and(STORAGE_POOL_HOST_MAP.REMOVED.isNull())) .join(STORAGE_POOL) .on(STORAGE_POOL.ID.eq(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID)) .where(elligibleHostCondition() .and(HOST_LABEL_MAP.ACCOUNT_ID.equal(accountId)) .and(HOST_LABEL_MAP.REMOVED.isNull()) .and(LABEL.KEY.equalIgnoreCase("io.rancher.scheduler.ips"))).fetch().size() > 0; }
@Override public Map<Long, Long> findStoragePoolHostsByDriver(Long accountId, Long storageDriverId) { final Map<Long, Long> result = new HashMap<>(); create().select(HOST.ID, STORAGE_POOL.ID) .from(HOST) .leftOuterJoin(STORAGE_POOL_HOST_MAP) .on(STORAGE_POOL_HOST_MAP.HOST_ID.eq(HOST.ID)) .leftOuterJoin(STORAGE_POOL) .on(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID.eq(STORAGE_POOL.ID) .and(STORAGE_POOL.STORAGE_DRIVER_ID.eq(storageDriverId))) .where(STORAGE_POOL.REMOVED.isNull() .and(STORAGE_POOL_HOST_MAP.REMOVED.isNull()) .and(HOST.ACCOUNT_ID.eq(accountId)) .and(HOST.REMOVED.isNull())) .fetchInto(new RecordHandler<Record2<Long, Long>>() { @Override public void next(Record2<Long, Long> record) { Long hostId = record.getValue(HOST.ID); Long storagePoolId = record.getValue(STORAGE_POOL.ID); if (!result.containsKey(hostId) || storagePoolId != null) { result.put(hostId, storagePoolId); } } }); return result; }
.join(host) .on(INSTANCE_HOST_MAP.HOST_ID.eq(host.ID)) .leftOuterJoin(ipAddress) .on(port.PUBLIC_IP_ADDRESS_ID.eq(ipAddress.ID)) .leftOuterJoin(exposeMap) .on(exposeMap.INSTANCE_ID.eq(instance.ID)) .leftOuterJoin(HOST_IP_ADDRESS_MAP) .on(host.ID.eq(HOST_IP_ADDRESS_MAP.HOST_ID)) .leftOuterJoin(hostIp) .on(HOST_IP_ADDRESS_MAP.IP_ADDRESS_ID.eq(hostIp.ID)) .where(instance.ACCOUNT_ID.eq(accountId))
@Override public List<? extends Volume> findSharedOrUnmappedVolumes(long accountId, String volumeName) { List<VolumeRecord> volumes = create() .selectDistinct(VOLUME.fields()) .from(VOLUME) .leftOuterJoin(VOLUME_STORAGE_POOL_MAP) .on(VOLUME_STORAGE_POOL_MAP.VOLUME_ID.eq(VOLUME.ID)) .leftOuterJoin(STORAGE_POOL) .on(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(STORAGE_POOL.ID)) .where(VOLUME.NAME.eq(volumeName) .and((VOLUME.REMOVED.isNull()))) .and(VOLUME.ACCOUNT_ID.eq(accountId)) .and(STORAGE_POOL.KIND.notIn(LOCAL_POOL_KINDS).or(STORAGE_POOL.KIND.isNull())) .and(STORAGE_POOL.REMOVED.isNull()) .fetchInto(VolumeRecord.class); return volumes; }
protected List<? extends ConfigItemStatus> agentOutOfSyncItems() { return create() .select(CONFIG_ITEM_STATUS.fields()) .from(CONFIG_ITEM_STATUS) .join(AGENT) .on(AGENT.ID.eq(CONFIG_ITEM_STATUS.AGENT_ID)) .leftOuterJoin(INSTANCE) .on(INSTANCE.AGENT_ID.eq(AGENT.ID)) .where(CONFIG_ITEM_STATUS.REQUESTED_VERSION.ne(CONFIG_ITEM_STATUS.APPLIED_VERSION) .and(AGENT.STATE.in(CommonStatesConstants.ACTIVE, CommonStatesConstants.ACTIVATING, AgentConstants.STATE_RECONNECTING, AgentConstants.STATE_FINISHING_RECONNECT, AgentConstants.STATE_RECONNECTED)) .and(INSTANCE.STATE.isNull().or(INSTANCE.STATE.eq(InstanceConstants.STATE_RUNNING)))) .orderBy(AGENT.ID.asc()) .limit(BATCH_SIZE.get()) .fetchInto(ConfigItemStatusRecord.class); }
@Override public boolean hostHasContainerLabel(long hostId, String labelKey, String labelValue) { return create() .select(LABEL.ID) .from(LABEL) .join(INSTANCE_LABEL_MAP) .on(LABEL.ID.eq(INSTANCE_LABEL_MAP.LABEL_ID)) .join(INSTANCE_HOST_MAP) .on(INSTANCE_LABEL_MAP.INSTANCE_ID.eq(INSTANCE_HOST_MAP.INSTANCE_ID)) .join(INSTANCE) .on(INSTANCE_HOST_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .leftOuterJoin(SERVICE_EXPOSE_MAP) .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .where(INSTANCE_HOST_MAP.HOST_ID.eq(hostId)) .and(LABEL.REMOVED.isNull()) .and(INSTANCE_LABEL_MAP.REMOVED.isNull()) .and(INSTANCE_HOST_MAP.REMOVED.isNull()) .and(INSTANCE.REMOVED.isNull()) .and(INSTANCE.STATE.notIn(InstanceConstants.STATE_ERROR, InstanceConstants.STATE_ERRORING)) .and(LABEL.KEY.equalIgnoreCase(labelKey)) .and(LABEL.VALUE.equalIgnoreCase(labelValue)) .and(SERVICE_EXPOSE_MAP.UPGRADE.eq(false).or(SERVICE_EXPOSE_MAP.UPGRADE.isNull())) .fetchInto(Long.class).size() > 0; }
protected List<? extends ConfigItemStatus> agentMigrationItems() { return create() .select(CONFIG_ITEM_STATUS.fields()) .from(CONFIG_ITEM_STATUS) .join(AGENT) .on(AGENT.ID.eq(CONFIG_ITEM_STATUS.AGENT_ID)) .join(CONFIG_ITEM) .on(CONFIG_ITEM.NAME.eq(CONFIG_ITEM_STATUS.NAME)) .leftOuterJoin(INSTANCE) .on(INSTANCE.AGENT_ID.eq(AGENT.ID)) .where(CONFIG_ITEM_STATUS.SOURCE_VERSION.isNotNull() .and(CONFIG_ITEM_STATUS.SOURCE_VERSION.ne(CONFIG_ITEM.SOURCE_VERSION)) .and(AGENT.STATE.in(CommonStatesConstants.ACTIVE, CommonStatesConstants.ACTIVATING, AgentConstants.STATE_RECONNECTING, AgentConstants.STATE_FINISHING_RECONNECT, AgentConstants.STATE_RECONNECTED)) .and(INSTANCE.STATE.isNull().or(INSTANCE.STATE.eq(InstanceConstants.STATE_RUNNING)))) .orderBy(AGENT.ID.asc()) .limit(BATCH_SIZE.get()) .fetchInto(ConfigItemStatusRecord.class); }
.on(PG_ATTRIBUTE.ATTRELID.eq(oid(PG_CLASS))) .and(PG_ATTRIBUTE.ATTNAME.eq(COLUMNS.COLUMN_NAME)) .leftOuterJoin(PG_DESCRIPTION) .on(PG_DESCRIPTION.OBJOID.eq(oid(PG_CLASS))) .and(PG_DESCRIPTION.OBJSUBID.eq(COLUMNS.ORDINAL_POSITION))
@Override public List<Port> getUsedPortsForHostExcludingInstance(long hostId, long instanceId) { return create() .select(PORT.fields()) .from(PORT) .join(INSTANCE_HOST_MAP) .on(PORT.INSTANCE_ID.eq(INSTANCE_HOST_MAP.INSTANCE_ID)) .join(INSTANCE) .on(INSTANCE_HOST_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .leftOuterJoin(SERVICE_EXPOSE_MAP) .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .where(INSTANCE_HOST_MAP.HOST_ID.eq(hostId) .and(INSTANCE.REMOVED.isNull()) .and(INSTANCE.ID.ne(instanceId)) .and(INSTANCE.STATE.in(InstanceConstants.STATE_STARTING, InstanceConstants.STATE_RESTARTING, InstanceConstants.STATE_RUNNING)) .and(INSTANCE_HOST_MAP.REMOVED.isNull()) .and(PORT.REMOVED.isNull()) .and(SERVICE_EXPOSE_MAP.UPGRADE.eq(false).or(SERVICE_EXPOSE_MAP.UPGRADE.isNull()))) .fetchInto(Port.class); }
@Override public Host getHost(Instance instance) { Condition cond = getInstanceHostConstraint(instance); try { return create() .selectDistinct(HOST.fields()) .from(HOST) .join(INSTANCE_HOST_MAP) .on(INSTANCE_HOST_MAP.HOST_ID.eq(HOST.ID)) .join(INSTANCE) .on(INSTANCE_HOST_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .leftOuterJoin(SERVICE_EXPOSE_MAP) .on(INSTANCE.ID.eq(SERVICE_EXPOSE_MAP.INSTANCE_ID)) .where( INSTANCE_HOST_MAP.REMOVED.isNull() .and(HOST.REMOVED.isNull()) .and(INSTANCE.REMOVED.isNull()) .and(SERVICE_EXPOSE_MAP.REMOVED.isNull()) .and(SERVICE_EXPOSE_MAP.UPGRADE.isNull().or(SERVICE_EXPOSE_MAP.UPGRADE.eq(false))) .and(cond)) .fetchOneInto(HostRecord.class); } catch (InvalidResultException e) { throw new FailedToAllocate("Instances to allocate assigned to different hosts."); } }
.on(PARAMETERS.SPECIFIC_SCHEMA.equal(ROUTINES.SPECIFIC_SCHEMA)) .and(PARAMETERS.SPECIFIC_NAME.equal(ROUTINES.SPECIFIC_NAME)) .leftOuterJoin(ELEMENT_TYPES) .on(ROUTINES.ROUTINE_SCHEMA.equal(ELEMENT_TYPES.OBJECT_SCHEMA)) .and(ROUTINES.ROUTINE_NAME.equal(ELEMENT_TYPES.OBJECT_NAME))
.join(NIC) .on(NIC.INSTANCE_ID.eq(INSTANCE_HOST_MAP.INSTANCE_ID)) .leftOuterJoin(IP_ADDRESS_NIC_MAP) .on(IP_ADDRESS_NIC_MAP.NIC_ID.eq(NIC.ID)) .leftOuterJoin(IP_ADDRESS) .on(IP_ADDRESS.ID.eq(IP_ADDRESS_NIC_MAP.IP_ADDRESS_ID)) .join(NETWORK)
.on(PG_CLASS.RELNAME.eq(TABLES.TABLE_NAME)) .and(PG_CLASS.RELNAMESPACE.eq(oid(PG_NAMESPACE))) .leftOuterJoin(PG_DESCRIPTION) .on(PG_DESCRIPTION.OBJOID.eq(oid(PG_CLASS))) .and(PG_DESCRIPTION.OBJSUBID.eq(0)) .join(PG_NAMESPACE) .on(PG_CLASS.RELNAMESPACE.eq(oid(PG_NAMESPACE))) .leftOuterJoin(PG_DESCRIPTION) .on(PG_DESCRIPTION.OBJOID.eq(oid(PG_CLASS))) .and(PG_DESCRIPTION.OBJSUBID.eq(0))