SwitchIntegrationService.java

Go to the documentation of this file.

package org.openkilda.integration.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.util.UriComponentsBuilder;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.http.HttpResponse;
import org.openkilda.helper.RestClientManager;
import org.openkilda.integration.converter.IslLinkConverter;
import org.openkilda.integration.exception.ContentNotFoundException;
import org.openkilda.integration.exception.IntegrationException;
import org.openkilda.integration.exception.InvalidResponseException;
import org.openkilda.integration.model.PortConfiguration;
import org.openkilda.integration.model.response.ConfiguredPort;
import org.openkilda.integration.model.response.IslLink;
import org.openkilda.model.IslLinkInfo;
import org.openkilda.model.LinkProps;
import org.openkilda.model.SwitchInfo;
import org.openkilda.service.ApplicationService;
import org.openkilda.utility.ApplicationProperties;
import org.openkilda.utility.CollectionUtil;
import org.openkilda.utility.IoUtil;
import org.openkilda.utility.JsonUtil;

@Service
public class SwitchIntegrationService {

    private static final Logger LOGGER = LoggerFactory.getLogger(SwitchIntegrationService.class);

    @Autowired
    private RestClientManager restClientManager;

    @Autowired
    private ApplicationProperties applicationProperties;

    @Autowired
    private ApplicationService applicationService;

    @Autowired
    private IslLinkConverter islLinkConverter;

    @Autowired
    ObjectMapper objectMapper;

    public List<SwitchInfo> getSwitches() {
        HttpResponse response = restClientManager.invoke(applicationProperties.getSwitches(),
                HttpMethod.GET, "", "", applicationService.getAuthHeader());
        if (RestClientManager.isValidResponse(response)) {
            List<SwitchInfo> switchesResponse =
                    restClientManager.getResponseList(response, SwitchInfo.class);
            return getSwitchInfoSetName(switchesResponse);
        }
        return null;
    }

    private List<SwitchInfo> getSwitchInfoSetName(List<SwitchInfo> switches) {

        LOGGER.info("Inside getSwitchInfoSetName : Start");
        if (switches != null && !StringUtils.isEmpty(switches)) {

            Map<String, String> csNames = getCustomSwitchNameFromFile();

            for (SwitchInfo switchInfo : switches) {
                switchInfo.setName(customSwitchName(csNames, switchInfo.getSwitchId()));
            }
        }
        return switches;
    }

    public String customSwitchName(Map<String, String> csNames, String switchId) {
        if (csNames != null && !StringUtils.isEmpty(csNames) && csNames.size() > 0) {
            if (csNames.containsKey(switchId.toLowerCase())
                    || csNames.containsKey(switchId.toUpperCase())) {
                if (!IoUtil.chkStringIsNotEmpty(csNames.get(switchId))) {
                    return switchId;
                } else {
                    return csNames.get(switchId);
                }
            } else {
                return switchId;
            }
        } else
            return switchId;
    }

    public List<IslLinkInfo> getIslLinks() {
        List<IslLink> links = getIslLinkPortsInfo();
        if (CollectionUtil.isEmpty(links)) {
            throw new ContentNotFoundException();
        }
        return islLinkConverter.toIslLinksInfo(links, islCostMap());
    }
    
    public List<IslLink> getIslLinkPortsInfo() {
        HttpResponse response = restClientManager.invoke(applicationProperties.getLinks(),
                HttpMethod.GET, "", "", applicationService.getAuthHeader());
        if (RestClientManager.isValidResponse(response)) {
            List<IslLink> links = restClientManager.getResponseList(response, IslLink.class);
            return links;
        }
        return null;
    }
    
   private Map<String,String> islCostMap(){
    List<LinkProps> linkProps = getIslLinkProps(null);
    Map<String,String> islCostMap = new HashMap<>();
        if (linkProps != null) {

            linkProps.forEach(linkProp -> {
                String key =
                        linkProp.getSrc_switch() + "-" + linkProp.getSrc_port() + "-"
                                + linkProp.getDst_switch() + "-" + linkProp.getDst_port();
                String value = linkProp.getProperty("cost");
                islCostMap.put(key, value);
            });
        }

        return islCostMap;

    }
    

