Reformat all files in the project according to java conventions.
This commit is contained in:
Jonathan Leibiusky
@@ -8,28 +8,28 @@ public interface Hashing {
|
||||
public ThreadLocal<MessageDigest> md5Holder = new ThreadLocal<MessageDigest>();
|
||||
|
||||
public static final Hashing MD5 = new Hashing() {
|
||||
public long hash(String key) {
|
||||
return hash(SafeEncoder.encode(key));
|
||||
}
|
||||
public long hash(String key) {
|
||||
return hash(SafeEncoder.encode(key));
|
||||
}
|
||||
|
||||
public long hash(byte[] key) {
|
||||
try {
|
||||
if (md5Holder.get() == null) {
|
||||
md5Holder.set(MessageDigest.getInstance("MD5"));
|
||||
}
|
||||
} catch (NoSuchAlgorithmException e) {
|
||||
throw new IllegalStateException("++++ no md5 algorythm found");
|
||||
}
|
||||
MessageDigest md5 = md5Holder.get();
|
||||
public long hash(byte[] key) {
|
||||
try {
|
||||
if (md5Holder.get() == null) {
|
||||
md5Holder.set(MessageDigest.getInstance("MD5"));
|
||||
}
|
||||
} catch (NoSuchAlgorithmException e) {
|
||||
throw new IllegalStateException("++++ no md5 algorythm found");
|
||||
}
|
||||
MessageDigest md5 = md5Holder.get();
|
||||
|
||||
md5.reset();
|
||||
md5.update(key);
|
||||
byte[] bKey = md5.digest();
|
||||
long res = ((long) (bKey[3] & 0xFF) << 24)
|
||||
| ((long) (bKey[2] & 0xFF) << 16)
|
||||
| ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF);
|
||||
return res;
|
||||
}
|
||||
md5.reset();
|
||||
md5.update(key);
|
||||
byte[] bKey = md5.digest();
|
||||
long res = ((long) (bKey[3] & 0xFF) << 24)
|
||||
| ((long) (bKey[2] & 0xFF) << 16)
|
||||
| ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF);
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
public long hash(String key);
|
||||
|
||||
@@ -10,127 +10,127 @@ import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
public class JedisByteHashMap implements Map<byte[], byte[]>, Cloneable,
|
||||
Serializable {
|
||||
Serializable {
|
||||
private static final long serialVersionUID = -6971431362627219416L;
|
||||
private Map<ByteArrayWrapper, byte[]> internalMap = new HashMap<ByteArrayWrapper, byte[]>();
|
||||
|
||||
public void clear() {
|
||||
internalMap.clear();
|
||||
internalMap.clear();
|
||||
}
|
||||
|
||||
public boolean containsKey(Object key) {
|
||||
if (key instanceof byte[])
|
||||
return internalMap.containsKey(new ByteArrayWrapper((byte[]) key));
|
||||
return internalMap.containsKey(key);
|
||||
if (key instanceof byte[])
|
||||
return internalMap.containsKey(new ByteArrayWrapper((byte[]) key));
|
||||
return internalMap.containsKey(key);
|
||||
}
|
||||
|
||||
public boolean containsValue(Object value) {
|
||||
return internalMap.containsValue(value);
|
||||
return internalMap.containsValue(value);
|
||||
}
|
||||
|
||||
public Set<java.util.Map.Entry<byte[], byte[]>> entrySet() {
|
||||
Iterator<java.util.Map.Entry<ByteArrayWrapper, byte[]>> iterator = internalMap
|
||||
.entrySet().iterator();
|
||||
HashSet<Entry<byte[], byte[]>> hashSet = new HashSet<java.util.Map.Entry<byte[], byte[]>>();
|
||||
while (iterator.hasNext()) {
|
||||
Entry<ByteArrayWrapper, byte[]> entry = iterator.next();
|
||||
hashSet.add(new JedisByteEntry(entry.getKey().data, entry
|
||||
.getValue()));
|
||||
}
|
||||
return hashSet;
|
||||
Iterator<java.util.Map.Entry<ByteArrayWrapper, byte[]>> iterator = internalMap
|
||||
.entrySet().iterator();
|
||||
HashSet<Entry<byte[], byte[]>> hashSet = new HashSet<java.util.Map.Entry<byte[], byte[]>>();
|
||||
while (iterator.hasNext()) {
|
||||
Entry<ByteArrayWrapper, byte[]> entry = iterator.next();
|
||||
hashSet.add(new JedisByteEntry(entry.getKey().data, entry
|
||||
.getValue()));
|
||||
}
|
||||
return hashSet;
|
||||
}
|
||||
|
||||
public byte[] get(Object key) {
|
||||
if (key instanceof byte[])
|
||||
return internalMap.get(new ByteArrayWrapper((byte[]) key));
|
||||
return internalMap.get(key);
|
||||
if (key instanceof byte[])
|
||||
return internalMap.get(new ByteArrayWrapper((byte[]) key));
|
||||
return internalMap.get(key);
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return internalMap.isEmpty();
|
||||
return internalMap.isEmpty();
|
||||
}
|
||||
|
||||
public Set<byte[]> keySet() {
|
||||
Set<byte[]> keySet = new HashSet<byte[]>();
|
||||
Iterator<ByteArrayWrapper> iterator = internalMap.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
keySet.add(iterator.next().data);
|
||||
}
|
||||
return keySet;
|
||||
Set<byte[]> keySet = new HashSet<byte[]>();
|
||||
Iterator<ByteArrayWrapper> iterator = internalMap.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
keySet.add(iterator.next().data);
|
||||
}
|
||||
return keySet;
|
||||
}
|
||||
|
||||
public byte[] put(byte[] key, byte[] value) {
|
||||
return internalMap.put(new ByteArrayWrapper(key), value);
|
||||
return internalMap.put(new ByteArrayWrapper(key), value);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void putAll(Map<? extends byte[], ? extends byte[]> m) {
|
||||
Iterator<?> iterator = m.entrySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Entry<? extends byte[], ? extends byte[]> next = (Entry<? extends byte[], ? extends byte[]>) iterator
|
||||
.next();
|
||||
internalMap.put(new ByteArrayWrapper(next.getKey()), next
|
||||
.getValue());
|
||||
}
|
||||
Iterator<?> iterator = m.entrySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Entry<? extends byte[], ? extends byte[]> next = (Entry<? extends byte[], ? extends byte[]>) iterator
|
||||
.next();
|
||||
internalMap.put(new ByteArrayWrapper(next.getKey()),
|
||||
next.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] remove(Object key) {
|
||||
if (key instanceof byte[])
|
||||
return internalMap.remove(new ByteArrayWrapper((byte[]) key));
|
||||
return internalMap.remove(key);
|
||||
if (key instanceof byte[])
|
||||
return internalMap.remove(new ByteArrayWrapper((byte[]) key));
|
||||
return internalMap.remove(key);
|
||||
}
|
||||
|
||||
public int size() {
|
||||
return internalMap.size();
|
||||
return internalMap.size();
|
||||
}
|
||||
|
||||
public Collection<byte[]> values() {
|
||||
return internalMap.values();
|
||||
return internalMap.values();
|
||||
}
|
||||
|
||||
private static final class ByteArrayWrapper {
|
||||
private final byte[] data;
|
||||
private final byte[] data;
|
||||
|
||||
public ByteArrayWrapper(byte[] data) {
|
||||
if (data == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
this.data = data;
|
||||
}
|
||||
public ByteArrayWrapper(byte[] data) {
|
||||
if (data == null) {
|
||||
throw new NullPointerException();
|
||||
}
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
public boolean equals(Object other) {
|
||||
if (!(other instanceof ByteArrayWrapper)) {
|
||||
return false;
|
||||
}
|
||||
return Arrays.equals(data, ((ByteArrayWrapper) other).data);
|
||||
}
|
||||
public boolean equals(Object other) {
|
||||
if (!(other instanceof ByteArrayWrapper)) {
|
||||
return false;
|
||||
}
|
||||
return Arrays.equals(data, ((ByteArrayWrapper) other).data);
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return Arrays.hashCode(data);
|
||||
}
|
||||
public int hashCode() {
|
||||
return Arrays.hashCode(data);
|
||||
}
|
||||
}
|
||||
|
||||
private static final class JedisByteEntry implements Entry<byte[], byte[]> {
|
||||
private byte[] value;
|
||||
private byte[] key;
|
||||
private byte[] value;
|
||||
private byte[] key;
|
||||
|
||||
public JedisByteEntry(byte[] key, byte[] value) {
|
||||
this.key = key;
|
||||
this.value = value;
|
||||
}
|
||||
public JedisByteEntry(byte[] key, byte[] value) {
|
||||
this.key = key;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public byte[] getKey() {
|
||||
return this.key;
|
||||
}
|
||||
public byte[] getKey() {
|
||||
return this.key;
|
||||
}
|
||||
|
||||
public byte[] getValue() {
|
||||
return this.value;
|
||||
}
|
||||
public byte[] getValue() {
|
||||
return this.value;
|
||||
}
|
||||
|
||||
public byte[] setValue(byte[] value) {
|
||||
this.value = value;
|
||||
return value;
|
||||
}
|
||||
public byte[] setValue(byte[] value) {
|
||||
this.value = value;
|
||||
return value;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,21 +1,23 @@
|
||||
package redis.clients.util;
|
||||
|
||||
public class JedisClusterCRC16 {
|
||||
public final static int polynomial = 0x1021; // Represents x^16+x^12+x^5+1
|
||||
static int crc;
|
||||
|
||||
public static int getSlot(String key) {
|
||||
crc = 0x0000;
|
||||
for (byte b : key.getBytes()) {
|
||||
for (int i = 0; i < 8; i++) {
|
||||
boolean bit = ((b >> (7-i) & 1) == 1);
|
||||
boolean c15 = ((crc >> 15 & 1) == 1);
|
||||
crc <<= 1;
|
||||
// If coefficient of bit and remainder polynomial = 1 xor crc with polynomial
|
||||
if (c15 ^ bit) crc ^= polynomial;
|
||||
}
|
||||
}
|
||||
public final static int polynomial = 0x1021; // Represents x^16+x^12+x^5+1
|
||||
static int crc;
|
||||
|
||||
return crc &= 0xffff % 16384;
|
||||
}
|
||||
public static int getSlot(String key) {
|
||||
crc = 0x0000;
|
||||
for (byte b : key.getBytes()) {
|
||||
for (int i = 0; i < 8; i++) {
|
||||
boolean bit = ((b >> (7 - i) & 1) == 1);
|
||||
boolean c15 = ((crc >> 15 & 1) == 1);
|
||||
crc <<= 1;
|
||||
// If coefficient of bit and remainder polynomial = 1 xor crc
|
||||
// with polynomial
|
||||
if (c15 ^ bit)
|
||||
crc ^= polynomial;
|
||||
}
|
||||
}
|
||||
|
||||
return crc &= 0xffff % 16384;
|
||||
}
|
||||
}
|
||||
@@ -40,7 +40,7 @@ public class MurmurHash implements Hashing {
|
||||
* @return The 32 bit hash of the bytes in question.
|
||||
*/
|
||||
public static int hash(byte[] data, int seed) {
|
||||
return hash(ByteBuffer.wrap(data), seed);
|
||||
return hash(ByteBuffer.wrap(data), seed);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -57,7 +57,7 @@ public class MurmurHash implements Hashing {
|
||||
* @return The 32-bit hash of the data in question.
|
||||
*/
|
||||
public static int hash(byte[] data, int offset, int length, int seed) {
|
||||
return hash(ByteBuffer.wrap(data, offset, length), seed);
|
||||
return hash(ByteBuffer.wrap(data, offset, length), seed);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -70,97 +70,97 @@ public class MurmurHash implements Hashing {
|
||||
* @return The 32 bit murmur hash of the bytes in the buffer.
|
||||
*/
|
||||
public static int hash(ByteBuffer buf, int seed) {
|
||||
// save byte order for later restoration
|
||||
ByteOrder byteOrder = buf.order();
|
||||
buf.order(ByteOrder.LITTLE_ENDIAN);
|
||||
// save byte order for later restoration
|
||||
ByteOrder byteOrder = buf.order();
|
||||
buf.order(ByteOrder.LITTLE_ENDIAN);
|
||||
|
||||
int m = 0x5bd1e995;
|
||||
int r = 24;
|
||||
int m = 0x5bd1e995;
|
||||
int r = 24;
|
||||
|
||||
int h = seed ^ buf.remaining();
|
||||
int h = seed ^ buf.remaining();
|
||||
|
||||
int k;
|
||||
while (buf.remaining() >= 4) {
|
||||
k = buf.getInt();
|
||||
int k;
|
||||
while (buf.remaining() >= 4) {
|
||||
k = buf.getInt();
|
||||
|
||||
k *= m;
|
||||
k ^= k >>> r;
|
||||
k *= m;
|
||||
k *= m;
|
||||
k ^= k >>> r;
|
||||
k *= m;
|
||||
|
||||
h *= m;
|
||||
h ^= k;
|
||||
}
|
||||
h *= m;
|
||||
h ^= k;
|
||||
}
|
||||
|
||||
if (buf.remaining() > 0) {
|
||||
ByteBuffer finish = ByteBuffer.allocate(4).order(
|
||||
ByteOrder.LITTLE_ENDIAN);
|
||||
// for big-endian version, use this first:
|
||||
// finish.position(4-buf.remaining());
|
||||
finish.put(buf).rewind();
|
||||
h ^= finish.getInt();
|
||||
h *= m;
|
||||
}
|
||||
if (buf.remaining() > 0) {
|
||||
ByteBuffer finish = ByteBuffer.allocate(4).order(
|
||||
ByteOrder.LITTLE_ENDIAN);
|
||||
// for big-endian version, use this first:
|
||||
// finish.position(4-buf.remaining());
|
||||
finish.put(buf).rewind();
|
||||
h ^= finish.getInt();
|
||||
h *= m;
|
||||
}
|
||||
|
||||
h ^= h >>> 13;
|
||||
h *= m;
|
||||
h ^= h >>> 15;
|
||||
h ^= h >>> 13;
|
||||
h *= m;
|
||||
h ^= h >>> 15;
|
||||
|
||||
buf.order(byteOrder);
|
||||
return h;
|
||||
buf.order(byteOrder);
|
||||
return h;
|
||||
}
|
||||
|
||||
public static long hash64A(byte[] data, int seed) {
|
||||
return hash64A(ByteBuffer.wrap(data), seed);
|
||||
return hash64A(ByteBuffer.wrap(data), seed);
|
||||
}
|
||||
|
||||
public static long hash64A(byte[] data, int offset, int length, int seed) {
|
||||
return hash64A(ByteBuffer.wrap(data, offset, length), seed);
|
||||
return hash64A(ByteBuffer.wrap(data, offset, length), seed);
|
||||
}
|
||||
|
||||
public static long hash64A(ByteBuffer buf, int seed) {
|
||||
ByteOrder byteOrder = buf.order();
|
||||
buf.order(ByteOrder.LITTLE_ENDIAN);
|
||||
ByteOrder byteOrder = buf.order();
|
||||
buf.order(ByteOrder.LITTLE_ENDIAN);
|
||||
|
||||
long m = 0xc6a4a7935bd1e995L;
|
||||
int r = 47;
|
||||
long m = 0xc6a4a7935bd1e995L;
|
||||
int r = 47;
|
||||
|
||||
long h = seed ^ (buf.remaining() * m);
|
||||
long h = seed ^ (buf.remaining() * m);
|
||||
|
||||
long k;
|
||||
while (buf.remaining() >= 8) {
|
||||
k = buf.getLong();
|
||||
long k;
|
||||
while (buf.remaining() >= 8) {
|
||||
k = buf.getLong();
|
||||
|
||||
k *= m;
|
||||
k ^= k >>> r;
|
||||
k *= m;
|
||||
k *= m;
|
||||
k ^= k >>> r;
|
||||
k *= m;
|
||||
|
||||
h ^= k;
|
||||
h *= m;
|
||||
}
|
||||
h ^= k;
|
||||
h *= m;
|
||||
}
|
||||
|
||||
if (buf.remaining() > 0) {
|
||||
ByteBuffer finish = ByteBuffer.allocate(8).order(
|
||||
ByteOrder.LITTLE_ENDIAN);
|
||||
// for big-endian version, do this first:
|
||||
// finish.position(8-buf.remaining());
|
||||
finish.put(buf).rewind();
|
||||
h ^= finish.getLong();
|
||||
h *= m;
|
||||
}
|
||||
if (buf.remaining() > 0) {
|
||||
ByteBuffer finish = ByteBuffer.allocate(8).order(
|
||||
ByteOrder.LITTLE_ENDIAN);
|
||||
// for big-endian version, do this first:
|
||||
// finish.position(8-buf.remaining());
|
||||
finish.put(buf).rewind();
|
||||
h ^= finish.getLong();
|
||||
h *= m;
|
||||
}
|
||||
|
||||
h ^= h >>> r;
|
||||
h *= m;
|
||||
h ^= h >>> r;
|
||||
h ^= h >>> r;
|
||||
h *= m;
|
||||
h ^= h >>> r;
|
||||
|
||||
buf.order(byteOrder);
|
||||
return h;
|
||||
buf.order(byteOrder);
|
||||
return h;
|
||||
}
|
||||
|
||||
public long hash(byte[] key) {
|
||||
return hash64A(key, 0x1234ABCD);
|
||||
return hash64A(key, 0x1234ABCD);
|
||||
}
|
||||
|
||||
public long hash(String key) {
|
||||
return hash(SafeEncoder.encode(key));
|
||||
return hash(SafeEncoder.encode(key));
|
||||
}
|
||||
}
|
||||
@@ -29,84 +29,84 @@ public class RedisInputStream extends FilterInputStream {
|
||||
protected int count, limit;
|
||||
|
||||
public RedisInputStream(InputStream in, int size) {
|
||||
super(in);
|
||||
if (size <= 0) {
|
||||
throw new IllegalArgumentException("Buffer size <= 0");
|
||||
}
|
||||
buf = new byte[size];
|
||||
super(in);
|
||||
if (size <= 0) {
|
||||
throw new IllegalArgumentException("Buffer size <= 0");
|
||||
}
|
||||
buf = new byte[size];
|
||||
}
|
||||
|
||||
public RedisInputStream(InputStream in) {
|
||||
this(in, 8192);
|
||||
this(in, 8192);
|
||||
}
|
||||
|
||||
public byte readByte() throws IOException {
|
||||
if (count == limit) {
|
||||
fill();
|
||||
}
|
||||
if (count == limit) {
|
||||
fill();
|
||||
}
|
||||
|
||||
return buf[count++];
|
||||
return buf[count++];
|
||||
}
|
||||
|
||||
public String readLine() {
|
||||
int b;
|
||||
byte c;
|
||||
StringBuilder sb = new StringBuilder();
|
||||
int b;
|
||||
byte c;
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
try {
|
||||
while (true) {
|
||||
if (count == limit) {
|
||||
fill();
|
||||
}
|
||||
if (limit == -1)
|
||||
break;
|
||||
try {
|
||||
while (true) {
|
||||
if (count == limit) {
|
||||
fill();
|
||||
}
|
||||
if (limit == -1)
|
||||
break;
|
||||
|
||||
b = buf[count++];
|
||||
if (b == '\r') {
|
||||
if (count == limit) {
|
||||
fill();
|
||||
}
|
||||
b = buf[count++];
|
||||
if (b == '\r') {
|
||||
if (count == limit) {
|
||||
fill();
|
||||
}
|
||||
|
||||
if (limit == -1) {
|
||||
sb.append((char) b);
|
||||
break;
|
||||
}
|
||||
if (limit == -1) {
|
||||
sb.append((char) b);
|
||||
break;
|
||||
}
|
||||
|
||||
c = buf[count++];
|
||||
if (c == '\n') {
|
||||
break;
|
||||
}
|
||||
sb.append((char) b);
|
||||
sb.append((char) c);
|
||||
} else {
|
||||
sb.append((char) b);
|
||||
}
|
||||
}
|
||||
} catch (IOException e) {
|
||||
throw new JedisConnectionException(e);
|
||||
}
|
||||
String reply = sb.toString();
|
||||
if (reply.length() == 0) {
|
||||
throw new JedisConnectionException(
|
||||
"It seems like server has closed the connection.");
|
||||
}
|
||||
return reply;
|
||||
c = buf[count++];
|
||||
if (c == '\n') {
|
||||
break;
|
||||
}
|
||||
sb.append((char) b);
|
||||
sb.append((char) c);
|
||||
} else {
|
||||
sb.append((char) b);
|
||||
}
|
||||
}
|
||||
} catch (IOException e) {
|
||||
throw new JedisConnectionException(e);
|
||||
}
|
||||
String reply = sb.toString();
|
||||
if (reply.length() == 0) {
|
||||
throw new JedisConnectionException(
|
||||
"It seems like server has closed the connection.");
|
||||
}
|
||||
return reply;
|
||||
}
|
||||
|
||||
public int read(byte[] b, int off, int len) throws IOException {
|
||||
if (count == limit) {
|
||||
fill();
|
||||
if (limit == -1)
|
||||
return -1;
|
||||
}
|
||||
final int length = Math.min(limit - count, len);
|
||||
System.arraycopy(buf, count, b, off, length);
|
||||
count += length;
|
||||
return length;
|
||||
if (count == limit) {
|
||||
fill();
|
||||
if (limit == -1)
|
||||
return -1;
|
||||
}
|
||||
final int length = Math.min(limit - count, len);
|
||||
System.arraycopy(buf, count, b, off, length);
|
||||
count += length;
|
||||
return length;
|
||||
}
|
||||
|
||||
private void fill() throws IOException {
|
||||
limit = in.read(buf);
|
||||
count = 0;
|
||||
limit = in.read(buf);
|
||||
count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,11 +1,13 @@
|
||||
package redis.clients.util;
|
||||
|
||||
import java.io.*;
|
||||
import java.io.FilterOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
|
||||
/**
|
||||
* The class implements a buffered output stream without synchronization
|
||||
* There are also special operations like in-place string encoding.
|
||||
* This stream fully ignore mark/reset and should not be used outside Jedis
|
||||
* The class implements a buffered output stream without synchronization There
|
||||
* are also special operations like in-place string encoding. This stream fully
|
||||
* ignore mark/reset and should not be used outside Jedis
|
||||
*/
|
||||
public final class RedisOutputStream extends FilterOutputStream {
|
||||
protected final byte buf[];
|
||||
@@ -13,218 +15,212 @@ public final class RedisOutputStream extends FilterOutputStream {
|
||||
protected int count;
|
||||
|
||||
public RedisOutputStream(final OutputStream out) {
|
||||
this(out, 8192);
|
||||
this(out, 8192);
|
||||
}
|
||||
|
||||
public RedisOutputStream(final OutputStream out, final int size) {
|
||||
super(out);
|
||||
if (size <= 0) {
|
||||
throw new IllegalArgumentException("Buffer size <= 0");
|
||||
}
|
||||
buf = new byte[size];
|
||||
super(out);
|
||||
if (size <= 0) {
|
||||
throw new IllegalArgumentException("Buffer size <= 0");
|
||||
}
|
||||
buf = new byte[size];
|
||||
}
|
||||
|
||||
private void flushBuffer() throws IOException {
|
||||
if (count > 0) {
|
||||
out.write(buf, 0, count);
|
||||
count = 0;
|
||||
}
|
||||
if (count > 0) {
|
||||
out.write(buf, 0, count);
|
||||
count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
public void write(final byte b) throws IOException {
|
||||
buf[count++] = b;
|
||||
if (count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
buf[count++] = b;
|
||||
if (count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public void write(final byte[] b) throws IOException {
|
||||
write(b, 0, b.length);
|
||||
write(b, 0, b.length);
|
||||
}
|
||||
|
||||
public void write(final byte b[], final int off, final int len) throws IOException {
|
||||
if (len >= buf.length) {
|
||||
flushBuffer();
|
||||
out.write(b, off, len);
|
||||
} else {
|
||||
if (len >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
public void write(final byte b[], final int off, final int len)
|
||||
throws IOException {
|
||||
if (len >= buf.length) {
|
||||
flushBuffer();
|
||||
out.write(b, off, len);
|
||||
} else {
|
||||
if (len >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
|
||||
System.arraycopy(b, off, buf, count, len);
|
||||
count += len;
|
||||
}
|
||||
System.arraycopy(b, off, buf, count, len);
|
||||
count += len;
|
||||
}
|
||||
}
|
||||
|
||||
public void writeAsciiCrLf(final String in) throws IOException {
|
||||
final int size = in.length();
|
||||
final int size = in.length();
|
||||
|
||||
for (int i = 0; i != size; ++i) {
|
||||
buf[count++] = (byte) in.charAt(i);
|
||||
if (count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
}
|
||||
for (int i = 0; i != size; ++i) {
|
||||
buf[count++] = (byte) in.charAt(i);
|
||||
if (count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
writeCrLf();
|
||||
writeCrLf();
|
||||
}
|
||||
|
||||
public static boolean isSurrogate(final char ch) {
|
||||
return ch >= Character.MIN_SURROGATE && ch <= Character.MAX_SURROGATE;
|
||||
return ch >= Character.MIN_SURROGATE && ch <= Character.MAX_SURROGATE;
|
||||
}
|
||||
|
||||
public static int utf8Length (final String str) {
|
||||
int strLen = str.length(), utfLen = 0;
|
||||
for(int i = 0; i != strLen; ++i) {
|
||||
char c = str.charAt(i);
|
||||
if (c < 0x80) {
|
||||
utfLen++;
|
||||
} else if (c < 0x800) {
|
||||
utfLen += 2;
|
||||
} else if (isSurrogate(c)) {
|
||||
i++;
|
||||
utfLen += 4;
|
||||
} else {
|
||||
utfLen += 3;
|
||||
}
|
||||
}
|
||||
return utfLen;
|
||||
public static int utf8Length(final String str) {
|
||||
int strLen = str.length(), utfLen = 0;
|
||||
for (int i = 0; i != strLen; ++i) {
|
||||
char c = str.charAt(i);
|
||||
if (c < 0x80) {
|
||||
utfLen++;
|
||||
} else if (c < 0x800) {
|
||||
utfLen += 2;
|
||||
} else if (isSurrogate(c)) {
|
||||
i++;
|
||||
utfLen += 4;
|
||||
} else {
|
||||
utfLen += 3;
|
||||
}
|
||||
}
|
||||
return utfLen;
|
||||
}
|
||||
|
||||
public void writeCrLf() throws IOException {
|
||||
if (2 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
if (2 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
|
||||
buf[count++] = '\r';
|
||||
buf[count++] = '\n';
|
||||
buf[count++] = '\r';
|
||||
buf[count++] = '\n';
|
||||
}
|
||||
|
||||
public void writeUtf8CrLf(final String str) throws IOException {
|
||||
int strLen = str.length();
|
||||
int strLen = str.length();
|
||||
|
||||
int i;
|
||||
for (i = 0; i < strLen; i++) {
|
||||
char c = str.charAt(i);
|
||||
if (!(c < 0x80)) break;
|
||||
buf[count++] = (byte) c;
|
||||
if(count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
}
|
||||
int i;
|
||||
for (i = 0; i < strLen; i++) {
|
||||
char c = str.charAt(i);
|
||||
if (!(c < 0x80))
|
||||
break;
|
||||
buf[count++] = (byte) c;
|
||||
if (count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
for (; i < strLen; i++) {
|
||||
char c = str.charAt(i);
|
||||
if (c < 0x80) {
|
||||
buf[count++] = (byte) c;
|
||||
if(count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
} else if (c < 0x800) {
|
||||
if(2 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
buf[count++] = (byte)(0xc0 | (c >> 6));
|
||||
buf[count++] = (byte)(0x80 | (c & 0x3f));
|
||||
} else if (isSurrogate(c)) {
|
||||
if(4 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
int uc = Character.toCodePoint(c, str.charAt(i++));
|
||||
buf[count++] = ((byte)(0xf0 | ((uc >> 18))));
|
||||
buf[count++] = ((byte)(0x80 | ((uc >> 12) & 0x3f)));
|
||||
buf[count++] = ((byte)(0x80 | ((uc >> 6) & 0x3f)));
|
||||
buf[count++] = ((byte)(0x80 | (uc & 0x3f)));
|
||||
} else {
|
||||
if(3 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
buf[count++] =((byte)(0xe0 | ((c >> 12))));
|
||||
buf[count++] =((byte)(0x80 | ((c >> 6) & 0x3f)));
|
||||
buf[count++] =((byte)(0x80 | (c & 0x3f)));
|
||||
}
|
||||
}
|
||||
for (; i < strLen; i++) {
|
||||
char c = str.charAt(i);
|
||||
if (c < 0x80) {
|
||||
buf[count++] = (byte) c;
|
||||
if (count == buf.length) {
|
||||
flushBuffer();
|
||||
}
|
||||
} else if (c < 0x800) {
|
||||
if (2 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
buf[count++] = (byte) (0xc0 | (c >> 6));
|
||||
buf[count++] = (byte) (0x80 | (c & 0x3f));
|
||||
} else if (isSurrogate(c)) {
|
||||
if (4 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
int uc = Character.toCodePoint(c, str.charAt(i++));
|
||||
buf[count++] = ((byte) (0xf0 | ((uc >> 18))));
|
||||
buf[count++] = ((byte) (0x80 | ((uc >> 12) & 0x3f)));
|
||||
buf[count++] = ((byte) (0x80 | ((uc >> 6) & 0x3f)));
|
||||
buf[count++] = ((byte) (0x80 | (uc & 0x3f)));
|
||||
} else {
|
||||
if (3 >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
buf[count++] = ((byte) (0xe0 | ((c >> 12))));
|
||||
buf[count++] = ((byte) (0x80 | ((c >> 6) & 0x3f)));
|
||||
buf[count++] = ((byte) (0x80 | (c & 0x3f)));
|
||||
}
|
||||
}
|
||||
|
||||
writeCrLf();
|
||||
writeCrLf();
|
||||
}
|
||||
|
||||
private final static int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE};
|
||||
private final static int[] sizeTable = { 9, 99, 999, 9999, 99999, 999999,
|
||||
9999999, 99999999, 999999999, Integer.MAX_VALUE };
|
||||
|
||||
private final static byte[] DigitTens = {
|
||||
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
|
||||
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
|
||||
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
|
||||
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
|
||||
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
|
||||
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
|
||||
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
|
||||
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
|
||||
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
|
||||
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
|
||||
};
|
||||
private final static byte[] DigitTens = { '0', '0', '0', '0', '0', '0',
|
||||
'0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1',
|
||||
'1', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '3', '3',
|
||||
'3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4',
|
||||
'4', '4', '4', '4', '4', '5', '5', '5', '5', '5', '5', '5', '5',
|
||||
'5', '5', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7',
|
||||
'7', '7', '7', '7', '7', '7', '7', '7', '7', '8', '8', '8', '8',
|
||||
'8', '8', '8', '8', '8', '8', '9', '9', '9', '9', '9', '9', '9',
|
||||
'9', '9', '9', };
|
||||
|
||||
private final static byte[] DigitOnes = {
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
};
|
||||
private final static byte[] DigitOnes = { '0', '1', '2', '3', '4', '5',
|
||||
'6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8',
|
||||
'9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
|
||||
'2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4',
|
||||
'5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7',
|
||||
'8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
|
||||
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3',
|
||||
'4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6',
|
||||
'7', '8', '9', };
|
||||
|
||||
private final static byte[] digits = {
|
||||
'0', '1', '2', '3', '4', '5',
|
||||
'6', '7', '8', '9', 'a', 'b',
|
||||
'c', 'd', 'e', 'f', 'g', 'h',
|
||||
'i', 'j', 'k', 'l', 'm', 'n',
|
||||
'o', 'p', 'q', 'r', 's', 't',
|
||||
'u', 'v', 'w', 'x', 'y', 'z'
|
||||
};
|
||||
private final static byte[] digits = { '0', '1', '2', '3', '4', '5', '6',
|
||||
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
|
||||
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
|
||||
'x', 'y', 'z' };
|
||||
|
||||
public void writeIntCrLf(int value) throws IOException {
|
||||
if (value < 0) {
|
||||
write((byte)'-');
|
||||
value = -value;
|
||||
}
|
||||
if (value < 0) {
|
||||
write((byte) '-');
|
||||
value = -value;
|
||||
}
|
||||
|
||||
int size = 0;
|
||||
while (value > sizeTable[size])
|
||||
size++;
|
||||
int size = 0;
|
||||
while (value > sizeTable[size])
|
||||
size++;
|
||||
|
||||
size++;
|
||||
if (size >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
size++;
|
||||
if (size >= buf.length - count) {
|
||||
flushBuffer();
|
||||
}
|
||||
|
||||
int q, r;
|
||||
int charPos = count + size;
|
||||
int q, r;
|
||||
int charPos = count + size;
|
||||
|
||||
while (value >= 65536) {
|
||||
q = value / 100;
|
||||
r = value - ((q << 6) + (q << 5) + (q << 2));
|
||||
value = q;
|
||||
buf[--charPos] = DigitOnes[r];
|
||||
buf[--charPos] = DigitTens[r];
|
||||
}
|
||||
while (value >= 65536) {
|
||||
q = value / 100;
|
||||
r = value - ((q << 6) + (q << 5) + (q << 2));
|
||||
value = q;
|
||||
buf[--charPos] = DigitOnes[r];
|
||||
buf[--charPos] = DigitTens[r];
|
||||
}
|
||||
|
||||
for (; ;) {
|
||||
q = (value * 52429) >>> (16 + 3);
|
||||
r = value - ((q << 3) + (q << 1));
|
||||
buf[--charPos] = digits[r];
|
||||
value = q;
|
||||
if (value == 0) break;
|
||||
}
|
||||
count += size;
|
||||
for (;;) {
|
||||
q = (value * 52429) >>> (16 + 3);
|
||||
r = value - ((q << 3) + (q << 1));
|
||||
buf[--charPos] = digits[r];
|
||||
value = q;
|
||||
if (value == 0)
|
||||
break;
|
||||
}
|
||||
count += size;
|
||||
|
||||
writeCrLf();
|
||||
writeCrLf();
|
||||
}
|
||||
|
||||
public void flush() throws IOException {
|
||||
flushBuffer();
|
||||
out.flush();
|
||||
flushBuffer();
|
||||
out.flush();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,31 +11,31 @@ import redis.clients.jedis.exceptions.JedisException;
|
||||
*
|
||||
*/
|
||||
public class SafeEncoder {
|
||||
public static byte[][] encodeMany(final String... strs){
|
||||
byte[][] many = new byte[strs.length][];
|
||||
for(int i=0;i<strs.length;i++){
|
||||
many[i] = encode(strs[i]);
|
||||
}
|
||||
return many;
|
||||
public static byte[][] encodeMany(final String... strs) {
|
||||
byte[][] many = new byte[strs.length][];
|
||||
for (int i = 0; i < strs.length; i++) {
|
||||
many[i] = encode(strs[i]);
|
||||
}
|
||||
|
||||
return many;
|
||||
}
|
||||
|
||||
public static byte[] encode(final String str) {
|
||||
try {
|
||||
if (str == null) {
|
||||
throw new JedisDataException(
|
||||
"value sent to redis cannot be null");
|
||||
}
|
||||
return str.getBytes(Protocol.CHARSET);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
throw new JedisException(e);
|
||||
}
|
||||
try {
|
||||
if (str == null) {
|
||||
throw new JedisDataException(
|
||||
"value sent to redis cannot be null");
|
||||
}
|
||||
return str.getBytes(Protocol.CHARSET);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
throw new JedisException(e);
|
||||
}
|
||||
}
|
||||
|
||||
public static String encode(final byte[] data) {
|
||||
try {
|
||||
return new String(data, Protocol.CHARSET);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
throw new JedisException(e);
|
||||
}
|
||||
try {
|
||||
return new String(data, Protocol.CHARSET);
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
throw new JedisException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,14 +7,14 @@ public abstract class ShardInfo<T> {
|
||||
}
|
||||
|
||||
public ShardInfo(int weight) {
|
||||
this.weight = weight;
|
||||
this.weight = weight;
|
||||
}
|
||||
|
||||
public int getWeight() {
|
||||
return this.weight;
|
||||
return this.weight;
|
||||
}
|
||||
|
||||
protected abstract T createResource();
|
||||
|
||||
|
||||
public abstract String getName();
|
||||
}
|
||||
|
||||
@@ -26,91 +26,93 @@ public class Sharded<R, S extends ShardInfo<R>> {
|
||||
private Pattern tagPattern = null;
|
||||
// the tag is anything between {}
|
||||
public static final Pattern DEFAULT_KEY_TAG_PATTERN = Pattern
|
||||
.compile("\\{(.+?)\\}");
|
||||
.compile("\\{(.+?)\\}");
|
||||
|
||||
public Sharded(List<S> shards) {
|
||||
this(shards, Hashing.MURMUR_HASH); // MD5 is really not good as we works
|
||||
// with 64-bits not 128
|
||||
this(shards, Hashing.MURMUR_HASH); // MD5 is really not good as we works
|
||||
// with 64-bits not 128
|
||||
}
|
||||
|
||||
public Sharded(List<S> shards, Hashing algo) {
|
||||
this.algo = algo;
|
||||
initialize(shards);
|
||||
this.algo = algo;
|
||||
initialize(shards);
|
||||
}
|
||||
|
||||
public Sharded(List<S> shards, Pattern tagPattern) {
|
||||
this(shards, Hashing.MURMUR_HASH, tagPattern); // MD5 is really not good
|
||||
// as we works with
|
||||
// 64-bits not 128
|
||||
this(shards, Hashing.MURMUR_HASH, tagPattern); // MD5 is really not good
|
||||
// as we works with
|
||||
// 64-bits not 128
|
||||
}
|
||||
|
||||
public Sharded(List<S> shards, Hashing algo, Pattern tagPattern) {
|
||||
this.algo = algo;
|
||||
this.tagPattern = tagPattern;
|
||||
initialize(shards);
|
||||
this.algo = algo;
|
||||
this.tagPattern = tagPattern;
|
||||
initialize(shards);
|
||||
}
|
||||
|
||||
private void initialize(List<S> shards) {
|
||||
nodes = new TreeMap<Long, S>();
|
||||
nodes = new TreeMap<Long, S>();
|
||||
|
||||
for (int i = 0; i != shards.size(); ++i) {
|
||||
final S shardInfo = shards.get(i);
|
||||
if (shardInfo.getName() == null)
|
||||
for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {
|
||||
nodes.put(this.algo.hash("SHARD-" + i + "-NODE-" + n), shardInfo);
|
||||
}
|
||||
else
|
||||
for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {
|
||||
nodes.put(this.algo.hash(shardInfo.getName() + "*" + shardInfo.getWeight() + n), shardInfo);
|
||||
}
|
||||
resources.put(shardInfo, shardInfo.createResource());
|
||||
}
|
||||
for (int i = 0; i != shards.size(); ++i) {
|
||||
final S shardInfo = shards.get(i);
|
||||
if (shardInfo.getName() == null)
|
||||
for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {
|
||||
nodes.put(this.algo.hash("SHARD-" + i + "-NODE-" + n),
|
||||
shardInfo);
|
||||
}
|
||||
else
|
||||
for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {
|
||||
nodes.put(
|
||||
this.algo.hash(shardInfo.getName() + "*"
|
||||
+ shardInfo.getWeight() + n), shardInfo);
|
||||
}
|
||||
resources.put(shardInfo, shardInfo.createResource());
|
||||
}
|
||||
}
|
||||
|
||||
public R getShard(byte[] key) {
|
||||
return resources.get(getShardInfo(key));
|
||||
return resources.get(getShardInfo(key));
|
||||
}
|
||||
|
||||
public R getShard(String key) {
|
||||
return resources.get(getShardInfo(key));
|
||||
return resources.get(getShardInfo(key));
|
||||
}
|
||||
|
||||
public S getShardInfo(byte[] key) {
|
||||
SortedMap<Long, S> tail = nodes.tailMap(algo.hash(key));
|
||||
if (tail.isEmpty()) {
|
||||
return nodes.get(nodes.firstKey());
|
||||
}
|
||||
return tail.get(tail.firstKey());
|
||||
SortedMap<Long, S> tail = nodes.tailMap(algo.hash(key));
|
||||
if (tail.isEmpty()) {
|
||||
return nodes.get(nodes.firstKey());
|
||||
}
|
||||
return tail.get(tail.firstKey());
|
||||
}
|
||||
|
||||
public S getShardInfo(String key) {
|
||||
return getShardInfo(SafeEncoder.encode(getKeyTag(key)));
|
||||
return getShardInfo(SafeEncoder.encode(getKeyTag(key)));
|
||||
}
|
||||
|
||||
/**
|
||||
* A key tag is a special pattern inside a key that, if preset, is the only
|
||||
* part of the key hashed in order to select the server for this key.
|
||||
*
|
||||
*
|
||||
* @see http://code.google.com/p/redis/wiki/FAQ#I
|
||||
* 'm_using_some_form_of_key_hashing_for_partitioning,_but_wh
|
||||
* @param key
|
||||
* @return The tag if it exists, or the original key
|
||||
*/
|
||||
public String getKeyTag(String key) {
|
||||
if (tagPattern != null) {
|
||||
Matcher m = tagPattern.matcher(key);
|
||||
if (m.find())
|
||||
return m.group(1);
|
||||
}
|
||||
return key;
|
||||
if (tagPattern != null) {
|
||||
Matcher m = tagPattern.matcher(key);
|
||||
if (m.find())
|
||||
return m.group(1);
|
||||
}
|
||||
return key;
|
||||
}
|
||||
|
||||
public Collection<S> getAllShardInfo() {
|
||||
return Collections.unmodifiableCollection(nodes.values());
|
||||
return Collections.unmodifiableCollection(nodes.values());
|
||||
}
|
||||
|
||||
public Collection<R> getAllShards() {
|
||||
return Collections.unmodifiableCollection(resources.values());
|
||||
return Collections.unmodifiableCollection(resources.values());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -4,50 +4,50 @@ import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class Slowlog {
|
||||
private final long id;
|
||||
private final long timeStamp;
|
||||
private final long executionTime;
|
||||
private final List<String> args;
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public static List<Slowlog> from(List<Object> nestedMultiBulkReply){
|
||||
List<Slowlog> logs = new ArrayList<Slowlog>(nestedMultiBulkReply.size());
|
||||
for(Object obj : nestedMultiBulkReply){
|
||||
List<Object> properties = (List<Object>)obj;
|
||||
logs.add(new Slowlog(properties));
|
||||
}
|
||||
|
||||
return logs;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private Slowlog(List<Object> properties) {
|
||||
super();
|
||||
this.id = (Long)properties.get(0);
|
||||
this.timeStamp = (Long)properties.get(1);
|
||||
this.executionTime = (Long)properties.get(2);
|
||||
|
||||
List<byte[]> bargs = (List<byte[]>)properties.get(3);
|
||||
this.args = new ArrayList<String>(bargs.size());
|
||||
|
||||
for(byte[] barg:bargs){
|
||||
this.args.add(SafeEncoder.encode(barg));
|
||||
}
|
||||
private final long id;
|
||||
private final long timeStamp;
|
||||
private final long executionTime;
|
||||
private final List<String> args;
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public static List<Slowlog> from(List<Object> nestedMultiBulkReply) {
|
||||
List<Slowlog> logs = new ArrayList<Slowlog>(nestedMultiBulkReply.size());
|
||||
for (Object obj : nestedMultiBulkReply) {
|
||||
List<Object> properties = (List<Object>) obj;
|
||||
logs.add(new Slowlog(properties));
|
||||
}
|
||||
|
||||
public long getId() {
|
||||
return id;
|
||||
}
|
||||
return logs;
|
||||
}
|
||||
|
||||
public long getTimeStamp() {
|
||||
return timeStamp;
|
||||
}
|
||||
@SuppressWarnings("unchecked")
|
||||
private Slowlog(List<Object> properties) {
|
||||
super();
|
||||
this.id = (Long) properties.get(0);
|
||||
this.timeStamp = (Long) properties.get(1);
|
||||
this.executionTime = (Long) properties.get(2);
|
||||
|
||||
public long getExecutionTime() {
|
||||
return executionTime;
|
||||
}
|
||||
List<byte[]> bargs = (List<byte[]>) properties.get(3);
|
||||
this.args = new ArrayList<String>(bargs.size());
|
||||
|
||||
public List<String> getArgs() {
|
||||
return args;
|
||||
for (byte[] barg : bargs) {
|
||||
this.args.add(SafeEncoder.encode(barg));
|
||||
}
|
||||
}
|
||||
|
||||
public long getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public long getTimeStamp() {
|
||||
return timeStamp;
|
||||
}
|
||||
|
||||
public long getExecutionTime() {
|
||||
return executionTime;
|
||||
}
|
||||
|
||||
public List<String> getArgs() {
|
||||
return args;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user