|
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 import com.daffodilwoods.daffodildb.server.datasystem.indexsystem.IndexDatabase;
35 import com.daffodilwoods.daffodildb.server.datasystem.mergesystem.MergeDatabase;
36 import com.daffodilwoods.daffodildb.server.serversystem._Server;
37 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.DRandomAccessFileUpto3_2;
38
39
49
50 public class OfflineBackup {
51 _Server ss ;
52 public OfflineBackup(_Server serverSystem) throws DException {
53 ss = serverSystem;
54 }
55
56
77
78 public void offlineBackup(String destination,String databaseNameSource,
79 String databaseNameDestination, boolean overwrite) throws DException {
80
81 String sourcePath = ((ServerSystem)ss).getDaffodilHome();
82 if (sourcePath.equalsIgnoreCase(destination))
83 throw new DException("DSE5574", null);
84
85 checkDatabase(sourcePath,databaseNameSource);
86
87 if (databaseNameSource.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
88 throw new DException("DSE5570", new Object [] {databaseNameSource});
89
90 if (databaseNameDestination.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE+"_Bk"))
91 throw new DException("DSE5571", new Object [] {databaseNameDestination});
92
93 PersistentDatabase systemDatabaseSourcePath = (PersistentDatabase) ( (
94 IndexDatabase) ( (
95 MergeDatabase) ((ServerSystem)ss).getMergeDatabase(DatabaseConstants.SYSTEMDATABASE)).
96 getFileDatabase()).
97 getUnderLyingDatabase();
98
99 _DatabaseUser user1 = systemDatabaseSourcePath.getDatabaseUser();
100 try {
101 DRandomAccessFileUpto3_2 dRAM = systemDatabaseSourcePath.getDrandomAccessFile();
102 synchronized (dRAM) {
103
104 boolean ifExists = BackupHelper.backupSystemDatabase(dRAM,
105 destination, DatabaseConstants.SYSTEMDATABASE);
106 if (!ifExists) {
107 BackupPersistentSystem ps = new BackupPersistentSystem(destination);
108 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(
109 DatabaseConstants.SYSTEMDATABASE+"_Bk");
110 BackupHelper.removingEntriesForSchedules(pd);
111 _DataTable databaseInfoTable = (_DataTable) pd.getTable(SystemTables.
112 DATABASEINFO);
113 DatabaseUserTableIterator databaseTableIteartor = (
114 DatabaseUserTableIterator) databaseInfoTable.getIterator();
115 ArrayList list = new ArrayList ();
116 list.add(SystemTables.DATABASEINFO);
117 _DatabaseUser user = pd.getDatabaseUser(list);
118
119 if (databaseTableIteartor.first()) {
120 do {
121 databaseTableIteartor.delete(user); }
123 while (databaseTableIteartor.next());
124 }
125 user.writeToFile();
126 BackupHelper.createDatabase(user1,systemDatabaseSourcePath,destination, databaseNameSource,
127 databaseNameDestination);
128 offLineBackupUserDatabase(sourcePath, destination, databaseNameSource,
129 databaseNameDestination);
130 }
131 else {
132 BackupPersistentSystem ps = new BackupPersistentSystem(destination);
133 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(
134 DatabaseConstants.SYSTEMDATABASE+"_Bk");
135 checkDatabase(pd);
136 try {
137 pd = (PersistentDatabase) ps.getDatabase(databaseNameDestination);
138 if (pd != null && overwrite) {
139 ps.removeDatabase(databaseNameDestination);
140 ps.dropDatabase(databaseNameDestination);
141 BackupHelper.createDatabase(user1,systemDatabaseSourcePath,destination, databaseNameSource,
142 databaseNameDestination);
143 offLineBackupUserDatabase(sourcePath, destination, databaseNameSource,
144 databaseNameDestination);
145 }
146 else {
147 throw new DException("DSE5567",new Object [] {databaseNameDestination});
148 }
149 }
150 catch (DException ex) {
151 if (ex.getDseCode().equalsIgnoreCase("DSE316")){
152 BackupHelper.createDatabase(user1,systemDatabaseSourcePath,destination, databaseNameSource,
153 databaseNameDestination);
154 offLineBackupUserDatabase(sourcePath, destination, databaseNameSource,
155 databaseNameDestination);
156 }
157 else
158 throw ex;
159 }
160 }
161 }
162 }
163 finally {
164 user1.releaseCluster();
165 }
166 }
167 public void offlineRestore(String sourcePath, String destination,String databaseNameSource,
168 String databaseNameDestination, boolean overwrite) throws DException {
169
170 synchronized(ss) {
171
172 RandomAccessFile raf = null;
173 ServerSystem ss = null;
174 try {
175 raf = checkDatabaseInUse(sourcePath);
176 String systemDatabaseSourcePath = sourcePath + File.separator +
177 DatabaseConstants.SYSTEMDATABASE + "_Bk" + File.separator +
178 DatabaseConstants.SYSTEMDATABASE + ".ddb";
179 String systemDatabaseDestinationPath = destination + File.separator +
180 DatabaseConstants.SYSTEMDATABASE + File.separator +
181 DatabaseConstants.SYSTEMDATABASE + ".ddb";
182 File ff = new File (systemDatabaseSourcePath);
183 File df = new File (systemDatabaseDestinationPath);
184 if (!df.exists()) {
185 copyDatabase(systemDatabaseSourcePath, systemDatabaseDestinationPath,
186 destination, databaseNameDestination);
187 RestorePersistentSystem ps = new RestorePersistentSystem(destination);
188 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(
189 DatabaseConstants.SYSTEMDATABASE);
190 _DataTable databaseInfoTable = (_DataTable) pd.getTable(SystemTables.
191 DATABASEINFO);
192 DatabaseUserTableIterator databaseTableIteartor = (
193 DatabaseUserTableIterator) databaseInfoTable.getIterator();
194 ArrayList list = new ArrayList ();
195 list.add(SystemTables.DATABASEINFO);
196 _DatabaseUser user = pd.getDatabaseUser(list);
197
198 if (databaseTableIteartor.first()) {
199 do {
200 databaseTableIteartor.delete(user);
201 }
202 while (databaseTableIteartor.next());
203 }
204 user.writeToFile();
205
206
207 }
208 else {
209
210
211 RestorePersistentSystem ps = new RestorePersistentSystem(destination);
212 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(
213 DatabaseConstants.SYSTEMDATABASE);
214 checkDatabase(pd);
215 try {
216 pd = (PersistentDatabase) ps.getDatabase(databaseNameDestination);
217 if (pd != null && overwrite) {
218 ps.removeDatabase(databaseNameDestination);
219 ps.dropDatabase(databaseNameDestination);
220 }
221 else {
222 throw new DException("DSE5566",
223 new Object [] {databaseNameDestination});
224 }
225 }
226 catch (DException ex) {
227 if (ex.getDseCode().equalsIgnoreCase("DSE316"))
228 createDatabase(sourcePath, databaseNameSource,databaseNameDestination,null);
230 else
231 throw ex;
232 }
233 }
234 }
235 finally {
236 try {
237 if (raf != null)
238 raf.close();
239 }
240 catch (Exception e) {
241 throw new DException("DSE5564", new Object [] {e.getMessage()});
242 }
243 }
244 }
245
246 }
247
248
260
261 private void offLineBackupUserDatabase(String sourcePath, String destination,
262 String databaseNameSource,
263 String databaseNameDestination) throws DException {
264
265
266 String userDatabaseSourcePath = sourcePath + File.separator + databaseNameSource +
267 File.separator + databaseNameSource + ".ddb";
268 String userDatabaseDestinationPath = destination + File.separator +
269 databaseNameDestination +"_Bk"+ File.separator + databaseNameDestination +
270 ".ddb";
271 copyDatabase(userDatabaseSourcePath, userDatabaseDestinationPath, destination,
272 databaseNameDestination);
273 }
274
275
276
288
289 private void offLineRestoreUserDatabase(String sourcePath, String destination,
290 String databaseNameSource,
291 String databaseNameDestination) throws DException {
292
293
294 String userDatabaseSourcePath = sourcePath + File.separator + databaseNameSource+"_Bk" +
295 File.separator + databaseNameSource + ".ddb";
296 String userDatabaseDestinationPath = destination + File.separator +
297 databaseNameDestination + File.separator + databaseNameDestination +
298 ".ddb";
299 copyDatabase(userDatabaseSourcePath, userDatabaseDestinationPath, destination,
300 databaseNameDestination);
301 }
302
303
316 private void createDatabase1(String sourcePath, String destination,
317 String databaseNameSource,
318 String databaseNameDestination) throws DException {
319 int index = 0;
320 BackupPersistentSystem ps = new BackupPersistentSystem(sourcePath);
321 PersistentDatabase systemDatabaseSourcePath = (PersistentDatabase)ps.getDatabase(DatabaseConstants.SYSTEMDATABASE+"_Bk");
322 _DataTable databaseInfoTable = (_DataTable) systemDatabaseSourcePath.getTable(SystemTables.DATABASEINFO);
323 DatabaseUserTableIterator databaseTableIteartor = (
324 DatabaseUserTableIterator) databaseInfoTable.getIterator();
325 Object [] databaseProperties = null;
326 BufferRange bytesOfDestinationDatabaseName = new BufferRange(CCzufDpowfsufs.
327 getBytes(databaseNameDestination, databaseNameDestination.length(), false));
328 BufferRange bytesOfSourceDatabaseName = new BufferRange(CCzufDpowfsufs.
329 getBytes(databaseNameSource, databaseNameSource.length(), false));
330 CTusjohJoTfotjujwfDpnqbsbups stringComparator = new CTusjohJoTfotjujwfDpnqbsbups();
331
332 if (databaseTableIteartor.first())
333 do {
334 BufferRange[] bytesGot = (BufferRange[]) databaseTableIteartor.
335 getColumnValues();
336 if (stringComparator.compare(bytesGot[0], bytesOfSourceDatabaseName) ==
337 0) {
338 _TableCharacteristics tableCharacteristics = databaseInfoTable.
339 getTableCharacteristics();
340 databaseProperties = (Object []) tableCharacteristics.getObject(
341 bytesGot);
342 break;
343 }
344 }
345 while (databaseTableIteartor.next());
346 Object [] databaseProps = Utility.convertIntoFieldBase(databaseProperties);
347 String initialSize = (String ) databaseProps[1];
348 int incrementFactor = databaseProps[4].hashCode();
349 boolean unicodeSupport = ( (Boolean ) databaseProps[5]).booleanValue();
350 boolean multiFilesSupport = ( (Boolean ) databaseProps[6]).booleanValue();
351 boolean encryptionSupport = ( (Boolean ) databaseProps[7]).booleanValue();
352 String encrytpionAlgo = (String ) databaseProps[8];
353 String encryptionKey = (String ) databaseProps[9];
354 String clusterSize = (String ) databaseProps[10];
355 if (multiFilesSupport) {
356 DatabaseUserTableIterator databaseFileInfoIterator = (
357 DatabaseUserTableIterator) ( (_DataTable) systemDatabaseSourcePath.getTable(
358 SystemTables.DATABASEFILEINFO)).getIterator();
359 if (databaseFileInfoIterator.first())
360 do {
361 BufferRange[] bytesGot = (BufferRange[]) databaseFileInfoIterator.
362 getColumnValues();
363 if (stringComparator.compare(bytesGot[0],
364 bytesOfSourceDatabaseName) == 0) {
365 index = CCzufDpowfsufs.getInt(bytesGot[1].getBytes()).hashCode();
366 break;
367 }
368 }
369 while (databaseFileInfoIterator.next());
370 }
371
372 DatabaseUserTableIterator scheduleInfoTableIteartor = null; ArrayList
373 scheduleEntries = null;
374 try {
375 _DataTable table = (_DataTable) systemDatabaseSourcePath.getTable(
376 SystemTables.SCHEDULEINFO);
377 scheduleInfoTableIteartor = (DatabaseUserTableIterator) table.
378 getIterator();
379 scheduleEntries = new ArrayList ();
380 if (scheduleInfoTableIteartor.first()) {
381 do {
382 BufferRange[] bytesGot = (BufferRange[])
383 scheduleInfoTableIteartor.getColumnValues();
384 if (stringComparator.compare(bytesGot[0],
385 bytesOfSourceDatabaseName) == 0) {
386 scheduleEntries.add(bytesGot);
387 }
388 }
389 while (scheduleInfoTableIteartor.next());
390 }
391 }
392 catch (DException ex) {
393 if (!ex.getDseCode().equalsIgnoreCase("DSE959"))
394 throw ex;
395 }
396 RestorePersistentSystem ps1 = new RestorePersistentSystem(destination);
397 ps1.createDatabase(databaseNameDestination, initialSize, incrementFactor,
398 unicodeSupport, multiFilesSupport, encryptionSupport,
399 encrytpionAlgo, encryptionKey, clusterSize);
400
401 if (multiFilesSupport) {
402 PersistentDatabase systemDatabaseDestinationPath = (PersistentDatabase) ps1.getDatabase(
403 DatabaseConstants.SYSTEMDATABASE);
404 DatabaseUserTableIterator databaseFileInfoIterator = (
405 DatabaseUserTableIterator) ( (_DataTable) systemDatabaseDestinationPath.getTable(
406 SystemTables.DATABASEFILEINFO)).getIterator();
407 if (databaseFileInfoIterator.first())
408 do {
409 BufferRange[] bytesGot = (BufferRange[]) databaseFileInfoIterator.getColumnValues();
410 if (stringComparator.compare(bytesGot[0],bytesOfDestinationDatabaseName) == 0) {
411 _DatabaseUser user = systemDatabaseDestinationPath.getDatabaseUser();
412 databaseFileInfoIterator.update(user,
413 new BufferRange[] {bytesOfDestinationDatabaseName,
414 new
415 BufferRange(CCzufDpowfsufs.
416 getBytes(new Integer (index)))});
417 user.writeToFile();
418 break;
419 }
420 }
421 while (databaseTableIteartor.next());
422 }
423
424 if (scheduleEntries!= null && scheduleEntries.size() > 0) {
425 PersistentDatabase systemDatabaseDestination = (PersistentDatabase) ps1.getDatabase(DatabaseConstants.SYSTEMDATABASE);
426 DatabaseUserTableIterator scheduleInfoTableIteartorDestination = null;
427 _DatabaseUser user = null;
428 try {
429 _DataTable scheduleInfoTable = (_DataTable) systemDatabaseDestination.
430 getTable(SystemTables.SCHEDULEINFO);
431 scheduleInfoTableIteartorDestination = (DatabaseUserTableIterator)
432 scheduleInfoTable.getIterator();
433 ArrayList list = new ArrayList ();
434 list.add(SystemTables.SCHEDULEINFO);
435 user = systemDatabaseDestination.getDatabaseUser(list);
436
437 if (scheduleInfoTableIteartorDestination.first()) {
438 do {
439 BufferRange bytesGot = (BufferRange)
440 scheduleInfoTableIteartorDestination.getColumnValues(0);
441 if (stringComparator.compare(bytesGot, bytesOfSourceDatabaseName) ==
442 0) {
443 scheduleInfoTableIteartorDestination.delete(user);
444 }
445 }
446 while (scheduleInfoTableIteartor.next());
447 }
448 }
449 catch (DException ex1) {
450 if (!ex1.getDseCode().equalsIgnoreCase("DSE959"))
451 throw ex1;
452 }
453
454
455 for (int i = 0; i < scheduleEntries.size(); i++) {
456 BufferRange[] entry = (BufferRange[]) scheduleEntries.get(i);
457 entry[0] = bytesOfDestinationDatabaseName;
458 ( (_UserTableOperations) scheduleInfoTableIteartorDestination).insert(user,entry);
459 }
460 user.writeToFile();
461 }
462
463 deleteFiles(databaseNameDestination, destination);
464 offLineRestoreUserDatabase(sourcePath, destination, databaseNameSource,databaseNameDestination);
465 }
466
467 private void createDatabase(String sourcePath,
468 String databaseNameSource,
469 String databaseNameDestination,PersistentSystem ps1) throws DException {
470 int index = 0;
471 BackupPersistentSystem ps = new BackupPersistentSystem(sourcePath);
472 PersistentDatabase systemDatabaseSourcePath = (PersistentDatabase)ps.getDatabase(DatabaseConstants.SYSTEMDATABASE+"_Bk");
473 _DataTable databaseInfoTable = (_DataTable) systemDatabaseSourcePath.getTable(SystemTables.DATABASEINFO);
474 DatabaseUserTableIterator databaseTableIteartor = (
475 DatabaseUserTableIterator) databaseInfoTable.getIterator();
476 Object [] databaseProperties = null;
477 BufferRange bytesOfDestinationDatabaseName = new BufferRange(CCzufDpowfsufs.
478 getBytes(databaseNameDestination, databaseNameDestination.length(), false));
479 BufferRange bytesOfSourceDatabaseName = new BufferRange(CCzufDpowfsufs.
480 getBytes(databaseNameSource, databaseNameSource.length(), false));
481 CTusjohJoTfotjujwfDpnqbsbups stringComparator = new CTusjohJoTfotjujwfDpnqbsbups();
482
483 if (databaseTableIteartor.first())
484 do {
485 BufferRange[] bytesGot = (BufferRange[]) databaseTableIteartor.
486 getColumnValues();
487 if (stringComparator.compare(bytesGot[0], bytesOfSourceDatabaseName) ==
488 0) {
489 _TableCharacteristics tableCharacteristics = databaseInfoTable.
490 getTableCharacteristics();
491 databaseProperties = (Object []) tableCharacteristics.getObject(
492 bytesGot);
493 break;
494 }
495 }
496 while (databaseTableIteartor.next());
497 Object [] databaseProps = Utility.convertIntoFieldBase(databaseProperties);
498 String initialSize = (String ) databaseProps[1];
499 int incrementFactor = databaseProps[4].hashCode();
500 boolean unicodeSupport = ( (Boolean ) databaseProps[5]).booleanValue();
501 boolean multiFilesSupport = ( (Boolean ) databaseProps[6]).booleanValue();
502 boolean encryptionSupport = ( (Boolean ) databaseProps[7]).booleanValue();
503 String encrytpionAlgo = (String ) databaseProps[8];
504 String encryptionKey = (String ) databaseProps[9];
505 String clusterSize = (String ) databaseProps[10];
506 if (multiFilesSupport) {
507 DatabaseUserTableIterator databaseFileInfoIterator = (
508 DatabaseUserTableIterator) ( (_DataTable) systemDatabaseSourcePath.getTable(
509 SystemTables.DATABASEFILEINFO)).getIterator();
510 if (databaseFileInfoIterator.first())
511 do {
512 BufferRange[] bytesGot = (BufferRange[]) databaseFileInfoIterator.
513 getColumnValues();
514 if (stringComparator.compare(bytesGot[0],
515 bytesOfSourceDatabaseName) == 0) {
516 index = CCzufDpowfsufs.getInt(bytesGot[1].getBytes()).hashCode();
517 break;
518 }
519 }
520 while (databaseTableIteartor.next());
521 }
522
523
524
525 createDatabaseAtCurrentPath(ps1, databaseNameSource,
526 databaseNameDestination, initialSize,
527 incrementFactor, unicodeSupport,
528 multiFilesSupport, encryptionSupport,
529 encrytpionAlgo, encryptionKey, clusterSize,
530 null, index);
531
532 String destination = ((ServerSystem)ss).getDaffodilHome();
533 deleteFiles(databaseNameDestination, destination);
534 offLineRestoreUserDatabase(sourcePath, destination, databaseNameSource,databaseNameDestination);
535 }
536
537
544 private void deleteFiles(String databaseName, String destination) throws
545 DException {
546 String path = destination + File.separator + databaseName + File.separator +
547 databaseName + ".ddb";
548 File f = new File (path);
549 f.delete();
550 File ff1 = f.getParentFile();
551 path = destination + File.separator + databaseName + File.separator +
552 DatabaseConstants.TEMPDATABASE + ".ddb";
553 File f1 = new File (path);
554 f1.delete();
555 ff1.delete();
556 }
557
558
580 public void restoreBackup(String path,String databaseNameSource,
581 String databaseNameDestination, boolean overwrite) throws DException {
582 if (databaseNameSource.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
583 throw new DException("DSE5568", new Object [] {databaseNameSource});
584 if (databaseNameDestination.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
585 throw new DException("DSE5569", new Object [] {databaseNameDestination});
586
587 checkDatabaseBeforeRestoring(path, databaseNameSource);
588
589 if (databaseNameSource.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE))
590 throw new DException("DSE5570", new Object [] {databaseNameSource});
591
592 if (databaseNameDestination.equalsIgnoreCase(DatabaseConstants.
593 SYSTEMDATABASE))
594 throw new DException("DSE5571", new Object [] {databaseNameDestination});
595
596
597 restoreAtCurrentPath(path, databaseNameSource,
598 databaseNameDestination, overwrite);
599 }
600
601
605 private void checkDatabase(PersistentDatabase pd) throws DException {
606 byte[] bytes = pd.readBytes(pd.getDatabaseProperties().
607 ISCOMPLETE_BIT_IN_DATABASE, 1);
608 Boolean isComplete = CCzufDpowfsufs.getBoolean(bytes);
609 if (!isComplete.booleanValue()) {
610 throw new DException("DSE5543", null);
611 }
612 }
613
614
620 private RandomAccessFile checkDatabaseInUse(String sourcePath) throws DException {
621 String logFile = sourcePath + File.separator + "log.lg";
622 File ff = new File (logFile);
623 boolean isDelete = false;
624 if (ff.exists()) {
625 isDelete = ff.delete();
626 if (!isDelete) {
627 ; throw new DException("DSE5564", new Object [] {});
629 }
630 }
631 RandomAccessFile raf = null;
632 try {
633 raf = new RandomAccessFile (ff, "rw");
634 }
635 catch (FileNotFoundException ex) {
636 }
637 return raf;
638 }
639
640
652 private void copyDatabase(String sourcePath, String destinationPath, String destination,String databaseNameDestination) throws DException{
653 File ff = new File (sourcePath);
654 File df = new File (destinationPath,databaseNameDestination);
655 if(!df.getName().equals(databaseNameDestination))
656 throw new DException("DSE2049",new Object [] {databaseNameDestination});
657 df = new File (destinationPath);
658 try {
659 File ff1 = ff.getParentFile();
660 ff1.mkdirs();
661 File df1 = df.getParentFile();
662 df1.mkdirs();
663 FileInputStream file = new FileInputStream(ff);
664 FileOutputStream DestinationFile = new FileOutputStream(df);
665 CopyFile cf = new CopyFile();
666 cf.copyFile(file,DestinationFile);
667
668
669 destinationPath = destinationPath.substring(0,destinationPath.lastIndexOf(File.separator));
670 File [] files = ff1.listFiles(new PowerFileFilter());
671 for (int i = 0; i < files.length; i++) {
672 FileInputStream powerFile = new FileInputStream(files[i]);
673 String name = files[i].getName();
674 if(!name.startsWith("_"))
675 name = databaseNameDestination+"_" + i +"_PowerFile.log";
676 String destinationPath1 = destinationPath + File.separator + name;
677 DestinationFile = new FileOutputStream(new File (destinationPath1));
678 cf.copyFile(powerFile,DestinationFile);
679 }
680 files = ff1.listFiles(new MultiFileFilter());
681 for (int i = 0; i < files.length; i++) {
682 FileInputStream multiFile = new FileInputStream(files[i]);
683 String name = files[i].getName();
684 if(!name.startsWith("_"))
685 name = databaseNameDestination+(i+1)+".dat";
686 String destinationPath1 = destinationPath + File.separator + name;
687 DestinationFile = new FileOutputStream(new File (destinationPath1));
688 cf.copyFile(multiFile,DestinationFile);
689 }
690 }
691 catch (Exception ex) {
692 throw new DException("DSE0",new Object [] {ex.getMessage()});
693 }
694
695 }
696
697
703 private void checkDatabase(String sourcePath,String databaseName) throws DException {
704 String databaseURLSystemDatabase = sourcePath + File.separator +DatabaseConstants.SYSTEMDATABASE;
705 String databaseURL = sourcePath + File.separator + databaseName;
706 File fs = new File (databaseURLSystemDatabase);
707
708 if (!fs.exists())
709 throw new DException("DSE5572", new Object []{sourcePath});
710 File f = new File (databaseURL);
711 if(!f.exists())
712 throw new DException("DSE5563", new Object []{databaseName});
713 }
714
715
721 private void checkDatabaseBeforeRestoring(String sourcePath,String databaseName) throws DException {
722 String databaseURLSystemDatabase = sourcePath + File.separator +DatabaseConstants.SYSTEMDATABASE+"_Bk";
723 String databaseURL = sourcePath + File.separator + databaseName+"_Bk";
724 File fs = new File (databaseURLSystemDatabase);
725
726 if (!fs.exists())
727 throw new DException("DSE5572", new Object []{sourcePath});
728 File f = new File (databaseURL);
729 if(!f.exists())
730 throw new DException("DSE5563", new Object []{databaseName});
731 checkDatabaseEntryInSystemDatabase(sourcePath,databaseName);
732 }
733
734
741 private void checkDatabaseEntryInSystemDatabase(String sourcePath,String userDatabase) throws DException{
742 BackupPersistentSystem ps = new BackupPersistentSystem(sourcePath);
743 try {
744 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(userDatabase);
745 }
746 catch (DException ex) {
747 if (ex.getDseCode().equalsIgnoreCase("DSE316"))
748 throw new DException("DSE5573",new Object []{userDatabase});
749 }
750 }
751
752 private void restoreAtCurrentPath(String sourcePath,String databaseNameSource,
753 String databaseNameDestination, boolean overwrite) throws DException{
754 RandomAccessFile raf = null;
755 try{
756 raf = checkDatabaseInUse(sourcePath);
757 String systemDatabaseSourcePath = sourcePath + File.separator +
758 DatabaseConstants.SYSTEMDATABASE + "_Bk" + File.separator +
759 DatabaseConstants.SYSTEMDATABASE + ".ddb";
760 PersistentSystem ps = (PersistentSystem)(((ServerSystem)ss).getPersistentSystem());
761 PersistentDatabase systemDatabaseDestinationPath = (PersistentDatabase) ( (
762 IndexDatabase) ( (
763 MergeDatabase) ((ServerSystem)ss).getMergeDatabase(DatabaseConstants.SYSTEMDATABASE)).
764 getFileDatabase()).
765 getUnderLyingDatabase();
766
767 try {
768 DRandomAccessFileUpto3_2 dRAM = systemDatabaseDestinationPath.
769 getDrandomAccessFile();
770 synchronized (dRAM) {
771 try {
772 PersistentDatabase pd = (PersistentDatabase) ps.getDatabase(databaseNameDestination);
773 if (pd != null && overwrite) {
774 ps.removeDatabase(databaseNameDestination);
775 ps.dropDatabase(databaseNameDestination);
776 createDatabase(sourcePath, databaseNameSource,
777 databaseNameDestination,ps);
778 }
779 else {
780 throw new DException("DSE5566",
781 new Object [] {databaseNameDestination});
782 }
783 }
784 catch (DException ex) {
785 if (ex.getDseCode().equalsIgnoreCase("DSE316")){
786 ; createDatabase(sourcePath, databaseNameSource,
788 databaseNameDestination, ps);
789 }
790 else
791 throw ex;
792 }
793 }
794 }finally {
795 }
796
797 }finally {
798 try {
799 if (raf != null)
800 raf.close();
801 }
802 catch (Exception e) {
803 throw new DException("DSE5564", new Object [] {e.getMessage()});
804 }
805 }
806
807
808 }
809
810 private void createDatabaseAtCurrentPath(PersistentSystem ps1,String databaseNameSource ,String databaseNameDestination,String initialSize, int incrementFactor, boolean unicodeSupport, boolean multifileSupport,boolean encryptionSupport,String encryptionAlgo,String encryptionKey,String clusterSize,ArrayList scheduleEntries,int index) throws DException{
811
812 ps1.createDatabase(databaseNameDestination, initialSize, incrementFactor,
813 unicodeSupport, multifileSupport, encryptionSupport,
814 encryptionAlgo, encryptionKey, clusterSize);
815 CTusjohJoTfotjujwfDpnqbsbups stringComparator = new CTusjohJoTfotjujwfDpnqbsbups();
816 BufferRange bytesOfDestinationDatabaseName = new BufferRange(CCzufDpowfsufs.
817 getBytes(databaseNameDestination, databaseNameDestination.length(), false));
818 BufferRange bytesOfSourceDatabaseName = new BufferRange(CCzufDpowfsufs.
819 getBytes(databaseNameSource, databaseNameSource.length(), false));
820 _DatabaseUser user = null;
821
822 if (multifileSupport) {
823 try {
824 PersistentDatabase systemDatabaseDestinationPath = (PersistentDatabase)
825 ps1.getDatabase(
826 DatabaseConstants.SYSTEMDATABASE);
827 DatabaseUserTableIterator databaseFileInfoIterator = (
828 DatabaseUserTableIterator) ( (_DataTable)
829 systemDatabaseDestinationPath.getTable(
830 SystemTables.DATABASEFILEINFO)).getIterator();
831 if (databaseFileInfoIterator.first()) {
832 do {
833 BufferRange[] bytesGot = (BufferRange[]) databaseFileInfoIterator.
834 getColumnValues();
835 if (stringComparator.compare(bytesGot[0],
836 bytesOfDestinationDatabaseName) == 0) {
837 user = systemDatabaseDestinationPath.getDatabaseUser();
838 databaseFileInfoIterator.update(user,
839 new BufferRange[] {
840 bytesOfDestinationDatabaseName,
841 new
842 BufferRange(CCzufDpowfsufs.
843 getBytes(new Integer (index)))});
844 break;
845 }
846 }
847 while (databaseFileInfoIterator.next());
848 }
849 }
850 finally {
851 if(user!= null)
852 user.writeToFile();
853 }
854 }
855 if (scheduleEntries!= null && scheduleEntries.size() > 0) {
856 PersistentDatabase systemDatabaseDestination = (PersistentDatabase) ps1.getDatabase(DatabaseConstants.SYSTEMDATABASE);
857 DatabaseUserTableIterator scheduleInfoTableIteartorDestination = null;
858 _DatabaseUser user1 = null;
859 try {
860 _DataTable scheduleInfoTable = (_DataTable) systemDatabaseDestination.
861 getTable(SystemTables.SCHEDULEINFO);
862 scheduleInfoTableIteartorDestination = (DatabaseUserTableIterator)
863 scheduleInfoTable.getIterator();
864 ArrayList list = new ArrayList ();
865 list.add(SystemTables.SCHEDULEINFO);
866 user1 = systemDatabaseDestination.getDatabaseUser(list);
867
868 if (scheduleInfoTableIteartorDestination.first()) {
869 do {
870 BufferRange bytesGot = (BufferRange)
871 scheduleInfoTableIteartorDestination.getColumnValues(0);
872 if (stringComparator.compare(bytesGot, bytesOfSourceDatabaseName) ==
873 0) {
874 scheduleInfoTableIteartorDestination.delete(user1);
875 }
876 }
877 while (scheduleInfoTableIteartorDestination.next());
878 }
879
880
881
882 for (int i = 0; i < scheduleEntries.size(); i++) {
883 BufferRange[] entry = (BufferRange[]) scheduleEntries.get(i);
884 entry[0] = bytesOfDestinationDatabaseName;
885 ( (_UserTableOperations) scheduleInfoTableIteartorDestination).insert(user1,entry);
886 }
887 }
888 catch (DException ex1) {
889 if (!ex1.getDseCode().equalsIgnoreCase("DSE959"))
890 throw ex1;
891 }finally{
892 user1.writeToFile();
893 }
894 }
895
896 }
897
898 class PowerFileFilter
899 implements FilenameFilter {
900 public boolean accept(File dir, String name) {
901 return name.endsWith("PowerFile.log") ? true
902 : false;
903 }
904 }
905
906 class MultiFileFilter
907 implements FilenameFilter {
908 public boolean accept(File dir, String name) {
909 return name.endsWith(".dat") ? true
910 : false;
911 }
912 }
913
914
915 private void removingEntriesForSchedules(PersistentDatabase systemDatabaseSourcePath,_DatabaseUser user) throws DException{
916 try {
917 _DataTable table = (_DataTable) systemDatabaseSourcePath.getTable(
918 SystemTables.SCHEDULEINFO);
919 DatabaseUserTableIterator scheduleInfoTableIteartor = (DatabaseUserTableIterator) table.
920 getIterator();
921
922 if (scheduleInfoTableIteartor.first()) {
923 do {
924 scheduleInfoTableIteartor.delete(user);
925 }
926 while (scheduleInfoTableIteartor.next());
927 }
928 }
929 catch (DException ex) {
930 if (!ex.getDseCode().equalsIgnoreCase("DSE959"))
931 throw ex;
932 }
933
934 }
935
936 }
937 |
Popular Tags |
Java API By Example, From Geeks To Geeks.