summaryrefslogtreecommitdiffstats
path: root/infra/impl/src/main/java/io/fd/honeycomb/impl/NorthboundFacadeHoneycombDOMBroker.java
blob: 7e5dfd873fc070b1ecd4605131160150cac207b9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
/*
 * Copyright (c) 2015 Cisco and/or its affiliates.
 *
 * 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 io.fd.honeycomb.impl;

import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.controller.sal.core.api.BrokerService;
import org.opendaylight.controller.sal.core.api.Consumer;
import org.opendaylight.controller.sal.core.api.Provider;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.osgi.framework.BundleContext;

/**
 * Implementation of dom broker to facade VPP pipeline for northbound APIs
 */
public class NorthboundFacadeHoneycombDOMBroker implements AutoCloseable, Broker {

    private static final BrokerService EMPTY_DOM_RPC_SERVICE = new EmptyDomRpcService();
    private static final BrokerService EMPTY_DOM_MOUNT_SERVICE = new EmptyDomMountService();

    private Map<Class<? extends BrokerService>, BrokerService> services;

    public NorthboundFacadeHoneycombDOMBroker(@Nonnull final DOMDataBroker domDataBrokerDependency,
                                              @Nonnull final SchemaService schemaBiService,
                                              @Nonnull final DOMNotificationService domNotificatioNService) {
        services = Maps.newHashMap();
        services.put(DOMDataBroker.class, domDataBrokerDependency);
        // All services below are required to be present by Restconf northbound
        services.put(SchemaService.class, schemaBiService);
        services.put(DOMRpcService.class, EMPTY_DOM_RPC_SERVICE);
        services.put(DOMMountPointService.class, EMPTY_DOM_MOUNT_SERVICE);
        services.put(DOMNotificationService.class, domNotificatioNService);
        // TODO do both notification service types have to be registered ?
        services.put(DOMNotificationPublishService.class, domNotificatioNService);
    }

    @Override
    public void close() throws Exception {
        // NOOP
    }

    @Override
    public ConsumerSession registerConsumer(final Consumer consumer) {
        final SimpleConsumerSession session = new SimpleConsumerSession(services);
        consumer.onSessionInitiated(session);
        return session;
    }

    @Deprecated
    @Override
    public ConsumerSession registerConsumer(final Consumer consumer, final BundleContext bundleContext) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ProviderSession registerProvider(final Provider provider) {
        final SimpleProviderSession session = new SimpleProviderSession(services);
        provider.onSessionInitiated(session);
        return session;
    }

    @Override
    public ProviderSession registerProvider(final Provider provider, final BundleContext bundleContext) {
        throw new UnsupportedOperationException();
    }

    @NotThreadSafe
    private static class SimpleConsumerSession implements ConsumerSession {
        private boolean closed;
        private final Map<Class<? extends BrokerService>, BrokerService> services;

        private SimpleConsumerSession(final Map<Class<? extends BrokerService>, BrokerService> services) {
            this.services = services;
        }

        @Override
        public boolean isClosed() {
            return closed;
        }

        @Override
        public <T extends BrokerService> T getService(final Class<T> aClass) {
            return (T)services.get(aClass);
        }

        @Override
        public void close() {
            closed = true;
        }
    }

    @NotThreadSafe
    private static class SimpleProviderSession implements ProviderSession {
        private boolean closed;
        private final Map<Class<? extends BrokerService>, BrokerService> services;

        private SimpleProviderSession(final Map<Class<? extends BrokerService>, BrokerService> services) {
            this.services = services;
        }

        @Override
        public boolean isClosed() {
            return closed;
        }

        @Override
        public <T extends BrokerService> T getService(final Class<T> aClass) {
            return (T)services.get(aClass);
        }

        @Override
        public void close() {
            closed = true;
        }
    }

    private static class EmptyDomRpcService implements DOMRpcService {
        @Nonnull
        @Override
        public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath schemaPath,
                                                                      @Nullable final NormalizedNode<?, ?> normalizedNode) {
            return Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(
                new DOMRpcImplementationNotAvailableException("RPCs not supported"));
        }

        @Nonnull
        @Override
        public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(@Nonnull final T t) {
            return new ListenerRegistration<T>() {
                @Override
                public void close() {
                    // Noop
                }

                @Override
                public T getInstance() {
                    return t;
                }
            };
        }
    }

    private static class EmptyDomMountService implements DOMMountPointService {
        @Override
        public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier yangInstanceIdentifier) {
            return Optional.absent();
        }

        @Override
        public DOMMountPointBuilder createMountPoint(final YangInstanceIdentifier yangInstanceIdentifier) {
            throw new UnsupportedOperationException("No mountpoint support");
        }

        @Override
        public ListenerRegistration<MountProvisionListener> registerProvisionListener(
            final MountProvisionListener mountProvisionListener) {
            return new ListenerRegistration<MountProvisionListener>() {
                @Override
                public void close() {
                    // Noop
                }

                @Override
                public MountProvisionListener getInstance() {
                    return mountProvisionListener;
                }
            };
        }
    }
}