MetaDataInfoDaoImpl.java

package io.cattle.platform.configitem.context.dao.impl;

import static io.cattle.platform.core.model.tables.HealthcheckInstanceHostMapTable.*;
import static io.cattle.platform.core.model.tables.HostIpAddressMapTable.*;
import static io.cattle.platform.core.model.tables.HostTable.*;
import static io.cattle.platform.core.model.tables.InstanceHostMapTable.*;
import static io.cattle.platform.core.model.tables.InstanceLinkTable.*;
import static io.cattle.platform.core.model.tables.InstanceTable.*;
import static io.cattle.platform.core.model.tables.IpAddressNicMapTable.*;
import static io.cattle.platform.core.model.tables.IpAddressTable.*;
import static io.cattle.platform.core.model.tables.NetworkTable.*;
import static io.cattle.platform.core.model.tables.NicTable.*;
import static io.cattle.platform.core.model.tables.ServiceConsumeMapTable.*;
import static io.cattle.platform.core.model.tables.ServiceExposeMapTable.*;
import static io.cattle.platform.core.model.tables.ServiceTable.*;
import static io.cattle.platform.core.model.tables.StackTable.*;

import io.cattle.platform.configitem.context.dao.MetaDataInfoDao;
import io.cattle.platform.configitem.context.data.metadata.common.ContainerLinkMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.ContainerMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.DefaultMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.HostMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.MetaHelperInfo;
import io.cattle.platform.configitem.context.data.metadata.common.NetworkMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.ServiceContainerLinkMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.ServiceLinkMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.ServiceMetaData;
import io.cattle.platform.configitem.context.data.metadata.common.StackMetaData;
import io.cattle.platform.core.addon.InstanceHealthCheck;
import io.cattle.platform.core.constants.CommonStatesConstants;
import io.cattle.platform.core.constants.InstanceConstants;
import io.cattle.platform.core.constants.IpAddressConstants;
import io.cattle.platform.core.constants.NetworkConstants;
import io.cattle.platform.core.constants.ServiceConstants;
import io.cattle.platform.core.dao.InstanceDao;
import io.cattle.platform.core.dao.LoadBalancerInfoDao;
import io.cattle.platform.core.model.Account;
import io.cattle.platform.core.model.HealthcheckInstanceHostMap;
import io.cattle.platform.core.model.Host;
import io.cattle.platform.core.model.IpAddress;
import io.cattle.platform.core.model.Service;
import io.cattle.platform.core.model.tables.HostTable;
import io.cattle.platform.core.model.tables.InstanceHostMapTable;
import io.cattle.platform.core.model.tables.InstanceTable;
import io.cattle.platform.core.model.tables.IpAddressTable;
import io.cattle.platform.core.model.tables.ServiceExposeMapTable;
import io.cattle.platform.core.model.tables.ServiceTable;
import io.cattle.platform.core.model.tables.records.InstanceRecord;
import io.cattle.platform.core.model.tables.records.NetworkRecord;
import io.cattle.platform.core.model.tables.records.ServiceRecord;
import io.cattle.platform.core.util.LBMetadataUtil.LBConfigMetadataStyle;
import io.cattle.platform.db.jooq.dao.impl.AbstractJooqDao;
import io.cattle.platform.db.jooq.mapper.MultiRecordMapper;
import io.cattle.platform.json.JsonMapper;
import io.cattle.platform.object.ObjectManager;
import io.cattle.platform.object.util.DataAccessor;
import io.cattle.platform.servicediscovery.api.util.ServiceDiscoveryUtil;
import io.cattle.platform.util.exception.ExceptionUtils;

import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.inject.Inject;

import org.apache.commons.lang3.StringUtils;
import org.jooq.Condition;
import org.jooq.JoinType;
import org.jooq.Record10;
import org.jooq.Record20;
import org.jooq.Record3;
import org.jooq.Record4;
import org.jooq.Record5;
import org.jooq.RecordHandler;

