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
  34 import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry;
  35 import org.opendaylight.yangtools.yang.binding.DataObject;
  36 import org.opendaylight.yangtools.yang.common.QName;
  37 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  38 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  39 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  40 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  41 import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
  42 import org.opendaylight.yangtools.yang.data.codec.gson.JSONNormalizedNodeStreamWriter;
  43 import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
  44 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  45 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  46 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  47 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 public class JSONDataObjectConverter extends AbstractDataObjectConverter {
  52
  53     private static final Logger LOG = LoggerFactory.getLogger(JSONDataObjectConverter.class);
  54
  55     private JSONDataObjectConverter(SchemaContext schemaContext, BindingNormalizedNodeCodecRegistry codecRegistry) {
  56         super(schemaContext, codecRegistry);
  57     }
  58
  59     /**
  60      * extracts codec and schema context (?).
  61      *
  62      * @param dataStoreContextUtil datastore context util used to extract codec and schema context
  63      * @return {@link AbstractDataObjectConverter}
  64      */
  65     public static DataObjectConverter createWithDataStoreUtil(@Nonnull DataStoreContext dataStoreContextUtil) {
  66         return new JSONDataObjectConverter(dataStoreContextUtil.getSchemaContext(),
  67                 dataStoreContextUtil.getBindingToNormalizedNodeCodec());
  68     }
  69
  70     /**
  71      * extracts codec and schema context (?).
  72      *
  73      * @param schemaContext schema context for converter
  74      * @param codecRegistry codec registry used for converting
  75      * @return converter
  76      */
  77     public static DataObjectConverter createWithSchemaContext(@Nonnull SchemaContext schemaContext,
  78             @Nonnull BindingNormalizedNodeCodecRegistry codecRegistry) {
  79         return new JSONDataObjectConverter(schemaContext, codecRegistry);
  80     }
  81
  82     /**
  83      * Transforms the JSON input stream into normalized nodes.
  84      *
  85      * @param inputStream of the given JSON
  86      * @return {@link Optional} instance of {@link NormalizedNode}.
  87      */
  88     @Override
  89     public Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> transformIntoNormalizedNode(
  90             @Nonnull InputStream inputStream) {
  91         try {
  92             JsonReader reader = new JsonReader(new InputStreamReader(inputStream, "UTF-8"));
  93             return parseInputJSON(reader);
  94         } catch (IOException e) {
  95             LOG.warn(e.getMessage(), e);
  96             return Optional.empty();
  97         }
  98     }
  99
 100     @Override
 101     public Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> transformIntoNormalizedNode(
 102             @Nonnull Reader inputReader, SchemaNode parentSchema) {
 103         throw new UnsupportedOperationException("Not Implemented yet");
 104     }
 105
 106     @Override
 107     public Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> transformIntoNormalizedNode(
 108             @Nonnull Reader inputReader) {
 109         JsonReader reader = new JsonReader(inputReader);
 110         return parseInputJSON(reader);
 111     }
 112
 113     @Override
 114     public <T extends DataObject> Writer writerFromDataObject(@Nonnull DataObject object, Class<T> dataObjectClass,
 115             ConvertType<T> convertType) {
 116         Writer writer = new StringWriter();
 117         JsonWriter jsonWriter = new JsonWriter(writer);
 118         JSONCodecFactory jsonCodecFactory = JSONCodecFactory.createLazy(getSchemaContext());
 119         NormalizedNodeStreamWriter create =
 120                 JSONNormalizedNodeStreamWriter.createExclusiveWriter(jsonCodecFactory, null, null, jsonWriter);
 121
 122         try (NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(create);) {
 123             normalizedNodeWriter
 124                     .write(convertType.toNormalizedNodes(dataObjectClass.cast(object), dataObjectClass).get());
 125         } catch (IOException ioe) {
 126             throw new IllegalStateException(ioe);
 127         }
 128         return writer;
 129     }
 130
 131     @Override
 132     public <T extends DataObject> Writer writerFromRpcDataObject(@Nonnull DataObject object, Class<T> dataObjectClass,
 133             ConvertType<T> convertType, QName rpcOutputQName, String rpcName) {
 134         return null;
 135     }
 136
 137     /**
 138      * Parses the input json with concrete implementation of {@link JsonParserStream}.
 139      *
 140      * @param reader of the given JSON
 141      *
 142      */
 143     private Optional<NormalizedNode<? extends YangInstanceIdentifier.PathArgument, ?>> parseInputJSON(
 144             JsonReader reader) {
 145         NormalizedNodeResult result = new NormalizedNodeResult();
 146         try (NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 147             JsonParserStream jsonParser = JsonParserStream.create(streamWriter, getSchemaContext(),
 148             getSchemaContext())) {
 149             jsonParser.parse(reader);
 150         } catch (IOException e) {
 151             LOG.warn("An error {} occured during parsing Json input stream", e.getMessage(), e);
 152             return Optional.empty();
 153         }
 154         return Optional.ofNullable(result.getResult());
 155     }
 156
 157 }