update documentation with new APIs

Author: Baptouuuu

documentation/advanced/logging.md

@@ -2,16 +2,12 @@
 
 If you want to trace everything that is done on your operating system you can use the logger decorator that will automatically write to your log file (almost) all operations.
 
-!!! note ""
-    Data and actions done on a socket are not logged as well as processes output to prevent logging too much data (at least for now).
-
 ```php
-use Innmind\OperatingSystem\OperatingSystem\Logger;
+use Innmind\OperatingSystem\Config\Logger;
 use Psr\Log\LoggerInterface;
 
-$os = Logger::psr(
-    $os,
-    /* any instance of LoggerInterface */
+$os = $os->map(
+    Logger::psr(/* any instance of LoggerInterface */),
 );
 ```
 

documentation/use_cases/filesystem.md

@@ -17,8 +17,14 @@ $backup = function(Adapter $source, Adapter $target): void {
     });
 };
 $backup(
-    $os->filesystem()->mount(Path::of('/path/to/source/')),
-    $os->filesystem()->mount(Path::of('/path/to/target/')),
+    $os
+        ->filesystem()
+        ->mount(Path::of('/path/to/source/'))
+        ->unwrap(),
+    $os
+        ->filesystem()
+        ->mount(Path::of('/path/to/target/'))
+        ->unwrap(),
 );
 ```
 
@@ -53,7 +59,10 @@ $addUserPicture = function(
         );
 };
 $addUserPicture(
-    $os->filesystem()->mount(Path::of('/path/to/users/data/')),
+    $os
+        ->filesystem()
+        ->mount(Path::of('/path/to/users/data/'))
+        ->unwrap(),
     'some-unique-id',
     File::named(
         'picture.png',
@@ -94,10 +103,18 @@ use Innmind\Url\Path;
 $path = Path::of('/path/to/some/required/folder/');
 
 if (!$os->filesystem()->contains($path)) {
-    $os->control()->processes()->execute($mkdirCommand);
+    $os
+        ->control()
+        ->processes()
+        ->execute($mkdirCommand)
+        ->unwrap();
 }
 
-$os->control()->processes()->execute($subProcessCommand);
+$os
+    ->control()
+    ->processes()
+    ->execute($subProcessCommand)
+    ->unwrap();
 ```
 
 See [processes](processes.md) section on how to execute commands on your operating system.
@@ -109,7 +126,10 @@ Sometimes you want to use the `tmp` folder to write down files such as cache tha
 ```php
 use Innmind\Filesystem\Adapter;
 
-$tmp = $os->filesystem()->mount($os->status()->tmp());
+$tmp = $os
+    ->filesystem()
+    ->mount($os->status()->tmp())
+    ->unwrap();
 $tmp instanceof Adapter; // true
 ```
 
@@ -131,10 +151,17 @@ $count = $runTests(
             return $continuation->stop($count);
         }
 
-        $os->control()->processes()->execute($phpunitCommand);
+        $os
+            ->control()
+            ->processes()
+            ->execute($phpunitCommand)
+            ->unwrap();
 
         return $continuation->continue(++$count);
     },
+)->match(
+    static fn(int $count) => $count, // always 42 as it's the stopping value
+    static fn(\Throwable $e) => throw $e,
 );
 ```
 

documentation/use_cases/http.md

@@ -36,10 +36,10 @@ All elements of a request/response call is built using objects to enforce correc
 One of the first things taught when working with distributed systems is that they will intermittently fail. To prevent your app to crash for an occasional failure a common pattern is the _retry pattern_ with a backoff strategy allowing the client to retry safe requests a certain amount of time before giving up. You can use this pattern like so:
 
 ```php
-use Innmind\OperatingSystem\OperatingSystem\Resilient;
+use Innmind\OperatingSystem\Config\Resilient;
 use Innmind\HttpTransport\ExponentialBackoff;
 
