Java tutorial
/* * Copyright 2014 Cask Data, Inc. * * Licensed 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 distributed 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. */ package co.cask.cdap.metrics.store.upgrade; import co.cask.cdap.common.utils.ImmutablePair; import co.cask.cdap.data2.dataset2.lib.timeseries.EntityTable; import com.google.common.base.Preconditions; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.collect.Maps; import java.util.Arrays; import java.util.EnumMap; import java.util.concurrent.TimeUnit; import java.util.regex.Pattern; /** * Class for encode/decode metric entities (context, metric and tag). */ final class MetricsEntityCodec { private static final long CACHE_EXPIRE_MINUTE = 10; private static final Pattern ENTITY_SPLITTER = Pattern.compile("\\."); private static final String[] EMPTY_STRINGS = new String[0]; private final EntityTable entityTable; private final int contextDepth; private final int metricDepth; private final int tagDepth; private final EnumMap<MetricsEntityType, LoadingCache<String, byte[]>> entityCaches; MetricsEntityCodec(EntityTable entityTable, int contextDepth, int metricDepth, int tagDepth) { this.entityTable = entityTable; this.contextDepth = contextDepth; this.metricDepth = metricDepth; this.tagDepth = tagDepth; this.entityCaches = Maps.newEnumMap(MetricsEntityType.class); for (MetricsEntityType type : MetricsEntityType.values()) { LoadingCache<String, byte[]> cache = CacheBuilder.newBuilder() .expireAfterAccess(CACHE_EXPIRE_MINUTE, TimeUnit.MINUTES).build(createCacheLoader(type)); this.entityCaches.put(type, cache); } } /** * Encodes a '.' separated entity into bytes. * @param type Type of the entity. * @param entity Value of the entity. * @return byte[] representing the given entity. */ public byte[] encode(MetricsEntityType type, String entity) { return entityCaches.get(type).getUnchecked(entity); } /** * Encodes a dot separated entity into bytes without padding. * @param type Type of the entity. * @param entity Value of the entity. * @return byte[] representing the given entity. */ public byte[] encodeWithoutPadding(MetricsEntityType type, String entity) { int idSize = entityTable.getIdSize(); String[] entityParts = entity == null ? EMPTY_STRINGS : ENTITY_SPLITTER.split(entity); byte[] result = new byte[entityParts.length * idSize]; for (int i = 0; i < entityParts.length; i++) { idToBytes(entityTable.getId(type.getType() + i, entityParts[i]), idSize, result, i * idSize); } return result; } /** * Encodes a '.' separated entity into bytes. If the entity has less than the given parts or {@code null}, * the remaining bytes would be padded by the given padding. * @param type Type of the entity. * @param entity Value of the entity. * @param padding Padding byte to apply for padding. * @return byte[] representing the given entity that may have padding at the end. */ public byte[] paddedEncode(MetricsEntityType type, String entity, int padding) { int idSize = entityTable.getIdSize(); int depth = getDepth(type); String[] entityParts = entity == null ? EMPTY_STRINGS : ENTITY_SPLITTER.split(entity, depth); byte[] result = new byte[depth * idSize]; for (int i = 0; i < entityParts.length; i++) { if (entityParts[i].isEmpty()) { throw new IllegalArgumentException("found empty part in metrics entity " + entity); } idToBytes(entityTable.getId(type.getType() + i, entityParts[i]), idSize, result, i * idSize); } Arrays.fill(result, entityParts.length * idSize, depth * idSize, (byte) (padding & 0xff)); return result; } /** * Encodes a '.' separated entity into bytes. If the entity has less than the given parts, the remaining bytes * would be padded by the given padding. Also return a fuzzy mask with byte value = 1 for the padded bytes and * 0 for non padded bytes. * * @param type Type of the entity. * @param entity Value of the entity. * @param padding Padding byte to apply for padding. * @return ImmutablePair with first byte[] representing the given entity that may have padding at the end and * second byte[] as the fuzzy mask. */ public ImmutablePair<byte[], byte[]> paddedFuzzyEncode(MetricsEntityType type, String entity, int padding) { int idSize = entityTable.getIdSize(); int depth = getDepth(type); String[] entityParts = entity == null ? EMPTY_STRINGS : ENTITY_SPLITTER.split(entity, depth); byte[] result = new byte[depth * idSize]; byte[] mask = new byte[depth * idSize]; Arrays.fill(mask, (byte) 0); for (int i = 0; i < entityParts.length; i++) { idToBytes(entityTable.getId(type.getType() + i, entityParts[i]), idSize, result, i * idSize); } Arrays.fill(result, entityParts.length * idSize, depth * idSize, (byte) (padding & 0xff)); Arrays.fill(mask, entityParts.length * idSize, depth * idSize, (byte) 1); return new ImmutablePair<>(result, mask); } public String decode(MetricsEntityType type, byte[] encoded) { return decode(type, encoded, 0); } /** * Decodes a byte[] into '.' separated entity string. */ public String decode(MetricsEntityType type, byte[] encoded, int offset) { return decode(type, encoded, offset, entityTable.getIdSize()); } /** * Decodes a byte[] into '.' separated entity string. */ public String decode(MetricsEntityType type, byte[] encoded, int offset, int idSize) { StringBuilder builder = new StringBuilder(); int length = getDepth(type); Preconditions.checkArgument(length > 0, "Too few bytes to decode."); for (int i = 0; i < length; i++) { long id = decodeId(encoded, offset + i * idSize, idSize); if (id == 0) { // It's the padding byte, break the loop. break; } builder.append(entityTable.getName(id, type.getType() + i)).append('.'); } builder.setLength(builder.length() - 1); return builder.toString(); } /** * Returns the number of bytes that the given entity type would occupy. */ public int getEncodedSize(MetricsEntityType type, int size) { return getDepth(type) * size; } /** * Creates a CacheLoader for entity name to encoded byte[]. * @param type Type of the entity. */ private CacheLoader<String, byte[]> createCacheLoader(final MetricsEntityType type) { return new CacheLoader<String, byte[]>() { @Override public byte[] load(String key) throws Exception { return paddedEncode(type, key, 0); } }; } private int getDepth(MetricsEntityType type) { switch (type) { case CONTEXT: return contextDepth; case RUN: return 1; // RunId doesn't have hierarchy case METRIC: return metricDepth; case TAG: return tagDepth; } throw new IllegalArgumentException("Unsupported entity type: " + type); } /** * Save a long id into the given byte array, assuming the given array is always big enough. */ private void idToBytes(long id, int idSize, byte[] bytes, int offset) { while (idSize != 0) { idSize--; bytes[offset + idSize] = (byte) (id & 0xff); id >>= 8; } } private long decodeId(byte[] bytes, int offset, int idSize) { long id = 0; for (int i = 0; i < idSize; i++) { id |= (bytes[offset + i] & 0xff) << ((idSize - i - 1) * 8); } return id; } }