28a36102f0ce5ccc870f95ad3211bebbd726bbe2
[sixth-data.git] / src / main / java / eu / svjatoslav / sixth / data / store / file / FileDataStore.java
1 /*
2  * Sixth Data. Copyright ©2012-2018, Svjatoslav Agejenko, svjatoslav@svjatoslav.eu
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of version 3 of the GNU Lesser General Public License
6  * or later as published by the Free Software Foundation.
7  */
8
9 package eu.svjatoslav.sixth.data.store.file;
10
11 import eu.svjatoslav.sixth.data.store.DataStore;
12
13 import java.io.File;
14 import java.io.FileNotFoundException;
15 import java.io.IOException;
16 import java.io.RandomAccessFile;
17 import java.util.List;
18
19 /**
20  * DataStore backed by single filesystem file.
21  */
22 public class FileDataStore implements DataStore {
23
24     final MetaData metaData = new MetaData(this);
25     final EntryAllocationTable entryAllocationTable = new EntryAllocationTable(this);
26     RandomAccessFile randomAccessFile;
27
28     public FileDataStore(final File backingFile) throws IOException {
29         if (backingFile.exists())
30             initializeFromExistingFile(backingFile);
31         else
32             initializeNewFile(backingFile);
33     }
34
35     @Override
36     public synchronized void close() throws IOException {
37         metaData.writeFileHeader();
38         randomAccessFile.close();
39     }
40
41     @Override
42     public synchronized int createRecord(final byte[] value) throws IOException {
43
44         if (metaData.entriesTableNeedsIncreasing())
45             increaseEntriesTable();
46
47         final int newEntryId = entryAllocationTable.getNewUnusedEntryId();
48
49         final long currentLocation = metaData
50                 .allocateStorageSpace(value.length);
51
52         final EntryRecord record = new EntryRecord(newEntryId, currentLocation,
53                 value.length);
54
55         metaData.increaseUsedEntriesCount();
56
57         record.save(this);
58
59         randomAccessFile.seek(currentLocation);
60         randomAccessFile.write(value);
61
62         // update header to increase crash resilience
63         metaData.writeFileHeader();
64         return newEntryId;
65     }
66
67     @Override
68     public synchronized void deleteRecord(final int id) throws IOException {
69         final EntryRecord entryRecord = new EntryRecord(this, id);
70
71         if (!entryRecord.isUsed())
72             throw new RuntimeException("Record already does not exist!");
73
74         entryRecord.clear();
75         entryRecord.save(this);
76         metaData.decreaseUsedEntriesCount();
77
78         // update header to increase crash resilience
79         metaData.writeFileHeader();
80     }
81
82     public long getDefragmentationStartAddress(final int allowedFragmentationPercent,
83                                                final List<EntryRecord> allEntryRecords) {
84
85         final VacuumContext context = new VacuumContext(this,
86                 metaData.allocateStorageSpace(0), allowedFragmentationPercent);
87
88         for (int i = allEntryRecords.size() - 1; i >= 0; i--) {
89             final EntryRecord entryRecord = allEntryRecords.get(i);
90             context.analyzeEntry(entryRecord);
91         }
92         context.analyzeStartOfDataArea();
93
94         return context.defragmentationStartAddress;
95     }
96
97     public void increaseEntriesTable() throws IOException {
98         final List<EntryRecord> allEntryRecords = entryAllocationTable
99                 .loadAllEntryRecords();
100
101         final int newEntriesTableSize = metaData.getEntriesTableSize() * 2;
102
103         final long dataEvacuationTreshold = metaData
104                 .getEntriesStorageAreaStart(newEntriesTableSize);
105
106         metaData.ensureMinimumCurrentLocation(dataEvacuationTreshold);
107
108         for (final EntryRecord record : allEntryRecords)
109             if (record.location < dataEvacuationTreshold) {
110
111                 final long newEntryLocation = metaData
112                         .allocateStorageSpace(record.length);
113
114                 // read record content
115                 final byte[] entryContent = new byte[record.length];
116
117                 randomAccessFile.seek(record.location);
118                 randomAccessFile.readFully(entryContent);
119
120                 // write record content to new location
121                 randomAccessFile.seek(newEntryLocation);
122                 randomAccessFile.write(entryContent);
123
124                 // update record header
125                 record.location = newEntryLocation;
126                 record.save(this);
127             }
128
129         entryAllocationTable.enlarge(newEntriesTableSize);
130         System.out.println("Entries table increased.");
131
132         // update header to increase crash resilience
133         metaData.writeFileHeader();
134     }
135
136     public void initializeFromExistingFile(final File backingFile)
137             throws IOException {
138         try {
139             randomAccessFile = new RandomAccessFile(backingFile, "rw");
140
141             metaData.readFileHeader();
142
143         } catch (final FileNotFoundException e) {
144             throw new RuntimeException(e);
145         }
146     }
147
148     public void initializeNewFile(final File backingFile) throws IOException {
149         try {
150             randomAccessFile = new RandomAccessFile(backingFile, "rw");
151         } catch (final FileNotFoundException e) {
152             throw new RuntimeException(e);
153         }
154
155         metaData.initializeNewFile();
156
157         entryAllocationTable.initializeNewFile();
158     }
159
160     public int readInt(final long position) throws IOException {
161         randomAccessFile.seek(position);
162         return randomAccessFile.readInt();
163     }
164
165     public long readLong(final long position) throws IOException {
166         randomAccessFile.seek(position);
167         return randomAccessFile.readLong();
168     }
169
170     @Override
171     public synchronized byte[] readRecord(final int id) throws IOException {
172
173         final EntryRecord entryRecord = new EntryRecord(this, id);
174
175         if (!entryRecord.isUsed())
176             throw new RuntimeException("Entity record by id: " + id
177                     + " does not exist.");
178
179         final byte[] result = new byte[entryRecord.length];
180
181         randomAccessFile.seek(entryRecord.location);
182         randomAccessFile.readFully(result);
183
184         return result;
185     }
186
187     public long relocateEntry(final EntryRecord record, final long newLocation)
188             throws IOException {
189
190         if (record.location != newLocation) {
191             System.out.println("Relocating record " + record.id + " from: "
192                     + record.location + " to: " + newLocation);
193
194             final byte[] result = new byte[record.length];
195
196             randomAccessFile.seek(record.location);
197             randomAccessFile.readFully(result);
198
199             randomAccessFile.seek(newLocation);
200             randomAccessFile.write(result);
201
202             record.location = newLocation;
203             record.save(this);
204         }
205
206         return newLocation + record.length;
207     }
208
209     @Override
210     public synchronized void updateRecord(final int id, final byte[] value)
211             throws IOException {
212
213         final EntryRecord entryRecord = new EntryRecord(this, id);
214
215         if (!entryRecord.isUsed())
216             throw new RuntimeException("Entry record is empty!");
217
218         final int newDataSize = value.length;
219
220         if (entryRecord.length >= newDataSize) {
221             // update record in place
222             if (entryRecord.length != newDataSize) {
223                 entryRecord.length = newDataSize;
224                 entryRecord.save(this);
225             }
226         } else {
227             // save record to the new location
228             entryRecord.location = metaData.allocateStorageSpace(newDataSize);
229             entryRecord.length = newDataSize;
230             entryRecord.save(this);
231         }
232
233         randomAccessFile.seek(entryRecord.location);
234         randomAccessFile.write(value);
235
236         // update header to increase crash resilience
237         metaData.writeFileHeader();
238     }
239
240     /**
241      * Defragment empty space.
242      *
243      * @param allowedFragmentationPercent allowed maximum percentage of free space, relative to total
244      *                                    used space.
245      * @throws IOException
246      */
247     public void vacuum(final int allowedFragmentationPercent) throws IOException {
248
249         final List<EntryRecord> allEntryRecords = entryAllocationTable
250                 .loadAllEntryRecords();
251
252         final long defragmentationStart = getDefragmentationStartAddress(
253                 allowedFragmentationPercent, allEntryRecords);
254
255         long nextFreeSpace = defragmentationStart;
256
257         for (final EntryRecord record : allEntryRecords) {
258             if (record.location < defragmentationStart)
259                 continue;
260
261             nextFreeSpace = relocateEntry(record, nextFreeSpace);
262
263         }
264
265         metaData.setCurrentLocation(nextFreeSpace);
266
267         // update header to increase crash resilience
268         metaData.writeFileHeader();
269     }
270
271     public void writeInt(final long position, final int value)
272             throws IOException {
273         randomAccessFile.seek(position);
274         randomAccessFile.writeInt(value);
275     }
276
277     public void writeLong(final long position, final long value)
278             throws IOException {
279         randomAccessFile.seek(position);
280         randomAccessFile.writeLong(value);
281     }
282 }