ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [41/54] [abbrv] incubator-ignite git commit: # ignite-63
Date Thu, 22 Jan 2015 15:17:50 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java
new file mode 100644
index 0000000..1e90237
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheCountDownLatch.java
@@ -0,0 +1,227 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.gridgain.grid.*;
+
+import java.util.concurrent.*;
+
+/**
+ * This interface provides a rich API for working with distributed count down latch.
+ * <p>
+ * <h1 class="header">Functionality</h1>
+ * Distributed count down latch provides functionality similar to {@code java.util.CountDownLatch}.
+ * Note that you cannot remove count down latch having count greater that zero. It should be
+ * counted down to zero first.
+ * <h1 class="header">Creating Distributed Count Down Latch</h1>
+ * Instance of cache count down latch can be created by calling the following method:
+ * {@link GridCacheDataStructures#countDownLatch(String, int, boolean, boolean)}.
+ * @see GridCacheDataStructures#countDownLatch(String, int, boolean, boolean)
+ * @see GridCacheDataStructures#removeCountDownLatch(String)
+ */
+public interface GridCacheCountDownLatch {
+    /**
+     * Gets name of the latch.
+     *
+     * @return Name of the latch.
+     */
+    public String name();
+
+    /**
+     * Gets current count value of the latch.
+     *
+     * @return Current count.
+     */
+    public int count();
+
+    /**
+     * Gets initial count value of the latch.
+     *
+     * @return Initial count.
+     */
+    public int initialCount();
+
+    /**
+     * Gets {@code autoDelete} flag. If this flag is {@code true} latch is removed
+     * from cache when it has been counted down to 0.
+     *
+     * @return Value of {@code autoDelete} flag.
+     */
+    public boolean autoDelete();
+
+    /**
+     * Causes the current thread to wait until the latch has counted down to
+     * zero, unless current thread is interrupted.
+     * <p>
+     * If the current count of the latch is zero then this method returns immediately.
+     * <p>
+     * If the current count is greater than zero then the current
+     * thread becomes disabled for thread scheduling purposes and lies
+     * dormant until one of two things happen:
+     * <ul>
+     *     <li>The count reaches zero due to invocations of the
+     *      {@link #countDown} method on any node; or
+     *      <li>Some other thread interrupts the current thread.
+     * </ul>
+     * <p>
+     * If the current thread:
+     * <ul>
+     *      <li>has its interrupted status set on entry to this method; or
+     *      <li>is interrupted while waiting,
+     * </ul>
+     * then {@link GridInterruptedException} is thrown and the current thread's
+     * interrupted status is cleared.
+     *
+     * @throws IgniteCheckedException If operation failed.
+     * @throws GridInterruptedException if the current thread is interrupted
+     *      while waiting
+     */
+    public void await() throws IgniteCheckedException;
+
+    /**
+     * Causes the current thread to wait until the latch has counted down to
+     * zero, unless the thread is interrupted, or the specified waiting time elapses.
+     * <p>
+     * If the current count is zero then this method returns immediately
+     * with the value {@code true}.
+     * <p>
+     * If the current count is greater than zero then the current
+     * thread becomes disabled for thread scheduling purposes and lies
+     * dormant until one of three things happen:
+     * <ul>
+     *      <li>The count reaches zero due to invocations of the
+     *      {@link #countDown} method on any node; or
+     *      <li>Some other thread interrupts the current thread; or
+     *      <li>The specified waiting time elapses.
+     * </ul>
+     * <p>
+     * If the count reaches zero then the method returns with the
+     * value {@code true}.
+     * <p>
+     * If the current thread:
+     * <ul>
+     *      <li>has its interrupted status set on entry to this method; or
+     *      <li>is interrupted while waiting,
+     * </ul>
+     * then {@link GridInterruptedException} is thrown and the current thread's
+     * interrupted status is cleared.
+     * <p>
+     * If the specified waiting time elapses then the value {@code false}
+     * is returned.  If the time is less than or equal to zero, the method
+     * will not wait at all.
+     *
+     * @param timeout The maximum time to wait in milliseconds.
+     * @return {@code True} if the count reached zero and {@code false}
+     *      if the waiting time elapsed before the count reached zero.
+     * @throws GridInterruptedException If the current thread is interrupted
+     *      while waiting.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean await(long timeout) throws IgniteCheckedException;
+
+    /**
+     * Causes the current thread to wait until the latch has counted down to
+     * zero, unless the thread is interrupted, or the specified waiting time elapses.
+     * <p>
+     * If the current count is zero then this method returns immediately
+     * with the value {@code true}.
+     * <p>
+     * If the current count is greater than zero then the current
+     * thread becomes disabled for thread scheduling purposes and lies
+     * dormant until one of three things happen:
+     * <ul>
+     *      <li>The count reaches zero due to invocations of the
+     *      {@link #countDown} method on any node; or
+     *      <li>Some other thread interrupts the current thread; or
+     *      <li>The specified waiting time elapses.
+     * </ul>
+     * <p>
+     * If the count reaches zero then the method returns with the
+     * value {@code true}.
+     * <p>
+     * If the current thread:
+     * <ul>
+     *      <li>has its interrupted status set on entry to this method; or
+     *      <li>is interrupted while waiting,
+     * </ul>
+     * then {@link GridInterruptedException} is thrown and the current thread's
+     * interrupted status is cleared.
+     * <p>
+     * If the specified waiting time elapses then the value {@code false}
+     * is returned.  If the time is less than or equal to zero, the method
+     * will not wait at all.
+     *
+     *
+     * @param timeout The maximum time to wait.
+     * @param unit The time unit of the {@code timeout} argument.
+     * @return {@code True} if the count reached zero and {@code false}
+     *      if the waiting time elapsed before the count reached zero.
+     * @throws GridInterruptedException If the current thread is interrupted
+     *      while waiting.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean await(long timeout, TimeUnit unit) throws IgniteCheckedException;
+
+    /**
+     * Decrements the count of the latch, releasing all waiting threads
+     * on all nodes if the count reaches zero.
+     * <p>
+     * If the current count is greater than zero then it is decremented.
+     * If the new count is zero then all waiting threads are re-enabled for
+     * thread scheduling purposes.
+     * <p>
+     * If the current count equals zero then nothing happens.
+     *
+     * @return Count after decrement.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public int countDown() throws IgniteCheckedException;
+
+    /**
+     * Decreases the count of the latch using passed in value,
+     * releasing all waiting threads on all nodes if the count reaches zero.
+     * <p>
+     * If the current count is greater than zero then it is decreased.
+     * If the new count is zero then all waiting threads are re-enabled for
+     * thread scheduling purposes.
+     * <p>
+     * If the current count equals zero then nothing happens.
+     *
+     * @param val Value to decrease counter on.
+     * @return Count after decreasing.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public int countDown(int val) throws IgniteCheckedException;
+
+    /**
+     * Counts down this latch to zero, releasing all waiting threads on all nodes.
+     * <p>
+     * If the current count equals zero then nothing happens.
+     *
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public void countDownAll() throws IgniteCheckedException;
+
+    /**
+     * Gets {@code removed} status of the latch.
+     *
+     * @return {@code True} if latch was removed from cache, {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidException.java
new file mode 100644
index 0000000..dfde5de
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidException.java
@@ -0,0 +1,66 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.jetbrains.annotations.*;
+
+/**
+ * This checked exception gets thrown if attempt to access an invalid data structure has been made.
+ * Data structure may become invalid if communication with remote nodes has been lost or
+ * any other error condition happened that prevented from insuring consistent state.
+ * <p>
+ * The best way to handle this error is to discard the invalid data structure instance and try
+ * getting the underlying data structure from cache again.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class GridCacheDataStructureInvalidException extends IgniteCheckedException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public GridCacheDataStructureInvalidException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public GridCacheDataStructureInvalidException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public GridCacheDataStructureInvalidException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidRuntimeException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidRuntimeException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidRuntimeException.java
new file mode 100644
index 0000000..7ca87e1
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureInvalidRuntimeException.java
@@ -0,0 +1,66 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.jetbrains.annotations.*;
+
+/**
+ * This runtime exception gets thrown if attempt to access an invalid data structure has been made.
+ * Data structure may become invalid if communication with remote nodes has been lost or
+ * any other error condition happened that prevented from insuring consistent state.
+ * <p>
+ * The best way to handle this error is to discard the invalid data structure instance and try
+ * getting the underlying data structure from cache again.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class GridCacheDataStructureInvalidRuntimeException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public GridCacheDataStructureInvalidRuntimeException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public GridCacheDataStructureInvalidRuntimeException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public GridCacheDataStructureInvalidRuntimeException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedException.java
new file mode 100644
index 0000000..8427ee9
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedException.java
@@ -0,0 +1,61 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.jetbrains.annotations.*;
+
+/**
+ * This checked exception gets thrown if attempt to access a removed data structure has been made.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class GridCacheDataStructureRemovedException extends IgniteCheckedException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public GridCacheDataStructureRemovedException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public GridCacheDataStructureRemovedException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public GridCacheDataStructureRemovedException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedRuntimeException.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedRuntimeException.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedRuntimeException.java
new file mode 100644
index 0000000..31ebedf
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructureRemovedRuntimeException.java
@@ -0,0 +1,61 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.jetbrains.annotations.*;
+
+/**
+ * This runtime exception gets thrown if attempt to access a removed data structure has been made.
+ * <p>
+ * Note that data structures throw runtime exceptions out of methods that don't have
+ * checked exceptions in the signature.
+ */
+public class GridCacheDataStructureRemovedRuntimeException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new exception with given error message.
+     *
+     * @param msg Error message.
+     */
+    public GridCacheDataStructureRemovedRuntimeException(String msg) {
+        super(msg);
+    }
+
+    /**
+     * Creates new exception with given throwable as a nested cause and
+     * source of error message.
+     *
+     * @param cause Non-null throwable cause.
+     */
+    public GridCacheDataStructureRemovedRuntimeException(Throwable cause) {
+        this(cause.getMessage(), cause);
+    }
+
+    /**
+     * Creates a new exception with given error message and optional nested cause exception.
+     *
+     * @param msg Error message.
+     * @param cause Optional nested exception (can be {@code null}).
+     */
+    public GridCacheDataStructureRemovedRuntimeException(String msg, @Nullable Throwable cause) {
+        super(msg, cause);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructures.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructures.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructures.java
new file mode 100644
index 0000000..72855f1
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheDataStructures.java
@@ -0,0 +1,221 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.gridgain.grid.cache.*;
+import org.jetbrains.annotations.*;
+
+/**
+ * Facade for working with distributed cache data structures. All cache data structures are similar
+ * in APIs to {@code 'java.util.concurrent'} package, but all operations on them are grid-aware.
+ * For example, if you increment {@link GridCacheAtomicLong} on one node, another node will
+ * know about the change. Or if you add an element to {@link GridCacheQueue} on one node,
+ * you can poll it on another node.
+ * <p>
+ * You can get data structures facade by calling {@link org.apache.ignite.cache.GridCache#dataStructures()} method.
+ */
+public interface GridCacheDataStructures {
+    /**
+     * Will get an atomic sequence from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Sequence name.
+     * @param initVal Initial value for sequence. If sequence already cached, {@code initVal} will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Sequence for the given name.
+     * @throws IgniteCheckedException If sequence could not be fetched or created.
+     */
+    @Nullable public GridCacheAtomicSequence atomicSequence(String name, long initVal, boolean create)
+        throws IgniteCheckedException;
+
+    /**
+     * Remove sequence from cache.
+     *
+     * @param name Sequence name.
+     * @return {@code True} if sequence has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeAtomicSequence(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a atomic long from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Name of atomic long.
+     * @param initVal Initial value for atomic long. If atomic long already cached, {@code initVal}
+     *        will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Atomic long.
+     * @throws IgniteCheckedException If atomic long could not be fetched or created.
+     */
+    @Nullable public GridCacheAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteCheckedException;
+
+    /**
+     * Remove atomic long from cache.
+     *
+     * @param name Name of atomic long.
+     * @return {@code True} if atomic long has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If removing failed.
+     */
+    public boolean removeAtomicLong(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a named queue from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     * If queue is present in cache already, queue properties will not be changed. Use
+     * collocation for {@link org.apache.ignite.cache.GridCacheMode#PARTITIONED} caches if you have lots of relatively
+     * small queues as it will make fetching, querying, and iteration a lot faster. If you have
+     * few very large queues, then you should consider turning off collocation as they simply
+     * may not fit in a single node's memory. However note that in this case
+     * to get a single element off the queue all nodes may have to be queried.
+     *
+     * @param name Name of queue.
+     * @param cap Capacity of queue, {@code 0} for unbounded queue.
+     * @param collocated If {@code true} then all items within the same queue will be collocated on the same node.
+     *      Otherwise elements of the same queue maybe be cached on different nodes. If you have lots of relatively
+     *      small queues, then you should use collocation. If you have few large queues, then you should turn off
+     *      collocation. This parameter works only for {@link org.apache.ignite.cache.GridCacheMode#PARTITIONED} cache.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Queue with given properties.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    @Nullable public <T> GridCacheQueue<T> queue(String name, int cap, boolean collocated,
+        boolean create) throws IgniteCheckedException;
+
+    /**
+     * Remove queue from cache. Internally one transaction will be created for all elements
+     * in the queue. If you anticipate that queue may be large, then it's better to use
+     * {@link #removeQueue(String, int)} which allows to specify batch size. In that case
+     * transaction will be split into multiple transactions which will have upto {@code batchSize}
+     * elements in it.
+     *
+     * @param name Name queue.
+     * @return {@code True} if queue has been removed and false if it's not cached.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeQueue(String name) throws IgniteCheckedException;
+
+    /**
+     * Remove queue from cache. Internally multiple transactions will be created
+     * with no more than {@code batchSize} elements in them. For larger queues, this
+     * method is preferrable over {@link #removeQueue(String)} which will create only
+     * one transaction for the whole operation.
+     *
+     * @param name Name queue.
+     * @param batchSize Batch size.
+     * @return {@code True} if queue has been removed and false if it's not cached.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeQueue(String name, int batchSize) throws IgniteCheckedException;
+
+    /**
+     * Will get a named set from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Set name.
+     * @param collocated If {@code true} then all items within the same set will be collocated on the same node.
+     *      Otherwise elements of the same set maybe be cached on different nodes. This parameter works only
+     *      for {@link org.apache.ignite.cache.GridCacheMode#PARTITIONED} cache.
+     * @param create Flag indicating whether set should be created if does not exist.
+     * @return Set with given properties.
+     * @throws IgniteCheckedException If failed.
+     */
+    @Nullable public <T> GridCacheSet<T> set(String name, boolean collocated, boolean create) throws IgniteCheckedException;
+
+    /**
+     * Removes set from cache.
+     *
+     * @param name Set name.
+     * @return {@code True} if set has been removed and false if it's not cached.
+     * @throws IgniteCheckedException If failed.
+     */
+    public boolean removeSet(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a atomic reference from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Atomic reference name.
+     * @param initVal Initial value for atomic reference. If atomic reference already cached,
+     *      {@code initVal} will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Atomic reference for the given name.
+     * @throws IgniteCheckedException If atomic reference could not be fetched or created.
+     */
+    @Nullable public <T> GridCacheAtomicReference<T> atomicReference(String name, @Nullable T initVal, boolean create)
+        throws IgniteCheckedException;
+
+    /**
+     * Remove atomic reference from cache.
+     *
+     * @param name Atomic reference name.
+     * @return {@code True} if atomic reference has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeAtomicReference(String name) throws IgniteCheckedException;
+
+    /**
+     * Will get a atomic stamped from cache and create one if it has not been created yet and {@code create} flag
+     * is {@code true}.
+     *
+     * @param name Atomic stamped name.
+     * @param initVal Initial value for atomic stamped. If atomic stamped already cached,
+     *      {@code initVal} will be ignored.
+     * @param initStamp Initial stamp for atomic stamped. If atomic stamped already cached,
+     *      {@code initStamp} will be ignored.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Atomic stamped for the given name.
+     * @throws IgniteCheckedException If atomic stamped could not be fetched or created.
+     */
+    @Nullable public <T, S> GridCacheAtomicStamped<T, S> atomicStamped(String name, @Nullable T initVal,
+        @Nullable S initStamp, boolean create) throws IgniteCheckedException;
+
+    /**
+     * Remove atomic stamped from cache.
+     *
+     * @param name Atomic stamped name.
+     * @return {@code True} if atomic stamped has been removed, {@code false} otherwise.
+     * @throws IgniteCheckedException If remove failed.
+     */
+    public boolean removeAtomicStamped(String name) throws IgniteCheckedException;
+
+    /**
+     * Gets or creates count down latch. If count down latch is not found in cache and {@code create} flag
+     * is {@code true}, it is created using provided name and count parameter.
+     *
+     * @param name Name of the latch.
+     * @param cnt Count for new latch creation.
+     * @param autoDel {@code True} to automatically delete latch from cache
+     *      when its count reaches zero.
+     * @param create Boolean flag indicating whether data structure should be created if does not exist.
+     * @return Count down latch for the given name.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    @Nullable public GridCacheCountDownLatch countDownLatch(String name, int cnt, boolean autoDel, boolean create)
+        throws IgniteCheckedException;
+
+    /**
+     * Removes count down latch from cache.
+     *
+     * @param name Name of the latch.
+     * @return Count down latch for the given name.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean removeCountDownLatch(String name) throws IgniteCheckedException;
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheQueue.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheQueue.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheQueue.java
new file mode 100644
index 0000000..9636338
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheQueue.java
@@ -0,0 +1,182 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * This interface provides a rich API for working with distributed queues based on In-Memory Data Grid.
+ * <p>
+ * <h1 class="header">Overview</h1>
+ * Cache queue provides an access to cache elements using typical queue API. Cache queue also implements
+ * {@link Collection} interface and provides all methods from collections including
+ * {@link Collection#addAll(Collection)}, {@link Collection#removeAll(Collection)}, and
+ * {@link Collection#retainAll(Collection)} methods for bulk operations. Note that all
+ * {@link Collection} methods in the queue may throw {@link IgniteException} in case
+ * of failure.
+ * <p>
+ * All queue operations have synchronous and asynchronous counterparts.
+ * <h1 class="header">Bounded vs Unbounded</h1>
+ * Queues can be {@code unbounded} or {@code bounded}. {@code Bounded} queues can
+ * have maximum capacity. Queue capacity can be set at creation time and cannot be
+ * changed later. Here is an example of how to create {@code bounded} {@code LIFO} queue with
+ * capacity of {@code 1000} items.
+ * <pre name="code" class="java">
+ * GridCacheQueue&lt;String&gt; queue = cache().queue("anyName", LIFO, 1000);
+ * ...
+ * queue.add("item");
+ * </pre>
+ * For {@code bounded} queues <b>blocking</b> operations, such as {@link #take()} or {@link #put(Object)}
+ * are available. These operations will block until queue capacity changes to make the operation
+ * possible.
+ * <h1 class="header">Collocated vs Non-collocated</h1>
+ * Queue items can be placed on one node or distributed throughout grid nodes
+ * (governed by {@code collocated} parameter). {@code Non-collocated} mode is provided only
+ * for partitioned caches. If {@code collocated} parameter is {@code true}, then all queue items
+ * will be collocated on one node, otherwise items will be distributed through all grid nodes.
+ * Unless explicitly specified, by default queues are {@code collocated}.
+ * <p>
+ * Here is an example of how create {@code unbounded} queue
+ * in non-collocated mode.
+ * <pre name="code" class="java">
+ * GridCacheQueue&lt;String&gt; queue = cache().queue("anyName", 0 &#047;*unbounded*&#047;, false &#047;*non-collocated*&#047;);
+ * ...
+ * queue.add("item");
+ * </pre>
+ * <h1 class="header">Creating Cache Queues</h1>
+ * Instances of distributed cache queues can be created by calling the following method
+ * on {@link GridCacheDataStructures} API:
+ * <ul>
+ *     <li>{@link GridCacheDataStructures#queue(String, int, boolean, boolean)}</li>
+ * </ul>
+ * @see GridCacheDataStructures#queue(String, int, boolean, boolean)
+ * @see GridCacheDataStructures#removeQueue(String)
+ * @see GridCacheDataStructures#removeQueue(String, int)
+ */
+public interface GridCacheQueue<T> extends BlockingQueue<T> {
+    /**
+     * Gets queue name.
+     *
+     * @return Queue name.
+     */
+    public String name();
+
+    /** {@inheritDoc} */
+    @Override public boolean add(T item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean offer(T item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean offer(T item, long timeout, TimeUnit unit) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean addAll(Collection<? extends T> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean contains(Object item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean containsAll(Collection<?> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public void clear() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean remove(Object item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean removeAll(Collection<?> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean isEmpty() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public Iterator<T> iterator() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public Object[] toArray() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public <T> T[] toArray(T[] a) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public boolean retainAll(Collection<?> items) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public int size() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T poll() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T peek() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override public void put(T item) throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T take() throws IgniteException;
+
+    /** {@inheritDoc} */
+    @Override @Nullable public T poll(long timeout, TimeUnit unit) throws IgniteException;
+
+    /**
+     * Removes all of the elements from this queue. Method is used in massive queues with huge numbers of elements.
+     *
+     * @param batchSize Batch size.
+     * @throws IgniteException if operation failed.
+     */
+    public void clear(int batchSize) throws IgniteException;
+
+    /**
+     * Gets maximum number of elements of the queue.
+     *
+     * @return Maximum number of elements. If queue is unbounded {@code Integer.MAX_SIZE} will return.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public int capacity() throws IgniteCheckedException;
+
+    /**
+     * Returns {@code true} if this queue is bounded.
+     *
+     * @return {@code true} if this queue is bounded.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean bounded() throws IgniteCheckedException;
+
+    /**
+     * Returns {@code true} if this queue can be kept on the one node only.
+     * Returns {@code false} if this queue can be kept on the many nodes.
+     *
+     * @return {@code true} if this queue is in {@code collocated} mode {@code false} otherwise.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean collocated() throws IgniteCheckedException;
+
+    /**
+     * Gets status of queue.
+     *
+     * @return {@code true} if queue was removed from cache {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheSet.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheSet.java b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheSet.java
new file mode 100644
index 0000000..37f7c80
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/GridCacheSet.java
@@ -0,0 +1,61 @@
+/*
+ * 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.ignite.cache.datastructures;
+
+import org.apache.ignite.*;
+
+import java.util.*;
+
+/**
+ * Set implementation based on on In-Memory Data Grid.
+ * <h1 class="header">Overview</h1>
+ * Cache set implements {@link Set} interface and provides all methods from collections.
+ * Note that all {@link Collection} methods in the set may throw {@link IgniteException} in case of failure
+ * or if set was removed.
+ * <h1 class="header">Collocated vs Non-collocated</h1>
+ * Set items can be placed on one node or distributed throughout grid nodes
+ * (governed by {@code collocated} parameter). {@code Non-collocated} mode is provided only
+ * for partitioned caches. If {@code collocated} parameter is {@code true}, then all set items
+ * will be collocated on one node, otherwise items will be distributed through all grid nodes.
+ * @see GridCacheDataStructures#set(String, boolean, boolean)
+ * @see GridCacheDataStructures#removeSet(String)
+ */
+public interface GridCacheSet<T> extends Set<T> {
+    /**
+     * Gets set name.
+     *
+     * @return Set name.
+     */
+    public String name();
+
+    /**
+     * Returns {@code true} if this set can be kept on the one node only.
+     * Returns {@code false} if this set can be kept on the many nodes.
+     *
+     * @return {@code True} if this set is in {@code collocated} mode {@code false} otherwise.
+     * @throws IgniteCheckedException If operation failed.
+     */
+    public boolean collocated() throws IgniteCheckedException;
+
+    /**
+     * Gets status of set.
+     *
+     * @return {@code True} if set was removed from cache {@code false} otherwise.
+     */
+    public boolean removed();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/datastructures/package.html
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/datastructures/package.html b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/package.html
new file mode 100644
index 0000000..af7bc37
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/datastructures/package.html
@@ -0,0 +1,24 @@
+<!--
+  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.
+  -->
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+    <!-- Package description. -->
+    Contains distributed data structures that work on top of in-memory data grid.
+</body>
+</html>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/EvictableEntry.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/EvictableEntry.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/EvictableEntry.java
index 4b244ba..ce5fb82 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/EvictableEntry.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/EvictableEntry.java
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.*;
 import javax.cache.*;
 
 /**
- * Evictable cache entry passed into {@link org.gridgain.grid.cache.eviction.GridCacheEvictionPolicy}.
+ * Evictable cache entry passed into {@link org.apache.ignite.cache.eviction.GridCacheEvictionPolicy}.
  *
  * @author @java.author
  * @version @java.version

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionFilter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionFilter.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionFilter.java
new file mode 100644
index 0000000..4dca249
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionFilter.java
@@ -0,0 +1,41 @@
+/*
+ * 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.ignite.cache.eviction;
+
+import org.apache.ignite.cache.*;
+import org.gridgain.grid.cache.*;
+
+/**
+ * Eviction filter to specify which entries should not be evicted. Not applicable when
+ * calling explicit evict via {@link org.apache.ignite.cache.GridCacheEntry#evict()}.
+ * If {@link #evictAllowed(org.apache.ignite.cache.GridCacheEntry)} method returns {@code false} then eviction
+ * policy will not be notified and entry will never be evicted.
+ * <p>
+ * Eviction filter can be configured via {@link CacheConfiguration#getEvictionFilter()}
+ * configuration property. Default value is {@code null} which means that all
+ * cache entries will be tracked by eviction policy.
+ */
+public interface GridCacheEvictionFilter<K, V> {
+    /**
+     * Checks if entry may be evicted from cache.
+     *
+     * @param entry Cache entry.
+     * @return {@code True} if it is allowed to evict this entry.
+     */
+    public boolean evictAllowed(GridCacheEntry<K, V> entry);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionPolicy.java
new file mode 100644
index 0000000..719caee
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/GridCacheEvictionPolicy.java
@@ -0,0 +1,54 @@
+/*
+ * 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.ignite.cache.eviction;
+
+import org.apache.ignite.cache.*;
+import org.gridgain.grid.cache.*;
+
+/**
+ * Pluggable cache eviction policy. Usually, implementations will internally order
+ * cache entries based on {@link #onEntryAccessed(boolean, org.apache.ignite.cache.GridCacheEntry)} notifications and
+ * whenever an element needs to be evicted, {@link org.apache.ignite.cache.GridCacheEntry#evict()}
+ * method should be called. If you need to access the underlying cache directly
+ * from this policy, you can get it via {@link org.apache.ignite.cache.GridCacheEntry#projection()} method.
+ * <p>
+ * GridGain comes with following eviction policies out-of-the-box:
+ * <ul>
+ * <li>{@link org.apache.ignite.cache.eviction.lru.GridCacheLruEvictionPolicy}</li>
+ * <li>{@link org.apache.ignite.cache.eviction.random.GridCacheRandomEvictionPolicy}</li>
+ * <li>{@link org.apache.ignite.cache.eviction.fifo.GridCacheFifoEvictionPolicy}</li>
+ * </ul>
+ * <p>
+ * The eviction policy thread-safety is ensured by GridGain. Implementations of this interface should
+ * not worry about concurrency and should be implemented as they were only accessed from one thread.
+ * <p>
+ * Note that implementations of all eviction policies provided by GridGain are very
+ * light weight in a way that they are all lock-free (or very close to it), and do not
+ * create any internal tables, arrays, or other expensive structures.
+ * The eviction order is preserved by attaching light-weight meta-data to existing
+ * cache entries.
+ */
+public interface GridCacheEvictionPolicy<K, V> {
+    /**
+     * Callback for whenever entry is accessed.
+     *
+     * @param rmv {@code True} if entry has been removed, {@code false} otherwise.
+     * @param entry Accessed entry.
+     */
+    public void onEntryAccessed(boolean rmv, GridCacheEntry<K, V> entry);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicy.java
new file mode 100644
index 0000000..b57deb4
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicy.java
@@ -0,0 +1,209 @@
+/*
+ * 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.ignite.cache.eviction.fifo;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.*;
+import org.gridgain.grid.cache.*;
+import org.jdk8.backport.*;
+import org.jdk8.backport.ConcurrentLinkedDeque8.*;
+import org.gridgain.grid.util.typedef.*;
+import org.gridgain.grid.util.typedef.internal.*;
+
+import java.util.*;
+
+/**
+ * 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 = CacheConfiguration.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(GridCachePeekMode.GLOBAL)) == null;
+        }
+        catch (IgniteCheckedException 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);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicyMBean.java
new file mode 100644
index 0000000..a330cad
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/GridCacheFifoEvictionPolicyMBean.java
@@ -0,0 +1,58 @@
+/*
+ * 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.ignite.cache.eviction.fifo;
+
+import org.apache.ignite.mbean.*;
+
+/**
+ * MBean for {@code FIFO} eviction policy.
+ */
+@IgniteMBeanDescription("MBean for FIFO cache eviction policy.")
+public interface GridCacheFifoEvictionPolicyMBean {
+    /**
+     * Gets name of metadata attribute used to store eviction policy data.
+     *
+     * @return Name of metadata attribute used to store eviction policy data.
+     */
+    @IgniteMBeanDescription("Name of metadata attribute used to store eviction policy data.")
+    public String getMetaAttributeName();
+
+    /**
+     * Gets maximum allowed cache size.
+     *
+     * @return Maximum allowed cache size.
+     */
+    @IgniteMBeanDescription("Maximum allowed cache size.")
+    public int getMaxSize();
+
+    /**
+     * Sets maximum allowed cache size.
+     *
+     * @param max Maximum allowed cache size.
+     */
+    @IgniteMBeanDescription("Set maximum allowed cache size.")
+    public void setMaxSize(int max);
+
+    /**
+     * Gets current queue size.
+     *
+     * @return Current queue size.
+     */
+    @IgniteMBeanDescription("Current FIFO queue size.")
+    public int getCurrentSize();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/package.html
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/package.html b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/package.html
new file mode 100644
index 0000000..a9bf047
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/package.html
@@ -0,0 +1,23 @@
+<!--
+  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.
+  -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+    <!-- Package description. -->
+    Contains cache FIFO eviction policy implementations.
+</body>
+</html>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsEvictionFilter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsEvictionFilter.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsEvictionFilter.java
new file mode 100644
index 0000000..a2c6a1c
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsEvictionFilter.java
@@ -0,0 +1,35 @@
+/*
+ * 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.ignite.cache.eviction.ggfs;
+
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.kernal.processors.ggfs.*;
+
+/**
+ * GGFS eviction filter which will not evict blocks of particular files.
+ */
+public class GridCacheGgfsEvictionFilter implements GridCacheEvictionFilter {
+    /** {@inheritDoc} */
+    @Override public boolean evictAllowed(GridCacheEntry entry) {
+        Object key = entry.getKey();
+
+        return !(key instanceof GridGgfsBlockKey && ((GridGgfsBlockKey)key).evictExclude());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicy.java
new file mode 100644
index 0000000..5a1d7d3
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicy.java
@@ -0,0 +1,354 @@
+/*
+ * 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.ignite.cache.eviction.ggfs;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.fs.*;
+import org.gridgain.grid.cache.*;
+import org.gridgain.grid.kernal.processors.ggfs.*;
+import org.jdk8.backport.*;
+import org.jdk8.backport.ConcurrentLinkedDeque8.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.atomic.*;
+import java.util.regex.*;
+
+/**
+ * GGFS eviction policy which evicts particular blocks.
+ */
+public class GridCacheGgfsPerBlockLruEvictionPolicy implements GridCacheEvictionPolicy<GridGgfsBlockKey, byte[]>,
+    GridCacheGgfsPerBlockLruEvictionPolicyMBean {
+    /** Meta denoting node in the queue. */
+    public static final String META_NODE = "ggfs_node";
+
+    /** Maximum size. When reached, eviction begins. */
+    private volatile long maxSize;
+
+    /** Maximum amount of blocks. When reached, eviction begins. */
+    private volatile int maxBlocks;
+
+    /** Collection of regex for paths which must not be evicted. */
+    private volatile Collection<String> excludePaths;
+
+    /** Exclusion patterns. */
+    private volatile Collection<Pattern> excludePatterns;
+
+    /** Whether patterns must be recompiled during the next call. */
+    private final AtomicBoolean excludeRecompile = new AtomicBoolean(true);
+
+    /** Queue. */
+    private final ConcurrentLinkedDeque8<GridCacheEntry<GridGgfsBlockKey, byte[]>> queue =
+        new ConcurrentLinkedDeque8<>();
+
+    /** Current size of all enqueued blocks in bytes. */
+    private final LongAdder curSize = new LongAdder();
+
+    /**
+     * Default constructor.
+     */
+    public GridCacheGgfsPerBlockLruEvictionPolicy() {
+        // No-op.
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param maxSize Maximum size. When reached, eviction begins.
+     * @param maxBlocks Maximum amount of blocks. When reached, eviction begins.
+     */
+    public GridCacheGgfsPerBlockLruEvictionPolicy(long maxSize, int maxBlocks) {
+        this(maxSize, maxBlocks, null);
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param maxSize Maximum size. When reached, eviction begins.
+     * @param maxBlocks Maximum amount of blocks. When reached, eviction begins.
+     * @param excludePaths Collection of regex for path which must not be evicted.
+     */
+    public GridCacheGgfsPerBlockLruEvictionPolicy(long maxSize, int maxBlocks,
+        @Nullable Collection<String> excludePaths) {
+        this.maxSize = maxSize;
+        this.maxBlocks = maxBlocks;
+        this.excludePaths = excludePaths;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void onEntryAccessed(boolean rmv, GridCacheEntry<GridGgfsBlockKey, byte[]> entry) {
+        if (!rmv) {
+            if (!entry.isCached())
+                return;
+
+            if (touch(entry))
+                shrink();
+        }
+        else {
+            MetaEntry meta = entry.removeMeta(META_NODE);
+
+            if (meta != null && queue.unlinkx(meta.node()))
+                changeSize(-meta.size());
+        }
+    }
+
+    /**
+     * @param entry Entry to touch.
+     * @return {@code True} if new node has been added to queue by this call.
+     */
+    private boolean touch(GridCacheEntry<GridGgfsBlockKey, byte[]> entry) {
+        byte[] val = entry.peek();
+
+        int blockSize = val != null ? val.length : 0;
+
+        MetaEntry meta = entry.meta(META_NODE);
+
+        // Entry has not been enqueued yet.
+        if (meta == null) {
+            while (true) {
+                Node<GridCacheEntry<GridGgfsBlockKey, byte[]>> node = queue.offerLastx(entry);
+
+                meta = new MetaEntry(node, blockSize);
+
+                if (entry.putMetaIfAbsent(META_NODE, meta) != 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;
+                    }
+
+                    // Increment current size.
+                    changeSize(blockSize);
+
+                    return true;
+                }
+                // If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
+                else if (!entry.removeMeta(META_NODE, node))
+                    return false;
+            }
+        }
+        else {
+            int oldBlockSize = meta.size();
+
+            Node<GridCacheEntry<GridGgfsBlockKey, byte[]>> node = meta.node();
+
+            if (queue.unlinkx(node)) {
+                // Move node to tail.
+                Node<GridCacheEntry<GridGgfsBlockKey, byte[]>> newNode = queue.offerLastx(entry);
+
+                int delta = blockSize - oldBlockSize;
+
+                if (!entry.replaceMeta(META_NODE, meta, new MetaEntry(newNode, blockSize))) {
+                    // Was concurrently added, need to clear it from queue.
+                    if (queue.unlinkx(newNode))
+                        delta -= blockSize;
+                }
+
+                if (delta != 0) {
+                    changeSize(delta);
+
+                   if (delta > 0)
+                       // Total size increased, so shrinking could be needed.
+                       return true;
+                }
+            }
+        }
+
+        // Entry is already in queue.
+        return false;
+    }
+
+    /**
+     * Shrinks queue to maximum allowed size.
+     */
+    private void shrink() {
+        long maxSize = this.maxSize;
+        int maxBlocks = this.maxBlocks;
+
+        int cnt = queue.sizex();
+
+        for (int i = 0; i < cnt && (maxBlocks > 0 && queue.sizex() > maxBlocks ||
+            maxSize > 0 && curSize.longValue() > maxSize); i++) {
+            GridCacheEntry<GridGgfsBlockKey, byte[]> entry = queue.poll();
+
+            if (entry == null)
+                break; // Queue is empty.
+
+            byte[] val = entry.peek();
+
+            if (val != null)
+                changeSize(-val.length); // Change current size as we polled entry from the queue.
+
+            if (!entry.evict()) {
+                // Reorder entries which we failed to evict.
+                entry.removeMeta(META_NODE);
+
+                touch(entry);
+            }
+        }
+    }
+
+    /**
+     * Change current size.
+     *
+     * @param delta Delta in bytes.
+     */
+    private void changeSize(int delta) {
+        if (delta != 0)
+            curSize.add(delta);
+    }
+
+    /** {@inheritDoc} */
+    @Override public long getMaxSize() {
+        return maxSize;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setMaxSize(long maxSize) {
+        this.maxSize = maxSize;
+    }
+
+    /** {@inheritDoc} */
+    @Override public int getMaxBlocks() {
+        return maxBlocks;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setMaxBlocks(int maxBlocks) {
+        this.maxBlocks = maxBlocks;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<String> getExcludePaths() {
+        return Collections.unmodifiableCollection(excludePaths);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setExcludePaths(@Nullable Collection<String> excludePaths) {
+        this.excludePaths = excludePaths;
+
+        excludeRecompile.set(true);
+    }
+
+    /** {@inheritDoc} */
+    @Override public long getCurrentSize() {
+        return curSize.longValue();
+    }
+
+    /** {@inheritDoc} */
+    @Override public int getCurrentBlocks() {
+        return queue.size();
+    }
+
+    /**
+     * Check whether provided path must be excluded from evictions.
+     *
+     * @param path Path.
+     * @return {@code True} in case non block of related file must be excluded.
+     * @throws IgniteCheckedException In case of faulty patterns.
+     */
+    public boolean exclude(IgniteFsPath path) throws IgniteCheckedException {
+        assert path != null;
+
+        Collection<Pattern> excludePatterns0;
+
+        if (excludeRecompile.compareAndSet(true, false)) {
+            // Recompile.
+            Collection<String> excludePaths0 = excludePaths;
+
+            if (excludePaths0 != null) {
+                excludePatterns0 = new HashSet<>(excludePaths0.size(), 1.0f);
+
+                for (String excludePath : excludePaths0) {
+                    try {
+                        excludePatterns0.add(Pattern.compile(excludePath));
+                    }
+                    catch (PatternSyntaxException ignore) {
+                        throw new IgniteCheckedException("Invalid regex pattern: " + excludePath);
+                    }
+                }
+
+                excludePatterns = excludePatterns0;
+            }
+            else
+                excludePatterns0 = excludePatterns = null;
+        }
+        else
+            excludePatterns0 = excludePatterns;
+
+        if (excludePatterns0 != null) {
+            String pathStr = path.toString();
+
+            for (Pattern pattern : excludePatterns0) {
+                if (pattern.matcher(pathStr).matches())
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Meta entry.
+     */
+    private static class MetaEntry {
+        /** Queue node. */
+        private final Node<GridCacheEntry<GridGgfsBlockKey, byte[]>> node;
+
+        /** Data size. */
+        private final int size;
+
+        /**
+         * Constructor.
+         *
+         * @param node Queue node.
+         * @param size Data size.
+         */
+        private MetaEntry(Node<GridCacheEntry<GridGgfsBlockKey, byte[]>> node, int size) {
+            assert node != null;
+            assert size >= 0;
+
+            this.node = node;
+            this.size = size;
+        }
+
+        /**
+         * @return Queue node.
+         */
+        private Node<GridCacheEntry<GridGgfsBlockKey, byte[]>> node() {
+            return node;
+        }
+
+        /**
+         * @return Data size.
+         */
+        private int size() {
+            return size;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicyMBean.java
new file mode 100644
index 0000000..994a227
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/GridCacheGgfsPerBlockLruEvictionPolicyMBean.java
@@ -0,0 +1,93 @@
+/*
+ * 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.ignite.cache.eviction.ggfs;
+
+import org.apache.ignite.mbean.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * MBean for {@code GGFS per-block LRU} eviction policy.
+ */
+@IgniteMBeanDescription("MBean for GGFS per-block LRU cache eviction policy.")
+public interface GridCacheGgfsPerBlockLruEvictionPolicyMBean {
+    /**
+     * Gets maximum allowed size of all blocks in bytes.
+     *
+     * @return Maximum allowed size of all blocks in bytes.
+     */
+    @IgniteMBeanDescription("Maximum allowed size of all blocks in bytes.")
+    public long getMaxSize();
+
+    /**
+     * Sets maximum allowed size of data in all blocks in bytes.
+     *
+     * @param maxSize Maximum allowed size of data in all blocks in bytes.
+     */
+    @IgniteMBeanDescription("Sets aximum allowed size of data in all blocks in bytes.")
+    public void setMaxSize(long maxSize);
+
+    /**
+     * Gets maximum allowed amount of blocks.
+     *
+     * @return Maximum allowed amount of blocks.
+     */
+    @IgniteMBeanDescription("Maximum allowed amount of blocks.")
+    public int getMaxBlocks();
+
+    /**
+     * Sets maximum allowed amount of blocks.
+     *
+     * @param maxBlocks Maximum allowed amount of blocks.
+     */
+    @IgniteMBeanDescription("Sets maximum allowed amount of blocks.")
+    public void setMaxBlocks(int maxBlocks);
+
+    /**
+     * Gets collection of regex for paths whose blocks must not be evicted.
+     *
+     * @return Collection of regex for paths whose blocks must not be evicted.
+     */
+    @IgniteMBeanDescription("Collection of regex for paths whose blocks must not be evicted.")
+    @Nullable public Collection<String> getExcludePaths();
+
+    /**
+     * Sets collection of regex for paths whose blocks must not be evicted.
+     *
+     * @param excludePaths Collection of regex for paths whose blocks must not be evicted.
+     */
+    @IgniteMBeanDescription("Sets collection of regex for paths whose blocks must not be evicted.")
+    public void setExcludePaths(@Nullable Collection<String> excludePaths);
+
+    /**
+     * Gets current size of data in all blocks.
+     *
+     * @return Current size of data in all blocks.
+     */
+    @IgniteMBeanDescription("Current size of data in all blocks.")
+    public long getCurrentSize();
+
+    /**
+     * Gets current amount of blocks.
+     *
+     * @return Current amount of blocks.
+     */
+    @IgniteMBeanDescription("Current amount of blocks.")
+    public int getCurrentBlocks();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7b1a738d/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/package.html
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/package.html b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/package.html
new file mode 100644
index 0000000..7505d73
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/ggfs/package.html
@@ -0,0 +1,23 @@
+<!--
+  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.
+  -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+<!-- Package description. -->
+Contains GGFS LRU eviction policy implementations.
+</body>
+</html>


Mime
View raw message