public class MetaDataInfoDaoImpl extends AbstractJooqDao implements MetaDataInfoDao {

    @Inject
    InstanceDao instanceDao;
    @Inject
    ObjectManager objMgr;
    @Inject
    LoadBalancerInfoDao lbInfoDao;
    @Inject
    JsonMapper jsonMapper;

    @Override
    public void fetchContainers(final MetaHelperInfo helperInfo,
            final OutputStream os) {

        Condition condition = getMultiAccountInstanceSearchCondition(helperInfo);
        final InstanceTable targetInstance = INSTANCE.as("target_instance");
        create()
                .select(INSTANCE.ID, INSTANCE.ACCOUNT_ID, INSTANCE.UUID, INSTANCE.NAME, INSTANCE.CREATE_INDEX,
                        INSTANCE.HEALTH_STATE, INSTANCE.START_COUNT, INSTANCE.STATE, INSTANCE.EXTERNAL_ID,
                        INSTANCE.DNS_INTERNAL, INSTANCE.DNS_SEARCH_INTERNAL, INSTANCE.MEMORY_RESERVATION,
                        INSTANCE.MILLI_CPU_RESERVATION, INSTANCE.SYSTEM, IP_ADDRESS.ADDRESS, NIC.MAC_ADDRESS,
                        NETWORK.UUID, NETWORK.KIND, HOST.ID, targetInstance.UUID)
                .from(INSTANCE)
                .leftOuterJoin(targetInstance)
                .on(INSTANCE.NETWORK_CONTAINER_ID.eq(targetInstance.ID))
                .join(INSTANCE_HOST_MAP)
                .on(INSTANCE.ID.eq(INSTANCE_HOST_MAP.INSTANCE_ID))
                .join(HOST)
                .on(HOST.ID.eq(INSTANCE_HOST_MAP.HOST_ID))
                .join(SERVICE_EXPOSE_MAP, JoinType.LEFT_OUTER_JOIN)
                .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID))
                .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(NIC.NETWORK_ID.eq(NETWORK.ID))
                .where(INSTANCE.REMOVED.isNull())
                .and(INSTANCE.STATE.notIn(CommonStatesConstants.REMOVING, CommonStatesConstants.REMOVED,
                        InstanceConstants.STATE_ERROR, InstanceConstants.STATE_ERRORING))
                .and(SERVICE_EXPOSE_MAP.REMOVED.isNull())
                .and(IP_ADDRESS.ROLE.eq(IpAddressConstants.ROLE_PRIMARY)
                        .or(IP_ADDRESS.ID.isNull())
                        .or(IP_ADDRESS.ROLE.isNull().and(NETWORK.KIND.eq(NetworkConstants.KIND_DOCKER_HOST)))
                        .or(IP_ADDRESS.ROLE.isNull().and(INSTANCE.NETWORK_CONTAINER_ID.isNotNull())))
                .and(NETWORK.REMOVED.isNull())
                .and((HOST.REMOVED.isNull()))
                .and(targetInstance.REMOVED.isNull())
                .and(SERVICE_EXPOSE_MAP.STATE.isNull().or(
                        SERVICE_EXPOSE_MAP.STATE.notIn(CommonStatesConstants.REMOVING, CommonStatesConstants.REMOVED)))
                .and(SERVICE_EXPOSE_MAP.UPGRADE.isNull().or(SERVICE_EXPOSE_MAP.UPGRADE.eq(false)))
                .and(condition)
                .fetchInto(
                        new RecordHandler<Record20<Long, Long, String, String, Long, String, Long, String, String, String, String, Long, Long, Boolean, String, String, String, String, Long, String>>() {
                            @Override
                            public void next(
                                    Record20<Long, Long, String, String, Long, String, Long, String, String, String, String, Long, Long, Boolean, String, String, String, String, Long, String> record) {
                                InstanceRecord instance = new InstanceRecord();
                                instance.setId(record.getValue(INSTANCE.ID));
                                instance.setName(record.getValue(INSTANCE.NAME));
                                instance.setUuid(record.getValue(INSTANCE.UUID));
                                instance.setCreateIndex(record.getValue(INSTANCE.CREATE_INDEX));
                                instance.setHealthState(record.getValue(INSTANCE.HEALTH_STATE));
                                instance.setStartCount(record.getValue(INSTANCE.START_COUNT));
                                instance.setState(record.getValue(INSTANCE.STATE));
                                instance.setExternalId(record.getValue(INSTANCE.EXTERNAL_ID));
                                instance.setDnsInternal(record.getValue(INSTANCE.DNS_INTERNAL));
                                instance.setDnsSearchInternal(record.getValue(INSTANCE.DNS_SEARCH_INTERNAL));
                                instance.setMemoryReservation(record.getValue(INSTANCE.MEMORY_RESERVATION));
                                instance.setMilliCpuReservation(record.getValue(INSTANCE.MILLI_CPU_RESERVATION));
                                instance.setSystem(record.getValue(INSTANCE.SYSTEM));
                                instance.setAccountId(record.getValue(INSTANCE.ACCOUNT_ID));
                                String primaryIp = record.getValue(IP_ADDRESS.ADDRESS);
                                String macAddress = record.getValue(NIC.MAC_ADDRESS);
                                String networkUUID = record.getValue(NETWORK.UUID);
                                String networkKind = record.getValue(NETWORK.KIND);
                                Long hostId = record.getValue(HOST.ID);
                                String targetInstanceUUID = record.getValue(targetInstance.UUID);

                                ContainerMetaData data = new ContainerMetaData();
                                instance.setData(instanceDao.getCacheInstanceData(instance.getId()));
                                String serviceIndex = DataAccessor.fieldString(instance,
                                        InstanceConstants.FIELD_SERVICE_INSTANCE_SERVICE_INDEX);

                                HostMetaData hostMetaData = helperInfo.getHostIdToHostMetadata().get(hostId);
                                List<String> healthCheckers = new ArrayList<>();
                                if (helperInfo.getInstanceIdToHealthCheckers().get(instance.getId()) != null) {
                                    for (HealthcheckInstanceHostMap hostMap : helperInfo.getInstanceIdToHealthCheckers().get(
                                            instance.getId())) {
                                        HostMetaData h = helperInfo.getHostIdToHostMetadata().get(hostMap.getHostId());
                                        if (h == null) {
                                            continue;
                                        }
                                        healthCheckers.add(h.getUuid());
                                    }
                                }
                                data.setInstanceAndHostMetadata(instance, hostMetaData, healthCheckers,
                                        helperInfo.getAccounts().get(instance.getAccountId()));

                                data.setService_index(serviceIndex);
                                if (networkKind.equalsIgnoreCase(NetworkConstants.KIND_DOCKER_HOST)
                                        && hostMetaData != null) {
                                    primaryIp = hostMetaData.getAgent_ip();
                                }
                                data.setIp(primaryIp);
                                data.setNetwork_uuid(networkUUID);
                                data.setNetwork_from_container_uuid(targetInstanceUUID);
                                data.setPrimary_mac_address(macAddress);

                                writeToJson(os, data);
                            }
                        });
    }

    @Override
    public Map<Long, HostMetaData> getHostIdToHostMetadata(Account account, Map<Long, Account> accounts,
            Set<Long> linkedServicesIds) {
        Map<Long, HostMetaData> toReturn = new HashMap<>();
        List<HostMetaData> hosts = getAllInstanceHostMetaDataForAccount(account);
        if (!linkedServicesIds.isEmpty()) {
            hosts.addAll(getAllInstanceHostMetaDataForLinkedServices(accounts, linkedServicesIds));
        }

        for (HostMetaData host : hosts) {
            toReturn.put(host.getHostId(), host);
        }
        return toReturn;
    }

    protected List<HostMetaData> getAllInstanceHostMetaDataForLinkedServices(final Map<Long, Account> accounts,
            final Set<Long> linkedServicesIds) {
        MultiRecordMapper<HostMetaData> mapper = new MultiRecordMapper<HostMetaData>() {
            @Override
            protected HostMetaData map(List<Object> input) {
                Host host = (Host) input.get(0);
                IpAddress hostIp = (IpAddress) input.get(1);
                HostMetaData data = new HostMetaData(hostIp.getAddress(), host, accounts.get(host.getAccountId()));
                return data;
            }
        };

        HostTable host = mapper.add(HOST);
        IpAddressTable hostIpAddress = mapper.add(IP_ADDRESS);
        InstanceHostMapTable instanceHostMap = mapper.add(INSTANCE_HOST_MAP, INSTANCE_HOST_MAP.INSTANCE_ID,
                INSTANCE_HOST_MAP.HOST_ID);
        ServiceExposeMapTable exposeMap = mapper.add(SERVICE_EXPOSE_MAP, SERVICE_EXPOSE_MAP.INSTANCE_ID,
                SERVICE_EXPOSE_MAP.SERVICE_ID);
        return create()
                .select(mapper.fields())
                .from(hostIpAddress)
                .join(HOST_IP_ADDRESS_MAP)
                .on(HOST_IP_ADDRESS_MAP.IP_ADDRESS_ID.eq(hostIpAddress.ID))
                .join(host)
                .on(host.ID.eq(HOST_IP_ADDRESS_MAP.HOST_ID))
                .join(instanceHostMap)
                .on(instanceHostMap.HOST_ID.eq(host.ID))
                .join(exposeMap)
                .on(exposeMap.INSTANCE_ID.eq(instanceHostMap.INSTANCE_ID))
                .where(host.REMOVED.isNull())
                .and(exposeMap.REMOVED.isNull())
                .and(instanceHostMap.REMOVED.isNull())
                .and(host.STATE.notIn(CommonStatesConstants.REMOVING, CommonStatesConstants.REMOVED))
                .and(hostIpAddress.REMOVED.isNull())
                .and(exposeMap.SERVICE_ID.in(linkedServicesIds))
                .fetch().map(mapper);
    }

    protected List<HostMetaData> getAllInstanceHostMetaDataForAccount(final Account account) {
        MultiRecordMapper<HostMetaData> mapper = new MultiRecordMapper<HostMetaData>() {
            @Override
            protected HostMetaData map(List<Object> input) {
                Host host = (Host) input.get(0);
                IpAddress hostIp = (IpAddress) input.get(1);
                HostMetaData data = new HostMetaData(hostIp.getAddress(), host, account);
                return data;
            }
        };

        HostTable host = mapper.add(HOST);
        IpAddressTable hostIpAddress = mapper.add(IP_ADDRESS);

        return create()
                .select(mapper.fields())
                .from(hostIpAddress)
                .join(HOST_IP_ADDRESS_MAP)
                .on(HOST_IP_ADDRESS_MAP.IP_ADDRESS_ID.eq(hostIpAddress.ID))
                .join(host)
                .on(host.ID.eq(HOST_IP_ADDRESS_MAP.HOST_ID))
                .where(host.REMOVED.isNull())
                .and(host.STATE.notIn(CommonStatesConstants.REMOVING, CommonStatesConstants.REMOVED))
                .and(hostIpAddress.REMOVED.isNull())
                .and(host.ACCOUNT_ID.eq(account.getId()))
                .fetch().map(mapper);
    }

    @Override
    public Map<Long, List<HealthcheckInstanceHostMap>> getInstanceIdToHealthCheckers(Account account) {
        Map<Long, List<HealthcheckInstanceHostMap>> instanceIdToHealthCheckers = new HashMap<>();
        List<? extends HealthcheckInstanceHostMap> hostMaps = objMgr.find(HealthcheckInstanceHostMap.class,
                HEALTHCHECK_INSTANCE_HOST_MAP.ACCOUNT_ID, account.getId(), HEALTHCHECK_INSTANCE_HOST_MAP.REMOVED, null);

        for (HealthcheckInstanceHostMap hostMap : hostMaps) {
            List<HealthcheckInstanceHostMap> instanceHostMaps = instanceIdToHealthCheckers
                    .get(hostMap.getInstanceId());
            if (instanceHostMaps == null) {
                instanceHostMaps = new ArrayList<>();
            }
            instanceHostMaps.add(hostMap);
            instanceIdToHealthCheckers.put(hostMap.getInstanceId(), instanceHostMaps);
        }

        return instanceIdToHealthCheckers;
    }


    @Override
    public void fetchNetworks(final MetaHelperInfo helperInfo, final OutputStream os) {
        create()
                .select(NETWORK.NAME, NETWORK.UUID, NETWORK.ACCOUNT_ID, NETWORK.ID, NETWORK.DATA)
                .from(NETWORK)
                .where(NETWORK.REMOVED.isNull())
                .and(NETWORK.ACCOUNT_ID.eq(helperInfo.getAccount().getId()))
                .fetchInto(new RecordHandler<Record5<String, String, Long, Long, Map<String, Object>>>() {
                    @Override
                    public void next(Record5<String, String, Long, Long, Map<String, Object>> record) {
                        fetchNetwork(helperInfo, os, record);
                    }
                });

        if (!helperInfo.getOtherAccountsServicesIds().isEmpty()) {
            create()
                    .select(NETWORK.NAME, NETWORK.UUID, NETWORK.ACCOUNT_ID, NETWORK.ID, NETWORK.DATA)
                    .from(NETWORK)
                    .join(NIC)
                    .on(NIC.NETWORK_ID.eq(NETWORK.ID))
                    .join(SERVICE_EXPOSE_MAP)
                    .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(NIC.INSTANCE_ID))
                    .where(NETWORK.REMOVED.isNull())
                    .and(SERVICE_EXPOSE_MAP.REMOVED.isNull())
                    .and(SERVICE_EXPOSE_MAP.SERVICE_ID.in(helperInfo.getOtherAccountsServicesIds()))
                    .fetchInto(new RecordHandler<Record5<String, String, Long, Long, Map<String, Object>>>() {
                        @Override
                        public void next(Record5<String, String, Long, Long, Map<String, Object>> record) {
                            fetchNetwork(helperInfo, os, record);
                        }
                    });
        }

    }

    private void fetchNetwork(final MetaHelperInfo helperInfo, final OutputStream os,
            Record5<String, String, Long, Long, Map<String, Object>> record) {
        String name = record.getValue(NETWORK.NAME);
        String uuid = record.getValue(NETWORK.UUID);
        Long accountId = record.getValue(NETWORK.ACCOUNT_ID);
        Long id = record.getValue(NETWORK.ID);
        Map<String, Object> data = record.getValue(NETWORK.DATA);
        NetworkRecord ntwk = new NetworkRecord();
        ntwk.setData(data);
        Map<String, Object> meta = DataAccessor.fieldMap(ntwk, ServiceConstants.FIELD_METADATA);
        Account account = helperInfo.getAccounts().get(accountId);
        boolean isDefault = account.getDefaultNetworkId() == null ? false : account
                .getDefaultNetworkId().equals(id);
        boolean host_ports = DataAccessor.fieldBool(ntwk, NetworkConstants.FIELD_HOST_PORTS);
        Object policy = DataAccessor.field(ntwk, NetworkConstants.FIELD_POLICY, Object.class);
        String dpa = DataAccessor.fieldString(ntwk, NetworkConstants.FIELD_DEFAULT_POLICY_ACTION);
        NetworkMetaData ntwkMeta = new NetworkMetaData(name, uuid, host_ports, isDefault, meta, dpa, policy, account);
        writeToJson(os, ntwkMeta);
    }

    @Override
    public void fetchContainerLinks(MetaHelperInfo helperInfo, final OutputStream os) {
        final InstanceTable targetInstance = INSTANCE.as("target_instance");
        create()
                .select(INSTANCE_LINK.LINK_NAME, INSTANCE.UUID, targetInstance.UUID)
                .from(INSTANCE_LINK)
                .join(INSTANCE)
                .on(INSTANCE_LINK.INSTANCE_ID.eq(INSTANCE.ID))
                .join(targetInstance)
                .on(INSTANCE_LINK.TARGET_INSTANCE_ID.eq(targetInstance.ID))
                .where(INSTANCE.REMOVED.isNull())
                .and(INSTANCE_LINK.REMOVED.isNull())
                .and(targetInstance.REMOVED.isNull())
                .and(INSTANCE_LINK.ACCOUNT_ID.eq(helperInfo.getAccount().getId()))
                .fetchInto(new RecordHandler<Record3<String, String, String>>() {
                    @Override
                    public void next(Record3<String, String, String> record) {
                        String linkName = record.getValue(INSTANCE_LINK.LINK_NAME);
                        String instanceUUID = record.getValue(INSTANCE.UUID);
                        String targetInstanceUUID = record.getValue(targetInstance.UUID);
                        ContainerLinkMetaData data = new ContainerLinkMetaData(instanceUUID,
                                targetInstanceUUID,
                                linkName);
                        writeToJson(os, data);
                    }
                });
}


    private Condition getMultiAccountInstanceSearchCondition(final MetaHelperInfo helperInfo) {
        Condition condition = INSTANCE.ACCOUNT_ID.eq(helperInfo.getAccount().getId());
        if (!helperInfo.getOtherAccountsServicesIds().isEmpty()) {
            condition = INSTANCE.ACCOUNT_ID.eq(helperInfo.getAccount().getId()).or(
                    SERVICE_EXPOSE_MAP.SERVICE_ID.in(helperInfo.getOtherAccountsServicesIds()));
        }
        return condition;
    }

    protected void writeToJson(OutputStream os, Object data) {
        try {
            jsonMapper.writeValue(os, data);
        } catch (Throwable t) {
            ExceptionUtils.rethrowExpectedRuntime(t);
        }
    }

    @Override
    public void fetchHosts(MetaHelperInfo helperInfo, OutputStream os) {
        for (HostMetaData host : helperInfo.getHostIdToHostMetadata().values()) {
            writeToJson(os, host);
        }
    }

    @Override
    public void fetchSelf(HostMetaData selfHost, String version, OutputStream os) {
        DefaultMetaData def = new DefaultMetaData(version, selfHost);
        writeToJson(os, def);
    }

    protected void fetchLaunchConfigInfo(final MetaHelperInfo helperInfo, final OutputStream os, Service service,
            String stackName, String stackUUID, String launchConfigName, List<String> launchConfigNames) {
        List<String> sidekicks = new ArrayList<>();
        for (String lc : launchConfigNames) {
            if (!lc.equalsIgnoreCase(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME)) {
                sidekicks.add(lc);
            }
        }
        LBConfigMetadataStyle lbConfig = lbInfoDao.generateLBConfigMetadataStyle(service);
        Object hcO = null;
        if (service.getKind().equalsIgnoreCase(ServiceConstants.KIND_EXTERNAL_SERVICE)) {
            hcO = DataAccessor.field(service, InstanceConstants.FIELD_HEALTH_CHECK, Object.class);
        } else {
            hcO = ServiceDiscoveryUtil.getLaunchConfigObject(service, launchConfigName,
                    InstanceConstants.FIELD_HEALTH_CHECK);
        }

        InstanceHealthCheck hc = null;
        if (hcO != null) {
            hc = jsonMapper.convertValue(hcO, InstanceHealthCheck.class);
        }
        String name = launchConfigName;
        if (launchConfigName.equalsIgnoreCase(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME)) {
            name = service.getName();
        }

        ServiceMetaData data = new ServiceMetaData(service, name, stackName, stackUUID, sidekicks,
                hc, lbConfig, helperInfo.getAccount());

        writeToJson(os, data);
    }

    @Override
    public void fetchServices(final MetaHelperInfo helperInfo, final OutputStream os) {
        Condition condition = SERVICE.ACCOUNT_ID.eq(helperInfo.getAccount().getId());
        if (!helperInfo.getOtherAccountsServicesIds().isEmpty()) {
            condition = SERVICE.ACCOUNT_ID.eq(helperInfo.getAccount().getId()).or(
                    SERVICE.ID.in(helperInfo.getOtherAccountsServicesIds()));
        }
        create()
                .select(SERVICE.UUID, SERVICE.NAME, SERVICE.STATE, SERVICE.CREATE_INDEX, SERVICE.KIND, SERVICE.SYSTEM,
                        SERVICE.DATA, SERVICE.ACCOUNT_ID,
                        STACK.UUID, STACK.NAME)
                .from(SERVICE)
                .join(STACK)
                .on(SERVICE.STACK_ID.eq(STACK.ID))
                .where(STACK.REMOVED.isNull())
                .and(SERVICE.REMOVED.isNull())
                .and(condition)
                .fetchInto(
                        new RecordHandler<Record10<String, String, String, Long, String, Boolean, Map<String, Object>, Long, String, String>>() {
                    @Override
                            public void next(
                                    Record10<String, String, String, Long, String, Boolean, Map<String, Object>, Long, String, String> record) {
                                ServiceRecord service = new ServiceRecord();
                                service.setName(record.getValue(SERVICE.NAME));
                                service.setUuid(record.getValue(SERVICE.UUID));
                                service.setState(record.getValue(SERVICE.STATE));
                                service.setCreateIndex(record.getValue(SERVICE.CREATE_INDEX));
                                service.setSystem(record.getValue(SERVICE.SYSTEM));
                                service.setData(record.getValue(SERVICE.DATA));
                                service.setKind(record.getValue(SERVICE.KIND));
                                service.setAccountId(record.getValue(SERVICE.ACCOUNT_ID));
                                String stackName = record.getValue(STACK.NAME);
                                String stackUUID = record.getValue(STACK.UUID);

                                List<String> launchConfigNames = ServiceDiscoveryUtil
                                        .getServiceLaunchConfigNames(service);
                                if (launchConfigNames.isEmpty()) {
                                    launchConfigNames.add(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME);
                                }

                                for (String launchConfigName : launchConfigNames) {
                                    fetchLaunchConfigInfo(helperInfo, os, service, stackName, stackUUID,
                                            launchConfigName,
                                            launchConfigNames);
                                }
                    }
                });
    }

    @Override
    public void fetchStacks(final MetaHelperInfo helperInfo, final OutputStream os) {
        Condition condition = STACK.ACCOUNT_ID.eq(helperInfo.getAccount().getId());
        if (!helperInfo.getOtherAccountsServicesIds().isEmpty()) {
            condition = STACK.ACCOUNT_ID.eq(helperInfo.getAccount().getId()).or(
                    STACK.ID.in(helperInfo.getOtherAccountsStackIds()));
        }
        create()
                .select(STACK.NAME, STACK.UUID, STACK.SYSTEM)
                .from(STACK)
                .where(STACK.REMOVED.isNull())
                .and(condition)
                .fetchInto(new RecordHandler<Record3<String, String, Boolean>>() {
                    @Override
                    public void next(Record3<String, String, Boolean> record) {
                        String name = record.getValue(STACK.NAME);
                        String uuid = record.getValue(STACK.UUID);
                        Boolean system = record.getValue(STACK.SYSTEM);
                        StackMetaData data = new StackMetaData(name, uuid, system, helperInfo.getAccount());
                        writeToJson(os, data);
                    }
                });
    }

    @Override
    public void fetchServiceLinks(final MetaHelperInfo helperInfo, final OutputStream os) {
        final ServiceTable consumedService = SERVICE.as("consumed_service");
        Condition condition = SERVICE_CONSUME_MAP.ACCOUNT_ID.eq(helperInfo.getAccount().getId());
        if (!helperInfo.getOtherAccountsServicesIds().isEmpty()) {
            condition = SERVICE_CONSUME_MAP.ACCOUNT_ID.eq(helperInfo.getAccount().getId()).or(
                    SERVICE_CONSUME_MAP.SERVICE_ID.in(helperInfo.getOtherAccountsServicesIds()));
        }
        create()
                .select(SERVICE_CONSUME_MAP.NAME, SERVICE.UUID, STACK.NAME, consumedService.NAME)
                .from(SERVICE_CONSUME_MAP)
                .join(SERVICE)
                .on(SERVICE_CONSUME_MAP.SERVICE_ID.eq(SERVICE.ID))
                .join(consumedService)
                .on(SERVICE_CONSUME_MAP.CONSUMED_SERVICE_ID.eq(consumedService.ID))
                .join(STACK)
                .on(STACK.ID.eq(consumedService.STACK_ID))
                .where(SERVICE_CONSUME_MAP.REMOVED.isNull())
                .and(SERVICE.REMOVED.isNull())
                .and(consumedService.REMOVED.isNull())
                .and(STACK.REMOVED.isNull())
                .and(condition)
                .fetchInto(new RecordHandler<Record4<String, String, String, String>>() {
                    @Override
                    public void next(Record4<String, String, String, String> record) {
                        String consumeMapName = record.getValue(SERVICE_CONSUME_MAP.NAME);
                        String serviceUUID = record.getValue(SERVICE.UUID);
                        String stackName = record.getValue(STACK.NAME);
                        String consumedServiceName = record.getValue(consumedService.NAME);
                        String linkAlias = !StringUtils.isEmpty(consumeMapName) ? consumeMapName : consumedServiceName;

                        ServiceLinkMetaData data = new ServiceLinkMetaData(serviceUUID,
                                consumedServiceName,
                                stackName, linkAlias);
                        writeToJson(os, data);
                    }
                });
    }

    @Override
    public void fetchServiceContainerLinks(final MetaHelperInfo helperInfo, final OutputStream os) {
        Condition condition = SERVICE_EXPOSE_MAP.ACCOUNT_ID.eq(helperInfo.getAccount().getId());
        if (!helperInfo.getOtherAccountsServicesIds().isEmpty()) {
            condition = SERVICE_EXPOSE_MAP.ACCOUNT_ID.eq(helperInfo.getAccount().getId()).or(
                    SERVICE_EXPOSE_MAP.SERVICE_ID.in(helperInfo.getOtherAccountsServicesIds()));
        }
        create()
                .select(SERVICE_EXPOSE_MAP.DNS_PREFIX, INSTANCE.UUID, SERVICE.UUID, SERVICE.NAME)
                .from(SERVICE_EXPOSE_MAP)
                .join(INSTANCE)
                .on(INSTANCE.ID.eq(SERVICE_EXPOSE_MAP.INSTANCE_ID))
                .join(SERVICE)
                .on(SERVICE_EXPOSE_MAP.SERVICE_ID.eq(SERVICE.ID))
                .where(SERVICE_EXPOSE_MAP.REMOVED.isNull())
                .and(SERVICE.REMOVED.isNull())
                .and(INSTANCE.REMOVED.isNull())
                .and(condition)
                .fetchInto(new RecordHandler<Record4<String, String, String, String>>() {
                    @Override
                    public void next(Record4<String, String, String, String> record) {
                        String dnsPrefix = record.getValue(SERVICE_EXPOSE_MAP.DNS_PREFIX);
                        String instanceUUID = record.getValue(INSTANCE.UUID);
                        String serviceName = record.getValue(SERVICE.NAME);
                        String serviceUUID = record.getValue(SERVICE.UUID);
                        String svcName = dnsPrefix != null ? dnsPrefix : serviceName;
                        ServiceContainerLinkMetaData data = new ServiceContainerLinkMetaData(serviceUUID, svcName,
                                instanceUUID);
                        writeToJson(os, data);
                    }
                });
    }
}