/** @throws Exception If failed. */
public void testCreateFileColocated() throws Exception {
GridGgfsPath path = new GridGgfsPath("/colocated");
UUID uuid = UUID.randomUUID();
GridUuid affKey;
long idx = 0;
while (true) {
affKey = new GridUuid(uuid, idx);
if (grid(0).mapKeyToNode(DATA_CACHE_NAME, affKey).id().equals(grid(0).localNode().id()))
break;
idx++;
}
try (GridGgfsOutputStream out = fs.create(path, 1024, true, affKey, 0, 1024, null)) {
// Write 5M, should be enough to test distribution.
for (int i = 0; i < 15; i++) out.write(new byte[1024 * 1024]);
}
GridGgfsFile info = fs.info(path);
Collection<GridGgfsBlockLocation> affNodes = fs.affinity(path, 0, info.length());
assertEquals(1, affNodes.size());
Collection<UUID> nodeIds = F.first(affNodes).nodeIds();
assertEquals(1, nodeIds.size());
assertEquals(grid(0).localNode().id(), F.first(nodeIds));
}
/**
* Converts message to bytes to send over network.
*
* @return Bytes representing this packet.
*/
public byte[] toBytes() {
byte[] buf = new byte[PACKET_SIZE];
int off = 0;
off = U.longToBytes(origNodeId.getLeastSignificantBits(), buf, off);
off = U.longToBytes(origNodeId.getMostSignificantBits(), buf, off);
off = U.longToBytes(targetNodeId.getLeastSignificantBits(), buf, off);
off = U.longToBytes(targetNodeId.getMostSignificantBits(), buf, off);
off = U.longToBytes(origTs, buf, off);
off = U.longToBytes(replyTs, buf, off);
assert off == PACKET_SIZE;
return buf;
}
/**
* Retrieves UUID value from parameters map.
*
* @param key Key.
* @param params Parameters map.
* @return UUID value from parameters map or {@code null} if null or not exists.
* @throws GridException If parsing failed.
*/
@Nullable
private static UUID uuidValue(String key, Map<String, Object> params) throws GridException {
assert key != null;
String val = (String) params.get(key);
try {
return val == null ? null : UUID.fromString(val);
} catch (NumberFormatException ignore) {
throw new GridException("Failed to parse parameter of UUID type [" + key + "=" + val + "]");
}
}
/**
* Creates REST request.
*
* @param cmd Command.
* @param params Parameters.
* @return REST request.
* @throws GridException If creation failed.
*/
@Nullable
private GridRestRequest createRequest(
GridRestCommand cmd, Map<String, Object> params, ServletRequest req) throws GridException {
GridRestRequest restReq;
switch (cmd) {
case CACHE_GET:
case CACHE_GET_ALL:
case CACHE_PUT:
case CACHE_PUT_ALL:
case CACHE_REMOVE:
case CACHE_REMOVE_ALL:
case CACHE_ADD:
case CACHE_CAS:
case CACHE_METRICS:
case CACHE_REPLACE:
case CACHE_DECREMENT:
case CACHE_INCREMENT:
case CACHE_APPEND:
case CACHE_PREPEND:
{
GridRestCacheRequest restReq0 = new GridRestCacheRequest();
restReq0.cacheName((String) params.get("cacheName"));
restReq0.key(params.get("key"));
restReq0.value(params.get("val"));
restReq0.value2(params.get("val2"));
Object val1 = params.get("val1");
if (val1 != null) restReq0.value(val1);
restReq0.cacheFlags(intValue("cacheFlags", params, 0));
restReq0.ttl(longValue("exp", params, null));
restReq0.initial(longValue("init", params, null));
restReq0.delta(longValue("delta", params, null));
if (cmd == CACHE_GET_ALL || cmd == CACHE_PUT_ALL || cmd == CACHE_REMOVE_ALL) {
List<Object> keys = values("k", params);
List<Object> vals = values("v", params);
if (keys.size() < vals.size())
throw new GridException(
"Number of keys must be greater or equals to number of values.");
Map<Object, Object> map = U.newHashMap(keys.size());
Iterator<Object> keyIt = keys.iterator();
Iterator<Object> valIt = vals.iterator();
while (keyIt.hasNext()) map.put(keyIt.next(), valIt.hasNext() ? valIt.next() : null);
restReq0.values(map);
}
restReq = restReq0;
break;
}
case TOPOLOGY:
case NODE:
{
GridRestTopologyRequest restReq0 = new GridRestTopologyRequest();
restReq0.includeMetrics(Boolean.parseBoolean((String) params.get("mtr")));
restReq0.includeAttributes(Boolean.parseBoolean((String) params.get("attr")));
restReq0.nodeIp((String) params.get("ip"));
restReq0.nodeId(uuidValue("id", params));
restReq = restReq0;
break;
}
case EXE:
case RESULT:
case NOOP:
{
GridRestTaskRequest restReq0 = new GridRestTaskRequest();
restReq0.taskId((String) params.get("id"));
restReq0.taskName((String) params.get("name"));
restReq0.params(values("p", params));
restReq0.async(Boolean.parseBoolean((String) params.get("async")));
restReq0.timeout(longValue("timeout", params, 0L));
restReq = restReq0;
break;
}
case LOG:
{
GridRestLogRequest restReq0 = new GridRestLogRequest();
restReq0.path((String) params.get("path"));
restReq0.from(intValue("from", params, -1));
restReq0.to(intValue("to", params, -1));
restReq = restReq0;
break;
}
case VERSION:
{
restReq = new GridRestRequest();
break;
}
default:
throw new GridException("Invalid command: " + cmd);
}
restReq.address(new InetSocketAddress(req.getRemoteAddr(), req.getRemotePort()));
restReq.command(cmd);
if (params.containsKey("gridgain.login") || params.containsKey("gridgain.password")) {
GridSecurityCredentials cred =
new GridSecurityCredentials(
(String) params.get("gridgain.login"), (String) params.get("gridgain.password"));
restReq.credentials(cred);
}
String clientId = (String) params.get("clientId");
try {
if (clientId != null) restReq.clientId(UUID.fromString(clientId));
} catch (Exception ignored) {
// Ignore invalid client id. Rest handler will process this logic.
}
String destId = (String) params.get("destId");
try {
if (destId != null) restReq.destinationId(UUID.fromString(destId));
} catch (IllegalArgumentException ignored) {
// Don't fail - try to execute locally.
}
String sesTokStr = (String) params.get("sessionToken");
try {
if (sesTokStr != null) restReq.sessionToken(U.hexString2ByteArray(sesTokStr));
} catch (IllegalArgumentException ignored) {
// Ignore invalid session token.
}
return restReq;
}
/**
* Eviction policy based on {@code First In First Out (FIFO)} algorithm. This implementation is very
* efficient since it does not create any additional table-like data structures. The {@code FIFO}
* ordering information is maintained by attaching ordering metadata to cache entries.
*/
public class GridCacheFifoEvictionPolicy<K, V>
implements GridCacheEvictionPolicy<K, V>, GridCacheFifoEvictionPolicyMBean {
/** Tag. */
private final String meta = UUID.randomUUID().toString();
/** Maximum size. */
private volatile int max = GridCacheConfiguration.DFLT_CACHE_SIZE;
/** FIFO queue. */
private final ConcurrentLinkedDeque8<GridCacheEntry<K, V>> queue = new ConcurrentLinkedDeque8<>();
/** Constructs FIFO eviction policy with all defaults. */
public GridCacheFifoEvictionPolicy() {
// No-op.
}
/**
* Constructs FIFO eviction policy with maximum size. Empty entries are allowed.
*
* @param max Maximum allowed size of cache before entry will start getting evicted.
*/
public GridCacheFifoEvictionPolicy(int max) {
A.ensure(max > 0, "max > 0");
this.max = max;
}
/**
* Gets maximum allowed size of cache before entry will start getting evicted.
*
* @return Maximum allowed size of cache before entry will start getting evicted.
*/
@Override
public int getMaxSize() {
return max;
}
/**
* Sets maximum allowed size of cache before entry will start getting evicted.
*
* @param max Maximum allowed size of cache before entry will start getting evicted.
*/
@Override
public void setMaxSize(int max) {
A.ensure(max > 0, "max > 0");
this.max = max;
}
/** {@inheritDoc} */
@Override
public int getCurrentSize() {
return queue.size();
}
/** {@inheritDoc} */
@Override
public String getMetaAttributeName() {
return meta;
}
/**
* Gets read-only view on internal {@code FIFO} queue in proper order.
*
* @return Read-only view ono internal {@code 'FIFO'} queue.
*/
public Collection<GridCacheEntry<K, V>> queue() {
return Collections.unmodifiableCollection(queue);
}
/** {@inheritDoc} */
@Override
public void onEntryAccessed(boolean rmv, GridCacheEntry<K, V> entry) {
if (!rmv) {
if (!entry.isCached()) return;
// Shrink only if queue was changed.
if (touch(entry)) shrink();
} else {
Node<GridCacheEntry<K, V>> node = entry.removeMeta(meta);
if (node != null) queue.unlinkx(node);
}
}
/**
* @param entry Entry to touch.
* @return {@code True} if queue has been changed by this call.
*/
private boolean touch(GridCacheEntry<K, V> entry) {
Node<GridCacheEntry<K, V>> node = entry.meta(meta);
// Entry has not been enqueued yet.
if (node == null) {
while (true) {
node = queue.offerLastx(entry);
if (entry.putMetaIfAbsent(meta, node) != null) {
// Was concurrently added, need to clear it from queue.
queue.unlinkx(node);
// Queue has not been changed.
return false;
} else if (node.item() != null) {
if (!entry.isCached()) {
// Was concurrently evicted, need to clear it from queue.
queue.unlinkx(node);
return false;
}
return true;
}
// If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
else if (!entry.removeMeta(meta, node)) return false;
}
}
// Entry is already in queue.
return false;
}
/** Shrinks FIFO queue to maximum allowed size. */
private void shrink() {
int max = this.max;
int startSize = queue.sizex();
for (int i = 0; i < startSize && queue.sizex() > max; i++) {
GridCacheEntry<K, V> entry = queue.poll();
if (entry == null) break;
if (!entry.evict()) {
entry.removeMeta(meta);
touch(entry);
}
}
}
/**
* Checks entry for empty value.
*
* @param entry Entry to check.
* @return {@code True} if entry is empty.
*/
private boolean empty(GridCacheEntry<K, V> entry) {
try {
return entry.peek(F.asList(GLOBAL)) == null;
} catch (GridException e) {
U.error(null, e.getMessage(), e);
assert false : "Should never happen: " + e;
return false;
}
}
/** {@inheritDoc} */
@Override
public String toString() {
return S.toString(GridCacheFifoEvictionPolicy.class, this);
}
}
/**
* Checks if this candidate matches version or thread-nodeId combination.
*
* @param nodeId Node ID to check.
* @param ver Version to check.
* @param threadId Thread ID to check.
* @return {@code True} if matched.
*/
public boolean matches(GridCacheVersion ver, UUID nodeId, long threadId) {
return ver.equals(this.ver) || (nodeId.equals(this.nodeId) && threadId == this.threadId);
}