tests/honeynode/2.2.1/honeynode-common/src/main/java/io/fd/honeycomb/transportpce/binding/converter/JSONDataObjectConverter.java

   1 /*
   2  * Copyright (c) 2018 AT&T and/or its affiliates.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package io.fd.honeycomb.transportpce.binding.converter;
  17
  18 import com.google.gson.stream.JsonReader;
  19 import com.google.gson.stream.JsonWriter;
  20
  21 import io.fd.honeycomb.transportpce.binding.converter.api.DataObjectConverter;
  22 import io.fd.honeycomb.transportpce.test.common.DataStoreContext;
  23
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26 import java.io.InputStreamReader;
  27 import java.io.Reader;
  28 import java.io.StringWriter;
  29 import java.io.Writer;
  30 import java.util.Optional;
  31
  32 import javax.annotation.Nonnull;
  33 import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
  34 import org.opendaylight.yangtools.yang.binding.DataObject;
  35 import org.opendaylight.yangtools.yang.common.QName;
  36 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  37 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  39 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  40 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
  41 import org.opendaylight.yangtools.yang.data.codec.gson.JSONNormalizedNodeStreamWriter;
  42 import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
  43 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  44 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  45 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  46 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 public final class JSONDataObjectConverter extends AbstractDataObjectConverter {
  51
  52     private static final Logger LOG = LoggerFactory.getLogger(JSONDataObjectConverter.class);
  53
  54     private JSONDataObjectConverter(SchemaContext schemaContext, BindingNormalizedNodeCodecRegistry codecRegistry) {
  55         super(schemaContext, codecRegistry);
  56     }
  57
  58     /**
  59      * extracts codec and schema context (?).
  60      *
  61      * @param dataStoreContextUtil datastore context util used to extract codec and schema context
  62      * @return {@link AbstractDataObjectConverter}
  63      */
  64     public static DataObjectConverter createWithDataStoreUtil(@Nonnull DataStoreContext dataStoreContextUtil) {
  65         return new JSONDataObjectConverter(dataStoreContextUtil.getSchemaContext(),
  66                 dataStoreContextUtil.getBindingToNormalizedNodeCodec());
  67     }
  68
  69     /**
  70      * extracts codec and schema context (?).
  71      *
  72      * @param schemaContext schema context for converter
  73      * @param codecRegistry codec registry used for converting
  74      * @return converter
  75      */
  76     public static DataObjectConverter createWithSchemaContext(@Nonnull SchemaContext schemaContext,
  77             @Nonnull BindingNormalizedNodeCodecRegistry codecRegistry) {
  78         return new JSONDataObjectConverter(schemaContext, codecRegistry);
  79     }
  80
  81     /**
  82      * Transforms the JSON input stream into normalized nodes.
  83      *
  84      * @param inputStream of the given JSON
  85      * @return {@link Optional} instance of {@link NormalizedNode}.
  86      */
  87     @Override
  88     public Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> transformIntoNormalizedNode(
  89             @Nonnull InputStream inputStream) {
  90         try {
  91             JsonReader reader = new JsonReader(new InputStreamReader(inputStream, "UTF-8"));
  92             return parseInputJSON(reader);
  93         } catch (IOException e) {
  94             LOG.warn(e.getMessage(), e);
  95             return Optional.empty();
  96         }
  97     }
  98
  99     @Override
 100     public Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> transformIntoNormalizedNode(
 101             @Nonnull Reader inputReader, SchemaNode parentSchema) {
 102         throw new UnsupportedOperationException("Not Implemented yet");
 103     }
 104
 105     @Override
 106     public Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> transformIntoNormalizedNode(
 107             @Nonnull Reader inputReader) {
 108         JsonReader reader = new JsonReader(inputReader);
 109         return parseInputJSON(reader);
 110     }
 111
 112     @Override
 113     public <T extends DataObject> Writer writerFromDataObject(@Nonnull DataObject object, Class<T> dataObjectClass,
 114             ConvertType<T> convertType) {
 115         Writer writer = new StringWriter();
 116         JsonWriter jsonWriter = new JsonWriter(writer);
 117         JSONCodecFactory jsonCodecFactory = JSONCodecFactory.createLazy(getSchemaContext());
 118         NormalizedNodeStreamWriter create =
 119                 JSONNormalizedNodeStreamWriter.createExclusiveWriter(jsonCodecFactory, null, null, jsonWriter);
 120
 121         try (NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(create);) {
 122             normalizedNodeWriter
 123                     .write(convertType.toNormalizedNodes(dataObjectClass.cast(object), dataObjectClass).get());
 124         } catch (IOException ioe) {
 125             throw new IllegalStateException(ioe);
 126         }
 127         return writer;
 128     }
 129
 130     @Override
 131     public <T extends DataObject> Writer writerFromRpcDataObject(@Nonnull DataObject object, Class<T> dataObjectClass,
 132             ConvertType<T> convertType, QName rpcOutputQName, String rpcName) {
 133         return null;
 134     }
 135
 136     /**
 137      * Parses the input json with concrete implementation of {@link JsonParserStream}.
 138      *
 139      * @param reader of the given JSON
 140      *
 141      */
 142     private Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> parseInputJSON(
 143             JsonReader reader) {
 144         NormalizedNodeResult result = new NormalizedNodeResult();
 145         try (NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 146             JsonParserStream jsonParser = JsonParserStream.create(streamWriter, getSchemaContext(),
 147                 getSchemaContext())) {
 148             jsonParser.parse(reader);
 149         } catch (IOException e) {
 150             LOG.warn("An error {} occured during parsing Json input stream", e.getMessage(), e);
 151             return Optional.empty();
 152         }
 153         return Optional.ofNullable(result.getResult());
 154     }
 155
 156 }