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.binding.api;
10 import org.opendaylight.controller.md.sal.common.api.routing.RoutedRegistration;
11 import org.opendaylight.yangtools.concepts.ObjectRegistration;
12 import org.opendaylight.yangtools.yang.binding.BaseIdentity;
13 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
14 import org.opendaylight.yangtools.yang.binding.RpcService;
15 import org.osgi.framework.BundleContext;
18 * Binding-aware core of the SAL layer responsible for wiring the SAL consumers.
20 * The responsibility of the broker is to maintain registration of SAL
21 * functionality Consumers and Providers, store provider and
22 * consumer specific context and functionality registration via
23 * {@link ConsumerContext} and provide access to infrastructure services, which
24 * removes direct dependencies between providers and consumers.
26 * The Binding-aware broker is also responsible for translation from Java
27 * classes modeling the functionality and data to binding-independent form which
28 * is used in SAL Core.
31 * <h3>Infrastructure services</h3> Some examples of infrastructure services:
34 * <li>YANG Module service - see {@link ConsumerContext#getRpcService(Class)},
35 * {@link ProviderContext}
36 * <li>Notification Service - see {@link NotificationService} and
37 * {@link NotificationProviderService}
40 * The services are exposed via session.
42 * <h3>Session-based access</h3>
44 * The providers and consumers needs to register in order to use the
45 * binding-independent SAL layer and to expose functionality via SAL layer.
47 * For more information about session-based access see {@link ConsumerContext}
48 * and {@link ProviderContext}
50 public interface BindingAwareBroker {
52 * @deprecated Use registerConsumer(BindingAwareConsumer cons) instead (BundleContext is no longer used)
55 ConsumerContext registerConsumer(BindingAwareConsumer consumer, BundleContext ctx);
58 * Registers the {@link BindingAwareConsumer}, which will use the SAL layer.
61 * Note that consumer could register additional functionality at later point
62 * by using service and functionality specific APIs.
65 * The consumer is required to use returned session for all communication
66 * with broker or one of the broker services. The session is announced to
67 * the consumer by invoking
68 * {@link BindingAwareConsumer#onSessionInitialized(ConsumerContext)}.
71 * Consumer to be registered.
72 * @return a session specific to consumer registration
73 * @throws IllegalArgumentException
74 * If the consumer is <code>null</code>.
75 * @throws IllegalStateException
76 * If the consumer is already registered.
78 ConsumerContext registerConsumer(BindingAwareConsumer consumer);
81 * @deprecated Use registerProvider(BindingAwareProvider prov) instead (BundleContext is no longer used)
84 ProviderContext registerProvider(BindingAwareProvider provider, BundleContext ctx);
87 * Registers the {@link BindingAwareProvider}, which will use the SAL layer.
90 * During the registration, the broker obtains the initial functionality
91 * from consumer, using the
92 * BindingAwareProvider#getImplementations(), and register that
93 * functionality into system and concrete infrastructure services.
96 * Note that provider could register additional functionality at later point
97 * by using service and functionality specific APIs.
100 * The consumer is <b>required to use</b> returned session for all
101 * communication with broker or one of the broker services. The session is
102 * announced to the consumer by invoking
103 * {@link BindingAwareProvider#onSessionInitiated(ProviderContext)}.
107 * Provider to be registered.
108 * @return a session unique to the provider registration.
109 * @throws IllegalArgumentException
110 * If the provider is <code>null</code>.
111 * @throws IllegalStateException
112 * If the consumer is already registered.
114 ProviderContext registerProvider(BindingAwareProvider provider);
117 * {@link BindingAwareConsumer} specific access to the SAL functionality.
120 * ConsumerSession is {@link BindingAwareConsumer}-specific access to the
121 * SAL functionality and infrastructure services.
124 * The session serves to store SAL context (e.g. registration of
125 * functionality) for the consumer and provides access to the SAL
126 * infrastructure services and other functionality provided by
127 * {@link BindingAwareProvider}s.
129 interface ConsumerContext extends RpcConsumerRegistry {
132 * Returns a session specific instance (implementation) of requested
133 * binding-aware infrastructural service
137 * @return Session specific implementation of service
139 <T extends BindingAwareService> T getSALService(Class<T> service);
143 * {@link BindingAwareProvider} specific access to the SAL functionality.
146 * ProviderSession is {@link BindingAwareProvider}-specific access to the
147 * SAL functionality and infrastructure services, which also allows for
148 * exposing the provider's functionality to the other
149 * {@link BindingAwareConsumer}s.
152 * The session serves to store SAL context (e.g. registration of
153 * functionality) for the providers and exposes access to the SAL
154 * infrastructure services, dynamic functionality registration and any other
155 * functionality provided by other {@link BindingAwareConsumer}s.
158 interface ProviderContext extends ConsumerContext, RpcProviderRegistry {
163 * Represents an RPC implementation registration. Users should call the
164 * {@link ObjectRegistration#close close} method when the registration is no longer needed.
166 * @param <T> the implemented RPC service interface
168 interface RpcRegistration<T extends RpcService> extends ObjectRegistration<T> {
171 * Returns the implemented RPC service interface.
173 Class<T> getServiceType();
180 * Represents a routed RPC implementation registration. Users should call the
181 * {@link RoutedRegistration#close close} method when the registration is no longer needed.
183 * @param <T> the implemented RPC service interface
185 interface RoutedRpcRegistration<T extends RpcService> extends RpcRegistration<T>,
186 RoutedRegistration<Class<? extends BaseIdentity>, InstanceIdentifier<?>, T> {
189 * Register particular instance identifier to be processed by this
192 * Deprecated in favor of RoutedRegistration#registerPath(Object, Object).
198 void registerInstance(Class<? extends BaseIdentity> context, InstanceIdentifier<?> instance);
201 * Unregister particular instance identifier to be processed by this
204 * Deprecated in favor of RoutedRegistration#unregisterPath(Class, InstanceIdentifier).
210 void unregisterInstance(Class<? extends BaseIdentity> context, InstanceIdentifier<?> instance);