b8920bab7b902fee574e4250deaffeafb2de6ff6
[vpnservice.git] / interfacemgr / interfacemgr-impl / src / main / java / org / opendaylight / vpnservice / interfacemgr / InterfaceManager.java
1 /*
2  * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.vpnservice.interfacemgr;
9
10 import com.google.common.util.concurrent.FutureCallback;
11 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.BaseIds;
12 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
13 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
14 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
15 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
16 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
17 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
18 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
19 import org.opendaylight.vpnservice.AbstractDataChangeListener;
20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
21 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
22 import org.opendaylight.yangtools.concepts.ListenerRegistration;
23 import org.opendaylight.yangtools.yang.binding.DataObject;
24 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
25 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
26 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
27 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
28 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
32 import org.slf4j.Logger;
33 import org.slf4j.LoggerFactory;
34 import com.google.common.base.Optional;
35
36 public class InterfaceManager extends AbstractDataChangeListener<Interface> implements AutoCloseable{
37     private static final Logger LOG = LoggerFactory.getLogger(InterfaceManager.class);
38     private ListenerRegistration<DataChangeListener> listenerRegistration;
39     private final DataBroker broker;
40
41     private static final FutureCallback<Void> DEFAULT_CALLBACK =
42                     new FutureCallback<Void>() {
43                         public void onSuccess(Void result) {
44                             LOG.debug("Success in Datastore write operation");
45                         }
46
47                         public void onFailure(Throwable error) {
48                             LOG.error("Error in Datastore write operation", error);
49                         };
50                     };
51
52     public InterfaceManager(final DataBroker db) {
53         super(Interface.class);
54         broker = db;
55         registerListener(db);
56     }
57
58     @Override
59     public void close() throws Exception {
60         if (listenerRegistration != null) {
61             try {
62                 listenerRegistration.close();
63             } catch (final Exception e) {
64                 LOG.error("Error when cleaning up DataChangeListener.", e);
65             }
66             listenerRegistration = null;
67         }
68         LOG.info("Interface Manager Closed");
69     }
70     
71     private void registerListener(final DataBroker db) {
72         try {
73             listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
74                     getWildCardPath(), InterfaceManager.this, DataChangeScope.SUBTREE);
75         } catch (final Exception e) {
76             LOG.error("InterfaceManager DataChange listener registration fail!", e);
77             throw new IllegalStateException("InterfaceManager registration Listener failed.", e);
78         }
79     }
80
81     @Override
82     protected void add(final InstanceIdentifier<Interface> identifier,
83             final Interface imgrInterface) {
84         LOG.trace("key: " + identifier + ", value=" + imgrInterface );
85         addInterface(identifier, imgrInterface);
86     }
87
88     private InstanceIdentifier<Interface> buildId(final InstanceIdentifier<Interface> identifier) {
89         //TODO Make this generic and move to AbstractDataChangeListener or Utils.
90         final InterfaceKey key = identifier.firstKeyOf(Interface.class, InterfaceKey.class);
91         String interfaceName = key.getName();
92         InstanceIdentifierBuilder<Interface> idBuilder = 
93                 InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName));
94         InstanceIdentifier<Interface> id = idBuilder.build();
95         return id;
96     }
97
98     private void addInterface(final InstanceIdentifier<Interface> identifier,
99                               final Interface imgrInterface) {
100         InstanceIdentifier<Interface> id = buildId(identifier);
101         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
102         if(port.isPresent()) {
103             Interface interf = port.get();
104             NodeConnector nodeConn = getNodeConnectorFromInterface(interf);
105             updateInterfaceState(identifier, imgrInterface, interf);
106             /* TODO:
107              *  1. Get interface-id from id manager
108              *  2. Update interface-state with following:
109              *    admin-status = set to enable value
110              *    oper-status = Down [?]
111              *    if-index = interface-id
112              *    
113              * FIXME:
114              *  1. Get operational data from node-connector-id?
115              *
116              */
117         }
118     }
119
120     private void updateInterfaceState(InstanceIdentifier<Interface> identifier, Interface imgrInterface,
121                     Interface interf) {
122         // TODO Update InterfaceState
123         
124     }
125
126     private NodeConnector getNodeConnectorFromInterface(Interface interf) {
127         NodeConnectorId ncId = interf.getAugmentation(BaseIds.class).getOfPortId();
128         NodeId nodeId = new NodeId(ncId.getValue().substring(0,ncId.getValue().lastIndexOf(":")));
129         InstanceIdentifier<NodeConnector> ncIdentifier = InstanceIdentifier.builder(Nodes.class)
130                         .child(Node.class, new NodeKey(nodeId))
131                         .child(NodeConnector.class, new NodeConnectorKey(ncId)).build();
132
133         Optional<NodeConnector> nc = read(LogicalDatastoreType.OPERATIONAL, ncIdentifier);
134         if(nc.isPresent()) {
135             NodeConnector nodeConn = nc.get();
136             LOG.trace("nodeConnector: {}",nodeConn);
137             return nodeConn;
138         }
139         return null;
140     }
141
142     private void delInterface(final InstanceIdentifier<Interface> identifier,
143                               final Interface del) {
144         InstanceIdentifier<Interface> id = buildId(identifier);
145         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
146         if(port.isPresent()) {
147             Interface interf = port.get();
148             // TODO: Update operational data
149         }
150     }
151
152     private void updateInterface(final InstanceIdentifier<Interface> identifier,
153                               final Interface original, final Interface udpate) {
154         InstanceIdentifier<Interface> id = buildId(identifier);
155         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
156         if(port.isPresent()) {
157             Interface interf = port.get();
158             //TODO: Update operational data
159         }
160     }
161
162     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
163             InstanceIdentifier<T> path) {
164
165         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
166
167         Optional<T> result = Optional.absent();
168         try {
169             result = tx.read(datastoreType, path).get();
170         } catch (Exception e) {
171             throw new RuntimeException(e);
172         }
173
174         return result;
175     }
176
177     private InstanceIdentifier<Interface> getWildCardPath() {
178         return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
179     }
180
181     @Override
182     protected void remove(InstanceIdentifier<Interface> identifier, Interface del) {
183         LOG.trace("key: " + identifier + ", value=" + del );
184         delInterface(identifier, del);
185     }
186
187     @Override
188     protected void update(InstanceIdentifier<Interface> identifier, Interface original, Interface update) {
189         LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update );
190         updateInterface(identifier, original, update);
191         
192     }
193
194 }