2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.sal.core.api;
11 import java.util.concurrent.Future;
13 import org.opendaylight.controller.md.sal.common.api.routing.RoutedRegistration;
14 import org.opendaylight.yangtools.concepts.ListenerRegistration;
15 import org.opendaylight.yangtools.concepts.ObjectRegistration;
16 import org.opendaylight.yangtools.yang.common.QName;
17 import org.opendaylight.yangtools.yang.common.RpcResult;
18 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
20 import org.osgi.framework.BundleContext;
23 * Core component of the SAL layer responsible for wiring the SAL consumers.
25 * The responsibility of the broker is to maintain registration of SAL
26 * functionality {@link Consumer}s and {@link Provider}s, store provider and
27 * consumer specific context and functionality registration via
28 * {@link ConsumerSession} and provide access to infrastructure services, which
29 * removes direct dependencies between providers and consumers.
32 * <h3>Infrastructure services</h3> Some examples of infrastructure services:
35 * <li>RPC Invocation - see {@link ConsumerSession#rpc(QName, CompositeNode)},
36 * {@link ProviderSession#addRpcImplementation(QName, RpcImplementation)} and
37 * {@link RpcImplementation}
38 * <li>Notification Service - see {@link org.opendaylight.controller.sal.core.api.notify.NotificationService} and
39 * {@link org.opendaylight.controller.sal.core.api.notify.NotificationPublishService}
40 * <li>Functionality and Data model
41 * <li>Data Store access and modification - see {@link org.opendaylight.controller.sal.core.api.data.DataBrokerService} and
42 * {@link org.opendaylight.controller.sal.core.api.data.DataProviderService}
45 * The services are exposed via session.
47 * <h3>Session-based access</h3>
49 * The providers and consumers needs to register in order to use the
50 * binding-independent SAL layer and to expose functionality via SAL layer.
52 * For more information about session-based access see {@link ConsumerSession}
53 * and {@link ProviderSession}
58 public interface Broker {
61 * Registers the {@link Consumer}, which will use the SAL layer.
64 * During the registration, the broker obtains the initial functionality
65 * from consumer, using the {@link Consumer#getConsumerFunctionality()}, and
66 * register that functionality into system and concrete infrastructure
70 * Note that consumer could register additional functionality at later point
71 * by using service and functionality specific APIs.
74 * The consumer is required to use returned session for all communication
75 * with broker or one of the broker services. The session is announced to
76 * the consumer by invoking
77 * {@link Consumer#onSessionInitiated(ConsumerSession)}.
80 * Consumer to be registered.
81 * @return a session specific to consumer registration
82 * @throws IllegalArgumentException
83 * If the consumer is <code>null</code>.
84 * @throws IllegalStateException
85 * If the consumer is already registered.
87 ConsumerSession registerConsumer(Consumer cons);
90 * @deprecated Use registerConsumer(Consumer cons) instead (BundleContext is no longer used)
93 ConsumerSession registerConsumer(Consumer cons, BundleContext context);
96 * Registers the {@link Provider}, which will use the SAL layer.
99 * During the registration, the broker obtains the initial functionality
100 * from consumer, using the {@link Provider#getProviderFunctionality()}, and
101 * register that functionality into system and concrete infrastructure
105 * Note that consumer could register additional functionality at later point
106 * by using service and functionality specific APIs (e.g.
107 * {@link ProviderSession#addRpcImplementation(QName, RpcImplementation)}
110 * The consumer is <b>required to use</b> returned session for all
111 * communication with broker or one of the broker services. The session is
112 * announced to the consumer by invoking
113 * {@link Provider#onSessionInitiated(ProviderSession)}.
117 * Provider to be registered.
118 * @return a session unique to the provider registration.
119 * @throws IllegalArgumentException
120 * If the provider is <code>null</code>.
121 * @throws IllegalStateException
122 * If the consumer is already registered.
124 ProviderSession registerProvider(Provider prov);
127 * @deprecated Use registerProvider(Provider cons) instead (BundleContext is no longer used)
130 ProviderSession registerProvider(Provider prov, BundleContext context);
133 * {@link Consumer} specific access to the SAL functionality.
136 * ConsumerSession is {@link Consumer}-specific access to the SAL
137 * functionality and infrastructure services.
140 * The session serves to store SAL context (e.g. registration of
141 * functionality) for the consumer and provides access to the SAL
142 * infrastructure services and other functionality provided by
148 public interface ConsumerSession {
151 * Sends an RPC to other components registered to the broker.
153 * @see RpcImplementation
157 * Input data to the RPC
158 * @return Result of the RPC call
160 Future<RpcResult<CompositeNode>> rpc(QName rpc, CompositeNode input);
165 * Returns a session specific instance (implementation) of requested
170 * @return Session specific implementation of service
172 <T extends BrokerService> T getService(Class<T> service);
175 * Closes a session between consumer and broker.
178 * The close operation unregisters a consumer and remove all registered
179 * functionality of the consumer from the system.
186 * {@link Provider} specific access to the SAL functionality.
189 * ProviderSession is {@link Provider}-specific access to the SAL
190 * functionality and infrastructure services, which also allows for exposing
191 * the provider's functionality to the other {@link Consumer}s.
194 * The session serves to store SAL context (e.g. registration of
195 * functionality) for the providers and exposes access to the SAL
196 * infrastructure services, dynamic functionality registration and any other
197 * functionality provided by other {@link Provider}s.
200 public interface ProviderSession extends ConsumerSession {
202 * Registers an implementation of the rpc.
205 * The registered rpc functionality will be available to all other
206 * consumers and providers registered to the broker, which are aware of
207 * the {@link QName} assigned to the rpc.
210 * There is no assumption that rpc type is in the set returned by
211 * invoking {@link RpcImplementation#getSupportedRpcs()}. This allows
212 * for dynamic rpc implementations.
216 * @param implementation
217 * Provider's Implementation of the RPC functionality
218 * @throws IllegalArgumentException
219 * If the name of RPC is invalid
221 RpcRegistration addRpcImplementation(QName rpcType, RpcImplementation implementation)
222 throws IllegalArgumentException;
224 RoutedRpcRegistration addRoutedRpcImplementation(QName rpcType, RpcImplementation implementation);
226 RoutedRpcRegistration addMountedRpcImplementation(QName rpcType, RpcImplementation implementation);
229 * Closes a session between provider and SAL.
232 * The close operation unregisters a provider and remove all registered
233 * functionality of the provider from the system.
241 Set<QName> getSupportedRpcs();
243 ListenerRegistration<RpcRegistrationListener> addRpcRegistrationListener(RpcRegistrationListener listener);
246 public interface RpcRegistration extends ObjectRegistration<RpcImplementation> {
253 public interface RoutedRpcRegistration extends RpcRegistration, RoutedRegistration<QName, YangInstanceIdentifier, RpcImplementation> {