|
1 package com.daffodilwoods.daffodildb.server.backup;
2
3 import java.io.File  ;
4 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
5 DatabaseConstants;
6 import java.io.RandomAccessFile ;
7 import com.daffodilwoods.database.resource.DException;
8 import java.io.*;
9 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
10 DatabaseProperties;
11 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
12 DRandomAccessFile;
13 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
14 PersistentDatabase;
15 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
16 FileGenerator;
17 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
18 PersistentSystem;
19 import java.util.Properties ;
20 import com.daffodilwoods.daffodildb.server.serversystem.ServerSystem;
21 import com.daffodilwoods.daffodildb.server.datadictionarysystem.SystemTables;
22 import com.daffodilwoods.daffodildb.server.datasystem.interfaces._DataTable;
23 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.
24 DatabaseUserTableIterator;
25 import com.daffodilwoods.daffodildb.utils.BufferRange;
26 import com.daffodilwoods.daffodildb.utils.byteconverter.CCzufDpowfsufs;
27 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.
28 _TableCharacteristics;
29 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.Utility;
30 import com.daffodilwoods.daffodildb.server.datasystem.interfaces._DatabaseUser;
31 import com.daffodilwoods.daffodildb.utils.comparator.CTusjohJoTfotjujwfDpnqbsbups;
32 import java.util.ArrayList ;
33 import com.daffodilwoods.daffodildb.server.datasystem.interfaces._UserTableOperations;
34
35
45
46 public class Backup {
47 private boolean isReadOnlyMode = false;
48 public Backup() throws DException {
49 }
50
51
72
73 public void offlineBackup(String sourcePath, String destination,String databaseNameSource,
74 String databaseNameDestination, boolean overwrite) throws DException {
75 if (sourcePath.equalsIgnoreCase(destination))
76 throw new DException("DSE5574", null);
77 checkDatabase(sourcePath,databaseNameSource);
78 if (databaseNameSource.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
79 throw new DException("DSE5570", new Object [] {databaseNameSource});
80 if (databaseNameDestination.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
81 throw new DException("DSE5571", new Object [] {databaseNameDestination});
82
83 RandomAccessFile raf = null;
84 ServerSystem ss = null;
85 try {
86 raf = checkDatabaseInUse(sourcePath);
87 String systemDatabaseSourcePath = sourcePath + File.separator +
88 DatabaseConstants.SYSTEMDATABASE + File.separator +
89 DatabaseConstants.SYSTEMDATABASE + ".ddb";
90 String systemDatabaseDestinationPath = destination + File.separator +
91 DatabaseConstants.SYSTEMDATABASE + File.separator +
92 DatabaseConstants.SYSTEMDATABASE + ".ddb";
93 File ff = new File (systemDatabaseSourcePath);
94 File df = new File (systemDatabaseDestinationPath);
95 if (!df.exists()) {
96 copyDatabase(systemDatabaseSourcePath, systemDatabaseDestinationPath,
97 destination, databaseNameDestination);
98 ss = new ServerSystem(destination);
99 PersistentSystem ps = new PersistentSystem(destination,isReadOnlyMode);
100 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(DatabaseConstants.SYSTEMDATABASE);
101 _DataTable databaseInfoTable = (_DataTable) pd.getTable(SystemTables.DATABASEINFO);
102 DatabaseUserTableIterator databaseTableIteartor = (DatabaseUserTableIterator) databaseInfoTable.getIterator();
103 ArrayList list = new ArrayList ();
104 list.add(SystemTables.DATABASEINFO);
105 _DatabaseUser user = pd.getDatabaseUser(list);
106
107 if (databaseTableIteartor.first()) {
108 do {
109 databaseTableIteartor.delete(user);
110 }
111 while (databaseTableIteartor.next());
112 }
113 user.writeToFile();
114 createDatabase(sourcePath, destination, databaseNameSource,
115 databaseNameDestination);
116 }
117 else {
118 ss = new ServerSystem(destination);
119 PersistentSystem ps = new PersistentSystem(destination,isReadOnlyMode);
120 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(
121 DatabaseConstants.SYSTEMDATABASE);
122 checkDatabase(pd);
123 try {
124 pd = (PersistentDatabase) ps.getDatabase(databaseNameDestination);
125 if (pd != null && overwrite) {
126 ps.removeDatabase(databaseNameDestination);
127 ps.dropDatabase(databaseNameDestination);
128 createDatabase(sourcePath, destination, databaseNameSource,
129 databaseNameDestination);
130 }
131 else {
132 throw new DException("DSE5567", new Object []{databaseNameDestination});
133 }
134 }
135 catch (DException ex) {
136 if (ex.getDseCode().equalsIgnoreCase("DSE316"))
137 createDatabase(sourcePath, destination, databaseNameSource,
138 databaseNameDestination);
139 else
140 throw ex;
141 }
142 }
143 }
144 finally {
145 try {
146 if (raf != null)
147 raf.close();
148 }
149 catch (Exception e) {
150 throw new DException("DSE5564", new Object [] {e.getMessage()});
151 }
152 }
153 }
154
155
167
168 private void offLineBackupUserDatabase(String sourcePath, String destination,
169 String databaseNameSource,
170 String databaseNameDestination,
171 boolean ifExists, boolean overwrite) throws
172 DException {
173
174 if (!ifExists) {
175 String userDatabaseSourcePath = sourcePath + File.separator + databaseNameSource +
176 File.separator + databaseNameSource + ".ddb";
177 String userDatabaseDestinationPath = destination + File.separator +
178 databaseNameDestination + File.separator + databaseNameDestination +
179 ".ddb";
180 copyDatabase(userDatabaseSourcePath, userDatabaseDestinationPath, destination,
181 databaseNameDestination);
182 }
183 else {
184 ServerSystem ss = new ServerSystem(destination);
185 PersistentSystem ps = new PersistentSystem(destination,isReadOnlyMode);
186 PersistentDatabase pd = null;
187 try {
188 pd = (PersistentDatabase) ps.getDatabase(databaseNameDestination);
189 if (pd != null && overwrite) {
190 ps.removeDatabase(databaseNameDestination);
191 ps.dropDatabase(databaseNameDestination);
192 createDatabase(sourcePath, destination, databaseNameSource,
193 databaseNameDestination);
194 }
195 else
196 throw new DException("DSE5567", new Object []{databaseNameDestination});
197 }
198 catch (DException ex) {
199 if (ex.getDseCode().equalsIgnoreCase("DSE316"))
200 createDatabase(sourcePath, destination, databaseNameSource,
201 databaseNameDestination);
202 else
203 throw ex;
204 }
205 }
206 }
207
208
221 private void createDatabase(String sourcePath, String destination,
222 String databaseNameSource,
223 String databaseNameDestination) throws DException {
224 int index = 0;
225 ServerSystem ss = new ServerSystem(sourcePath);
226 PersistentSystem ps = new PersistentSystem(sourcePath,isReadOnlyMode);
227 PersistentDatabase systemDatabaseSourcePath = (PersistentDatabase)ps.getDatabase(DatabaseConstants.SYSTEMDATABASE);
228 _DataTable databaseInfoTable = (_DataTable) systemDatabaseSourcePath.getTable(SystemTables.
229 DATABASEINFO);
230 DatabaseUserTableIterator databaseTableIteartor = (
231 DatabaseUserTableIterator) databaseInfoTable.getIterator();
232 Object [] databaseProperties = null;
233 BufferRange bytesOfDestinationDatabaseName = new BufferRange(CCzufDpowfsufs.
234 getBytes(databaseNameDestination, databaseNameDestination.length(), false));
235 BufferRange bytesOfSourceDatabaseName = new BufferRange(CCzufDpowfsufs.
236 getBytes(databaseNameSource, databaseNameSource.length(), false));
237 CTusjohJoTfotjujwfDpnqbsbups stringComparator = new CTusjohJoTfotjujwfDpnqbsbups();
238
239 if (databaseTableIteartor.first())
240 do {
241 BufferRange[] bytesGot = (BufferRange[]) databaseTableIteartor.
242 getColumnValues();
243 if (stringComparator.compare(bytesGot[0], bytesOfSourceDatabaseName) ==
244 0) {
245 _TableCharacteristics tableCharacteristics = databaseInfoTable.
246 getTableCharacteristics();
247 databaseProperties = (Object []) tableCharacteristics.getObject(
248 bytesGot);
249 break;
250 }
251 }
252 while (databaseTableIteartor.next());
253 Object [] databaseProps = Utility.convertIntoFieldBase(databaseProperties);
254 String initialSize = (String ) databaseProps[1];
255 int incrementFactor = databaseProps[4].hashCode();
256 boolean unicodeSupport = ( (Boolean ) databaseProps[5]).booleanValue();
257 boolean multiFilesSupport = ( (Boolean ) databaseProps[6]).booleanValue();
258 boolean encryptionSupport = ( (Boolean ) databaseProps[7]).booleanValue();
259 String encrytpionAlgo = (String ) databaseProps[8];
260 String encryptionKey = (String ) databaseProps[9];
261 String clusterSize = (String ) databaseProps[10];
262 if (multiFilesSupport) {
263 DatabaseUserTableIterator databaseFileInfoIterator = (
264 DatabaseUserTableIterator) ( (_DataTable) systemDatabaseSourcePath.getTable(
265 SystemTables.DATABASEFILEINFO)).getIterator();
266 if (databaseFileInfoIterator.first())
267 do {
268 BufferRange[] bytesGot = (BufferRange[]) databaseFileInfoIterator.
269 getColumnValues();
270 if (stringComparator.compare(bytesGot[0],
271 bytesOfSourceDatabaseName) == 0) {
272 index = CCzufDpowfsufs.getInt(bytesGot[1].getBytes()).hashCode();
273 break;
274 }
275 }
276 while (databaseTableIteartor.next());
277 }
278
279 _DataTable table = (_DataTable) systemDatabaseSourcePath.getTable(SystemTables.SCHEDULEINFO);
280 DatabaseUserTableIterator scheduleInfoTableIteartor = (DatabaseUserTableIterator) table.getIterator();
281 ArrayList scheduleEntries = new ArrayList ();
282 if (scheduleInfoTableIteartor.first())
283 do {
284 BufferRange[] bytesGot = (BufferRange[])scheduleInfoTableIteartor.getColumnValues();
285 if (stringComparator.compare(bytesGot[0],bytesOfSourceDatabaseName) == 0) {
286 scheduleEntries.add(bytesGot);
287 }
288 }
289 while (scheduleInfoTableIteartor.next());
290 ss = new ServerSystem(destination);
291 ps = new PersistentSystem(destination,isReadOnlyMode);
292 ps.createDatabase(databaseNameDestination, initialSize, incrementFactor,
293 unicodeSupport, multiFilesSupport, encryptionSupport,
294 encrytpionAlgo, encryptionKey, clusterSize);
295
296 if (multiFilesSupport) {
297 PersistentDatabase systemDatabaseDestinationPath = (PersistentDatabase) ps.getDatabase(
298 DatabaseConstants.SYSTEMDATABASE);
299 DatabaseUserTableIterator databaseFileInfoIterator = (
300 DatabaseUserTableIterator) ( (_DataTable) systemDatabaseDestinationPath.getTable(
301 SystemTables.DATABASEFILEINFO)).getIterator();
302 if (databaseFileInfoIterator.first())
303 do {
304 BufferRange[] bytesGot = (BufferRange[]) databaseFileInfoIterator.getColumnValues();
305 if (stringComparator.compare(bytesGot[0],bytesOfDestinationDatabaseName) == 0) {
306 _DatabaseUser user = systemDatabaseDestinationPath.getDatabaseUser();
307 databaseFileInfoIterator.update(user,
308 new BufferRange[] {bytesOfDestinationDatabaseName,
309 new
310 BufferRange(CCzufDpowfsufs.
311 getBytes(new Integer (index)))});
312 user.writeToFile();
313 break;
314 }
315 }
316 while (databaseTableIteartor.next());
317 }
318
319 if (scheduleEntries.size() > 0) {
320 PersistentDatabase systemDatabaseDestination = (PersistentDatabase) ps.getDatabase(DatabaseConstants.SYSTEMDATABASE);
321 _DataTable scheduleInfoTable = (_DataTable)systemDatabaseDestination.getTable(SystemTables.SCHEDULEINFO);
322 DatabaseUserTableIterator scheduleInfoTableIteartorDestination = (DatabaseUserTableIterator) scheduleInfoTable.getIterator();
323 ArrayList list = new ArrayList ();
324 list.add(SystemTables.SCHEDULEINFO);
325 _DatabaseUser user = systemDatabaseDestination.getDatabaseUser(list);
326 for (int i = 0; i < scheduleEntries.size(); i++) {
327 BufferRange[] entry = (BufferRange[]) scheduleEntries.get(i);
328 entry[0] = bytesOfDestinationDatabaseName;
329 ( (_UserTableOperations) scheduleInfoTableIteartorDestination).insert(user,entry);
330 }
331 user.writeToFile();
332 }
333
334 deleteFiles(databaseNameDestination, destination);
335 offLineBackupUserDatabase(sourcePath, destination, databaseNameSource,
336 databaseNameDestination, false, true);
337 }
338
339
346 private void deleteFiles(String databaseName, String destination) throws
347 DException {
348 String path = destination + File.separator + databaseName + File.separator +
349 databaseName + ".ddb";
350 File f = new File (path);
351 f.delete();
352 File ff1 = f.getParentFile();
353 path = destination + File.separator + databaseName + File.separator +
354 DatabaseConstants.TEMPDATABASE + ".ddb";
355 File f1 = new File (path);
356 f1.delete();
357 ff1.delete();
358 }
359
360
382
383 public void RestoreBackup(String path, String destination,String databaseNameSource,
384 String databaseNameDestination, boolean overwrite) throws DException {
385 if (databaseNameSource.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
386 throw new DException("DSE5568", new Object [] {databaseNameSource});
387 if (databaseNameDestination.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
388 throw new DException("DSE5569", new Object [] {databaseNameDestination});
389 try {
390 offlineBackup(path, destination, databaseNameSource,
391 databaseNameDestination, overwrite);
392 }
393 catch (DException ex) {
394 if (ex.getDseCode().equalsIgnoreCase("DSE5567"))
395 throw new DException("DSE5566", new Object []{databaseNameDestination});
396 else
397 throw ex;
398 }
399 }
400
401
405 private void checkDatabase(PersistentDatabase pd) throws DException {
406 byte[] bytes = pd.readBytes(pd.getDatabaseProperties().
407 ISCOMPLETE_BIT_IN_DATABASE, 1);
408 Boolean isComplete = CCzufDpowfsufs.getBoolean(bytes);
409 if (!isComplete.booleanValue()) {
410 throw new DException("DSE5543", null);
411 }
412 }
413
414
420 private RandomAccessFile checkDatabaseInUse(String sourcePath) throws DException {
421 String logFile = sourcePath + File.separator + "log.lg";
422 File ff = new File (logFile);
423 boolean isDelete = false;
424 if (ff.exists()) {
425 isDelete = ff.delete();
426 if (!isDelete) {
427 ; throw new DException("DSE5564", new Object [] {});
429 }
430 }
431 RandomAccessFile raf = null;
432 try {
433 raf = new RandomAccessFile (ff, "rw");
434 }
435 catch (FileNotFoundException ex) {
436 }
437 return raf;
438 }
439
440
452 private void copyDatabase(String sourcePath, String destinationPath, String destination,String databaseNameDestination) throws DException{
453 File ff = new File (sourcePath);
454 File df = new File (destinationPath);
455 try {
456 File ff1 = ff.getParentFile();
457 ff1.mkdirs();
458 File df1 = df.getParentFile();
459 df1.mkdirs();
460 FileInputStream file = new FileInputStream(ff);
461 FileOutputStream DestinationFile = new FileOutputStream(df);
462 CopyFile cf = new CopyFile();
463 cf.copyFile(file,DestinationFile);
464 destinationPath = destinationPath.substring(0,destinationPath.lastIndexOf(File.separator));
465 File [] files = ff1.listFiles(new PowerFileFilter());
466 for (int i = 0; i < files.length; i++) {
467 FileInputStream powerFile = new FileInputStream(files[i]);
468 String name = files[i].getName();
469 if(!name.startsWith("_"))
470 name = databaseNameDestination+"_" + i +"_PowerFile.log";
471 String destinationPath1 = destinationPath + File.separator + name;
472 DestinationFile = new FileOutputStream(new File (destinationPath1));
473 cf.copyFile(powerFile,DestinationFile);
474 }
475 files = ff1.listFiles(new MultiFileFilter());
476 for (int i = 0; i < files.length; i++) {
477 FileInputStream multiFile = new FileInputStream(files[i]);
478 String name = files[i].getName();
479 if(!name.startsWith("_"))
480 name = databaseNameDestination+(i+1)+".dat";
481 String destinationPath1 = destinationPath + File.separator + name;
482 DestinationFile = new FileOutputStream(new File (destinationPath1));
483 cf.copyFile(multiFile,DestinationFile);
484 }
485 }
486 catch (Exception ex) {
487 throw new DException("DSE0",new Object [] {ex.getMessage()});
488 }
489
490 }
491
492
498 private void checkDatabase(String sourcePath,String databaseName) throws DException {
499 String databaseURLSystemDatabase = sourcePath + File.separator +DatabaseConstants.SYSTEMDATABASE;
500 String databaseURL = sourcePath + File.separator + databaseName;
501 File fs = new File (databaseURLSystemDatabase);
502
503 if (!fs.exists())
504 throw new DException("DSE5572", new Object []{sourcePath});
505 File f = new File (databaseURL);
506 if(!f.exists())
507 throw new DException("DSE5563", new Object []{databaseName});
508 checkDatabaseEntryInSystemDatabase(sourcePath,databaseName);
509 }
510
511
518 private void checkDatabaseEntryInSystemDatabase(String sourcePath,String userDatabase) throws DException{
519 ServerSystem ss1 = new ServerSystem(sourcePath);
520 PersistentSystem ps = new PersistentSystem(sourcePath,isReadOnlyMode);
521 try {
522 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(userDatabase);
523 }
524 catch (DException ex) {
525 if (ex.getDseCode().equalsIgnoreCase("DSE316"))
526 throw new DException("DSE5573",new Object []{userDatabase});
527 }
528 }
529
530
531 class PowerFileFilter
532 implements FilenameFilter {
533 public boolean accept(File dir, String name) {
534 return name.endsWith("PowerFile.log") ? true
535 : false;
536 }
537 }
538
539 class MultiFileFilter
540 implements FilenameFilter {
541 public boolean accept(File dir, String name) {
542 return name.endsWith(".dat") ? true
543 : false;
544 }
545 }
546
547 }
548 |
Popular Tags |
Java API By Example, From Geeks To Geeks.