FlowController.java

Go to the documentation of this file.

package org.openkilda.controller;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.ModelAndView;
import org.usermanagement.model.UserInfo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.openkilda.auth.context.ServerContext;
import org.openkilda.auth.model.Permissions;
import org.openkilda.constants.IConstants;
import org.openkilda.integration.model.Flow;
import org.openkilda.integration.model.FlowStatus;
import org.openkilda.integration.model.response.FlowPayload;
import org.openkilda.log.ActivityLogger;
import org.openkilda.log.constants.ActivityType;
import org.openkilda.model.FlowCount;
import org.openkilda.model.FlowInfo;
import org.openkilda.model.FlowPath;
import org.openkilda.service.FlowService;

@Controller
@RequestMapping(value = "/flows")
public class FlowController extends BaseController {

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

    @Autowired
    private FlowService flowService;

    @Autowired
    private ActivityLogger activityLogger;
    
    @Autowired
    private ServerContext serverContext;

    @RequestMapping
    @Permissions(values = {IConstants.Permission.MENU_FLOWS})
    public ModelAndView flowList(final HttpServletRequest request) {
        return validateAndRedirect(request, IConstants.View.FLOW_LIST);
    }

    @RequestMapping(value = "/details")
    public ModelAndView flowDetails(final HttpServletRequest request) {
        return validateAndRedirect(request, IConstants.View.FLOW_DETAILS);
    }


    @RequestMapping(value = "/count", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody Collection<FlowCount> getFlowCount() {
        Collection<FlowCount> flowsInfo = new ArrayList<FlowCount>();
        List<Flow> flows = flowService.getAllFlowList();
        if (flows != null) {
            flowsInfo = flowService.getFlowsCount(flows);
        }
        return flowsInfo;
    }

    @RequestMapping(value = "/list", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody List<FlowInfo> getFlows() {
        return flowService.getAllFlows();
    }

    @RequestMapping(value = "/path/{flowId}", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody FlowPayload getFlowPath(@PathVariable final String flowId) {
        LOGGER.info("[getFlowPath] - start. Flow id: " + flowId);
        return flowService.getFlowPath(flowId);
    }

    @RequestMapping(value = "/{flowId}/reroute", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody FlowPath rerouteFlow(@PathVariable final String flowId) {
        activityLogger.log(ActivityType.FLOW_REROUTE, flowId);
        LOGGER.info("[rerouteFlow] - start. Flow id: " + flowId);
        return flowService.rerouteFlow(flowId);
    }

    @RequestMapping(value = "/{flowId}/validate", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody String validateFlow(@PathVariable final String flowId) {
        activityLogger.log(ActivityType.FLOW_VALIDATE, flowId);
        LOGGER.info("[validateFlow] - start. Flow id: " + flowId);
        return flowService.validateFlow(flowId);
    }

    @RequestMapping(value = "/{flowId}", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody Flow getFlowById(@PathVariable final String flowId) {
        LOGGER.info("[getFlowById] - start. Flow id: " + flowId);
        return flowService.getFlowById(flowId);
    }

    @RequestMapping(value = "/{flowId}/status", method = RequestMethod.GET)
    @ResponseStatus(HttpStatus.OK)
    public @ResponseBody FlowStatus getFlowStatusById(@PathVariable final String flowId) {
        LOGGER.info("[getFlowStatusById] - start. Flow id: " + flowId);
        return flowService.getFlowStatusById(flowId);
    }

    @RequestMapping(method = RequestMethod.PUT)
    @ResponseStatus(HttpStatus.CREATED)
    @Permissions(values = {IConstants.Permission.FW_FLOW_CREATE})
    public @ResponseBody Flow createFlow(@RequestBody final Flow flow) {
        LOGGER.info("[createFlow] - start. Flow id: " + flow.getId());
        return flowService.createFlow(flow);
    }

    @RequestMapping(value = "/{flowId}", method = RequestMethod.PUT)
    @ResponseStatus(HttpStatus.CREATED)
    @Permissions(values = {IConstants.Permission.FW_FLOW_UPDATE})
    public @ResponseBody Flow updateFlow(@PathVariable("flowId") final String flowId,@RequestBody final Flow flow) {
        LOGGER.info("[updateFlow] - start. Flow id: " + flowId);
        return flowService.updateFlow(flowId, flow);
    }

    @RequestMapping(value = "/{flowId}", method = RequestMethod.DELETE)
    @ResponseStatus(HttpStatus.OK)
    @Permissions(values = {IConstants.Permission.FW_FLOW_DELETE})
    public @ResponseBody Flow deleteFlow(@RequestBody final UserInfo userInfo,
            @PathVariable("flowId") final String flowId) {
        LOGGER.info("[deleteFlow] - start. Flow id: " + flowId);
        if (serverContext.getRequestContext() != null) {
            userInfo.setUserId(serverContext.getRequestContext().getUserId());
        }
        return flowService.deleteFlow(flowId, userInfo);
    }
}