Xcloner_Archive::start_incremental_backup()

Complexity

Conditions	31
Paths	> 20000

Size

Total Lines	234
Code Lines	131

Duplication

Lines	0
Ratio	0 %

Importance

Changes	8
Bugs	4	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 {
		    $encrypt = false;
            if(isset($backup_params['backup_encrypt']) && $backup_params['backup_encrypt']) {
                $encrypt = true;
            }
			$this->set_archive_name($backup_params['backup_name'], 0, $encrypt);
		}

		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()));

			$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;
	}