Xcloner_Archive::start_incremental_backup()

Complexity

Conditions	29
Paths	> 20000

Size

Total Lines	230
Code Lines	128

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

<?php
    public function start_incremental_backup($backup_params, $extra_params, $init)
    {
        $return = array();

        if (!isset($extra_params['backup_part'])) {
            $extra_params['backup_part'] = 0;
        }

        $return['extra']['backup_part'] = $extra_params['backup_part'];

        if (isset($extra_params['backup_archive_name'])) {
            $this->set_archive_name($extra_params['backup_archive_name'], $return['extra']['backup_part']);
        } else {
            $this->set_archive_name($backup_params['backup_name']);
        }

        if (!$this->get_archive_name()) {
            $this->set_archive_name();
        }

        $this->backup_archive = new Tar();
        $this->backup_archive->setCompression($this->compression_level);

        $archive_info = $this->filesystem->get_storage_path_file_info($this->get_archive_name_with_extension());

        if ($init) {
            $this->logger->info(sprintf(__("Initializing the backup archive %s"), $this->get_archive_name()));

The function __ was not found. Maybe you did not declare it correctly or list all dependencies?

            $this->backup_archive->create($archive_info->getPath().DS.$archive_info->getFilename());

            $return['extra']['backup_init'] = 1;

        } else {
            $this->logger->info(sprintf(__("Opening for append the backup archive %s"), $this->get_archive_name()));

            $this->backup_archive->openForAppend($archive_info->getPath().DS.$archive_info->getFilename());

            $return['extra']['backup_init'] = 0;

        }

        $return['extra']['backup_archive_name'] = $this->get_archive_name();
        $return['extra']['backup_archive_name_full'] = $this->get_archive_name_with_extension();

        if (!isset($extra_params['start_at_line'])) {
            $extra_params['start_at_line'] = 0;
        }

        if (!isset($extra_params['start_at_byte'])) {
            $extra_params['start_at_byte'] = 0;
        }

        if (!$this->filesystem->get_tmp_filesystem()->has($this->filesystem->get_included_files_handler())) {
            $this->logger->error(sprintf("Missing the includes file handler %s, aborting...",
                $this->filesystem->get_included_files_handler()));

            $return['finished'] = 1;
            return $return;
        }

        $included_files_handler = $this->filesystem->get_included_files_handler(1);

        $file = new SplFileObject($included_files_handler);

        $file->seek(PHP_INT_MAX);

        $return['extra']['lines_total'] = ($file->key() - 1);

        //we skip the first CSV line with headers
        if (!$extra_params['start_at_line']) {
            $file->seek(1);
        } else {
            $file->seek($extra_params['start_at_line'] + 1);
        }

        $this->processed_size_bytes = 0;

        $counter = 0;

        $start_byte = $extra_params['start_at_byte'];

        $byte_limit = 0;

The assignment to $byte_limit is dead and can be removed.

        while (!$file->eof() and $counter <= $this->files_to_process_per_request) {
            $current_line_str = $file->current();

            $line = str_getcsv($current_line_str);

It seems like $current_line_str can also be of type array; however, parameter $input of str_getcsv() does only seem to accept string, maybe add an additional type check?

            $relative_path = stripslashes($line[0]);

            $start_filesystem = "start_filesystem";

            if (isset($line[4])) {
                $start_filesystem = $line[4];
            }

            //$adapter = $this->filesystem->get_adapter($start_filesystem);

            if (!$relative_path || !$this->filesystem->get_filesystem($start_filesystem)->has($relative_path)) {
                if ($relative_path != "") {
                    $this->logger->error(sprintf("Could not add file %b to backup archive, file not found",
                        $relative_path));
                }

                $extra_params['start_at_line']++;
                $file->next();
                continue;
            }

            $file_info = $this->filesystem->get_filesystem($start_filesystem)->getMetadata($relative_path);

            if (!isset($file_info['size'])) {
                $file_info['size'] = 0;
            }

            if ($start_filesystem == "tmp_filesystem") {
                $file_info['archive_prefix_path'] = $this->xcloner_settings->get_xcloner_tmp_path_suffix();
            }

            $byte_limit = (int)$this->file_size_per_request_limit / 512;

            $append = 0;

            if ($file_info['size'] > $byte_limit * 512 or $start_byte) {
                $append = 1;
            }

            if (!isset($return['extra']['backup_size'])) {
                $return['extra']['backup_size'] = 0;
            }

            $return['extra']['backup_size'] = $archive_info->getSize();

            $estimated_new_size = $return['extra']['backup_size'] + $file_info['size'];

            //we create a new backup part if we reach the Split Achive Limit
            if ($this->xcloner_split_backup_limit and ($estimated_new_size > $this->xcloner_split_backup_limit) and (!$start_byte)) {
                $this->logger->info(sprintf("Backup size limit %s bytes reached, file add estimate %s, attempt to create a new archive ",
                    $this->xcloner_split_backup_limit, $estimated_new_size));
                list($archive_info, $return['extra']['backup_part']) = $this->create_new_backup_part($return['extra']['backup_part']);

                if ($file_info['size'] > $this->xcloner_split_backup_limit) {
                    $this->logger->info(sprintf("Excluding %s file as it's size(%s) is bigger than the backup split limit of %s and it won't fit a single backup file",
                        $file_info['path'], $file_info['size'], $this->xcloner_split_backup_limit));
                    $extra_params['start_at_line']++;
                }

                $return['extra']['start_at_line'] = $extra_params['start_at_line'];
                $return['extra']['start_at_byte'] = 0;

                $return['finished'] = 0;

                return $return;
            }

            list($bytes_wrote, $last_position) = $this->add_file_to_archive($file_info, $start_byte, $byte_limit,
                $append, $start_filesystem);
            $this->processed_size_bytes += $bytes_wrote;

            //echo" - processed ".$this->processed_size_bytes." bytes ".$this->file_size_per_request_limit." last_position:".$last_position." \n";
            $return['extra']['processed_file'] = $file_info['path'];
            $return['extra']['processed_file_size'] = $file_info['size'];
            $return['extra']['backup_size'] = $archive_info->getSize();

            if ($last_position > 0) {
                $start_byte = $last_position;
            } else {
                $extra_params['start_at_line']++;
                $file->next();
                $start_byte = 0;
                $counter++;
            }

            if ($this->processed_size_bytes >= $this->file_size_per_request_limit) {
                clearstatcache();
                $return['extra']['backup_size'] = $archive_info->getSize();

                $return['finished'] = 0;
                $return['extra']['start_at_line'] = $extra_params['start_at_line'];
                $return['extra']['start_at_byte'] = $last_position;
                $this->logger->info(sprintf("Reached the maximum %s request data limit, returning response",
                    $this->file_size_per_request_limit));
                return $return;
            }
        }

        if (!$file->eof()) {
            clearstatcache();
            $return['extra']['backup_size'] = $archive_info->getSize();

            $return['finished'] = 0;
            $return['extra']['start_at_line'] = $extra_params['start_at_line'];
            $return['extra']['start_at_byte'] = $last_position;

The variable $last_position does not seem to be defined for all execution paths leading up to this point.

            $this->logger->info(sprintf("We have reached the maximum files to process per request limit of %s, returning response",
                $this->files_to_process_per_request));

            return $return;
        }

        //close the backup archive by adding 2*512 blocks of zero bytes
        $this->logger->info(sprintf("Closing the backup archive %s with 2*512 zero bytes blocks.",
            $this->get_archive_name_with_extension()));
        $this->backup_archive->close();

        /**
         * XCloner HOOK backup_archive_finished.
         *
         * This will get triggered when a backup archive is finished writing.
         */
        //do_action('backup_archive_finished', $this->backup_archive, $this);

        //updating archive_info
        $archive_info = $this->filesystem->get_storage_path_file_info($this->get_archive_name_with_extension());

        if ($return['extra']['backup_part']) {
            $this->write_multipart_file($this->get_archive_name_with_extension());
        }

        $return['extra']['start_at_line'] = $extra_params['start_at_line'] - 1;

        if (isset($file_info)) {
            $return['extra']['processed_file'] = $file_info['path'];
            $return['extra']['processed_file_size'] = $file_info['size'];
        }

        clearstatcache();
        $return['extra']['backup_size'] = $archive_info->getSize();

        $return['finished'] = 1;
        return $return;
    }