Subversion-Projekte lars-tiefland.laravel_shop

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
148 lars 1 
<?php
2 
 
3 
namespace Illuminate\Console;
4 
 
5 
/**
6 
 * @internal
7 
 */
8 
class Signals
9 
{
10 
    /**
11 
     * The signal registry instance.
12 
     *
13 
     * @var \Symfony\Component\Console\SignalRegistry\SignalRegistry
14 
     */
15 
    protected $registry;
16 
 
17 
    /**
18 
     * The signal registry's previous list of handlers.
19 
     *
20 
     * @var array<int, array<int, callable>>|null
21 
     */
22 
    protected $previousHandlers;
23 
 
24 
    /**
25 
     * The current availability resolver, if any.
26 
     *
27 
     * @var (callable(): bool)|null
28 
     */
29 
    protected static $availabilityResolver;
30 
 
31 
    /**
32 
     * Create a new signal registrar instance.
33 
     *
34 
     * @param  \Symfony\Component\Console\SignalRegistry\SignalRegistry  $registry
35 
     * @return void
36 
     */
37 
    public function __construct($registry)
38 
    {
39 
        $this->registry = $registry;
40 
 
41 
        $this->previousHandlers = $this->getHandlers();
42 
    }
43 
 
44 
    /**
45 
     * Register a new signal handler.
46 
     *
47 
     * @param  int  $signal
48 
     * @param  callable(int $signal): void  $callback
49 
     * @return void
50 
     */
51 
    public function register($signal, $callback)
52 
    {
53 
        $this->previousHandlers[$signal] ??= $this->initializeSignal($signal);
54 
 
55 
        with($this->getHandlers(), function ($handlers) use ($signal) {
56 
            $handlers[$signal] ??= $this->initializeSignal($signal);
57 
 
58 
            $this->setHandlers($handlers);
59 
        });
60 
 
61 
        $this->registry->register($signal, $callback);
62 
 
63 
        with($this->getHandlers(), function ($handlers) use ($signal) {
64 
            $lastHandlerInserted = array_pop($handlers[$signal]);
65 
 
66 
            array_unshift($handlers[$signal], $lastHandlerInserted);
67 
 
68 
            $this->setHandlers($handlers);
69 
        });
70 
    }
71 
 
72 
    /**
73 
     * Gets the signal's existing handler in array format.
74 
     *
75 
     * @return array<int, callable(int $signal): void>
76 
     */
77 
    protected function initializeSignal($signal)
78 
    {
79 
        return is_callable($existingHandler = pcntl_signal_get_handler($signal))
80 
            ? [$existingHandler]
81 
            : null;
82 
    }
83 
 
84 
    /**
85 
     * Unregister the current signal handlers.
86 
     *
87 
     * @return array<int, array<int, callable(int $signal): void>>
88 
     */
89 
    public function unregister()
90 
    {
91 
        $previousHandlers = $this->previousHandlers;
92 
 
93 
        foreach ($previousHandlers as $signal => $handler) {
94 
            if (is_null($handler)) {
95 
                pcntl_signal($signal, SIG_DFL);
96 
 
97 
                unset($previousHandlers[$signal]);
98 
            }
99 
        }
100 
 
101 
        $this->setHandlers($previousHandlers);
102 
    }
103 
 
104 
    /**
105 
     * Execute the given callback if "signals" should be used and are available.
106 
     *
107 
     * @param  callable  $callback
108 
     * @return void
109 
     */
110 
    public static function whenAvailable($callback)
111 
    {
112 
        $resolver = static::$availabilityResolver;
113 
 
114 
        if ($resolver()) {
115 
            $callback();
116 
        }
117 
    }
118 
 
119 
    /**
120 
     * Get the registry's handlers.
121 
     *
122 
     * @return array<int, array<int, callable>>
123 
     */
124 
    protected function getHandlers()
125 
    {
126 
        return (fn () => $this->signalHandlers)
127 
            ->call($this->registry);
128 
    }
129 
 
130 
    /**
131 
     * Set the registry's handlers.
132 
     *
133 
     * @param  array<int, array<int, callable(int $signal):void>>  $handlers
134 
     * @return void
135 
     */
136 
    protected function setHandlers($handlers)
137 
    {
138 
        (fn () => $this->signalHandlers = $handlers)
139 
            ->call($this->registry);
140 
    }
141 
 
142 
    /**
143 
     * Set the availability resolver.
144 
     *
145 
     * @param  callable(): bool
146 
     * @return void
147 
     */
148 
    public static function resolveAvailabilityUsing($resolver)
149 
    {
150 
        static::$availabilityResolver = $resolver;
151 
    }
152 
}