* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distr=ibuted on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Protobufs utility.

*/

  private ProtobufUtil() {

  }

  /**

   * Primitive type to class mapping.

   */

  private final static Map<String, Class<?>>

    PRIMITIVES = new HashMap<String, Class<?>>();

  /**

   * Many results are simple: no cell, exists true or false. To save on object creations,

   *  we reuse them across calls.

   */

  private final static Cell[] EMPTY_CELL_ARRAY = new Cell[]{};

  private final static Result EMPTY_RESULT = Result.create(EMPTY_CELL_ARRAY);

  private final static Result EMPTY_RESULT_EXISTS_TRUE = Result.create(null, true);

  private final static Result EMPTY_RESULT_EXISTS_FALSE = Result.create(null, false);

  private final static ClientProtos.Result EMPTY_RESULT_PB;

  private final static ClientProtos.Result EMPTY_RESULT_PB_EXISTS_TRUE;

  private final static ClientProtos.Result EMPTY_RESULT_PB_EXISTS_FALSE;

  static {

    ClientProtos.Result.Builder builder = ClientProtos.Result.newBuilder();

    builder.setExists(true);

    builder.setAssociatedCellCount(0);

    EMPTY_RESULT_PB_EXISTS_TRUE =  builder.build();

    builder.clear();

    builder.setExists(false);

    builder.setAssociatedCellCount(0);

    EMPTY_RESULT_PB_EXISTS_FALSE =  builder.build();

    builder.clear();

    builder.setAssociatedCellCount(0);

    EMPTY_RESULT_PB =  builder.build();

  }

  /**

   * Dynamic class loader to load filter/comparators

   */

  private final static ClassLoader CLASS_LOADER;

  static {

    ClassLoader parent = ProtobufUtil.class.getClassLoader();

    Configuration conf = HBaseConfiguration.create();

    CLASS_LOADER = new DynamicClassLoader(conf, parent);

    PRIMITIVES.put(Boolean.TYPE.getName(), Boolean.TYPE);

    PRIMITIVES.put(Byte.TYPE.getName(), Byte.TYPE);

    PRIMITIVES.put(Character.TYPE.getName(), Character.TYPE);

    PRIMITIVES.put(Short.TYPE.getName(), Short.TYPE);

    PRIMITIVES.put(Integer.TYPE.getName(), Integer.TYPE);

    PRIMITIVES.put(Long.TYPE.getName(), Long.TYPE);

    PRIMITIVES.put(Float.TYPE.getName(), Float.TYPE);

    PRIMITIVES.put(Double.TYPE.getName(), Double.TYPE);

    PRIMITIVES.put(Void.TYPE.getName(), Void.TYPE);

  }

  /**

   * Magic we put ahead of a serialized protobuf message.

   * For example, all znode content is protobuf messages with the below magic

   * for preamble.

   */

  public static final byte [] PB_MAGIC = new byte [] {'P', 'B', 'U', 'F'};

  private static final String PB_MAGIC_STR = Bytes.toString(PB_MAGIC);

  /**

   * Prepend the passed bytes with four bytes of magic, {@link #PB_MAGIC}, to flag what

   * follows as a protobuf in hbase.  Prepend these bytes to all content written to znodes, etc.

   * @param bytes Bytes to decorate

   * @return The passed <code>bytes</codes> with magic prepended (Creates a new

   * byte array that is <code>bytes.length</code> plus {@link #PB_MAGIC}.length.

   */

  public static byte [] prependPBMagic(final byte [] bytes) {

    return Bytes.add(PB_MAGIC, bytes);

  }

  /**

   * @param bytes Bytes to check.

   * @return True if passed <code>bytes</code> has {@link #PB_MAGIC} for a prefix.

   */

  public static boolean isPBMagicPrefix(final byte [] bytes) {

    return isPBMagicPrefix(bytes, 0, bytes.length);

  }

  /**

   * @param bytes Bytes to check.

   * @return True if passed <code>bytes</code> has {@link #PB_MAGIC} for a prefix.

   */

  public static boolean isPBMagicPrefix(final byte [] bytes, int offset, int len) {

    if (bytes == null || len < PB_MAGIC.length) return false;

    return Bytes.compareTo(PB_MAGIC, 0, PB_MAGIC.length, bytes, offset, PB_MAGIC.length) == 0;

  }

  /**

   * @param bytes

   * @throws DeserializationException if we are missing the pb magic prefix

   */

  public static void expectPBMagicPrefix(final byte [] bytes) throws DeserializationException {

    if (!isPBMagicPrefix(bytes)) {

      throw new DeserializationException("Missing pb magic " + PB_MAGIC_STR + " prefix");

    }

  }

  /**

   * @return Length of {@link #PB_MAGIC}

   */

  public static int lengthOfPBMagic() {

    return PB_MAGIC.length;

  }

  /**

   * Return the IOException thrown by the remote server wrapped in

   * ServiceException as cause.

   *

   * @param se ServiceException that wraps IO exception thrown by the server

   * @return Exception wrapped in ServiceException or

   *   a new IOException that wraps the unexpected ServiceException.

   */

  public static IOException getRemoteException(ServiceException se) {

    Throwable e = se.getCause();

    if (e == null) {

      return new IOException(se);

    }

    if (ExceptionUtil.isInterrupt(e)) {

      return ExceptionUtil.asInterrupt(e);

    }

    if (e instanceof RemoteException) {

      e = ((RemoteException) e).unwrapRemoteException();

    }

    return e instanceof IOException ? (IOException) e : new IOException(se);

  }

  /**

   * Convert a ServerName to a protocol buffer ServerName

   *

   * @param serverName the ServerName to convert

   * @return the converted protocol buffer ServerName

   * @see #toServerName(org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName)

   */

  public static HBaseProtos.ServerName

      toServerName(final ServerName serverName) {

    if (serverName == null) return null;

    HBaseProtos.ServerName.Builder builder =

      HBaseProtos.ServerName.newBuilder();

    builder.setHostName(serverName.getHostname());

    if (serverName.getPort() >= 0) {

      builder.setPort(serverName.getPort());

    }

    if (serverName.getStartcode() >= 0) {

      builder.setStartCode(serverName.getStartcode());

    }

    return builder.build();

  }

  /**

   * Convert a protocol buffer ServerName to a ServerName

   *

   * @param proto the protocol buffer ServerName to convert

   * @return the converted ServerName

   */

  public static ServerName toServerName(final HBaseProtos.ServerName proto) {

    if (proto == null) return null;

    String hostName = proto.getHostName();

    long startCode = -1;

    int port = -1;

    if (proto.hasPort()) {

      port = proto.getPort();

    }

    if (proto.hasStartCode()) {

      startCode = proto.getStartCode();

    }

    return ServerName.valueOf(hostName, port, startCode);

  }

  /**

   * Get HTableDescriptor[] from GetTableDescriptorsResponse protobuf

   *

   * @param proto the GetTableDescriptorsResponse

   * @return HTableDescriptor[]

   */

  public static HTableDescriptor[] getHTableDescriptorArray(GetTableDescriptorsResponse proto) {

    if (proto == null) return null;

    HTableDescriptor[] ret = new HTableDescriptor[proto.getTableSchemaCount()];

    for (int i = 0; i < proto.getTableSchemaCount(); ++i) {

      ret[i] = HTableDescriptor.convert(proto.getTableSchema(i));

    }

    return ret;

  }

  /**

   * get the split keys in form "byte [][]" from a CreateTableRequest proto

   *

   * @param proto the CreateTableRequest

   * @return the split keys

   */

  public static byte [][] getSplitKeysArray(final CreateTableRequest proto) {

    byte [][] splitKeys = new byte[proto.getSplitKeysCount()][];

    for (int i = 0; i < proto.getSplitKeysCount(); ++i) {

      splitKeys[i] = proto.getSplitKeys(i).toByteArray();

    }

    return splitKeys;

  }

  /**

   * Convert a protobuf Durability into a client Durability

   */

  public static Durability toDurability(

      final ClientProtos.MutationProto.Durability proto) {

    switch(proto) {

    case USE_DEFAULT:

      return Durability.USE_DEFAULT;

    case SKIP_WAL:

      return Durability.SKIP_WAL;

    case ASYNC_WAL:

      return Durability.ASYNC_WAL;

    case SYNC_WAL:

      return Durability.SYNC_WAL;

    case FSYNC_WAL:

      return Durability.FSYNC_WAL;

    default:

      return Durability.USE_DEFAULT;

    }

  }

  /**

   * Convert a client Durability into a protbuf Durability

   */

  public static ClientProtos.MutationProto.Durability toDurability(

      final Durability d) {

    switch(d) {

    case USE_DEFAULT:

      return ClientProtos.MutationProto.Durability.USE_DEFAULT;

    case SKIP_WAL:

      return ClientProtos.MutationProto.Durability.SKIP_WAL;

    case ASYNC_WAL:

      return ClientProtos.MutationProto.Durability.ASYNC_WAL;

    case SYNC_WAL:

      return ClientProtos.MutationProto.Durability.SYNC_WAL;

    case FSYNC_WAL:

      return ClientProtos.MutationProto.Durability.FSYNC_WAL;

    default:

      return ClientProtos.MutationProto.Durability.USE_DEFAULT;

    }

  }

  /**

   * Convert a protocol buffer Get to a client Get

   *

   * @param proto the protocol buffer Get to convert

   * @return the converted client Get

   * @throws IOException

   */

  public static Get toGet(

      final ClientProtos.Get proto) throws IOException {

    if (proto == null) return null;

    byte[] row = proto.getRow().toByteArray();

    Get get = new Get(row);

    if (proto.hasCacheBlocks()) {

      get.setCacheBlocks(proto.getCacheBlocks());

    }

    if (proto.hasMaxVersions()) {

      get.setMaxVersions(proto.getMaxVersions());

    }

    if (proto.hasStoreLimit()) {

      get.setMaxResultsPerColumnFamily(proto.getStoreLimit());

    }

    if (proto.hasStoreOffset()) {

      get.setRowOffsetPerColumnFamily(proto.getStoreOffset());

    }

    if (proto.hasTimeRange()) {

      HBaseProtos.TimeRange timeRange = proto.getTimeRange();

      long minStamp = 0;

      long maxStamp = Long.MAX_VALUE;

      if (timeRange.hasFrom()) {

        minStamp = timeRange.getFrom();

      }

      if (timeRange.hasTo()) {

        maxStamp = timeRange.getTo();

      }

      get.setTimeRange(minStamp, maxStamp);

    }

    if (proto.hasFilter()) {

      FilterProtos.Filter filter = proto.getFilter();

      get.setFilter(ProtobufUtil.toFilter(filter));

    }

    for (NameBytesPair attribute: proto.getAttributeList()) {

      get.setAttribute(attribute.getName(), attribute.getValue().toByteArray());

    }

    if (proto.getColumnCount() > 0) {

      for (Column column: proto.getColumnList()) {

        byte[] family = column.getFamily().toByteArray();

        if (column.getQualifierCount() > 0) {

          for (ByteString qualifier: column.getQualifierList()) {

            get.addColumn(family, qualifier.toByteArray());

          }

        } else {

          get.addFamily(family);

        }

      }

    }

    if (proto.hasExistenceOnly() && proto.getExistenceOnly()){

      get.setCheckExistenceOnly(true);

    }

    if (proto.hasClosestRowBefore() && proto.getClosestRowBefore()){

      get.setClosestRowBefore(true);

    }

    return get;

  }

  /**

   * Convert a protocol buffer Mutate to a Put.

   *

   * @param proto The protocol buffer MutationProto to convert

   * @return A client Put.

   * @throws IOException

   */

  public static Put toPut(final MutationProto proto)

  throws IOException {

    return toPut(proto, null);

  }

  /**

   * Convert a protocol buffer Mutate to a Put.

   *

   * @param proto The protocol buffer MutationProto to convert

   * @param cellScanner If non-null, the Cell data that goes with this proto.

   * @return A client Put.

   * @throws IOException

   */

  public static Put toPut(final MutationProto proto, final CellScanner cellScanner)

  throws IOException {

    // TODO: Server-side at least why do we convert back to the Client types?  Why not just pb it?

    MutationType type = proto.getMutateType();

    assert type == MutationType.PUT: type.name();

    long timestamp = proto.hasTimestamp()? proto.getTimestamp(): HConstants.LATEST_TIMESTAMP;

    Put put = null;

    int cellCount = proto.hasAssociatedCellCount()? proto.getAssociatedCellCount(): 0;

    if (cellCount > 0) {

      // The proto has metadata only and the data is separate to be found in the cellScanner.

      if (cellScanner == null) {

        throw new DoNotRetryIOException("Cell count of " + cellCount + " but no cellScanner: " +

            toShortString(proto));

      }

      for (int i = 0; i < cellCount; i++) {

        if (!cellScanner.advance()) {

          throw new DoNotRetryIOException("Cell count of " + cellCount + " but at index " + i +

            " no cell returned: " + toShortString(proto));

        }

        Cell cell = cellScanner.current();

        if (put == null) {

          put = new Put(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength(), timestamp);

        }

        put.add(cell);

      }

    } else {

      if (proto.hasRow()) {

        put = new Put(proto.getRow().asReadOnlyByteBuffer(), timestamp);

      } else {

        throw new IllegalArgumentException("row cannot be null");

      }

      // The proto has the metadata and the data itself

      for (ColumnValue column: proto.getColumnValueList()) {

        byte[] family = column.getFamily().toByteArray();

        for (QualifierValue qv: column.getQualifierValueList()) {

          if (!qv.hasValue()) {

            throw new DoNotRetryIOException(

                "Missing required field: qualifier value");

          }

          ByteBuffer qualifier =

              qv.hasQualifier() ? qv.getQualifier().asReadOnlyByteBuffer() : null;

          ByteBuffer value =

              qv.hasValue() ? qv.getValue().asReadOnlyByteBuffer() : null;

          long ts = timestamp;

          if (qv.hasTimestamp()) {

            ts = qv.getTimestamp();

          }

          byte[] tags;

          if (qv.hasTags()) {

            tags = qv.getTags().toByteArray();

            Object[] array = Tag.asList(tags, 0, (short)tags.length).toArray();

            Tag[] tagArray = new Tag[array.length];

            for(int i = 0; i< array.length; i++) {

              tagArray[i] = (Tag)array[i];

            }

            put.addImmutable(family, qualifier, ts, value, tagArray);

          } else {

            put.addImmutable(family, qualifier, ts, value);

          }

        }

      }

    }

    put.setDurability(toDurability(proto.getDurability()));

    for (NameBytesPair attribute: proto.getAttributeList()) {

      put.setAttribute(attribute.getName(), attribute.getValue().toByteArray());

    }

    return put;

  }

  /**

   * Convert a protocol buffer Mutate to a Delete

   *

   * @param proto the protocol buffer Mutate to convert

   * @return the converted client Delete

   * @throws IOException

   */

  public static Delete toDelete(final MutationProto proto)

  throws IOException {

    return toDelete(proto, null);

  }

  /**

   * Convert a protocol buffer Mutate to a Delete

   *

   * @param proto the protocol buffer Mutate to convert

   * @param cellScanner if non-null, the data that goes with this delete.

   * @return the converted client Delete

   * @throws IOException

   */

  public static Delete toDelete(final MutationProto proto, final CellScanner cellScanner)

  throws IOException {

    MutationType type = proto.getMutateType();

    assert type == MutationType.DELETE : type.name();

    byte [] row = proto.hasRow()? proto.getRow().toByteArray(): null;

    long timestamp = HConstants.LATEST_TIMESTAMP;

    if (proto.hasTimestamp()) {

      timestamp = proto.getTimestamp();

    }

    Delete delete = null;

    int cellCount = proto.hasAssociatedCellCount()? proto.getAssociatedCellCount(): 0;

    if (cellCount > 0) {

      // The proto has metadata only and the data is separate to be found in the cellScanner.

      if (cellScanner == null) {

        // TextFormat should be fine for a Delete since it carries no data, just coordinates.

        throw new DoNotRetryIOException("Cell count of " + cellCount + " but no cellScanner: " +

          TextFormat.shortDebugString(proto));

      }

      for (int i = 0; i < cellCount; i++) {

        if (!cellScanner.advance()) {

          // TextFormat should be fine for a Delete since it carries no data, just coordinates.

          throw new DoNotRetryIOException("Cell count of " + cellCount + " but at index " + i +

            " no cell returned: " + TextFormat.shortDebugString(proto));

        }

        Cell cell = cellScanner.current();

        if (delete == null) {

          delete =

            new Delete(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength(), timestamp);

        }

        delete.addDeleteMarker(KeyValueUtil.ensureKeyValue(cell));

      }

    } else {

      delete = new Delete(row, timestamp);

      for (ColumnValue column: proto.getColumnValueList()) {

        byte[] family = column.getFamily().toByteArray();

        for (QualifierValue qv: column.getQualifierValueList()) {

          DeleteType deleteType = qv.getDeleteType();

          byte[] qualifier = null;

          if (qv.hasQualifier()) {

            qualifier = qv.getQualifier().toByteArray();

          }

          long ts = HConstants.LATEST_TIMESTAMP;

          if (qv.hasTimestamp()) {

            ts = qv.getTimestamp();

          }

          if (deleteType == DeleteType.DELETE_ONE_VERSION) {

            delete.deleteColumn(family, qualifier, ts);

          } else if (deleteType == DeleteType.DELETE_MULTIPLE_VERSIONS) {

            delete.deleteColumns(family, qualifier, ts);

          } else if (deleteType == DeleteType.DELETE_FAMILY_VERSION) {

            delete.deleteFamilyVersion(family, ts);

          } else {

            delete.deleteFamily(family, ts);

          }

        }

      }

    }

    delete.setDurability(toDurability(proto.getDurability()));

    for (NameBytesPair attribute: proto.getAttributeList()) {

      delete.setAttribute(attribute.getName(), attribute.getValue().toByteArray());

    }

    return delete;

  }

  /**

   * Convert a protocol buffer Mutate to an Append

   * @param cellScanner

   * @param proto the protocol buffer Mutate to convert

   * @return the converted client Append

   * @throws IOException

   */

  public static Append toAppend(final MutationProto proto, final CellScanner cellScanner)

  throws IOException {

    MutationType type = proto.getMutateType();

    assert type == MutationType.APPEND : type.name();

    byte [] row = proto.hasRow()? proto.getRow().toByteArray(): null;

    Append append = null;

    int cellCount = proto.hasAssociatedCellCount()? proto.getAssociatedCellCount(): 0;

    if (cellCount > 0) {

      // The proto has metadata only and the data is separate to be found in the cellScanner.

      if (cellScanner == null) {

        throw new DoNotRetryIOException("Cell count of " + cellCount + " but no cellScanner: " +

          toShortString(proto));

      }

      for (int i = 0; i < cellCount; i++) {

        if (!cellScanner.advance()) {

          throw new DoNotRetryIOException("Cell count of " + cellCount + " but at index " + i +

            " no cell returned: " + toShortString(proto));

        }

        Cell cell = cellScanner.current();

        if (append == null) {

          append = new Append(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());

        }

        append.add(KeyValueUtil.ensureKeyValue(cell));

      }

    } else {

      append = new Append(row);

      for (ColumnValue column: proto.getColumnValueList()) {

        byte[] family = column.getFamily().toByteArray();

        for (QualifierValue qv: column.getQualifierValueList()) {

          byte[] qualifier = qv.getQualifier().toByteArray();

          if (!qv.hasValue()) {

            throw new DoNotRetryIOException(

              "Missing required field: qualifer value");

          }

          byte[] value = qv.getValue().toByteArray();

          byte[] tags = null;

          if (qv.hasTags()) {

            tags = qv.getTags().toByteArray();