Xcloner_Scheduler

Complexity

Total Complexity

60

Size/Duplication

Total Lines	422
Duplicated Lines	3.55 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	delete_schedule_by_id()	0	8	1
A	deactivate_wp_cron_hooks()	0	10	2
B	update_wp_cron_hooks()	4	24	6
A	update_cron_hook()	9	17	3
A	disable_single_cron()	0	19	1
A	__construct()	0	11	1
A	get_xcloner_container()	0	3	1
A	set_xcloner_container()	0	3	1
A	get_scheduler_list()	0	17	4
A	get_next_run_schedule()	0	5	1
A	get_schedule_by_id_object()	0	5	1
A	get_schedule_by_id()	0	17	2
A	update_hash()	0	15	1
A	update_last_backup()	0	18	1
F	_xcloner_scheduler_callback()	2	170	23
B	xcloner_scheduler_callback()	0	27	8
A	get_available_intervals()	0	15	3

<?php

class Xcloner_Scheduler {

	private $db;
	private $scheduler_table = "xcloner_scheduler";

	private $xcloner_remote_storage;
	private $archive_system;
	private $xcloner_database;
	private $xcloner_settings;
	private $logger;
	private $xcloner_file_system;
	private $xcloner_encryption;

	private $allowed_schedules = array( "hourly", "twicedaily", "daily", "weekly", "monthly" );

	/*public function __call($method, $args) {
		echo "$method is not defined";
	}*/

	public function __construct( Xcloner $xcloner_container ) {
		global $wpdb;

		$this->db          = $wpdb;
		$wpdb->show_errors = false;

		$this->xcloner_container = $xcloner_container;

The property xcloner_container does not exist. Did you maybe forget to declare it?

		$this->xcloner_settings  = $xcloner_container->get_xcloner_settings();

The method get_xcloner_settings() does not seem to exist on object<Xcloner>.

		$this->scheduler_table = $this->db->prefix . $this->scheduler_table;
	}

	private function get_xcloner_container() {
		return $this->xcloner_container;
	}

	private function set_xcloner_container( Xcloner $container ) {
		$this->xcloner_container = $container;
	}

	public function get_scheduler_list( $return_only_enabled = 0 ) {
		$list = $this->db->get_results( "SELECT * FROM " . $this->scheduler_table );

		if ( $return_only_enabled ) {
			$new_list = array();

			foreach ( $list as $res ) {
				if ( $res->status ) {
					$res->next_run_time = wp_next_scheduled( 'xcloner_scheduler_' . $res->id, array( $res->id ) ) + ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS );
					$new_list[]         = $res;
				}
			}
			$list = $new_list;
		}

