Register the failed job services.

@return void
552602
protected function registerFailedJobServices()
    {
        Zilf::$container->register(
            'queue.failer', function () {
                $config = config('queue.failed');

                return isset($config['table'])
                        ? $this->databaseFailedJobProvider($config)
                        : new NullFailedJobProvider;
            }
        );
    }
1270979
static public function registerDefaults() {
		if (self::$registeredStatic) {
			require_once __DIR__ . '/Exceptions/RegisterationFailed.php';
			throw new RegistrationFailed('Is already registered');
		}
		
		$loader = new static();
		$loader->registerNamespace('ZExt', __DIR__ . '/..');
		$loader->register();
		
		self::$registeredStatic = true;
		
		return $loader;
	}
956824
public function register()
	{
		$this->app->singleton('command.queue.table', function($app)
		{
			return new TableCommand($app['files'], $app['composer']);
		});

		$this->app->singleton('command.queue.failed', function()
		{
			return new ListFailedCommand;
		});

		$this->app->singleton('command.queue.retry', function()
		{
			return new RetryCommand;
		});

		$this->app->singleton('command.queue.forget', function()
		{
			return new ForgetFailedCommand;
		});

		$this->app->singleton('command.queue.flush', function()
		{
			return new FlushFailedCommand;
		});

		$this->app->singleton('command.queue.failed-table', function($app)
		{
			return new FailedTableCommand($app['files'], $app['composer']);
		});

		$this->commands(
			'command.queue.table', 'command.queue.failed', 'command.queue.retry',
			'command.queue.forget', 'command.queue.flush', 'command.queue.failed-table'
		);
	}
909812
public function register()
    {
        if (env('USE_JSON_EXCEPTION_HANDLER', false)) {
            $this->app->bind(
                \Illuminate\Contracts\Debug\ExceptionHandler::class,
                'RobRogers3\LaravelExceptionHandler\JsonAwareExceptionHandler'
            );
        }
        
    }
115663
public function register()
    {
        $this->registerManager();
        $this->registerConnection();
        $this->registerWorker();
        $this->registerListener();
        $this->registerFailedJobServices();
        $this->registerOpisSecurityKey();
    }
691459
protected function getFailedJobs()
	{
		$results = [];

		foreach ($this->laravel['queue.failer']->all() as $failed) {
			$results[] = $this->parseFailedJob((array) $failed);
		}

		return array_filter($results);
	}
920608
public function register() : void
    {
        if ($this->getConfigParam('env') == 'prod') {
            ini_set('display_errors', 'Off');
        } else {
            ini_set('display_errors', 'On');
        }
        error_reporting(E_ALL);
        set_error_handler([$this, 'handleError']);
        set_exception_handler([$this, 'handleException']);
    }
1115292
public function failed()
	{
		$payload = json_decode($this->getRawBody(), true);

		list($class, $method) = $this->parseJob($payload['job']);

		$this->instance = $this->resolve($class);

		if (method_exists($this->instance, 'failed')) {
			$this->instance->failed($this->resolveQueueableEntities($payload['data']));
		}
	}
154203
protected function registerWorkerExitCallback()
    {
        $this->swooleServer->on('WorkerExit', function ($server, $workerId) {
            $this->events->dispatch(new Events\WorkerExiting($this, $workerId));

            $this->dispatchEvent('WorkerExit', $this, $workerId);
        });
    }
39395
public function register()
    {
        if (!$this->isRegistered) {
            // Workaround PHP bug 42098
            // https://bugs.php.net/bug.php?id=42098
            class_exists("\\Whoops\\Exception\\ErrorException");
            class_exists("\\Whoops\\Exception\\FrameCollection");
            class_exists("\\Whoops\\Exception\\Frame");
            class_exists("\\Whoops\\Exception\\Inspector");

            set_error_handler(array($this, self::ERROR_HANDLER));
            set_exception_handler(array($this, self::EXCEPTION_HANDLER));
            register_shutdown_function(array($this, self::SHUTDOWN_HANDLER));

            $this->isRegistered = true;
        }

        return $this;
    }
1220009
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/config.php', 'task');

        // Bind facade
        $this->app->bind('task', function ($app) {
            return $this->app->make('Litepie\Task\Task');
        });

        // Bind Task to repository
        $this->app->bind(
            'Litepie\Task\Interfaces\TaskRepositoryInterface',
            \Litepie\Task\Repositories\Eloquent\TaskRepository::class
        );

        $this->app->register(\Litepie\Task\Providers\AuthServiceProvider::class);
        $this->app->register(\Litepie\Task\Providers\EventServiceProvider::class);
        $this->app->register(\Litepie\Task\Providers\RouteServiceProvider::class);
    }
1093656
public function register()
    {
        ini_set('display_errors', false);
        set_exception_handler([$this, 'handleException']);
        set_error_handler([$this, 'handleError']);

        if ($this->memoryReserveSize > 0) {
            $this->_memoryReserve = str_repeat('x', $this->memoryReserveSize);
        }
        register_shutdown_function([$this, 'handleFatalError']);
    }
1010604
public function register() {
		if ($this->registered) {
			require_once __DIR__ . '/Exceptions/RegisterationFailed.php';
			throw new RegistrationFailed('Is already registered');
		}
		
		if ($this->namespaces->isEmpty()) {
			require_once __DIR__ . '/Exceptions/RegisterationFailed.php';
			throw new RegistrationFailed('No namespaces was registered');
		}
		
		spl_autoload_register(function($class) {
			foreach ($this->namespaces as $definition) {
				if (strpos($class, $definition->namespace) === 0) {
					$resolvedClass = substr($class, strlen($definition->namespace));
					
					if ($this->loadClass($resolvedClass, $definition->dirs)) {
						return;
					}
				}
			}
			
			if (! $this->dirs->isEmpty()) {
				$this->loadClass('\\' . $class, $this->dirs);
			}
		});
		
		$this->registered = true;
	}
204133
public static function register() {
		ini_set('display_errors', 0);
		ini_set('display_startup_errors', 0);
		error_reporting(-1);

		static::$reservedMemory = str_repeat('a', 10240);
		static::$errorAtStart = error_get_last();

		$errorHandler = new static();
		set_error_handler([$errorHandler, 'phpErrorHandler']);
		set_exception_handler([$errorHandler, 'exceptionHandler']);

		return $errorHandler;
	}
1086179
protected function registerMigrationService(): void
    {
        $config = $this->app['config'];
        $config->set('database.migrations', $config->get('database.migrations') ?: 'migrations');
        $this->app->register(\Illuminate\Database\MigrationServiceProvider::class);

        $this->app->alias(
            'migration.repository',
            \Illuminate\Database\Migrations\MigrationRepositoryInterface::class
        );

        $this->app->singleton(
            'migrator',
            function ($app) {
                $repository = $app['migration.repository'];

                return new Migrator($repository, $app['db'], $app['files']);
            }
        );

        $this->app->alias(
            'migrator',
            \Illuminate\Database\Migrations\Migrator::class
        );
    }
507671
public function fire()
	{
		$jobs = $this->getFailedJobs();

		if (count($jobs) == 0) {
			return $this->info('No failed jobs!');
		}

		$this->displayFailedJobs($jobs);
	}
475879
public function fire()
	{
		if ($this->flyphp['queue.failer']->forget($this->argument('id')))
		{
			$this->info('Failed job deleted successfully!');
		}
		else
		{
			$this->error('No failed job matches the given ID.');
		}
	}