g595.Manucharyan.task3

homework-g595-manucharyan/pom.xml

@@ -10,7 +10,6 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>homework-g595-manucharyan</artifactId>
-    <packaging>pom</packaging>
     <version>1.0.0</version>
 
     <dependencies>

homework-g595-manucharyan/src/main/java/ru/mipt/java2016/homework/g595/manucharyan/task3/ConcreteStrategyDoubleRandomAccess.java

@@ -0,0 +1,21 @@
+package ru.mipt.java2016.homework.g595.manucharyan.task3;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * @author Vardan Manucharyan
+ * @since 30.10.16
+ */
+public class ConcreteStrategyDoubleRandomAccess implements SerializationStrategyRandomAccess<Double> {
+    @Override
+    public void serializeToFile(Double value, DataOutput output) throws IOException {
+        output.writeDouble(value);
+    }
+
+    @Override
+    public Double deserializeFromFile(DataInput input) throws IOException {
+        return input.readDouble();
+    }
+}

homework-g595-manucharyan/src/main/java/ru/mipt/java2016/homework/g595/manucharyan/task3/ConcreteStrategyIntegerRandomAccess.java

@@ -0,0 +1,21 @@
+package ru.mipt.java2016.homework.g595.manucharyan.task3;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * @author Vardan Manucharyan
+ * @since 30.10.16
+ */
+public class ConcreteStrategyIntegerRandomAccess implements SerializationStrategyRandomAccess<Integer> {
+    @Override
+    public void serializeToFile(Integer value, DataOutput output) throws IOException {
+        output.writeInt(value);
+    }
+
+    @Override
+    public Integer deserializeFromFile(DataInput input) throws IOException {
+        return input.readInt();
+    }
+}

homework-g595-manucharyan/src/main/java/ru/mipt/java2016/homework/g595/manucharyan/task3/ConcreteStrategyStringRandomAccess.java

@@ -0,0 +1,22 @@
+package ru.mipt.java2016.homework.g595.manucharyan.task3;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * @author Vardan Manucharyan
+ * @since 30.10.16
+ */
+public class ConcreteStrategyStringRandomAccess implements SerializationStrategyRandomAccess<String> {
+    @Override
+    public void serializeToFile(String value, DataOutput output) throws IOException {
+        output.writeUTF(value);
+    }
+
+    @Override
+    public String deserializeFromFile(DataInput input) throws IOException {
+        return input.readUTF();
+    }
+
+}

homework-g595-manucharyan/src/main/java/ru/mipt/java2016/homework/g595/manucharyan/task3/OptimisedKeyValueStorage.java

