• Schedule artisan commands to run automatically
• Scheduling is maintained within your version control system
• Single source of truth for when and where commands run
• Schedule commands to run with arguments and options
• Run commands as other users
• Run commands in certain environments
• Use custom drivers for custom scheduling contexts

In all scheduled commands…

scheduled
  scheduled:make              Create a new scheduled artisan command
  scheduled:run               Run scheduled commands
  scheduled:summary           View a summary of all scheduled artisan commands

If commands are not visible via php artisan then they cannot be scheduled.

You may either implement \Indatus\Dispatcher\Scheduling\ScheduledCommandInterface or follow the below steps.

1. Add use statements to your command. If you’re using a custom driver you will use a different Scheduler class.

use Indatus\Dispatcher\Scheduling\ScheduledCommand;
use Indatus\Dispatcher\Scheduling\Schedulable;
use Indatus\Dispatcher\Drivers\DateTime\Scheduler;

2. Extend \Indatus\Dispatcher\Scheduling\ScheduledCommand
3. Implement schedule():

	/**
	 * When a command should run
	 *
	 * @param Scheduler $scheduler
	 *
	 * @return Scheduler
	 */
	public function schedule(Schedulable $scheduler)
	{
		return $scheduler;
    }

You may override user() to run a given artisan command as a specific user. Ensure your scheduled:run artisan command is running as root.

    public function user()
    {
        return 'backup';
    }

This feature may not be supported by all drivers.

You may override environment() to ensure your command is only scheduled in specific environments. It should provide a single environment or an array of environments.

    public function environment()
    {
        return ['development','staging'];
    }

By default, cron commands will not run when application is in Maintenance Mode. This will prevent all sorts of weird output that might occur if a cron command is run while you are migrating a database or doing a composer update.

You may override runInMaintenanceMode() to force your command to still be run while the application is in maintenance mode.

    public function runInMaintenanceMode()
    {
        return true;
    }

You may schedule a given command to to run at multiple times by schedule() returning multiple Schedulable instances.

	public function schedule(Schedulable $scheduler)
	{
        return [
            // 5am Mon-Fri
            $scheduler->everyWeekday()->hours(5),

            // 2am every Saturday
            App::make(get_class($scheduler))
                ->daysOfTheWeek(Scheduler::SATURDAY)
                ->hours(2)
        ];
    }

You may also schedule a command to run with arguments and options.

	public function schedule(Schedulable $scheduler)
	{
		return [
            // equivalent to: php /path/to/artisan command:name /path/to/file
            $scheduler->args(['/path/to/file'])
                ->everyWeekday()
                ->hours(5),

            // equivalent to: php /path/to/artisan command:name /path/to/file --force --toDelete="expired" --exclude="admins" --exclude="developers"
            $scheduler->args(['/path/to/file'])
                ->opts([
                    'force',
                    'toDelete' => 'expired',
                    'exclude' => [
                        'admins',
                        'developers'
                    ]
                ])
                ->daysOfTheMonth([1, 15])
                ->hours(2)
        ];
	}

NOTE: Both args() and opts(), whichever is called first, will internally create a new Schedulable instance for you so you don’t need to App::make().

Examples of how to schedule:

	public function schedule(Schedulable $scheduler)
	{
        //every day at 4:17am
        return $scheduler->daily()->hours(4)->minutes(17);
    }

	public function schedule(Schedulable $scheduler)
	{
        //every Tuesday/Thursday at 5:03am
        return $scheduler->daysOfTheWeek([
                Scheduler::TUESDAY,
                Scheduler::THURSDAY
            ])->hours(5)->minutes(3);
    }

	public function schedule(Schedulable $scheduler)
	{
        //the second and third Tuesday of every month at 12am
        return $scheduler->monthly()->week([2, 3])->daysOfTheWeek(Day::TUESDAY);
    }

Custom drivers allow you to provide application context within scheduling. For example, an education-based application may contain scheduling methods like inServiceDays(), springBreak() and christmasBreak() where commands are run or don’t run during those times.

Create a packagepath such as \MyApp\ScheduleDriver\ and create two classes:

• Scheduler that implements Indatus\Dispatcher\Scheduling\Schedulable. This class should provide a useful interface for programmers to schedule their commands.
• ScheduleService that extends \Indatus\Dispatcher\Services\ScheduleService. This class contains logic on how to determine if a command is due to run.

Publish the configs using php artisan config:publish indatus/dispatcher. Then update your driver configuration to reference the package in which these 2 classes are included (do not include a trailing slash):

    'driver' => '\MyApp\ScheduleDriver'

I need to deploy to multiple servers representing a single environment. How can I be sure my command is only run by a single server and not run on each server?