<optional>true</optional>
<scope>provided</scope>
</dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>rfc8528-data-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>rfc8528-data-util</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
import java.util.Set;
import javax.ws.rs.core.Application;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.JsonNormalizedNodeBodyReader;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.JsonNormalizedNodeBodyWriter;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.XmlNormalizedNodeBodyReader;
* Abstract Restconf Application.
*/
abstract class AbstractRestconfApplication extends Application {
- private final SchemaContextHandler schemaContextHandler;
+ private final DatabindProvider databindProvider;
private final DOMMountPointService mountPointService;
private final List<Object> services;
- AbstractRestconfApplication(final SchemaContextHandler schemaContextHandler,
- final DOMMountPointService mountPointService, final List<Object> services) {
- this.schemaContextHandler = requireNonNull(schemaContextHandler);
+ AbstractRestconfApplication(final DatabindProvider databindProvider, final DOMMountPointService mountPointService,
+ final List<Object> services) {
+ this.databindProvider = requireNonNull(databindProvider);
this.mountPointService = requireNonNull(mountPointService);
this.services = requireNonNull(services);
}
public final Set<Object> getSingletons() {
return ImmutableSet.<Object>builderWithExpectedSize(services.size() + 5)
.addAll(services)
- .add(new JsonNormalizedNodeBodyReader(schemaContextHandler, mountPointService))
- .add(new JsonPatchBodyReader(schemaContextHandler, mountPointService))
- .add(new XmlNormalizedNodeBodyReader(schemaContextHandler, mountPointService))
- .add(new XmlPatchBodyReader(schemaContextHandler, mountPointService))
- .add(new RestconfDocumentedExceptionMapper(schemaContextHandler))
+ .add(new JsonNormalizedNodeBodyReader(databindProvider, mountPointService))
+ .add(new JsonPatchBodyReader(databindProvider, mountPointService))
+ .add(new XmlNormalizedNodeBodyReader(databindProvider, mountPointService))
+ .add(new XmlPatchBodyReader(databindProvider, mountPointService))
+ .add(new RestconfDocumentedExceptionMapper(databindProvider))
.build();
}
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfDataStreamService;
/**
@Singleton
public class DataStreamApplication extends AbstractRestconfApplication {
@Inject
- public DataStreamApplication(final SchemaContextHandler schemaContextHandler,
- final DOMMountPointService mountPointService, final RestconfDataStreamService dataStreamService) {
- super(schemaContextHandler, mountPointService, List.of(dataStreamService));
+ public DataStreamApplication(final DatabindProvider databindProvider, final DOMMountPointService mountPointService,
+ final RestconfDataStreamService dataStreamService) {
+ super(databindProvider, mountPointService, List.of(dataStreamService));
}
}
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.restconf.nb.rfc8040.rests.services.impl.RestconfDataServiceImpl;
import org.opendaylight.restconf.nb.rfc8040.rests.services.impl.RestconfImpl;
@Singleton
public class RestconfApplication extends AbstractRestconfApplication {
- private RestconfApplication(final SchemaContextHandler schemaContextHandler,
- final DOMMountPointService mountPointService, final RestconfStreamsSubscriptionService streamSubscription,
- final DOMDataBroker dataBroker, final DOMRpcService rpcService, final DOMActionService actionService,
+ private RestconfApplication(final DatabindProvider databindProvider, final DOMMountPointService mountPointService,
+ final RestconfStreamsSubscriptionService streamSubscription, final DOMDataBroker dataBroker,
+ final DOMRpcService rpcService, final DOMActionService actionService,
final DOMNotificationService notificationService, final DOMSchemaService domSchemaService,
final Configuration configuration) {
- super(schemaContextHandler, mountPointService, List.of(
+ super(databindProvider, mountPointService, List.of(
streamSubscription,
- new RestconfDataServiceImpl(schemaContextHandler, dataBroker, mountPointService, streamSubscription,
+ new RestconfDataServiceImpl(databindProvider, dataBroker, mountPointService, streamSubscription,
actionService, configuration),
new RestconfInvokeOperationsServiceImpl(rpcService),
- new RestconfOperationsServiceImpl(schemaContextHandler, mountPointService),
+ new RestconfOperationsServiceImpl(databindProvider, mountPointService),
new RestconfSchemaServiceImpl(domSchemaService, mountPointService),
- new RestconfImpl(schemaContextHandler)));
+ new RestconfImpl(databindProvider)));
}
@Inject
- public RestconfApplication(final SchemaContextHandler schemaContextHandler,
- final DOMMountPointService mountPointService, final DOMDataBroker dataBroker,
- final DOMRpcService rpcService, final DOMActionService actionService,
- final DOMNotificationService notificationService,
- final DOMSchemaService domSchemaService, final Configuration configuration) {
- this(schemaContextHandler, mountPointService,
- new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService, schemaContextHandler,
+ public RestconfApplication(final DatabindProvider databindProvider, final DOMMountPointService mountPointService,
+ final DOMDataBroker dataBroker, final DOMRpcService rpcService, final DOMActionService actionService,
+ final DOMNotificationService notificationService, final DOMSchemaService domSchemaService,
+ final Configuration configuration) {
+ this(databindProvider, mountPointService,
+ new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService, databindProvider,
configuration),
dataBroker, rpcService, actionService, notificationService, domSchemaService, configuration);
}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.restconf.nb.rfc8040.databind;
+
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
+import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
+import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
+import org.opendaylight.yangtools.yang.data.codec.xml.XmlCodecFactory;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+
+/**
+ * An immutable context holding a consistent view of things related to data bind operations.
+ */
+public record DatabindContext(
+ @NonNull MountPointContext mountContext,
+ @NonNull JSONCodecFactory jsonCodecs,
+ @NonNull XmlCodecFactory xmlCodecs) {
+ public DatabindContext {
+ requireNonNull(mountContext);
+ requireNonNull(jsonCodecs);
+ requireNonNull(xmlCodecs);
+ }
+
+ public static @NonNull DatabindContext ofModel(final EffectiveModelContext modelContext) {
+ return ofMountPoint(new EmptyMountPointContext(modelContext));
+ }
+
+ public static @NonNull DatabindContext ofMountPoint(final MountPointContext mountContext) {
+ return new DatabindContext(mountContext,
+ JSONCodecFactorySupplier.RFC7951.getShared(mountContext.getEffectiveModelContext()),
+ XmlCodecFactory.create(mountContext));
+ }
+
+ public @NonNull EffectiveModelContext modelContext() {
+ return mountContext.getEffectiveModelContext();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.restconf.nb.rfc8040.databind;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+/**
+ * A service providing access to a {@link DatabindContext}.
+ */
+@NonNullByDefault
+public interface DatabindProvider {
+ /**
+ * Acquire current {@link DatabindContext}.
+ *
+ * @return Current {@link DatabindContext}
+ */
+ DatabindContext currentContext();
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.restconf.nb.rfc8040.databind.mdsal;
+
+import static com.google.common.base.Verify.verifyNotNull;
+
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
+import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+
+/**
+ * A {@link DatabindProvider} monitoring a {@link DOMSchemaService}.
+ */
+@Singleton
+@Component(service = DatabindProvider.class)
+public final class DOMDatabindProvider implements DatabindProvider, EffectiveModelContextListener, AutoCloseable {
+ private final Registration reg;
+
+ private volatile DatabindContext currentContext;
+
+ @Inject
+ @Activate
+ public DOMDatabindProvider(@Reference final DOMSchemaService schemaService) {
+ currentContext = DatabindContext.ofModel(schemaService.getGlobalContext());
+ reg = schemaService.registerSchemaContextListener(this);
+ }
+
+ @Override
+ public DatabindContext currentContext() {
+ return verifyNotNull(currentContext, "Provider already closed");
+ }
+
+ @Override
+ public void onModelContextUpdated(final EffectiveModelContext newModelContext) {
+ final var local = currentContext;
+ if (local != null && local.modelContext() != newModelContext) {
+ currentContext = DatabindContext.ofModel(newModelContext);
+ }
+ }
+
+ @PreDestroy
+ @Deactivate
+ @Override
+ public void close() {
+ reg.close();
+ currentContext = null;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+/**
+ * Package holding data binding components implemented on top of MD-SAL APIs.
+ */
+package org.opendaylight.restconf.nb.rfc8040.databind.mdsal;
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+/**
+ * Package holding concepts related to data binding.
+ */
+package org.opendaylight.restconf.nb.rfc8040.databind;
\ No newline at end of file
}
}
- public EffectiveModelContext get() {
+ @VisibleForTesting
+ EffectiveModelContext get() {
return schemaContext;
}
import javax.ws.rs.core.UriInfo;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.spi.AbstractIdentifierAwareJaxRsProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
* Common superclass for readers producing {@link NormalizedNodePayload}.
*/
abstract class AbstractNormalizedNodeBodyReader extends AbstractIdentifierAwareJaxRsProvider<NormalizedNodePayload> {
- AbstractNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler,
+ AbstractNormalizedNodeBodyReader(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- super(schemaContextHandler, mountPointService);
+ super(databindProvider, mountPointService);
}
public final void injectParams(final UriInfo uriInfo, final Request request) {
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
public class JsonNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReader {
private static final Logger LOG = LoggerFactory.getLogger(JsonNormalizedNodeBodyReader.class);
- public JsonNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler,
+ public JsonNormalizedNodeBodyReader(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- super(schemaContextHandler, mountPointService);
+ super(databindProvider, mountPointService);
}
@SuppressWarnings("checkstyle:IllegalCatch")
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.ErrorTag;
public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReader {
private static final Logger LOG = LoggerFactory.getLogger(XmlNormalizedNodeBodyReader.class);
- public XmlNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler,
+ public XmlNormalizedNodeBodyReader(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- super(schemaContextHandler, mountPointService);
+ super(databindProvider, mountPointService);
}
@SuppressWarnings("checkstyle:IllegalCatch")
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.Errors;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonWriterFactory;
/**
* Creation of the custom JSON stream-writer.
*
- * @param schemaContextHandler Handler that holds actual schema context.
- * @param outputWriter Output stream that is used for creation of JSON writers.
+ * @param databindContext {@link DatabindContext} to use
+ * @param outputWriter Output stream that is used for creation of JSON writers.
*/
- JsonStreamWriterWithDisabledValidation(final SchemaContextHandler schemaContextHandler,
+ JsonStreamWriterWithDisabledValidation(final DatabindContext databindContext,
final OutputStreamWriter outputWriter) {
jsonWriter = JsonWriterFactory.createJsonWriter(outputWriter, DEFAULT_INDENT_SPACES_NUM);
- final var inference = errorsContainerInference(schemaContextHandler);
- jsonNodeStreamWriter = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
- JSONCodecFactorySupplier.RFC7951.getShared(inference.getEffectiveModelContext()),
+ final var inference = errorsContainerInference(databindContext);
+ jsonNodeStreamWriter = JSONNormalizedNodeStreamWriter.createExclusiveWriter(databindContext.jsonCodecs(),
inference, IETF_RESTCONF_URI, jsonWriter);
}
package org.opendaylight.restconf.nb.rfc8040.jersey.providers.errors;
import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.$YangModuleInfoImpl.qnameOf;
import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.errors.Errors;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.errors.errors.Error;
import org.opendaylight.yangtools.yang.common.QName;
private static final QName ERROR_PATH_QNAME = qnameOf("error-path");
static final QName ERROR_INFO_QNAME = qnameOf("error-info");
+ private final DatabindProvider databindProvider;
+
@Context
private HttpHeaders headers;
- private final SchemaContextHandler schemaContextHandler;
/**
* Initialization of the exception mapper.
*
- * @param schemaContextHandler Handler that provides actual schema context.
+ * @param databindProvider A {@link DatabindProvider}
*/
- public RestconfDocumentedExceptionMapper(final SchemaContextHandler schemaContextHandler) {
- this.schemaContextHandler = schemaContextHandler;
+ public RestconfDocumentedExceptionMapper(final DatabindProvider databindProvider) {
+ this.databindProvider = requireNonNull(databindProvider);
}
@Override
OutputStreamWriter streamStreamWriter = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
) {
return writeNormalizedNode(errorsContainer, outputStream,
- new JsonStreamWriterWithDisabledValidation(schemaContextHandler, streamStreamWriter));
+ new JsonStreamWriterWithDisabledValidation(databindProvider.currentContext(), streamStreamWriter));
} catch (IOException e) {
throw new IllegalStateException("Cannot close some of the output JSON writers", e);
}
private String serializeErrorsContainerToXml(final ContainerNode errorsContainer) {
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
return writeNormalizedNode(errorsContainer, outputStream,
- new XmlStreamWriterWithDisabledValidation(schemaContextHandler, outputStream));
+ new XmlStreamWriterWithDisabledValidation(databindProvider.currentContext(), outputStream));
} catch (IOException e) {
throw new IllegalStateException("Cannot close some of the output XML writers", e);
}
package org.opendaylight.restconf.nb.rfc8040.jersey.providers.errors;
import java.io.IOException;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.Errors;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.stream.ForwardingNormalizedNodeStreamWriter;
*/
abstract void endNodeWithDisabledValidation() throws IOException;
- static final Inference errorsContainerInference(final SchemaContextHandler schemaContextHandler) {
- final var stack = SchemaInferenceStack.of(schemaContextHandler.get());
+ static final Inference errorsContainerInference(final DatabindContext databindContext) {
+ final var stack = SchemaInferenceStack.of(databindContext.modelContext());
stack.enterGrouping(Errors.QNAME);
return stack.toInference();
}
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
/**
* Creation of the custom XML stream-writer.
*
- * @param schemaContextHandler Handler that holds actual schema context.
- * @param outputStream Output stream that is used for creation of JSON writers.
+ * @param databindContext {@link DatabindContext} to use
+ * @param outputStream Output stream that is used for creation of JSON writers.
*/
- XmlStreamWriterWithDisabledValidation(final SchemaContextHandler schemaContextHandler,
- final OutputStream outputStream) {
+ XmlStreamWriterWithDisabledValidation(final DatabindContext databindContext, final OutputStream outputStream) {
try {
xmlWriter = XML_FACTORY.createXMLStreamWriter(outputStream, StandardCharsets.UTF_8.name());
} catch (final XMLStreamException | FactoryConfigurationError e) {
}
xmlNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(xmlWriter,
- errorsContainerInference(schemaContextHandler));
+ errorsContainerInference(databindContext));
}
@Override
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.patch.PatchContext;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.spi.AbstractIdentifierAwareJaxRsProvider;
/**
* @author Robert Varga
*/
abstract class AbstractPatchBodyReader extends AbstractIdentifierAwareJaxRsProvider<PatchContext> {
- protected AbstractPatchBodyReader(final SchemaContextHandler schemaContextHandler,
+ protected AbstractPatchBodyReader(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- super(schemaContextHandler, mountPointService);
+ super(databindProvider, mountPointService);
}
@Override
import org.opendaylight.restconf.common.patch.PatchEditOperation;
import org.opendaylight.restconf.common.patch.PatchEntity;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
public class JsonPatchBodyReader extends AbstractPatchBodyReader {
private static final Logger LOG = LoggerFactory.getLogger(JsonPatchBodyReader.class);
- public JsonPatchBodyReader(final SchemaContextHandler schemaContextHandler,
+ public JsonPatchBodyReader(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- super(schemaContextHandler, mountPointService);
+ super(databindProvider, mountPointService);
}
@SuppressWarnings("checkstyle:IllegalCatch")
import org.opendaylight.restconf.common.patch.PatchEditOperation;
import org.opendaylight.restconf.common.patch.PatchEntity;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.ErrorTag;
public class XmlPatchBodyReader extends AbstractPatchBodyReader {
private static final Logger LOG = LoggerFactory.getLogger(XmlPatchBodyReader.class);
- public XmlPatchBodyReader(final SchemaContextHandler schemaContextHandler,
+ public XmlPatchBodyReader(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- super(schemaContextHandler, mountPointService);
+ super(databindProvider, mountPointService);
}
@SuppressWarnings("checkstyle:IllegalCatch")
*/
package org.opendaylight.restconf.nb.rfc8040.jersey.providers.spi;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;
import javax.ws.rs.ext.MessageBodyReader;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@Context
private Request request;
- private final SchemaContextHandler schemaContextHandler;
+ private final DatabindProvider databindProvider;
private final DOMMountPointService mountPointService;
- protected AbstractIdentifierAwareJaxRsProvider(final SchemaContextHandler schemaContextHandler,
+ protected AbstractIdentifierAwareJaxRsProvider(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- this.schemaContextHandler = schemaContextHandler;
+ this.databindProvider = requireNonNull(databindProvider);
this.mountPointService = mountPointService;
}
}
protected EffectiveModelContext getSchemaContext() {
- return schemaContextHandler.get();
+ return databindProvider.currentContext().modelContext();
}
protected DOMMountPointService getMountPointService() {
import org.opendaylight.restconf.nb.rfc8040.ReadDataParams;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040;
import org.opendaylight.restconf.nb.rfc8040.WriteDataParams;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.databind.jaxrs.QueryParams;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.legacy.QueryParameters;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfDataService;
private static final QName NETCONF_BASE_QNAME = SchemaContext.NAME;
private final RestconfStreamsSubscriptionService delegRestconfSubscrService;
- private final SchemaContextHandler schemaContextHandler;
+ private final DatabindProvider databindProvider;
private final MdsalRestconfStrategy restconfStrategy;
private final DOMMountPointService mountPointService;
private final SubscribeToStreamUtil streamUtils;
private final DOMActionService actionService;
private final DOMDataBroker dataBroker;
- public RestconfDataServiceImpl(final SchemaContextHandler schemaContextHandler,
+ public RestconfDataServiceImpl(final DatabindProvider databindProvider,
final DOMDataBroker dataBroker, final DOMMountPointService mountPointService,
final RestconfStreamsSubscriptionService delegRestconfSubscrService,
final DOMActionService actionService, final Configuration configuration) {
- this.schemaContextHandler = requireNonNull(schemaContextHandler);
+ this.databindProvider = requireNonNull(databindProvider);
this.dataBroker = requireNonNull(dataBroker);
restconfStrategy = new MdsalRestconfStrategy(dataBroker);
this.mountPointService = requireNonNull(mountPointService);
public Response readData(final String identifier, final UriInfo uriInfo) {
final ReadDataParams readParams = QueryParams.newReadDataParams(uriInfo);
- final EffectiveModelContext schemaContextRef = schemaContextHandler.get();
+ final EffectiveModelContext schemaContextRef = databindProvider.currentContext().modelContext();
final InstanceIdentifierContext instanceIdentifier = ParserIdentifier.toInstanceIdentifier(
identifier, schemaContextRef, Optional.of(mountPointService));
final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint();
@Override
public Response deleteData(final String identifier) {
- final InstanceIdentifierContext instanceIdentifier = ParserIdentifier.toInstanceIdentifier(
- identifier, schemaContextHandler.get(), Optional.of(mountPointService));
+ final InstanceIdentifierContext instanceIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
+ databindProvider.currentContext().modelContext(), Optional.of(mountPointService));
final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint();
final RestconfStrategy strategy = getRestconfStrategy(mountPoint);
import javax.ws.rs.Path;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040.IetfYangLibrary;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.Restconf;
public class RestconfImpl implements RestconfService {
private static final QName YANG_LIBRARY_VERSION = QName.create(Restconf.QNAME, "yang-library-version").intern();
- private final SchemaContextHandler schemaContextHandler;
+ private final DatabindProvider databindProvider;
- public RestconfImpl(final SchemaContextHandler schemaContextHandler) {
- this.schemaContextHandler = requireNonNull(schemaContextHandler);
+ public RestconfImpl(final DatabindProvider databindProvider) {
+ this.databindProvider = requireNonNull(databindProvider);
}
@Override
public NormalizedNodePayload getLibraryVersion() {
- final EffectiveModelContext context = schemaContextHandler.get();
+ final EffectiveModelContext context = databindProvider.currentContext().modelContext();
final SchemaInferenceStack stack = SchemaInferenceStack.of(context);
// FIXME: use rc:data instantiation once the stack supports it
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfOperationsService;
import org.opendaylight.restconf.nb.rfc8040.utils.RestconfConstants;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class RestconfOperationsServiceImpl implements RestconfOperationsService {
private static final Logger LOG = LoggerFactory.getLogger(RestconfOperationsServiceImpl.class);
- private final SchemaContextHandler schemaContextHandler;
+ private final DatabindProvider databindProvider;
private final DOMMountPointService mountPointService;
/**
- * Set {@link SchemaContextHandler} for getting actual {@link SchemaContext}.
+ * Set {@link DatabindProvider} for getting actual {@link EffectiveModelContext}.
*
- * @param schemaContextHandler handling schema context
- * @param mountPointService handling dom mount point service
+ * @param databindProvider a {@link DatabindProvider}
+ * @param mountPointService a {@link DOMMountPointService}
*/
- public RestconfOperationsServiceImpl(final SchemaContextHandler schemaContextHandler,
+ public RestconfOperationsServiceImpl(final DatabindProvider databindProvider,
final DOMMountPointService mountPointService) {
- this.schemaContextHandler = requireNonNull(schemaContextHandler);
+ this.databindProvider = requireNonNull(databindProvider);
this.mountPointService = requireNonNull(mountPointService);
}
@Override
public String getOperationsJSON() {
- return OperationsContent.JSON.bodyFor(schemaContextHandler.get());
+ return OperationsContent.JSON.bodyFor(databindProvider.currentContext().modelContext());
}
@Override
public String getOperationsXML() {
- return OperationsContent.XML.bodyFor(schemaContextHandler.get());
+ return OperationsContent.XML.bodyFor(databindProvider.currentContext().modelContext());
}
@Override
}
final InstanceIdentifierContext mountPointIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
- schemaContextHandler.get(), Optional.of(mountPointService));
+ databindProvider.currentContext().modelContext(), Optional.of(mountPointService));
final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint();
final var entry = contextForModelContext(modelContext(mountPoint), mountPoint);
return NormalizedNodePayload.of(entry.getKey(), entry.getValue());
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.api.DOMYangTextSourceProvider;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfSchemaService;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.SchemaExportContext;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
/**
* Implementation of {@link RestconfSchemaService}.
private final DOMYangTextSourceProvider sourceProvider;
/**
- * Set {@link SchemaContextHandler} for getting actual {@link SchemaContext}.
+ * Default constructor.
*
* @param schemaService a {@link DOMSchemaService}
* @param mountPointService a {@link DOMMountPointService}
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.NotificationQueryParams;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.databind.jaxrs.QueryParams;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants;
import org.opendaylight.restconf.nb.rfc8040.streams.Configuration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @param dataBroker {@link DOMDataBroker}
* @param notificationService {@link DOMNotificationService}
- * @param schemaHandler
- * handler of {@link SchemaContext}
- * @param configuration
- * configuration for restconf {@link Configuration}}
+ * @param databindProvider a {@link DatabindProvider}
+ * @param configuration configuration for RESTCONF {@link Configuration}}
*/
public RestconfStreamsSubscriptionServiceImpl(final DOMDataBroker dataBroker,
- final DOMNotificationService notificationService, final SchemaContextHandler schemaHandler,
+ final DOMNotificationService notificationService, final DatabindProvider databindProvider,
final Configuration configuration) {
- handlersHolder = new HandlersHolder(dataBroker, notificationService, schemaHandler);
+ handlersHolder = new HandlersHolder(dataBroker, notificationService, databindProvider);
streamUtils = configuration.isUseSSE() ? SubscribeToStreamUtil.serverSentEvents()
: SubscribeToStreamUtil.webSockets();
}
}
// prepare node with value of location
- return NormalizedNodePayload.ofLocation(prepareIIDSubsStreamOutput(handlersHolder.getSchemaHandler()),
+ return NormalizedNodePayload.ofLocation(
+ prepareIIDSubsStreamOutput(handlersHolder.getDatabindProvider().currentContext().modelContext()),
LOCATION_NODEID, response);
}
* @param schemaHandler Schema context handler.
* @return InstanceIdentifier of Location leaf.
*/
- private static InstanceIdentifierContext prepareIIDSubsStreamOutput(final SchemaContextHandler schemaHandler) {
+ private static InstanceIdentifierContext prepareIIDSubsStreamOutput(final EffectiveModelContext modelContext) {
return InstanceIdentifierContext.ofStack(
- SchemaInferenceStack.ofDataTreePath(schemaHandler.get(), NOTIFI_QNAME, LOCATION_QNAME));
+ SchemaInferenceStack.ofDataTreePath(modelContext, NOTIFI_QNAME, LOCATION_QNAME));
}
/**
public static final class HandlersHolder {
private final DOMDataBroker dataBroker;
private final DOMNotificationService notificationService;
- private final SchemaContextHandler schemaHandler;
+ private final DatabindProvider databindProvider;
private HandlersHolder(final DOMDataBroker dataBroker, final DOMNotificationService notificationService,
- final SchemaContextHandler schemaHandler) {
+ final DatabindProvider databindProvider) {
this.dataBroker = dataBroker;
this.notificationService = notificationService;
- this.schemaHandler = schemaHandler;
+ this.databindProvider = databindProvider;
}
/**
}
/**
- * Get {@link SchemaContextHandler}.
+ * Get {@link DatabindProvider}.
*
* @return the schemaHandler
*/
- public SchemaContextHandler getSchemaHandler() {
- return schemaHandler;
+ public DatabindProvider getDatabindProvider() {
+ return databindProvider;
}
}
}
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.NotificationQueryParams;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.rests.services.impl.RestconfStreamsSubscriptionServiceImpl.HandlersHolder;
import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants;
import org.opendaylight.restconf.nb.rfc8040.streams.listeners.ListenerAdapter;
String.format("Stream with name %s was not found.", streamName),
ErrorType.PROTOCOL, ErrorTag.UNKNOWN_ELEMENT));
- final EffectiveModelContext schemaContext = handlersHolder.getSchemaHandler().get();
+ final EffectiveModelContext schemaContext = handlersHolder.getDatabindProvider().currentContext()
+ .modelContext();
final URI uri = prepareUriByStreamName(uriInfo, streamName);
notificationListenerAdapter.setQueryParams(notificationQueryParams);
notificationListenerAdapter.listen(handlersHolder.getNotificationServiceHandler());
final DOMDataBroker dataBroker = handlersHolder.getDataBroker();
- notificationListenerAdapter.setCloseVars(dataBroker, handlersHolder.getSchemaHandler());
+ notificationListenerAdapter.setCloseVars(dataBroker, handlersHolder.getDatabindProvider());
final MapEntryNode mapToStreams = RestconfMappingNodeUtil.mapYangNotificationStreamByIetfRestconfMonitoring(
notificationListenerAdapter.getSchemaPath().lastNodeIdentifier(),
schemaContext.getNotifications(), notificationListenerAdapter.getStart(),
listener.setQueryParams(notificationQueryParams);
final DOMDataBroker dataBroker = handlersHolder.getDataBroker();
- final SchemaContextHandler schemaHandler = handlersHolder.getSchemaHandler();
+ final DatabindProvider schemaHandler = handlersHolder.getDatabindProvider();
listener.setCloseVars(dataBroker, schemaHandler);
listener.listen(dataBroker, LogicalDatastoreType.valueOf(datastoreParam));
final URI uri = prepareUriByStreamName(uriInfo, streamName);
- final EffectiveModelContext schemaContext = schemaHandler.get();
+ final EffectiveModelContext schemaContext = schemaHandler.currentContext().modelContext();
final String serializedPath = IdentifierCodec.serialize(listener.getPath(), schemaContext);
final MapEntryNode mapToStreams =
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.slf4j.Logger;
private final String localName;
- protected SchemaContextHandler schemaHandler;
+ protected DatabindProvider databindProvider;
private DOMDataBroker dataBroker;
AbstractNotificationsData(final QName lastQName) {
* Data broker for delete data in DS on close().
*
* @param dataBroker creating new write transaction for delete data on close
- * @param schemaHandler for formatting notifications
+ * @param databindProvider for formatting notifications
*/
@SuppressWarnings("checkstyle:hiddenField")
// FIXME: this is pure lifecycle nightmare just because ...
- public void setCloseVars(final DOMDataBroker dataBroker, final SchemaContextHandler schemaHandler) {
+ public void setCloseVars(final DOMDataBroker dataBroker, final DatabindProvider databindProvider) {
this.dataBroker = dataBroker;
- this.schemaHandler = schemaHandler;
+ this.databindProvider = databindProvider;
}
/**
final Optional<String> maybeData;
try {
- maybeData = formatter().eventData(schemaHandler.get(), dataTreeCandidates, now, getLeafNodesOnly(),
- isSkipNotificationData());
+ maybeData = formatter().eventData(databindProvider.currentContext().modelContext(), dataTreeCandidates, now,
+ getLeafNodesOnly(), isSkipNotificationData());
} catch (final Exception e) {
LOG.error("Failed to process notification {}",
dataTreeCandidates.stream().map(Object::toString).collect(Collectors.joining(",")), e);
final Optional<String> maybeOutput;
try {
- maybeOutput = formatter().eventData(schemaHandler.get(), notification, now, getLeafNodesOnly(),
- isSkipNotificationData());
+ maybeOutput = formatter().eventData(databindProvider.currentContext().modelContext(), notification, now,
+ getLeafNodesOnly(), isSkipNotificationData());
} catch (Exception e) {
LOG.error("Failed to process notification {}", notification, e);
return;
</bean>
<bean id="dataStreamApplication" class="org.opendaylight.restconf.nb.rfc8040.DataStreamApplication">
- <argument ref="schemaContextHandler"/>
+ <argument ref="databindProvider"/>
<argument ref="dOMMountPointService"/>
<argument ref="restconfDataStreamServiceImpl"/>
</bean>
<bean id="restconfApplication" class="org.opendaylight.restconf.nb.rfc8040.RestconfApplication">
- <argument ref="schemaContextHandler"/>
+ <argument ref="databindProvider"/>
<argument ref="dOMMountPointService"/>
<argument ref="dOMDataBroker"/>
<argument ref="dOMRpcService"/>
<argument ref="scheduledThreadPool"/>
<argument ref="configuration"/>
</bean>
+ <reference id="databindProvider" interface="org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider"/>
<reference id="customFilterAdapterConfiguration" interface="org.opendaylight.aaa.filterchain.configuration.CustomFilterAdapterConfiguration"/>
<reference id="webContextSecurer" interface="org.opendaylight.aaa.web.WebContextSecurer"/>
<reference id="webServer" interface="org.opendaylight.aaa.web.WebServer"/>
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
-import org.opendaylight.mdsal.common.api.CommitInfo;
-import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
"some interface"))
.build();
}
-
- public static SchemaContextHandler newSchemaContextHandler(final EffectiveModelContext schemaContext) {
- DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
- DOMDataTreeWriteTransaction mockTx = mock(DOMDataTreeWriteTransaction.class);
- doReturn(CommitInfo.emptyFluentFuture()).when(mockTx).commit();
- doReturn(mockTx).when(mockDataBroker).newWriteOnlyTransaction();
-
- SchemaContextHandler schemaContextHandler = new SchemaContextHandler(mockDataBroker,
- mock(DOMSchemaService.class));
- schemaContextHandler.onModelContextUpdated(schemaContext);
- return schemaContextHandler;
- }
}
public XmlBodyReaderMountPointTest() throws Exception {
super(schemaContext);
- xmlBodyReader = new XmlNormalizedNodeBodyReader(schemaContextHandler, mountPointService);
+ xmlBodyReader = new XmlNormalizedNodeBodyReader(databindProvider, mountPointService);
}
@Override
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.skyscreamer.jsonassert.JSONAssert;
@BeforeClass
public static void setupExceptionMapper() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(
+ final var schemaContext = YangParserTestUtils.parseYangResources(
RestconfDocumentedExceptionMapperTest.class, "/restconf/impl/ietf-restconf@2017-01-26.yang",
"/instanceidentifier/yang/instance-identifier-patch-module.yang");
- final SchemaContextHandler schemaContextHandler = mock(SchemaContextHandler.class);
- doReturn(schemaContext).when(schemaContextHandler).get();
-
- exceptionMapper = new RestconfDocumentedExceptionMapper(schemaContextHandler);
+ exceptionMapper = new RestconfDocumentedExceptionMapper(() -> DatabindContext.ofModel(schemaContext));
}
/**
public JsonPatchBodyReaderMountPointTest() throws Exception {
super(schemaContext);
- jsonToPatchBodyReader = new JsonPatchBodyReader(schemaContextHandler, mountPointService);
+ jsonToPatchBodyReader = new JsonPatchBodyReader(databindProvider, mountPointService);
}
@Override
public JsonPatchBodyReaderTest() throws Exception {
super(schemaContext);
- jsonToPatchBodyReader = new JsonPatchBodyReader(schemaContextHandler, mountPointService);
+ jsonToPatchBodyReader = new JsonPatchBodyReader(databindProvider, mountPointService);
}
@Override
public XmlPatchBodyReaderMountPointTest() throws Exception {
super(schemaContext);
- xmlToPatchBodyReader = new XmlPatchBodyReader(schemaContextHandler, mountPointService);
+ xmlToPatchBodyReader = new XmlPatchBodyReader(databindProvider, mountPointService);
}
@Override
public XmlPatchBodyReaderTest() throws Exception {
super(schemaContext);
- xmlToPatchBodyReader = new XmlPatchBodyReader(schemaContextHandler, mountPointService);
+ xmlToPatchBodyReader = new XmlPatchBodyReader(databindProvider, mountPointService);
}
@Override
import org.opendaylight.restconf.common.errors.RestconfError;
import org.opendaylight.restconf.common.patch.PatchContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.TestUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.jersey.providers.spi.AbstractIdentifierAwareJaxRsProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.yangtools.yang.common.ErrorTag;
public abstract class AbstractBodyReaderTest {
protected final MediaType mediaType;
- protected final SchemaContextHandler schemaContextHandler;
+ protected final DatabindProvider databindProvider;
protected final DOMMountPointService mountPointService;
protected AbstractBodyReaderTest(final EffectiveModelContext schemaContext) throws NoSuchFieldException,
IllegalAccessException {
mediaType = getMediaType();
- schemaContextHandler = TestUtils.newSchemaContextHandler(schemaContext);
+ final var databindContext = DatabindContext.ofModel(schemaContext);
+ databindProvider = () -> databindContext;
mountPointService = mock(DOMMountPointService.class);
- final DOMMountPoint mountPoint = mock(DOMMountPoint.class);
+ final var mountPoint = mock(DOMMountPoint.class);
doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(any(YangInstanceIdentifier.class));
doReturn(Optional.of(FixedDOMSchemaService.of(schemaContext))).when(mountPoint)
.getService(DOMSchemaService.class);
public JsonBodyReaderTest() throws Exception {
super(schemaContext);
- jsonBodyReader = new JsonNormalizedNodeBodyReader(schemaContextHandler, mountPointService);
+ jsonBodyReader = new JsonNormalizedNodeBodyReader(databindProvider, mountPointService);
}
@Override
public XmlBodyReaderTest() throws Exception {
super(schemaContext);
- xmlBodyReader = new XmlNormalizedNodeBodyReader(schemaContextHandler, mountPointService);
+ xmlBodyReader = new XmlNormalizedNodeBodyReader(databindProvider, mountPointService);
}
@Override
import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.restconf.nb.rfc8040.streams.Configuration;
TestRestconfUtils.loadFiles("/instanceidentifier/yang"));
final DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
- final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(mockDataBroker,
- mock(DOMSchemaService.class));
- schemaContextHandler.onModelContextUpdated(contextRef);
final DOMActionService actionService = mock(DOMActionService.class);
doReturn(Futures.immediateFuture(new SimpleDOMActionResult(
Builders.containerBuilder().withNodeIdentifier(NodeIdentifier.create(OUTPUT_QNAME)).build())))
.when(actionService).invokeAction(eq(Absolute.of(CONT_QNAME, CONT1_QNAME, RESET_QNAME)), any(), any());
- final RestconfDataServiceImpl dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker,
- mock(DOMMountPointService.class), mock(RestconfStreamsSubscriptionService.class),
- actionService, mock(Configuration.class));
+ final RestconfDataServiceImpl dataService = new RestconfDataServiceImpl(
+ () -> DatabindContext.ofModel(contextRef), mockDataBroker, mock(DOMMountPointService.class),
+ mock(RestconfStreamsSubscriptionService.class), actionService, mock(Configuration.class));
final var nodeAndStack = DataSchemaContextTree.from(contextRef).enterPath(ACTION_YII).orElseThrow();
final var node = nodeAndStack.node().getDataSchemaNode();
import org.opendaylight.restconf.common.patch.PatchEntity;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
.node(baseQName)
.build();
- contextRef =
- YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
+ contextRef = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
- doReturn(CommitInfo.emptyFluentFuture()).when(write).commit();
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
- doReturn(write).when(mockDataBroker).newWriteOnlyTransaction();
- final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(
- mockDataBroker, mock(DOMSchemaService.class));
-
- schemaContextHandler.onModelContextUpdated(contextRef);
- dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker, mountPointService,
- delegRestconfSubscrService, actionService, configuration);
+ dataService = new RestconfDataServiceImpl(() -> DatabindContext.ofModel(contextRef), mockDataBroker,
+ mountPointService, delegRestconfSubscrService, actionService, configuration);
doReturn(Optional.of(mountPoint)).when(mountPointService)
.getMountPoint(any(YangInstanceIdentifier.class));
doReturn(Optional.of(FixedDOMSchemaService.of(contextRef))).when(mountPoint)
import org.junit.Test;
import org.opendaylight.restconf.nb.rfc8040.Rfc8040.IetfYangLibrary;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.TestUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class RestconfImplTest {
@Test
public void restImplTest() throws Exception {
- final SchemaContextHandler schemaContextHandler = TestUtils.newSchemaContextHandler(
- YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/restconf/impl")));
- final RestconfImpl restconfImpl = new RestconfImpl(schemaContextHandler);
+ final var context = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/restconf/impl"));
+ final RestconfImpl restconfImpl = new RestconfImpl(() -> DatabindContext.ofModel(context));
final NormalizedNodePayload libraryVersion = restconfImpl.getLibraryVersion();
final LeafNode<?> value = (LeafNode<?>) libraryVersion.getData();
assertEquals(IetfYangLibrary.REVISION.toString(), value.body());
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.TestUtils;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class RestconfOperationsServiceTest {
@Test
public void getOperationsTest() throws IOException {
- final var oper = new RestconfOperationsServiceImpl(
- TestUtils.newSchemaContextHandler(
- YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/modules"))),
+ final var context = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/modules"));
+ final var oper = new RestconfOperationsServiceImpl(() -> DatabindContext.ofModel(context),
mock(DOMMountPointService.class));
assertEquals("{\n"
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
import org.opendaylight.restconf.nb.rfc8040.streams.Configuration;
import org.opendaylight.restconf.nb.rfc8040.streams.listeners.ListenerAdapter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
private Configuration configurationWs;
private Configuration configurationSse;
- private SchemaContextHandler schemaHandler;
+ private EffectiveModelContext modelContext;
+ private DatabindProvider databindProvider;
@Before
public void setUp() throws FileNotFoundException, URISyntaxException {
doReturn(wTx).when(dataBroker).newWriteOnlyTransaction();
doReturn(CommitInfo.emptyFluentFuture()).when(wTx).commit();
- schemaHandler = new SchemaContextHandler(dataBroker, mock(DOMSchemaService.class));
-
DOMDataTreeChangeService dataTreeChangeService = mock(DOMDataTreeChangeService.class);
doReturn(mock(ListenerRegistration.class)).when(dataTreeChangeService)
.registerDataTreeChangeListener(any(), any());
// FIXME: just mock UriInfo here
doReturn(new LocalUriInfo().getBaseUriBuilder()).when(uriInfo).getBaseUriBuilder();
doReturn(new URI("http://127.0.0.1/" + URI)).when(uriInfo).getAbsolutePath();
- schemaHandler.onModelContextUpdated(
- YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/notifications")));
+
+ modelContext = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles("/notifications"));
+ databindProvider = () -> DatabindContext.ofModel(modelContext);
configurationWs = new Configuration(0, 100, 10, false);
configurationSse = new Configuration(0, 100, 10, true);
}
@Test
public void testSubscribeToStreamSSE() {
ListenersBroker.getInstance().registerDataChangeListener(
- IdentifierCodec.deserialize("toaster:toaster/toasterStatus", schemaHandler.get()),
+ IdentifierCodec.deserialize("toaster:toaster/toasterStatus", modelContext),
"data-change-event-subscription/toaster:toaster/toasterStatus/datastore=OPERATIONAL/scope=ONE",
NotificationOutputType.XML);
final RestconfStreamsSubscriptionServiceImpl streamsSubscriptionService =
- new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService,
- schemaHandler, configurationSse);
+ new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService, databindProvider,
+ configurationSse);
final NormalizedNodePayload response = streamsSubscriptionService.subscribeToStream(
"data-change-event-subscription/toaster:toaster/toasterStatus/datastore=OPERATIONAL/scope=ONE", uriInfo);
assertEquals("http://localhost:8181/" + RestconfConstants.BASE_URI_PATTERN
@Test
public void testSubscribeToStreamWS() {
ListenersBroker.getInstance().registerDataChangeListener(
- IdentifierCodec.deserialize("toaster:toaster/toasterStatus", schemaHandler.get()),
+ IdentifierCodec.deserialize("toaster:toaster/toasterStatus", modelContext),
"data-change-event-subscription/toaster:toaster/toasterStatus/datastore=OPERATIONAL/scope=ONE",
NotificationOutputType.XML);
final RestconfStreamsSubscriptionServiceImpl streamsSubscriptionService =
- new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService,
- schemaHandler, configurationWs);
+ new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService, databindProvider,
+ configurationWs);
final NormalizedNodePayload response = streamsSubscriptionService.subscribeToStream(
"data-change-event-subscription/toaster:toaster/toasterStatus/datastore=OPERATIONAL/scope=ONE", uriInfo);
assertEquals("ws://localhost:8181/" + RestconfConstants.BASE_URI_PATTERN
@Test
public void testSubscribeToStreamMissingDatastoreInPath() {
final RestconfStreamsSubscriptionServiceImpl streamsSubscriptionService =
- new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService,
- schemaHandler, configurationWs);
+ new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService, databindProvider,
+ configurationWs);
final var errors = assertThrows(RestconfDocumentedException.class,
() -> streamsSubscriptionService.subscribeToStream("toaster:toaster/toasterStatus/scope=ONE", uriInfo))
.getErrors();
@Test
public void testSubscribeToStreamMissingScopeInPath() {
final RestconfStreamsSubscriptionServiceImpl streamsSubscriptionService =
- new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService,
- schemaHandler, configurationWs);
+ new RestconfStreamsSubscriptionServiceImpl(dataBroker, notificationService, databindProvider,
+ configurationWs);
final var errors = assertThrows(RestconfDocumentedException.class,
() -> streamsSubscriptionService.subscribeToStream("toaster:toaster/toasterStatus/datastore=OPERATIONAL",
uriInfo)).getErrors();
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
import com.google.common.util.concurrent.Uninterruptibles;
import java.io.IOException;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.restconf.nb.rfc8040.LeafNodesOnlyParam;
import org.opendaylight.restconf.nb.rfc8040.NotificationQueryParams;
import org.opendaylight.restconf.nb.rfc8040.SkipNotificationDataParam;
import org.opendaylight.restconf.nb.rfc8040.StartTimeParam;
-import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
+import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.yang.gen.v1.augment.instance.identifier.patch.module.rev220218.PatchCont1Builder;
import org.opendaylight.yang.gen.v1.augment.instance.identifier.patch.module.rev220218.patch.cont.patch.choice1.PatchCase1Builder;
import org.opendaylight.yang.gen.v1.instance.identifier.patch.module.rev151121.PatchCont;
private DataBroker dataBroker;
private DOMDataBroker domDataBroker;
- private SchemaContextHandler schemaContextHandler;
+ private DatabindProvider databindProvider;
@BeforeClass
public static void beforeClass() {
- SCHEMA_CONTEXT = YangParserTestUtils.parseYangResourceDirectory(
- "/instanceidentifier/yang");
+ SCHEMA_CONTEXT = YangParserTestUtils.parseYangResourceDirectory("/instanceidentifier/yang");
}
@AfterClass
public void setUp() throws Exception {
dataBroker = getDataBroker();
domDataBroker = getDomBroker();
-
- schemaContextHandler = new SchemaContextHandler(domDataBroker, mock(DOMSchemaService.class));
- schemaContextHandler.onModelContextUpdated(SCHEMA_CONTEXT);
+ databindProvider = () -> DatabindContext.ofModel(SCHEMA_CONTEXT);
}
class ListenerAdapterTester extends ListenerAdapter {
public void testJsonNotifsLeaves() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey", NotificationOutputType.JSON,
true, false);
- adapter.setCloseVars(domDataBroker, schemaContextHandler);
+ adapter.setCloseVars(domDataBroker, databindProvider);
final DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
public void testJsonNotifs() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey", NotificationOutputType.JSON,
false, false);
- adapter.setCloseVars(domDataBroker, schemaContextHandler);
+ adapter.setCloseVars(domDataBroker, databindProvider);
final DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
public void testJsonNotifsWithoutData() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey", NotificationOutputType.JSON,
false, true);
- adapter.setCloseVars(domDataBroker, schemaContextHandler);
+ adapter.setCloseVars(domDataBroker, databindProvider);
DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
public void testXmlNotifications() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey", NotificationOutputType.XML,
false, false);
- adapter.setCloseVars(domDataBroker, schemaContextHandler);
+ adapter.setCloseVars(domDataBroker, databindProvider);
DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
public void testXmlSkipData() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey", NotificationOutputType.XML,
false, true);
- adapter.setCloseVars(domDataBroker, schemaContextHandler);
+ adapter.setCloseVars(domDataBroker, databindProvider);
DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
public void testXmlLeavesOnly() throws Exception {
ListenerAdapterTester adapter = new ListenerAdapterTester(PATCH_CONT_YIID, "Casey", NotificationOutputType.XML,
true, false);
- adapter.setCloseVars(domDataBroker, schemaContextHandler);
+ adapter.setCloseVars(domDataBroker, databindProvider);
DOMDataTreeChangeService changeService = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
Code Review / netconf.git / commitdiff