@@ -0,0 +1,278 @@
+package ru.mipt.java2016.homework.g595.manucharyan.task3;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
+
+/**
+ * @author Vardan Manucharyan
+ * @since 20.11.2016.
+ */
+public class OptimisedKeyValueStorage<K, V> implements KeyValueStorage<K, V> {
+
+    private static final long MAX_CACHE_SIZE = 100L;
+    private static final double FILLING_PERCENTAGE = 0.5; //when we need clean storage from deleted values
+    private static long deletedCount; //number of deleted elements
+
+    private final SerializationStrategyRandomAccess<K> keySerializationStrategy;
+    private final SerializationStrategyRandomAccess<V> valueSerializationStrategy;
+
+    //consist keys and offsets(the pair of begin and length)
+    private Map<K, Long> base = new HashMap<>();
+    private Map<K, V> cache = new HashMap<>();
+
+    private long maxOffset;
+    private final String pathname;
+    private final String storageName = "storage.txt";
+    private RandomAccessFile mapStorage;
+    private final String mapStorageName = "mapStorage.txt";
+
+    private File mutexFile; // для многопоточности
+    private boolean isClosed;
+
+    public OptimisedKeyValueStorage(SerializationStrategyRandomAccess<K> keySerializationStrategy,
+                                    SerializationStrategyRandomAccess<V> valueSerializaionStrategy,
+                                    String path) throws IOException {
+
+        this.keySerializationStrategy = keySerializationStrategy;
+        this.valueSerializationStrategy = valueSerializaionStrategy;
+        maxOffset = 0L;
+        deletedCount = 0L;
+        pathname = path;
+        isClosed = false;
+
+        mutexFile = new File(pathname, "Mutex");
+        if (!mutexFile.createNewFile()) {
+            throw new RuntimeException("Can't synchronize!");
+        }
+
+        File directory = new File(pathname);
+        if (!directory.isDirectory()) {
+            throw new RuntimeException("wrong path");
+        }
+
+        try {
+            File file2 = new File(path, mapStorageName);
+            mapStorage = new RandomAccessFile(file2, "rw");
+
+            downloadDataFromStorage();
+        } catch (IOException exception) {
+            throw new RuntimeException("Can't create a storage!");
+        }
+    }
+
+    /**
+     * Возвращает значение для данного ключа, если оно есть в хранилище.
+     * Иначе возвращает null.
+     */
+    @Override
+    public synchronized V read(K key) {
+        if (!exists(key)) {
+            return null;
+        } else {
+            try {
+                if (cache.get(key) != null) {
+                    return cache.get(key);
+                }
+                File file = new File(pathname, storageName);
+                RandomAccessFile storage = new RandomAccessFile(file, "rw");
+
+                Long offset = base.get(key);
+                storage.seek(offset);
+                V res = valueSerializationStrategy.deserializeFromFile(storage);
+                storage.close();
+                return res;
+            } catch (Exception exception) {
+                throw new RuntimeException("Can't read from storage");
+            }
+        }
+    }
+
+    /**
+     * Возвращает true, если данный ключ есть в хранилище
+     */
+    @Override
+    public boolean exists(K key) {
+        isClose();
+
+        if (cache.containsKey(key)) {
+            return true;
+        }
+        return base.containsKey(key);
+    }
+
+    /**
+     * Записывает в хранилище пару ключ-значение.
+     */
+    @Override
+    public synchronized void write(K key, V value) {
+        isClose();
+
+        cache.put(key, value);
+        base.put(key, 0L);
+
+        if (cache.size() > MAX_CACHE_SIZE) {
+            writeCacheToStorage();
+        }
+    }
+
+    /**
+     * Удаляет пару ключ-значение из хранилища.
+     */
+    @Override
+    public synchronized void delete(K key) {
+        isClose();
+
+        cache.remove(key);
+        base.remove(key);
+        deletedCount++;
+
+        if (deletedCount / size() > FILLING_PERCENTAGE) {
+            reorganiseStorage();
+        }
+    }
+
+    /**
+     * Читает все ключи в хранилище.
+     * <p>
+     * Итератор должен бросать {@link java.util.ConcurrentModificationException},
+     * если данные в хранилище были изменены в процессе итерирования.
+     */
+    @Override
+    public Iterator<K> readKeys() {
+        isClose();
+
+        return base.keySet().iterator();
+
+    }
+
+    /**
+     * Возвращает число ключей, которые сейчас в хранилище.
+     */
+    @Override
+    public int size() {
+        isClose();
+
+        return base.size();
+    }
+
+    @Override
+    public synchronized void close() {
+        if (isClosed) {
+            return;
+        }
+
+        reorganiseStorage();
+        uploadDataToStorage();
+
+        try {
+            mapStorage.close();
+        } catch (IOException excetion) {
+            throw new RuntimeException("Can't close storage");
+        } finally {
+            isClosed = true;
+            cache.clear();
+            base.clear();
+            mutexFile.delete();
+        }
+    }
+
+    private void downloadDataFromStorage() {
+        try {
+
+            int count = -1;
+            count = mapStorage.readInt();
+
+            for (int i = 0; i < count; i++) {
+                K key = keySerializationStrategy.deserializeFromFile(mapStorage);
+                Long tmp = mapStorage.readLong();
+                base.put(key, tmp);
+                maxOffset = Math.max(maxOffset, tmp);
+            }
+        } catch (IOException exception) {
+            base.clear();
+            //throw new RuntimeException("Trouble with storage.db");
+        }
+    }
+
+    private void uploadDataToStorage() {
+        try {
+            mapStorage.close();
+            File file = new File(pathname, mapStorageName);
+            assert (file.delete());
+            file = new File(pathname, mapStorageName);
+            mapStorage = new RandomAccessFile(file, "rw");
+
+            mapStorage.writeInt(size());
+            for (HashMap.Entry<K, Long> entry : base.entrySet()) {
+                keySerializationStrategy.serializeToFile(entry.getKey(), mapStorage);
+                mapStorage.writeLong(entry.getValue());
+            }
+        } catch (IOException exception) {
+            throw new RuntimeException("Trouble with storage.db");
+        }
+    }
+
+    private void writeCacheToStorage() {
+        isClose();
+        try {
+            File file = new File(pathname, storageName);
+            RandomAccessFile storage = new RandomAccessFile(file, "rw");
+
+            for (HashMap.Entry<K, V> entry : cache.entrySet()) {
+                storage.seek(maxOffset);
+                valueSerializationStrategy.serializeToFile(entry.getValue(), storage);
+                long curOffset = storage.getFilePointer();
+                base.put(entry.getKey(), maxOffset);
+                maxOffset = curOffset;
+            }
+            storage.close();
+            cache.clear();
+
+        } catch (IOException exception) {
+            throw new RuntimeException("Can't write cache on the disk");
+        }
+
+    }
+
+    private void reorganiseStorage() {
+        try {
+            File file1 = new File(pathname, storageName);
+            RandomAccessFile storage = new RandomAccessFile(file1, "rw");
+
+            File file = new File(pathname, "newStorage.txt");
+            RandomAccessFile newStorage = new RandomAccessFile(file, "rw");
+
+            writeCacheToStorage();
+
+            for (HashMap.Entry<K, Long> entry : base.entrySet()) {
+                storage.seek(entry.getValue());
+                Long tmp = newStorage.getFilePointer();
+                valueSerializationStrategy.serializeToFile(read(entry.getKey()), newStorage);
+                base.put(entry.getKey(), tmp);
+            }
+            deletedCount = 0;
+
+            storage.close();
+            assert (file1.delete());
+
+            newStorage.close();
+            assert (file.renameTo(file1));
+
+        } catch (IOException exception) {
+            throw new RuntimeException("Can't reorganise storage!");
+        }
+    }
+
+    private void isClose() {
+        if (isClosed) {
+            throw new IllegalStateException("Can't write: storage is closed");
+        }
+    }
+}
+

