public BackupStrategy getBackupStrategy()

in openAPI/src/main/java/jetbrains/exodus/backup/BackupBean.java [132:236]
94 lines of code
12 McCabe index (conditional complexity)

    public BackupStrategy getBackupStrategy() {
        final int targetsCount = targets.length;
        final BackupStrategy[] wrapped = new BackupStrategy[targetsCount];
        for (int i = 0; i < targetsCount; i++) {
            wrapped[i] = targets[i].getBackupStrategy();
        }
        return new BackupStrategy() {
            @Override
            public void beforeBackup() throws Exception {
                backupStartTicks = System.currentTimeMillis();
                logger.info("Backing up database...");
                for (final BackupStrategy strategy : wrapped) {
                    strategy.beforeBackup();
                }
            }

            @Override
            public Iterable<VirtualFileDescriptor> getContents() {
                return new Iterable<VirtualFileDescriptor>() {
                    @NotNull
                    @Override
                    public Iterator<VirtualFileDescriptor> iterator() {
                        return new Iterator<VirtualFileDescriptor>() {

                            @Nullable
                            private VirtualFileDescriptor next = null;
                            private int i = 0;
                            @NotNull
                            private Iterator<VirtualFileDescriptor> it = EMPTY.getContents().iterator();

                            @Override
                            public boolean hasNext() {
                                return getNext() != null;
                            }

                            @Override
                            public VirtualFileDescriptor next() {
                                try {
                                    return getNext();
                                } finally {
                                    next = null;
                                }
                            }

                            @Override
                            public void remove() {
                                throw new UnsupportedOperationException("remove");
                            }

                            private VirtualFileDescriptor getNext() {
                                if (next == null) {
                                    while (!it.hasNext()) {
                                        if (i >= targetsCount) {
                                            return next;
                                        }
                                        it = wrapped[i++].getContents().iterator();
                                    }
                                    final VirtualFileDescriptor next = it.next();
                                    final long acceptedSize = wrapped[i - 1].acceptFile(next);
                                    this.next = acceptedSize < next.getFileSize() ? next.copy(acceptedSize) : next;
                                }
                                return next;
                            }
                        };
                    }
                };
            }

            @Override
            public void afterBackup() throws Exception {
                try {
                    for (final BackupStrategy strategy : wrapped) {
                        strategy.afterBackup();
                    }
                } finally {
                    backupStartTicks = 0;
                }
                for (final Runnable runnable : runAfterBackup) {
                    runnable.run();
                }
                if (commandAfterBackup != null) {
                    logger.info("Executing \"" + commandAfterBackup + "\"...");
                    //noinspection CallToRuntimeExecWithNonConstantString,CallToRuntimeExec
                    Runtime.getRuntime().exec(commandAfterBackup);
                }
                logger.info("Backup finished.");
            }

            @Override
            public void onError(Throwable t) {
                backupException = t;
            }

            @Override
            public boolean isEncrypted() {
                for (BackupStrategy strategy : wrapped) {
                    if (strategy.isEncrypted()) {
                        return true;
                    }
                }

                return false;
            }
        };
    }