    public List<LinkProps> getIslLinkProps(LinkProps keys) {
        UriComponentsBuilder builder =
                UriComponentsBuilder.fromHttpUrl(applicationProperties.getLinkProps());
        builder = setLinkProps(keys, builder);
        String fullUri = builder.build().toUriString();
        HttpResponse response = restClientManager.invoke(fullUri, HttpMethod.GET, "", "",
                applicationService.getAuthHeader());
        try {
            if (RestClientManager.isValidResponse(response)) {
                List<LinkProps> linkPropsResponses =
                        restClientManager.getResponseList(response, LinkProps.class);
                if (!CollectionUtil.isEmpty(linkPropsResponses)) {
                    return linkPropsResponses;
                }
            }
        } catch (InvalidResponseException exception) {
            LOGGER.error("Exception in getIslLinkProps " + exception.getMessage(), exception);
            return null;
        }
        return null;
    }


    @SuppressWarnings("unchecked")
    public Map<String, String> getCustomSwitchNameFromFile() {
        Map<String, String> csNames = new HashMap<String, String>();

        InputStream inputStream = null;
        String data = null;
        try {
            inputStream = new URL(applicationProperties.getSwitchDataFilePath()).openStream();
            if (inputStream != null) {
                data = IoUtil.toString(inputStream);

                if (data != null && !StringUtils.isEmpty(data)) {
                    csNames = JsonUtil.toObject(data, HashMap.class);
                }
            }
        } catch (Exception ex) {
            LOGGER.error(
                    "Inside getCustomSwitchNameFromFile unable to find switch file path Exception :",
                    ex);
        }
        return csNames;

    }

    public String updateIslLinkProps(List<LinkProps> keys) {
        try {
            HttpResponse response = restClientManager.invoke(applicationProperties.getLinkProps(),
                    HttpMethod.PUT, objectMapper.writeValueAsString(keys), "application/json",
                    applicationService.getAuthHeader());
            return IoUtil.toString(response.getEntity().getContent());
        } catch (Exception e) {
            LOGGER.error("Inside updateIslLinkProps  Exception :", e);
            throw new IntegrationException(e);
        }
    }

    private UriComponentsBuilder setLinkProps(LinkProps keys, UriComponentsBuilder builder) {
        try {
            if (keys != null) {
                if (!keys.getSrc_switch().isEmpty())
                    builder.queryParam("src_switch",
                            URLEncoder.encode(keys.getSrc_switch(), "UTF-8"));
                if (!keys.getSrc_port().isEmpty())
                    builder.queryParam("src_port", URLEncoder.encode(keys.getSrc_port(), "UTF-8"));
                if (!keys.getDst_switch().isEmpty())
                    builder.queryParam("dst_switch",
                            URLEncoder.encode(keys.getDst_switch(), "UTF-8"));
                if (!keys.getDst_port().isEmpty())
                    builder.queryParam("dst_port", URLEncoder.encode(keys.getDst_port(), "UTF-8"));
            }
        } catch (UnsupportedEncodingException e) {
            throw new ContentNotFoundException();
        }
        return builder;
    }
    
    public String getSwitchRules(String switchId) {

        try {
            HttpResponse response =
                    restClientManager
                            .invoke(applicationProperties.getSwitchRules().replace("{switch_id}",
                                    switchId), HttpMethod.GET, "", "",
                                    applicationService.getAuthHeader());
            return IoUtil.toString(response.getEntity().getContent());
        } catch (Exception e) {
            LOGGER.error("Inside updateIslLinkProps  Exception :", e);
            throw new IntegrationException(e);
        }
    }
    
    public ConfiguredPort configurePort(String switchId, String port, PortConfiguration configuration) {
        try {
            HttpResponse response = restClientManager.invoke(
                    applicationProperties.getConfigSwitchPort().replace("{switch_id}", switchId).replace("{port_no}",
                            port),
                    HttpMethod.PUT, objectMapper.writeValueAsString(configuration), "application/json",
                    applicationService.getAuthHeader());
            if (RestClientManager.isValidResponse(response)) {
                return restClientManager.getResponse(response, ConfiguredPort.class);
            }
        } catch (JsonProcessingException e) {
            LOGGER.error("Error occurred while converting configration to string. Exception: " + e.getMessage(), e);
            throw new IntegrationException(e);
        }
        return null;
    }
}