homework-g595-manucharyan/src/main/java/ru/mipt/java2016/homework/g595/manucharyan/task3/SerializationStrategyRandomAccess.java

@@ -0,0 +1,16 @@
+package ru.mipt.java2016.homework.g595.manucharyan.task3;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+/**
+ * @author Vardan Manucharyan
+ * @since 30.10.16
+ */
+public interface SerializationStrategyRandomAccess<Value> {
+
+    void serializeToFile(Value value, DataOutput output) throws IOException;
+
+    Value deserializeFromFile(DataInput input) throws IOException;
+}

homework-g595-manucharyan/src/test/java/ru/mipt/java2016/homework/g595/manucharyan/task3/ConcreteStrategyStudentKeyRandomAccess.java

@@ -0,0 +1,25 @@
+package ru.mipt.java2016.homework.g595.manucharyan.task3;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import ru.mipt.java2016.homework.tests.task2.StudentKey;
+
+/**
+ * @author Vardan Manucharyan
+ * @since 30.10.16
+ */
+public class ConcreteStrategyStudentKeyRandomAccess implements SerializationStrategyRandomAccess<StudentKey> {
+
+    @Override
+    public void serializeToFile(StudentKey value, DataOutput output) throws IOException {
+        output.writeInt(value.getGroupId());
+        output.writeUTF(value.getName());
+    }
+
+    @Override
+    public StudentKey deserializeFromFile(DataInput input) throws IOException {
+        return new StudentKey(input.readInt(), input.readUTF());
+    }
+}