[ONOS-4193] Add handler for sfc gui.

Change-Id: Ie270988bc05914c6f9da1274e3a9fcfb917a8aa1

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.vtnweb.gui;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.onlab.packet.IpAddress;
+import org.onosproject.ui.RequestHandler;
+import org.onosproject.ui.UiMessageHandler;
+import org.onosproject.ui.table.TableModel;
+import org.onosproject.ui.table.TableRequestHandler;
+import org.onosproject.vtnrsc.FixedIp;
+import org.onosproject.vtnrsc.FlowClassifier;
+import org.onosproject.vtnrsc.FlowClassifierId;
+import org.onosproject.vtnrsc.PortChain;
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairGroup;
+import org.onosproject.vtnrsc.PortPairGroupId;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.VirtualPort;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.flowclassifier.FlowClassifierService;
+import org.onosproject.vtnrsc.portchain.PortChainService;
+import org.onosproject.vtnrsc.portpair.PortPairService;
+import org.onosproject.vtnrsc.portpairgroup.PortPairGroupService;
+import org.onosproject.vtnrsc.virtualport.VirtualPortService;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * Message handler for service function chain view related messages.
+ */
+public class SfcViewMessageHandler extends UiMessageHandler {
+
+    private static final String SLASH = " ; ";
+    private static final String NONE = "none";
+    private static final String SFCTYPE = "Service Function Chain";
+
+    private static final String SFC_DATA_REQ = "sfcDataRequest";
+    private static final String SFC_DATA_RESP = "sfcDataResponse";
+    private static final String SFCS = "sfcs";
+
+    private static final String ID = "id";
+    private static final String STATE = "_iconid_state";
+    private static final String PORTCHAINNAME = "portChainName";
+    private static final String HOSTS = "hosts";
+    private static final String TYPE = "type";
+    private static final String SRCIP = "srcIp";
+    private static final String DSTIP = "dstIp";
+
+    private static final String[] COL_IDS = {
+            ID, STATE, PORTCHAINNAME, HOSTS, TYPE, SRCIP, DSTIP
+    };
+
+    private static final String ICON_ID_ONLINE = "active";
+    private static final String ICON_ID_OFFLINE = "inactive";
+
+    @Override
+    protected Collection<RequestHandler> createRequestHandlers() {
+        return ImmutableSet.of(new SfcDataRequest());
+    }
+
+    // handler for sfc table requests
+    private final class SfcDataRequest extends TableRequestHandler {
+
+        private static final String NO_ROWS_MESSAGE = "No Service Function Chain found";
+
+        private SfcDataRequest() {
+            super(SFC_DATA_REQ, SFC_DATA_RESP, SFCS);
+        }
+
+        @Override
+        protected String[] getColumnIds() {
+            return COL_IDS;
+        }
+
+        @Override
+        protected String defaultColumnId() {
+            return PORTCHAINNAME;
+        }
+
+        @Override
+        protected String noRowsMessage(ObjectNode payload) {
+            return NO_ROWS_MESSAGE;
+        }
+
+        @Override
+        protected void populateTable(TableModel tm, ObjectNode payload) {
+            PortChainService pcs = get(PortChainService.class);
+            Iterable<PortChain> portChains = pcs.getPortChains();
+            portChains.forEach(pchain -> populateRow(tm.addRow(), pchain));
+        }
+
+        //populate the row of service function chain
+        private void populateRow(TableModel.Row row, PortChain pchain) {
+            PortChainIpRange portChainIpRange = portChainIpRange(pchain);
+            List<VirtualPort> vpList = sfcPorts(pchain);
+            row.cell(ID, pchain.portChainId().value().toString())
+                .cell(STATE, sfcState(vpList))
+                .cell(PORTCHAINNAME, pchain.name())
+                .cell(HOSTS, sfcHosts(vpList))
+                .cell(TYPE, SFCTYPE)
+                .cell(SRCIP, portChainIpRange.srcip())
+                .cell(DSTIP, portChainIpRange.dstip());
+        }
+
+        //PortChainIpRange
+        private PortChainIpRange portChainIpRange(PortChain pchain) {
+            List<FlowClassifierId> flowClassifierList = pchain.flowClassifiers();
+            FlowClassifierService fcs = get(FlowClassifierService.class);
+            StringBuffer srcipbuf = new StringBuffer();
+            StringBuffer dstipbuf = new StringBuffer();
+            if (flowClassifierList != null) {
+                flowClassifierList.stream().forEach(fcid -> {
+                    FlowClassifier fc = fcs.getFlowClassifier(fcid);
+                    String srcip = fc.srcIpPrefix().toString();
+                    String dstip = fc.dstIpPrefix().toString();
+                    srcipbuf.append(srcip).append(SLASH);
+                    dstipbuf.append(dstip).append(SLASH);
+                });
+            }
+            String srcip = NONE;
+            String dstip = NONE;
+            if (srcipbuf.length() > 0) {
+                srcip = srcipbuf.substring(0, srcipbuf.length() - SLASH.length());
+            }
+            if (dstipbuf.length() > 0) {
+                dstip = dstipbuf.substring(0, dstipbuf.length() - SLASH.length());
+            }
+            PortChainIpRange portChainIpRange = new PortChainIpRange(srcip, dstip);
+            return portChainIpRange;
+        }
+
+        //the VirtualPorts of service function chain
+        private List<VirtualPort> sfcPorts(PortChain pchain) {
+            List<PortPairGroupId> portPairGroupList = pchain.portPairGroups();
+            PortPairGroupService ppgs = get(PortPairGroupService.class);
+            PortPairService pps = get(PortPairService.class);
+            VirtualPortService vps = get(VirtualPortService.class);
+            List<VirtualPort> vpList = new ArrayList<VirtualPort>();
+            if (portPairGroupList != null) {
+                portPairGroupList.stream().forEach(ppgid -> {
+                    PortPairGroup ppg = ppgs.getPortPairGroup(ppgid);
+                    List<PortPairId> portPairList = ppg.portPairs();
+                    if (portPairList != null) {
+                        portPairList.stream().forEach(ppid -> {
+                            PortPair pp = pps.getPortPair(ppid);
+                            VirtualPort vp = vps.getPort(VirtualPortId.portId(pp.ingress()));
+                            vpList.add(vp);
+                        });
+                    }
+                });
+            }
+            return vpList;
+        }
+
+        //the state of service function chain
+        private String sfcState(List<VirtualPort> vpList) {
+            for (VirtualPort vp : vpList) {
+                if (vp.state().equals(VirtualPort.State.DOWN)) {
+                    return ICON_ID_OFFLINE;
+                }
+            }
+            return ICON_ID_ONLINE;
+        }
+
+        //the hosts of service function chain
+        private String sfcHosts(List<VirtualPort> vpList) {
+            StringBuffer hostsbuf = new StringBuffer();
+            for (VirtualPort vp : vpList) {
+                Iterator<FixedIp> fixedIps = vp.fixedIps().iterator();
+                if (fixedIps.hasNext()) {
+                    FixedIp fixedIp = fixedIps.next();
+                    IpAddress ip = fixedIp.ip();
+                    hostsbuf.append(ip.toString()).append(SLASH);
+                }
+            }
+            if (hostsbuf.length() > 0) {
+                return hostsbuf.substring(0, hostsbuf.length() - SLASH.length());
+            }
+            return hostsbuf.toString();
+        }
+
+        //source ip prefix and destination ip prefix
+        private final class PortChainIpRange {
+            private final String srcip;
+            private final String dstip;
+
+            private PortChainIpRange(String srcip, String dstip) {
+                this.srcip = srcip;
+                this.dstip = dstip;
+            }
+
+            public String srcip() {
+                return srcip;
+            }
+
+            public String dstip() {
+                return dstip;
+            }
+        }
+    }
+}

+/*
+ * Copyright 2016 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Service Function Chain gui.
+ */
+package org.onosproject.vtnweb.gui;