-$os = Resilient::of($os);
+$os = $os->map(Resilient::new());
 $http = $os->remote()->http();
 $http instanceof ExponentialBackoff; // true
 ```
@@ -48,12 +48,12 @@ Another strategy you can add on top of that is the [circuit breaker pattern](htt
 
 ```php
 use Innmind\HttpTransport\CircuitBreaker;
-use Innmind\TimeContinuum\Earth\Period\Minute;
+use Innmind\TimeContinuum\Period;
 
 $http = CircuitBreaker::of(
     $http,
     $os->clock(),
-    new Minute(1),
+    Period::minute(1),
 );
 $request = Request::of(/* ...args */)
 $response = $http($request);

documentation/use_cases/ipc.md

@@ -7,57 +7,60 @@ The later is the safest of the two (but not exempt of problems) and you will fin
 !!! tip ""
     The adage `share state through messages and not messages through state` is a pillar of the [actor model](https://en.wikipedia.org/wiki/Actor_model) and [initially of object oriented programming](https://www.youtube.com/watch?v=7erJ1DV_Tlo).
 
-```php
-# process acting as a server
-use Innmind\Socket\Address\Unix as Address;
-use Innmind\TimeContinuum\Earth\ElapsedPeriod;
-use Innmind\Immutable\{
-    Sequence,
-    Str,
-};
+=== "Server"
+    ```php
+    use Innmind\IO\Sockets\Unix\Address;
+    use Innmind\Url\Path;
+    use Innmind\TimeContinuum\Period;
+    use Innmind\Immutable\{
+        Sequence,
+        Str,
+    };
 
-$server = $os->sockets()->open(Address::of('/tmp/foo'))->match(
-    static fn($server) => $server,
-    static fn() => throw new \RuntimeException('Unable to start the server'),
-);
-$watch = $os->sockets()->watch(new ElapsedPeriod(1000))->forRead($server);
+    $server = $os
+        ->sockets()
+        ->open(Address::of(Path::of('/tmp/foo')))
+        ->unwrap();
+        ->timeoutAfter(Period::second(1));
 
-while (true) {
-    $_ = $server
-        ->timeoutAfter(ElapsedPeriod::of(1_000))
-        ->accept()
-        ->match(
-            static fn($client) => $client
-                ->send(Sequence::of(Str::of('Hello')))
-                ->flatMap(static fn() => $client->close())
-                ->match(
-                    static fn() => null, // everyhting is ok
-                    static fn() => throw new \RuntimeException('Unable to send data or close the connection'),
-                ),
-            static fn() => null, // no new connection available
-        ),
-}
-```
+    while (true) {
+        $_ = $server
+            ->accept()
+            ->match(
+                static fn($client) => $client
+                    ->sink(Sequence::of(Str::of('Hello')))
+                    ->flatMap(static fn() => $client->close())
+                    ->match(
+                        static fn() => null, // everyhting is ok
+                        static fn(\Throwable $e) => throw $e,
+                    ),
+                static fn() => null, // no new connection available
+            ),
+    }
+    ```
 
-```php
-# process acting as client
-use Innmind\Socket\Address\Unix as Address;
-use Innmind\IO\Readable\Frame;
+=== "Client"
+    ```php
+    use Innmind\IO\{
+        Sockets\Unix\Address,
+        Frame,
+    };
+    use Innmind\Url\Path;
 
-$client = $os->sockets()->connectTo(Address::of('/tmp/foo'))->match(
-    static fn($client) => $client,
-    static fn() => throw new \RuntimeException('Unable to connect to the server'),
-);
+    $client = $os
+        ->sockets()
+        ->connectTo(Address::of(Path::of('/tmp/foo')))
+        ->unwrap();
 
-echo $client
-    ->watch()
-    ->frames(Frame\Chunk::of(5))
-    ->one()
-    ->match(
-        static fn($data) => $data->toString(),
-        static fn() => 'unable to read the stream',
-    );
-```
+    echo $client
+        ->watch()
+        ->frames(Frame::chunk(5)->strict())
+        ->one()
+        ->match(
+            static fn($data) => $data->toString(),
+            static fn() => 'unable to read the stream',
+        );
+    ```
 
 In the case the server is started first then the client would print `Hello`.
 

documentation/use_cases/processes.md

@@ -12,23 +12,38 @@ use Innmind\Server\Control\Server\{
     Signal,
 };
 
-$webserver = $os->control()->processes()->execute(
-    Command::foreground('php')
-        ->withShortOption('S', 'localhost:8080'),
-);
+$webserver = $os
+    ->control()
+    ->processes()
+    ->execute(
+        Command::foreground('php')
+            ->withShortOption('S', 'localhost:8080'),
+    )
+    ->unwrap();
 // do some stuff
-$os->control()->processes()->kill($webserver->pid(), Signal::kill);
+$webserver->pid()->match(
+    static fn($pid) => $os
+        ->control()
+        ->processes()
+        ->kill($pid, Signal::kill)
+        ->unwrap(),
+    static fn() => null, // background processes don't have a pid
+);
 ```
 
 Here we start the PHP builtin webserver and perform some imaginary action before killing it, but you could also wait the process to finish (see below) instead of killing it (in the case of the webserver it never finishes unless with a crash).
 
 ```php
 use Innmind\Server\Control\Server\Command;
 
-$webserver = $os->control()->processes()->execute(
-    Command::foreground('php')
-        ->withShortOption('S', 'localhost:8080'),
-);
+$webserver = $os
+    ->control()
+    ->processes()
+    ->execute(
+        Command::foreground('php')
+            ->withShortOption('S', 'localhost:8080'),
+    )
+    ->unwrap();
 $webserver->wait();
 ```
 
@@ -37,10 +52,14 @@ Or you could start the process as an independent one (meaning you can't control
 ```php
 use Innmind\Server\Control\Server\Command;
 
-$os->control()->processes()->execute(
-    Command::background('php')
-        ->withShortOption('S', 'localhost:8080'),
-);
+$os
+    ->control()
+    ->processes()
+    ->execute(
+        Command::background('php')
+            ->withShortOption('S', 'localhost:8080'),
+    )
+    ->unwrap();
 ```
 
 ## Executing processes on a remote machine
@@ -63,15 +82,15 @@ $installMariadb($os->remote()->ssh(Url::of('ssh://user@replication2')));
 
 ```php
 use Innmind\Server\Status\Server\Process;
-use Innmind\TimeContinuum\Earth\Format\ISO8601;
+use Innmind\TimeContinuum\Format;
 
 $os->status()->processes()->all()->foreach(function(Process $process): void {
     \printf(
         "Process %s started by %s at %s\n",
         $process->command()->toString(),
         $process->user()->toString(),
         $process->start()->match(
-            static fn($date) => $date->format(new ISO8601),
+            static fn($date) => $date->format(Format::iso8601()),
             static fn() => 'unknown start date',
         ),
     );
@@ -97,9 +116,13 @@ $backupRunning = $os
     );
 
 if (!$backupRunning) {
-    $os->control()->processes()->execute(
-        Command::background('my-backup-tool'),
-    );
+    $os
+        ->control()
+        ->processes()
+        ->execute(
+            Command::background('my-backup-tool'),
+        )
+        ->unwrap();
 }
 ```
 
@@ -108,8 +131,8 @@ if (!$backupRunning) {
 ```php
 use Innmind\Url\Url;
 
-$os->control()->reboot();
-$os->control()->shutdown();
-$os->remote()->ssh(Url::of('ssh://user@remote-server'))->reboot();
-$os->remote()->ssh(Url::of('ssh://user@remote-server'))->shutdown();
+$os->control()->reboot()->unwrap();
+$os->control()->shutdown()->unwrap();
+$os->remote()->ssh(Url::of('ssh://user@remote-server'))->reboot()->unwrap();
+$os->remote()->ssh(Url::of('ssh://user@remote-server'))->shutdown()->unwrap();
 ```