@Override public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { return codecRegistry.fromNormalizedNode(path, data); }
@Override public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode( final InstanceIdentifier<T> path, final T data) { return codecRegistry.toNormalizedNode(path, data); }
@Override public ContainerNode toNormalizedNodeRpcData(final DataContainer data) { return codecRegistry.toNormalizedNodeRpcData(data); }
public TTPUtils(Iterable<? extends YangModuleInfo> moduleInfos) { System.out.println("Building context"); final ModuleInfoBackedContext moduleContext = ModuleInfoBackedContext.create(); moduleContext.addModuleInfos(moduleInfos); context = moduleContext.tryToCreateSchemaContext().get(); System.out.println("Context built"); System.out.println("Building Binding Context"); bindingContext = BindingRuntimeContext.create(moduleContext, context); System.out.println("Building Binding Codec Factory"); final BindingNormalizedNodeCodecRegistry bindingStreamCodecs = new BindingNormalizedNodeCodecRegistry(StreamWriterGenerator.create(JavassistUtils.forClassPool(ClassPool.getDefault()))); bindingStreamCodecs.onBindingRuntimeContextUpdated(bindingContext); codecRegistry = bindingStreamCodecs; System.out.println("Mapping service built"); // TODO Auto-generated constructor stub }
/** * Creates a new BindingToNormalizedNodeCodec instance. * * @param classLoadingStrategy * @return the BindingToNormalizedNodeCodec instance */ public static BindingToNormalizedNodeCodec newInstance(ClassLoadingStrategy classLoadingStrategy) { BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry( StreamWriterGenerator.create(SingletonHolder.JAVASSIST)); return new BindingToNormalizedNodeCodec(classLoadingStrategy, codecRegistry, true); }
@Override public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) { return codecRegistry.toYangInstanceIdentifier(binding); }
@Override public void onGlobalContextUpdated(final SchemaContext schemaContext) { legacyToNormalized = new DataNormalizer(schemaContext); BindingRuntimeContext runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, schemaContext); codecRegistry.onBindingRuntimeContextUpdated(runtimeContext); futureSchema.onRuntimeContextUpdated(runtimeContext); }
@Override public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) { return codecRegistry.fromNormalizedNodeRpcData(path, data); }
@Override public ContainerNode toNormalizedNodeNotification(final Notification data) { return codecRegistry.toNormalizedNodeNotification(data); }
public ClusteredNetconfTopology(final String topologyId, final NetconfClientDispatcher clientDispatcher, final BindingAwareBroker bindingAwareBroker, final Broker domBroker, final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor, final SchemaRepositoryProvider schemaRepositoryProvider, final ActorSystem actorSystem, final EntityOwnershipService entityOwnershipService) { super(topologyId, clientDispatcher, bindingAwareBroker, domBroker, eventExecutor, keepaliveExecutor, processingExecutor, schemaRepositoryProvider); final ModuleInfoBackedContext moduleInfoBackedContext = ModuleInfoBackedContext.create(); moduleInfoBackedContext.addModuleInfos(Collections.singletonList($YangModuleInfoImpl.getInstance())); final Optional<SchemaContext> schemaContextOptional = moduleInfoBackedContext.tryToCreateSchemaContext(); Preconditions.checkState(schemaContextOptional.isPresent()); final SchemaContext topologySchemaCtx = schemaContextOptional.get(); final JavassistUtils javassist = JavassistUtils.forClassPool(ClassPool.getDefault()); codecRegistry = new BindingNormalizedNodeCodecRegistry(StreamWriterGenerator.create(javassist)); codecRegistry.onBindingRuntimeContextUpdated(BindingRuntimeContext.create(moduleInfoBackedContext, topologySchemaCtx)); this.actorSystem = actorSystem; this.entityOwnershipService = entityOwnershipService; registerToSal(this, this); LOG.warn("Clustered netconf topo started"); }
public RestconfClientImpl(final URL url, final SchemaContextHolder schemaContextHolder) { Preconditions.checkArgument(url != null, "Restconf endpoint URL must be supplied."); Preconditions.checkNotNull(schemaContextHolder, "Schema Context Holder must not be null."); ClientConfig config = new DefaultClientConfig(); this.restClient = Client.create(config); URI uri = null; try { uri = url.toURI(); } catch (URISyntaxException e) { logger.trace("Error in URI syntax {}", e.getMessage(), e); } this.generator = StreamWriterGenerator.create(JavassistUtils.forClassPool(ClassPool.getDefault())); this.defaultUri = uri; this.mappingService = new BindingNormalizedNodeCodecRegistry(generator); this.schemaContextHolder = schemaContextHolder; }
/** * Translates supplied Binding Instance Identifier into NormalizedNode * instance identifier. * * @param binding * Binding Instance Identifier * @return DOM Instance Identifier * @throws IllegalArgumentException * If supplied Instance Identifier is not valid. */ public YangInstanceIdentifier toNormalized(final InstanceIdentifier<? extends DataObject> binding) { return codecRegistry.toYangInstanceIdentifier(binding); }
@Override public Object apply(final ClientResponse clientResponse) { if (clientResponse.getStatus() != 200) { throw new IllegalStateException("Can't get data from restconf. "+clientResponse.getClientResponseStatus()); } List<RpcError> errors = new ArrayList<>(); try { ContainerNode output = null; DataContainer rpcOutputDataObject = mappingService.fromNormalizedNodeRpcData(rpcOutputSchema.getPath(), output); return new RestRpcResult(true,rpcOutputDataObject); } catch (Exception e) { logger.trace("Error while extracting rpc output in proxy method {}",e); RestRpcError error = new RestRpcError(RpcError.ErrorSeverity.ERROR, RpcError.ErrorType.APPLICATION,"Error while extracting rpc output in proxy method.",e); errors.add(error); } return new RestRpcResult(false,errors); } });
private static NetconfNotification transform(final NetconfCapabilityChange capabilityChange, final Optional<Date> eventTime) { final ContainerNode containerNode = CODEC_REGISTRY.toNormalizedNodeNotification(capabilityChange); final DOMResult result = new DOMResult(XmlUtil.newDocument()); try { writeNormalizedNode(containerNode, result, CAPABILITY_CHANGE_SCHEMA_PATH); } catch (final XMLStreamException| IOException e) { throw new IllegalStateException("Unable to serialize " + capabilityChange, e); } final Document node = (Document) result.getNode(); return eventTime.isPresent() ? new NetconfNotification(node, eventTime.get()): new NetconfNotification(node); }
public DataObject dataObjectFromNormalizedNode(NormalizedNode<?, ?> nn) { return codecRegistry.fromNormalizedNode(TOP_ODL_TTPS_PATH, nn).getValue(); }
private static NormalizedNode<?, ?> toNormalized(final Netconf netconfSubtree) { return NotificationsTransformUtil.CODEC_REGISTRY.toNormalizedNode(NETCONF_SUBTREE_INSTANCE_IDENTIFIER, netconfSubtree).getValue(); }
/** * This method is deprecated in favor of newInstance/registerInstance. * * @param classLoadingStrategy * @param schemaService * @return BindingToNormalizedNodeCodec instance */ @Deprecated public static BindingToNormalizedNodeCodec getOrCreateInstance(ClassLoadingStrategy classLoadingStrategy, SchemaService schemaService) { BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry( StreamWriterGenerator.create(SingletonHolder.JAVASSIST)); BindingToNormalizedNodeCodec instance = new BindingToNormalizedNodeCodec( classLoadingStrategy, codecRegistry, true); schemaService.registerSchemaContextListener(instance); return instance; }
/** * Invokes create-subscription rpc on mounted device stream. If lastEventTime is provided and stream supports replay, * rpc will be invoked with start time parameter. * @param stream stream * @param lastEventTime last event time * @return rpc result */ CheckedFuture<DOMRpcResult, DOMRpcException> invokeCreateSubscription(final Stream stream, final Optional<Date> lastEventTime) { final CreateSubscriptionInputBuilder inputBuilder = new CreateSubscriptionInputBuilder() .setStream(stream.getName()); if(lastEventTime.isPresent() && stream.isReplaySupport()) { final ZonedDateTime dateTime = lastEventTime.get().toInstant().atZone(ZoneId.systemDefault()); final String formattedDate = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(dateTime); inputBuilder.setStartTime(new DateAndTime(formattedDate)); } final CreateSubscriptionInput input = inputBuilder.build(); final ContainerNode nnInput = CODEC_REGISTRY.toNormalizedNodeRpcData(input); return rpcService.invokeRpc(CREATE_SUBSCRIPTION, nnInput); }
YangInstanceIdentifier toYangInstanceIdentifierBlocking(final InstanceIdentifier<? extends DataObject> binding) { try { return codecRegistry.toYangInstanceIdentifier(binding); } catch (final MissingSchemaException e) { waitForSchema(decompose(binding),e); return codecRegistry.toYangInstanceIdentifier(binding); } }
@Override public void onComplete(Throwable failure, NormalizedNodeMessage success) throws Throwable { if (failure != null) { settableFuture.setException(failure); return; } final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codecRegistry.fromNormalizedNode(success.getIdentifier(), success.getNode()); final Node value = (Node) fromNormalizedNode.getValue(); settableFuture.set(value); } }, TypedActor.context().dispatcher());