org.apache.cassandra.dht.OrderPreservingPartitioner Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-all Show documentation
Show all versions of cassandra-all Show documentation
The Apache Cassandra Project develops a highly scalable second-generation distributed database, bringing together Dynamo's fully distributed design and Bigtable's ColumnFamily-based data model.
/*
* 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 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 org.apache.cassandra.dht;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.cassandra.db.DecoratedKey;
import org.apache.cassandra.db.CachedHashDecoratedKey;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.db.marshal.UTF8Type;
import org.apache.cassandra.exceptions.ConfigurationException;
import org.apache.cassandra.gms.VersionedValue;
import org.apache.cassandra.schema.Schema;
import org.apache.cassandra.schema.TableMetadata;
import org.apache.cassandra.service.StorageService;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.bytecomparable.ByteComparable;
import org.apache.cassandra.utils.bytecomparable.ByteSource;
import org.apache.cassandra.utils.bytecomparable.ByteSourceInverse;
import org.apache.cassandra.utils.FBUtilities;
import org.apache.cassandra.utils.ObjectSizes;
import org.apache.cassandra.utils.Pair;
public class OrderPreservingPartitioner implements IPartitioner
{
private static final String rndchars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
public static final StringToken MINIMUM = new StringToken("");
public static final BigInteger CHAR_MASK = new BigInteger("65535");
private static final long EMPTY_SIZE = ObjectSizes.measure(MINIMUM);
public static final OrderPreservingPartitioner instance = new OrderPreservingPartitioner();
public DecoratedKey decorateKey(ByteBuffer key)
{
return new CachedHashDecoratedKey(getToken(key), key);
}
public StringToken midpoint(Token ltoken, Token rtoken)
{
int sigchars = Math.max(((StringToken)ltoken).token.length(), ((StringToken)rtoken).token.length());
BigInteger left = bigForString(((StringToken)ltoken).token, sigchars);
BigInteger right = bigForString(((StringToken)rtoken).token, sigchars);
Pair midpair = FBUtilities.midpoint(left, right, 16*sigchars);
return new StringToken(stringForBig(midpair.left, sigchars, midpair.right));
}
public Token split(Token left, Token right, double ratioToLeft)
{
throw new UnsupportedOperationException();
}
/**
* Copies the characters of the given string into a BigInteger.
*
* TODO: Does not acknowledge any codepoints above 0xFFFF... problem?
*/
private static BigInteger bigForString(String str, int sigchars)
{
assert str.length() <= sigchars;
BigInteger big = BigInteger.ZERO;
for (int i = 0; i < str.length(); i++)
{
int charpos = 16 * (sigchars - (i + 1));
BigInteger charbig = BigInteger.valueOf(str.charAt(i) & 0xFFFF);
big = big.or(charbig.shiftLeft(charpos));
}
return big;
}
/**
* Convert a (positive) BigInteger into a String.
* If remainder is true, an additional char with the high order bit enabled
* will be added to the end of the String.
*/
private String stringForBig(BigInteger big, int sigchars, boolean remainder)
{
char[] chars = new char[sigchars + (remainder ? 1 : 0)];
if (remainder)
// remaining bit is the most significant in the last char
chars[sigchars] |= 0x8000;
for (int i = 0; i < sigchars; i++)
{
int maskpos = 16 * (sigchars - (i + 1));
// apply bitmask and get char value
chars[i] = (char)(big.and(CHAR_MASK.shiftLeft(maskpos)).shiftRight(maskpos).intValue() & 0xFFFF);
}
return new String(chars);
}
public StringToken getMinimumToken()
{
return MINIMUM;
}
public StringToken getRandomToken()
{
return getRandomToken(ThreadLocalRandom.current());
}
public StringToken getRandomToken(Random random)
{
StringBuilder buffer = new StringBuilder();
for (int j = 0; j < 16; j++)
buffer.append(rndchars.charAt(random.nextInt(rndchars.length())));
return new StringToken(buffer.toString());
}
private final Token.TokenFactory tokenFactory = new Token.TokenFactory()
{
public Token fromComparableBytes(ByteSource.Peekable comparableBytes, ByteComparable.Version version)
{
return new StringToken(ByteSourceInverse.getString(comparableBytes));
}
public ByteBuffer toByteArray(Token token)
{
StringToken stringToken = (StringToken) token;
return ByteBufferUtil.bytes(stringToken.token);
}
public Token fromByteArray(ByteBuffer bytes)
{
try
{
return new StringToken(ByteBufferUtil.string(bytes));
}
catch (CharacterCodingException e)
{
throw new RuntimeException(e);
}
}
public String toString(Token token)
{
StringToken stringToken = (StringToken) token;
return stringToken.token;
}
public void validate(String token) throws ConfigurationException
{
if (token.contains(VersionedValue.DELIMITER_STR))
throw new ConfigurationException("Tokens may not contain the character " + VersionedValue.DELIMITER_STR);
}
public Token fromString(String string)
{
return new StringToken(string);
}
};
public Token.TokenFactory getTokenFactory()
{
return tokenFactory;
}
public boolean preservesOrder()
{
return true;
}
public static class StringToken extends ComparableObjectToken
{
static final long serialVersionUID = 5464084395277974963L;
public StringToken(String token)
{
super(token);
}
@Override
public IPartitioner getPartitioner()
{
return instance;
}
@Override
public long getHeapSize()
{
return EMPTY_SIZE + ObjectSizes.sizeOf(token);
}
@Override
public ByteSource asComparableBytes(ByteComparable.Version version)
{
return ByteSource.of(token, version);
}
}
public StringToken getToken(ByteBuffer key)
{
String skey;
try
{
skey = ByteBufferUtil.string(key);
}
catch (CharacterCodingException e)
{
skey = ByteBufferUtil.bytesToHex(key);
}
return new StringToken(skey);
}
public Map describeOwnership(List sortedTokens)
{
// allTokens will contain the count and be returned, sorted_ranges is shorthand for token<->token math.
Map allTokens = new HashMap();
List> sortedRanges = new ArrayList>(sortedTokens.size());
// this initializes the counts to 0 and calcs the ranges in order.
Token lastToken = sortedTokens.get(sortedTokens.size() - 1);
for (Token node : sortedTokens)
{
allTokens.put(node, 0.0F);
sortedRanges.add(new Range(lastToken, node));
lastToken = node;
}
for (String ks : Schema.instance.getKeyspaces())
{
for (TableMetadata cfmd : Schema.instance.getTablesAndViews(ks))
{
for (Range r : sortedRanges)
{
// Looping over every KS:CF:Range, get the splits size and add it to the count
allTokens.put(r.right, allTokens.get(r.right) + StorageService.instance.getSplits(ks, cfmd.name, r, cfmd.params.minIndexInterval).size());
}
}
}
// Sum every count up and divide count/total for the fractional ownership.
Float total = 0.0F;
for (Float f : allTokens.values())
total += f;
for (Map.Entry row : allTokens.entrySet())
allTokens.put(row.getKey(), row.getValue() / total);
return allTokens;
}
public AbstractType getTokenValidator()
{
return UTF8Type.instance;
}
public AbstractType partitionOrdering()
{
return UTF8Type.instance;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy