64c72115f61519895ea3d8e3e44121b646319b77
[controller.git] / opendaylight / sal / networkconfiguration / implementation / src / main / java / org / opendaylight / controller / sal / networkconfig / bridgedomain / internal / BridgeDomainConfigService.java
1 /*
2  * Copyright (c) 2014 Cisco Systems, Inc. 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.controller.sal.networkconfig.bridgedomain.internal;
9
10 import java.util.List;
11 import java.util.Map;
12 import java.util.concurrent.ConcurrentHashMap;
13 import java.util.concurrent.ConcurrentMap;
14
15 import org.opendaylight.controller.sal.core.Node;
16 import org.opendaylight.controller.sal.core.NodeConnector;
17 import org.opendaylight.controller.sal.networkconfig.bridgedomain.ConfigConstants;
18 import org.opendaylight.controller.sal.networkconfig.bridgedomain.IBridgeDomainConfigService;
19 import org.opendaylight.controller.sal.networkconfig.bridgedomain.IPluginInBridgeDomainConfigService;
20 import org.opendaylight.controller.sal.utils.GlobalConstants;
21 import org.opendaylight.controller.sal.utils.Status;
22 import org.opendaylight.controller.sal.utils.StatusCode;
23 import org.slf4j.Logger;
24 import org.slf4j.LoggerFactory;
25
26 public class BridgeDomainConfigService implements IBridgeDomainConfigService {
27     protected static final Logger logger = LoggerFactory
28             .getLogger(BridgeDomainConfigService.class);
29     private ConcurrentMap<String, IPluginInBridgeDomainConfigService> pluginService =
30             new ConcurrentHashMap<String, IPluginInBridgeDomainConfigService>();
31
32     void setPluginInService (Map props, IPluginInBridgeDomainConfigService s) {
33         String type = null;
34         Object value = props.get(GlobalConstants.PROTOCOLPLUGINTYPE.toString());
35         if (value instanceof String) {
36             type = (String) value;
37         }
38         if (type == null) {
39             logger.error("Received a PluginInConnectionService without any "
40                     + "protocolPluginType provided");
41         } else {
42             this.pluginService.put(type, s);
43         }
44     }
45
46     void unsetPluginInService(Map props, IPluginInBridgeDomainConfigService s) {
47         String type = null;
48
49         Object value = props.get(GlobalConstants.PROTOCOLPLUGINTYPE.toString());
50         if (value instanceof String) {
51             type = (String) value;
52         }
53         if (type == null) {
54             logger.error("Received a PluginInConnectionService without any "
55                     + "protocolPluginType provided");
56         } else if (this.pluginService.get(type).equals(s)) {
57             this.pluginService.remove(type);
58         }
59     }
60
61     /**
62      * Function called by the dependency manager when all the required
63      * dependencies are satisfied
64      *
65      */
66     void init() {
67     }
68
69     /**
70      * Function called by the dependency manager when at least one dependency
71      * become unsatisfied or when the component is shutting down because for
72      * example bundle is being stopped.
73      *
74      */
75     void destroy() {
76         if (this.pluginService != null) {
77             this.pluginService.clear();
78         }
79     }
80
81     @Override
82     public Status createBridgeDomain(Node node, String bridgeIdentifier, Map<ConfigConstants, Object> params)
83             throws Throwable {
84         if (pluginService != null) {
85             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
86             if (plugin != null) {
87                 return plugin.createBridgeDomain(node, bridgeIdentifier, params);
88             }
89         }
90         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
91     }
92
93     @Override
94     public Status deleteBridgeDomain(Node node, String bridgeIdentifier) {
95         if (pluginService != null) {
96             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
97             if (plugin != null) {
98                 return plugin.deleteBridgeDomain(node, bridgeIdentifier);
99             }
100         }
101         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
102     }
103
104     @Override
105     public List<String> getBridgeDomains(Node node) {
106         if (pluginService != null) {
107             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
108             if (plugin != null) {
109                 return plugin.getBridgeDomains(node);
110             }
111         }
112         return null;
113     }
114
115     @Override
116     public Status addBridgeDomainConfig(Node node, String bridgeIdentifier, Map<ConfigConstants, Object> params) {
117         if (pluginService != null) {
118             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
119             if (plugin != null) {
120                 return plugin.addBridgeDomainConfig(node, bridgeIdentifier, params);
121             }
122         }
123         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
124     }
125
126     @Override
127     public Status removeBridgeDomainConfig(Node node, String bridgeIdentifier, Map<ConfigConstants, Object> params) {
128         if (pluginService != null) {
129             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
130             if (plugin != null) {
131                 return plugin.removeBridgeDomainConfig(node, bridgeIdentifier, params);
132             }
133         }
134         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
135     }
136
137     @Override
138     public Map<ConfigConstants, Object> getBridgeDomainConfigs(Node node, String bridgeIdentifier) {
139         if (pluginService != null) {
140             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
141             if (plugin != null) {
142                 return plugin.getBridgeDomainConfigs(node, bridgeIdentifier);
143             }
144         }
145         return null;
146     }
147
148     @Override
149     public Node getBridgeDomainNode(Node configNode, String bridgeIdentifier) {
150         if (pluginService != null) {
151             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(configNode.getType());
152             if (plugin != null) {
153                 return plugin.getBridgeDomainNode(configNode, bridgeIdentifier);
154             }
155         }
156         return null;
157     }
158
159     @Override
160     public Status addPort(Node node, String bridgeIdentifier, String portIdentifier, Map<ConfigConstants, Object> params) {
161         if (pluginService != null) {
162             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
163             if (plugin != null) {
164                 return plugin.addPort(node, bridgeIdentifier, portIdentifier, params);
165             }
166         }
167         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
168     }
169
170     @Override
171     public Status deletePort(Node node, String bridgeIdentifier, String portIdentifier) {
172         if (pluginService != null) {
173             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
174             if (plugin != null) {
175                 return plugin.deletePort(node, bridgeIdentifier, portIdentifier);
176             }
177         }
178         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
179     }
180
181     @Override
182     public Status addPortConfig(Node node, String bridgeIdentifier, String portIdentifier,
183             Map<ConfigConstants, Object> params) {
184         if (pluginService != null) {
185             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
186             if (plugin != null) {
187                 return plugin.addPortConfig(node, bridgeIdentifier, portIdentifier, params);
188             }
189         }
190         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
191     }
192
193     @Override
194     public Status removePortConfig(Node node, String bridgeIdentifier, String portIdentifier,
195             Map<ConfigConstants, Object> params) {
196         if (pluginService != null) {
197             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
198             if (plugin != null) {
199                 return plugin.removePortConfig(node, bridgeIdentifier, portIdentifier, params);
200             }
201         }
202         return new Status(StatusCode.NOSERVICE, "Requested Plugin Service Not available");
203     }
204
205     @Override
206     public Map<ConfigConstants, Object> getPortConfigs(Node node, String bridgeIdentifier, String portIdentifier) {
207         if (pluginService != null) {
208             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(node.getType());
209             if (plugin != null) {
210                 return plugin.getPortConfigs(node, bridgeIdentifier, portIdentifier);
211             }
212         }
213         return null;
214     }
215
216     @Override
217     public NodeConnector getNodeConnector(Node configNode, String bridgeIdentifier, String portIdentifier) {
218         if (pluginService != null) {
219             IPluginInBridgeDomainConfigService plugin = this.pluginService.get(configNode.getType());
220             if (plugin != null) {
221                 return plugin.getNodeConnector(configNode, bridgeIdentifier, portIdentifier);
222             }
223         }
224         return null;
225     }
226 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.