		return $list;
	}

	public function get_next_run_schedule( $xcloner_file_system = "" ) {

The parameter $xcloner_file_system is not used and could be removed.

		$list = $this->get_scheduler_list( $return_only_enabled = 1 );

		return $list;
	}

	public function get_schedule_by_id_object( $id ) {
		$data = $this->db->get_row( "SELECT * FROM " . $this->scheduler_table . " WHERE id=" . $id );

		return $data;
	}

	public function get_schedule_by_id( $id ) {
		$data = $this->db->get_row( "SELECT * FROM " . $this->scheduler_table . " WHERE id=" . $id, ARRAY_A );

		if ( ! $data ) {
			return false;
		}

		$params = json_decode( $data['params'] );

		//print_r($params);
		$data['params']         = "";
		$data['backup_params']  = $params->backup_params;
		$data['table_params']   = json_encode( $params->database );
		$data['excluded_files'] = json_encode( $params->excluded_files );

		return $data;
	}

	public function delete_schedule_by_id( $id ) {
		$hook = 'xcloner_scheduler_' . $id;
		wp_clear_scheduled_hook( $hook, array( $id ) );

		$data = $this->db->delete( $this->scheduler_table, array( 'id' => $id ) );

		return $data;
	}

	public function deactivate_wp_cron_hooks() {
		$list = $this->get_scheduler_list();

		foreach ( $list as $schedule ) {
			$hook = 'xcloner_scheduler_' . $schedule->id;

			$timestamp = wp_next_scheduled( $hook, array( $schedule->id ) );
			wp_unschedule_event( $timestamp, $hook, array( $schedule->id ) );
		}
	}

	public function update_wp_cron_hooks() {
		$list = $this->get_scheduler_list();

		foreach ( $list as $schedule ) {
			$hook = 'xcloner_scheduler_' . $schedule->id;

			//adding the xcloner_scheduler hook with xcloner_scheduler_callback callback
			add_action( $hook, array( $this, 'xcloner_scheduler_callback' ), 10, 1 );

			if ( ! wp_next_scheduled( $hook, array( $schedule->id ) ) and $schedule->status ) {

				if ( $schedule->recurrence == "single" ) {

This code seems to be duplicated across your project.

					wp_schedule_single_event( strtotime( $schedule->start_at ), $hook, array( $schedule->id ) );
				} else {
					wp_schedule_event( strtotime( $schedule->start_at ), $schedule->recurrence, $hook, array( $schedule->id ) );
				}

			} elseif ( ! $schedule->status ) {
				$timestamp = wp_next_scheduled( $hook, array( $schedule->id ) );
				wp_unschedule_event( $timestamp, $hook, array( $schedule->id ) );
			}
		}

	}

	public function update_cron_hook( $id ) {
		$schedule = $this->get_schedule_by_id_object( $id );
		$hook     = 'xcloner_scheduler_' . $schedule->id;

		$timestamp = wp_next_scheduled( $hook, array( $schedule->id ) );
		wp_unschedule_event( $timestamp, $hook, array( $schedule->id ) );

		if ( $schedule->status ) {

This code seems to be duplicated across your project.

			if ( $schedule->recurrence == "single" ) {
				wp_schedule_single_event( strtotime( $schedule->start_at ), $hook, array( $schedule->id ) );
			} else {
				wp_schedule_event( strtotime( $schedule->start_at ), $schedule->recurrence, $hook, array( $schedule->id ) );
			}

		}
	}

	public function disable_single_cron( $schedule_id ) {
		$hook      = 'xcloner_scheduler_' . $schedule_id;
		$timestamp = wp_next_scheduled( $hook, array( $schedule_id ) );
		wp_unschedule_event( $timestamp, $hook, array( $schedule_id ) );

		$schedule['status'] = 0;

$schedule was never initialized. Although not strictly required by PHP, it is generally a good practice to add $schedule = array(); before regardless.

		$update = $this->db->update(
			$this->scheduler_table,
			$schedule,
			array( 'id' => $schedule_id ),
			array(
				'%s',
				'%s'
			)
		);

		return $update;
	}

	public function update_hash( $schedule_id, $hash ) {
		$schedule['hash'] = $hash;

$schedule was never initialized. Although not strictly required by PHP, it is generally a good practice to add $schedule = array(); before regardless.

		$update = $this->db->update(
			$this->scheduler_table,
			$schedule,
			array( 'id' => $schedule_id ),
			array(
				'%s',
				'%s'
			)
		);

		return $update;
	}

	public function update_last_backup( $schedule_id, $last_backup ) {

	    $this->logger->info(sprintf('Updating last backup %s for schedule id #%s', $last_backup, $schedule_id));

		$schedule['last_backup'] = $last_backup;

$schedule was never initialized. Although not strictly required by PHP, it is generally a good practice to add $schedule = array(); before regardless.

		$update = $this->db->update(
			$this->scheduler_table,
			$schedule,
			array( 'id' => $schedule_id ),
			array(
				'%s',
				'%s'
			)
		);

		return $update;
	}

	private function _xcloner_scheduler_callback( $id, $schedule ) {
		set_time_limit( 0 );

		$xcloner = new XCloner();
		$xcloner->init();

The method init() does not seem to exist on object<Xcloner>.

		$this->set_xcloner_container( $xcloner );

		#$hash = $this->xcloner_settings->get_hash();
		#$this->get_xcloner_container()->get_xcloner_settings()->set_hash($hash);

		//$this->xcloner_settings 		= $this->get_xcloner_container()->get_xcloner_settings();		
		$this->xcloner_file_system    = $this->get_xcloner_container()->get_xcloner_filesystem();
		$this->xcloner_encryption    = $this->get_xcloner_container()->get_xcloner_encryption();
		$this->xcloner_database       = $this->get_xcloner_container()->get_xcloner_database();
		$this->archive_system         = $this->get_xcloner_container()->get_archive_system();
		$this->logger                 = $this->get_xcloner_container()->get_xcloner_logger()->withName( "xcloner_scheduler" );
		$this->xcloner_remote_storage = $this->get_xcloner_container()->get_xcloner_remote_storage();

		$this->logger->info( sprintf( "New schedule hash is %s", $this->xcloner_settings->get_hash() ) );

		if ( isset( $schedule['backup_params']->diff_start_date ) && $schedule['backup_params']->diff_start_date ) {
			$this->xcloner_file_system->set_diff_timestamp_start( $schedule['backup_params']->diff_start_date );
		}

		if ( $schedule['recurrence'] == "single" ) {
			$this->disable_single_cron( $schedule['id'] );
		}

		if ( ! $schedule ) {
			$this->logger->info( sprintf( "Could not load schedule with id'%s'", $id ), array( "CRON" ) );

			return;
		}

		//echo $this->get_xcloner_container()->get_xcloner_settings()->get_hash(); exit;

		$this->update_hash( $schedule['id'], $this->xcloner_settings->get_hash() );

		$this->logger->info( sprintf( "Starting cron schedule '%s'", $schedule['name'] ), array( "CRON" ) );

		$this->xcloner_file_system->set_excluded_files( json_decode( $schedule['excluded_files'] ) );

		$init     = 1;
		$continue = 1;

		while ( $continue ) {
			$continue = $this->xcloner_file_system->start_file_recursion( $init );

			$init = 0;
		}

		$this->logger->info( sprintf( "File scan finished" ), array( "CRON" ) );

		$this->logger->info( sprintf( "Starting the database backup" ), array( "CRON" ) );

		$init               = 1;
		$return['finished'] = 0;

$return was never initialized. Although not strictly required by PHP, it is generally a good practice to add $return = array(); before regardless.

		while ( ! $return['finished'] ) {
			$return = $this->xcloner_database->start_database_recursion( (array) json_decode( $schedule['table_params'] ), $return, $init );
			$init   = 0;
		}

		$this->logger->info( sprintf( "Database backup done" ), array( "CRON" ) );

		$this->logger->info( sprintf( "Starting file archive process" ), array( "CRON" ) );

		$init               = 0;
		$return['finished'] = 0;
		$return['extra']    = array();

		while ( ! $return['finished'] ) {
			$return = $this->archive_system->start_incremental_backup( (array) $schedule['backup_params'], $return['extra'], $init );
			$init   = 0;
		}
		$this->logger->info( sprintf( "File archive process FINISHED." ), array( "CRON" ) );

        //getting the last backup archive file
        $return['extra']['backup_parent'] = $this->archive_system->get_archive_name_with_extension();
		if ( $this->xcloner_file_system->is_part( $this->archive_system->get_archive_name_with_extension() ) ) {

This code seems to be duplicated across your project.

			$return['extra']['backup_parent'] = $this->archive_system->get_archive_name_multipart();
		}

		//Updating schedule last backup archive
        $this->update_last_backup( $schedule['id'], $return['extra']['backup_parent'] );

		//Encrypting the backup archive
        $return_encrypted['finished'] = 0;

$return_encrypted was never initialized. Although not strictly required by PHP, it is generally a good practice to add $return_encrypted = array(); before regardless.

        $return_encrypted['start'] = 0;
        $return_encrypted['iv'] = '';
        $return_encrypted['target_file'] = '';
        $part = 0;
        $backup_parts = array();

        if( $schedule['backup_params']->backup_encrypt){
            $this->logger->info( sprintf( "Encrypting backup archive %s.", $return['extra']['backup_parent'] ), array( "CRON" ) );

            $backup_file = $return['extra']['backup_parent'];

            if ($this->xcloner_file_system->is_multipart($return['extra']['backup_parent'])) {
                $backup_parts = $this->xcloner_file_system->get_multipart_files($return['extra']['backup_parent']);
                $backup_file = $backup_parts[$part];
            }

            while ( ! $return_encrypted['finished'] ) {
                $return_encrypted = $this->xcloner_encryption->encrypt_file(
                                            $backup_file,
                                            "",
                                            "",
                                            "",
                                            "",
                                            true,
                                            true
                );

                if($return_encrypted['finished']) {
                    ++$part;

                    if ($part < sizeof($backup_parts)) {
                        $return_encrypted['finished'] = 0;
                        $backup_file = $backup_parts[$part];
                    }
                }
            }
        }

        //Sending backup to remote storage
		if ( isset( $schedule['remote_storage'] ) && $schedule['remote_storage'] && array_key_exists( $schedule['remote_storage'], $this->xcloner_remote_storage->get_available_storages() ) ) {
			$backup_file = $return['extra']['backup_parent'];

			$this->logger->info( sprintf( "Transferring backup to remote storage %s", strtoupper( $schedule['remote_storage'] ) ), array( "CRON" ) );

			if ( method_exists( $this->xcloner_remote_storage, "upload_backup_to_storage" ) ) {
				call_user_func_array( array(
					$this->xcloner_remote_storage,
					"upload_backup_to_storage"
				), array( $backup_file, $schedule['remote_storage'] ) );
			}
		}

		//Sending email notification
		if ( isset( $schedule['backup_params']->email_notification ) and $to = $schedule['backup_params']->email_notification ) {
			try {
				$from                      = "";
				$additional['lines_total'] = $return['extra']['lines_total'];

$additional was never initialized. Although not strictly required by PHP, it is generally a good practice to add $additional = array(); before regardless.

				$subject                   = sprintf( __( "%s - new backup generated %s" ), $schedule['name'], $return['extra']['backup_parent'] );

				$this->archive_system->send_notification( $to, $from, $subject, $return['extra']['backup_parent'], $schedule, "", $additional );

			} catch ( Exception $e ) {
				$this->logger->error( $e->getMessage() );
			}
		}

		//CHECK IF WE SHOULD DELETE BACKUP AFTER REMOTE TRANSFER IS DONE
		if ( $schedule['remote_storage'] && $this->xcloner_settings->get_xcloner_option( 'xcloner_cleanup_delete_after_remote_transfer' ) ) {
			$this->logger->info( sprintf( "Deleting %s from local storage matching rule xcloner_cleanup_delete_after_remote_transfer", $return['extra']['backup_parent'] ) );
			$this->xcloner_file_system->delete_backup_by_name( $return['extra']['backup_parent'] );

		}

		//Removing the tmp filesystem used for backup
		$this->xcloner_file_system->remove_tmp_filesystem();

		//Backup Storage Cleanup
		$this->xcloner_file_system->backup_storage_cleanup();

		//Filesystem Cleanup
		$this->xcloner_file_system->cleanup_tmp_directories();
	}

	public function xcloner_scheduler_callback( $id, $schedule = "" ) {
		if ( $id ) {
			$schedule = $this->get_schedule_by_id( $id );
		}

		try {
            if( get_option('xcloner_disable_email_notification') ) {
                //we disable email notifications
                $schedule['backup_params']->email_notification = "";
            }
			$this->_xcloner_scheduler_callback( $id, $schedule );

		} catch ( Exception $e ) {

			//send email to site admin if email notification is not set in the scheduler
			if ( ! isset( $schedule['backup_params']->email_notification ) || ! $schedule['backup_params']->email_notification ) {
				$schedule['backup_params']->email_notification = get_option( 'admin_email' );
			}

			if ( isset( $schedule['backup_params']->email_notification ) && $to = $schedule['backup_params']->email_notification ) {
				$from = "";
				$this->archive_system->send_notification( $to, $from, $schedule['name'] . " - backup error", "", "", $e->getMessage() );
			}

		}

	}

	public function get_available_intervals() {
		$schedules     = wp_get_schedules();
		$new_schedules = array();

		foreach ( $schedules as $key => $row ) {
			if ( in_array( $key, $this->allowed_schedules ) ) {
				$new_schedules[ $key ] = $row;
				$intervals[ $key ]     = $row['interval'];

$intervals was never initialized. Although not strictly required by PHP, it is generally a good practice to add $intervals = array(); before regardless.

			}
		}

		array_multisort( $intervals, SORT_ASC, $new_schedules );

		return $new_schedules;
	}


}