Vert.x Core 手册

<?php
    $timerID = $vertx->setTimer(1000, function ($id) {
        echo "And one second later this is printed\n";
    });

    echo "First this is printed\n";

<?php
    $timerID = $vertx->setPeriodic(1000, function ($id) {
        echo "And every second this is printed\n";
    });

    echo "First this is printed\n";

<?php
    $vertx->cancelTimer($timerID);

<?php
    $eb = $vertx->eventBus();

<?php
    $eb = $vertx->eventBus();

    $eb->consumer("news.uk.sport", function ($message) {
        echo "I have received a message: ".$message->body()."\n";
    });

<?php
    $eb = $vertx->eventBus();

    $consumer = $eb->consumer("news.uk.sport");
    $consumer->handler(function ($message) {
        echo "I have received a message: ".$message->body()."\n";
    });

<?php
    $consumer->completionHandler(function ($res, $res_err) {
        if ($res != null) {
            echo "The handler registration has reached all nodes\n";
        } else {
            echo "Registration failed!\n";
        };
    });

<?php
    $consumer->unregister(function ($res, $res_err) {
        if ($res != null) {
            echo "The handler un-registration has reached all nodes\n";
        } else {
            echo "Un-registration failed!\n";
        };
    });

<?php
    $eventBus->publish("news.uk.sport", "Yay! Someone kicked a ball");

<?php
    $eventBus->send("news.uk.sport", "Yay! Someone kicked a ball");

<?php
    $consumer = $eventBus->consumer("news.uk.sport");
    $consumer->handler(function ($message) {
        echo "I have received a message: ".$message->body()."\n";
        $message->reply("how interesting!");
    });

<?php
    $eventBus->send("news.uk.sport", "Yay! Someone kicked a ball across a patch of grass", function ($ar, $ar_err) {
        if ($ar != null) {
            echo "Received reply: ".$ar->body()."\n";
        };
    });

<?php
    use io\vertx\jphp\core\Vertx;
    $options = array(
    );
    Vertx::clusteredVertx($options, function ($res, $res_err) {
        if ($res != null) {
            $vertx = $res;
            $eventBus = $vertx->eventBus();
            echo "We now have a clustered event bus: ".$eventBus."\n";
        } else {
            echo "Failed: ".$res_err."\n";
        };
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    $buff = Buffer::buffer();

    $buff->appendInt(123)->appendString("hello\n");

    $socket->write($buff);

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    $buff = Buffer::buffer();

    $buff->setInt(1000, 123);
    $buff->setString(0, "hello");

<?php
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => array(
            "path" => "/path/to/your/server-keystore.jks",
            "password" => "password-of-your-keystore"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $myKeyStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/server-keystore.jks");
    $jksOptions = array(
        "value" => $myKeyStoreAsABuffer,
        "password" => "password-of-your-keystore"
    );
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => $jksOptions
    );
    $server = $vertx->createNetServer($options);

<?php
    $options = array(
        "ssl" => true,
        "pfxKeyCertOptions" => array(
            "path" => "/path/to/your/server-keystore.pfx",
            "password" => "password-of-your-keystore"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $myKeyStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/server-keystore.pfx");
    $pfxOptions = array(
        "value" => $myKeyStoreAsABuffer,
        "password" => "password-of-your-keystore"
    );
    $options = array(
        "ssl" => true,
        "pfxKeyCertOptions" => $pfxOptions
    );
    $server = $vertx->createNetServer($options);

<?php
    $options = array(
        "ssl" => true,
        "pemKeyCertOptions" => array(
            "keyPath" => "/path/to/your/server-key.pem",
            "certPath" => "/path/to/your/server-cert.pem"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $myKeyAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/server-key.pem");
    $myCertAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/server-cert.pem");
    $pemOptions = array(
        "keyValue" => $myKeyAsABuffer,
        "certValue" => $myCertAsABuffer
    );
    $options = array(
        "ssl" => true,
        "pemKeyCertOptions" => $pemOptions
    );
    $server = $vertx->createNetServer($options);

<?php
    $options = array(
        "ssl" => true,
        "clientAuth" => "REQUIRED",
        "trustStoreOptions" => array(
            "path" => "/path/to/your/truststore.jks",
            "password" => "password-of-your-truststore"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $myTrustStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/truststore.jks");
    $options = array(
        "ssl" => true,
        "clientAuth" => "REQUIRED",
        "trustStoreOptions" => array(
            "value" => $myTrustStoreAsABuffer,
            "password" => "password-of-your-truststore"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $options = array(
        "ssl" => true,
        "clientAuth" => "REQUIRED",
        "pfxTrustOptions" => array(
            "path" => "/path/to/your/truststore.pfx",
            "password" => "password-of-your-truststore"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $myTrustStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/truststore.pfx");
    $options = array(
        "ssl" => true,
        "clientAuth" => "REQUIRED",
        "pfxTrustOptions" => array(
            "value" => $myTrustStoreAsABuffer,
            "password" => "password-of-your-truststore"
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $options = array(
        "ssl" => true,
        "clientAuth" => "REQUIRED",
        "pemTrustOptions" => array(
            "certPaths" => [
                "/path/to/your/server-ca.pem"
            ]
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $myCaAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/server-ca.pfx");
    $options = array(
        "ssl" => true,
        "clientAuth" => "REQUIRED",
        "pemTrustOptions" => array(
            "certValues" => [
                $myCaAsABuffer
            ]
        )
    );
    $server = $vertx->createNetServer($options);

<?php
    $options = array(
        "ssl" => true,
        "trustAll" => true
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "hostnameVerificationAlgorithm" => "HTTPS"
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "trustStoreOptions" => array(
            "path" => "/path/to/your/truststore.jks",
            "password" => "password-of-your-truststore"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $myTrustStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/truststore.jks");
    $options = array(
        "ssl" => true,
        "trustStoreOptions" => array(
            "value" => $myTrustStoreAsABuffer,
            "password" => "password-of-your-truststore"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "pfxTrustOptions" => array(
            "path" => "/path/to/your/truststore.pfx",
            "password" => "password-of-your-truststore"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $myTrustStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/truststore.pfx");
    $options = array(
        "ssl" => true,
        "pfxTrustOptions" => array(
            "value" => $myTrustStoreAsABuffer,
            "password" => "password-of-your-truststore"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "pemTrustOptions" => array(
            "certPaths" => [
                "/path/to/your/ca-cert.pem"
            ]
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $myTrustStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/ca-cert.pem");
    $options = array(
        "ssl" => true,
        "pemTrustOptions" => array(
            "certValues" => [
                $myTrustStoreAsABuffer
            ]
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => array(
            "path" => "/path/to/your/client-keystore.jks",
            "password" => "password-of-your-keystore"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $myKeyStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/client-keystore.jks");
    $jksOptions = array(
        "value" => $myKeyStoreAsABuffer,
        "password" => "password-of-your-keystore"
    );
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => $jksOptions
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "pfxKeyCertOptions" => array(
            "path" => "/path/to/your/client-keystore.pfx",
            "password" => "password-of-your-keystore"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $myKeyStoreAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/client-keystore.pfx");
    $pfxOptions = array(
        "value" => $myKeyStoreAsABuffer,
        "password" => "password-of-your-keystore"
    );
    $options = array(
        "ssl" => true,
        "pfxKeyCertOptions" => $pfxOptions
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "pemKeyCertOptions" => array(
            "keyPath" => "/path/to/your/client-key.pem",
            "certPath" => "/path/to/your/client-cert.pem"
        )
    );
    $client = $vertx->createNetClient($options);

<?php
    $myKeyAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/client-key.pem");
    $myCertAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/client-cert.pem");
    $pemOptions = array(
        "keyValue" => $myKeyAsABuffer,
        "certValue" => $myCertAsABuffer
    );
    $options = array(
        "ssl" => true,
        "pemKeyCertOptions" => $pemOptions
    );
    $client = $vertx->createNetClient($options);

<?php
    use io\vertx\jphp\core\net\SelfSignedCertificate;
    $certificate = SelfSignedCertificate::create();

    $serverOptions = array(
        "ssl" => true,
        "keyCertOptions" => $certificate->keyCertOptions(),
        "trustOptions" => $certificate->trustOptions()
    );

    $server = $vertx->createNetServer($serverOptions)->connectHandler(function ($socket) {
        $socket->write("Hello!")->end();
    })->listen(1234, "localhost");

    $clientOptions = array(
        "ssl" => true,
        "keyCertOptions" => $certificate->keyCertOptions(),
        "trustOptions" => $certificate->trustOptions()
    );

    $client = $vertx->createNetClient($clientOptions);
    $client->connect(1234, "localhost", function ($ar, $ar_err) {
        if ($ar != null) {
            $ar->handler(function ($buffer) {
                echo $buffer."\n";
            });
        } else {
            echo "Woops: ".$ar_err->getMessage()."\n";
        };
    });

<?php
    $clientOptions = array(
        "ssl" => true,
        "trustAll" => true
    );

<?php
    use io\vertx\jphp\core\net\SelfSignedCertificate;
    $certificate = SelfSignedCertificate::create();

    $vertx->createHttpServer(array(
        "ssl" => true,
        "keyCertOptions" => $certificate->keyCertOptions(),
        "trustOptions" => $certificate->trustOptions()
    ))->requestHandler(function ($req) {
        $req->response()->end("Hello!");
    })->listen(8080);

<?php
    $options = array(
        "ssl" => true,
        "trustStoreOptions" => $trustOptions,
        "crlPaths" => [
            "/path/to/your/crl.pem"
        ]
    );
    $client = $vertx->createNetClient($options);

<?php
    $myCrlAsABuffer = $vertx->fileSystem()->readFileBlocking("/path/to/your/crl.pem");
    $options = array(
        "ssl" => true,
        "trustStoreOptions" => $trustOptions,
        "crlValues" => [
            $myCrlAsABuffer
        ]
    );
    $client = $vertx->createNetClient($options);

<?php
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => $keyStoreOptions,
        "enabledCipherSuites" => [
            "ECDHE-RSA-AES128-GCM-SHA256",
            "ECDHE-ECDSA-AES128-GCM-SHA256",
            "ECDHE-RSA-AES256-GCM-SHA384",
            "CDHE-ECDSA-AES256-GCM-SHA384"
        ]
    );
    $server = $vertx->createNetServer($options);

Code not translatable

<?php

    // Use JDK SSL engine
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => $keyStoreOptions
    );

    // Use JDK SSL engine explicitly
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => $keyStoreOptions,
        "jdkSslEngineOptions" => array(
        )
    );

    // Use OpenSSL engine
    $options = array(
        "ssl" => true,
        "keyStoreOptions" => $keyStoreOptions,
        "openSslEngineOptions" => array(
        )
    );

<?php
    $keyCertOptions = array(
        "path" => "keystore.jks",
        "password" => "wibble"
    );

    $netServer = $vertx->createNetServer(array(
        "keyStoreOptions" => $keyCertOptions,
        "ssl" => true,
        "sni" => true
    ));

<?php
    $keyCertOptions = array(
        "keyPaths" => array( "default-key.pem",  "host1-key.pem",  "etc..."),
        "certPaths" => array( "default-cert.pem",  "host2-key.pem",  "etc...")
    );

    $netServer = $vertx->createNetServer(array(
        "pemKeyCertOptions" => $keyCertOptions,
        "ssl" => true,
        "sni" => true
    ));

<?php

    $client = $vertx->createNetClient(array(
        "trustStoreOptions" => $trustOptions,
        "ssl" => true
    ));

    // Connect to 'localhost' and present 'server.name' server name
    $client->connect(1234, "localhost", "server.name", function ($res, $res_err) {
        if ($res != null) {
            echo "Connected!\n";
            $socket = $res;
        } else {
            echo "Failed to connect: ".$res_err->getMessage()."\n";
        };
    });

<?php

    $headers = $request->headers();

    // Get the User-Agent:
    echo "User agent is ".$headers->get("user-agent")."\n";

    // You can also do this and get the same result:
    echo "User agent is ".$headers->get("User-Agent")."\n";

param1: 'abc'
param2: 'xyz

<?php

    $request->handler(function ($buffer) {
        echo "I have received a chunk of the body of length ".$buffer->length()."\n";
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    // Create an empty buffer
    $totalBuffer = Buffer::buffer();

    $request->handler(function ($buffer) {
        echo "I have received a chunk of the body of length ".$buffer->length()."\n";
        $totalBuffer->appendBuffer($buffer);
    });

    $request->endHandler(function ($v) {
        echo "Full body received, length = ".$totalBuffer->length()."\n";
    });

<?php

    $request->bodyHandler(function ($totalBuffer) {
        echo "Full body received, length = ".$totalBuffer->length()."\n";
    });

<?php

    $server->requestHandler(function ($request) {
        $request->setExpectMultipart(true);
        $request->endHandler(function ($v) {
            // The body has now been fully read, so retrieve the form attributes
            $formAttributes = $request->formAttributes();
        });
    });

<?php

    $server->requestHandler(function ($request) {
        $request->setExpectMultipart(true);
        $request->uploadHandler(function ($upload) {
            echo "Got a file upload ".$upload->name()."\n";
        });
    });

<?php

    $request->uploadHandler(function ($upload) {
        $upload->handler(function ($chunk) {
            echo "Received a chunk of the upload of length ".$chunk->length()."\n";
        });
    });

<?php

    $request->uploadHandler(function ($upload) {
        $upload->streamToFileSystem("myuploads_directory/".$upload->filename());
    });

<?php

    $request->customFrameHandler(function ($frame) {

        echo "Received a frame type=".$frame->type()." payload".$frame->payload()->toString()."\n";
    });

<?php
    $response = $request->response();
    $response->write($buffer);

<?php
    $response = $request->response();
    $response->write("hello world!");

<?php
    $response = $request->response();
    $response->write("hello world!", "UTF-16");

<?php
    $response = $request->response();
    $response->write("hello world!");
    $response->end();

<?php
    $response = $request->response();
    $response->end("hello world!");

<?php
    $response = $request->response();
    $headers = $response->headers();
    $headers->set("content-type", "text/html");
    $headers->set("other-header", "wibble");

<?php
    $response = $request->response();
    $response->putHeader("content-type", "text/html")->putHeader("other-header", "wibble");

<?php
    $response = $request->response();
    $response->setChunked(true);

<?php
    $response = $request->response();
    $response->setChunked(true);
    $trailers = $response->trailers();
    $trailers->set("X-wibble", "woobble")->set("X-quux", "flooble");

<?php
    $response = $request->response();
    $response->setChunked(true);
    $response->putTrailer("X-wibble", "woobble")->putTrailer("X-quux", "flooble");

<?php
    $vertx->createHttpServer()->requestHandler(function ($request) {
        $file = "";
        if ($request->path() == "/") {
            $file = "index.html";
        } else if (!$request->path()->contains("..")) {
            $file = $request->path();
        };
        $request->response()->sendFile("web/".$file);
    })->listen(8080);

<?php
    $vertx->createHttpServer()->requestHandler(function ($request) {
        $offset = 0;
        try {
            $offset = Java::type("java.lang.Long")->parseLong($request->getParam("start"));
        } catch(Exception $throwable) {
            // error handling...
        }
        ;

        $end = Java::type("java.lang.Long")->MAX_VALUE;
        try {
            $end = Java::type("java.lang.Long")->parseLong($request->getParam("end"));
        } catch(Exception $throwable) {
            // error handling...
        }
        ;

        $request->response()->sendFile("web/mybigfile.txt", $offset, $end);
    })->listen(8080);

<?php
    $vertx->createHttpServer()->requestHandler(function ($request) {
        $offset = 0;
        try {
            $offset = Java::type("java.lang.Long")->parseLong($request->getParam("start"));
        } catch(Exception $throwable) {
            // error handling...
        }
        ;

        $request->response()->sendFile("web/mybigfile.txt", $offset);
    })->listen(8080);

<?php
    use io\vertx\jphp\core\streams\Pump;
    $vertx->createHttpServer()->requestHandler(function ($request) {
        $response = $request->response();
        if ($request->method() == "PUT") {
            $response->setChunked(true);
            Pump::pump($request, $response)->start();
            $request->endHandler(function ($v) {
                $response->end();
            });
        } else {
            $response->setStatusCode(400)->end();
        };
    })->listen(8080);

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    $frameType = 40;
    $frameStatus = 10;
    $payload = Buffer::buffer("some data");

    // Sending a frame to the client
    $response->writeCustomFrame($frameType, $frameStatus, $payload);

<?php

    // Reset the stream
    $request->response()->reset();

<?php

    // Cancel the stream
    $request->response()->reset(8);

<?php

    $request->response()->exceptionHandler(function ($err) {
        if ($err.getClass().getSimpleName() == 'StreamResetException') {
            $reset = $err;
            echo "Stream reset ".$reset->getCode()."\n";
        };
    });

<?php

    $response = $request->response();

    // Push main.js to the client
    $response->push("GET", "/main.js", function ($ar, $ar_err) {

        if ($ar != null) {

            // The server is ready to push the response
            $pushedResponse = $ar;

            // Send main.js response
            $pushedResponse->putHeader("content-type", "application/json")->end("alert(\"Push response hello\")");
        } else {
            echo "Could not push client resource ".$ar_err."\n";
        };
    });

    // Send the requested resource
    $response->sendFile("<html><head><script src=\"/main.js\"></script></head><body></body></html>");

<?php
    $client = $vertx->createHttpClient();

    // Send a GET request
    $client->getNow("/some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });

    // Send a GET request
    $client->headNow("/other-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });

<?php
    $client = $vertx->createHttpClient();

    $client->request("GET", "some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    })->end();

    $client->request("POST", "foo-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    })->end("some-data");

<?php
    $client = $vertx->createHttpClient();

    $request = $client->post("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });

    // Now do stuff with the request
    $request->putHeader("content-length", "1000");
    $request->putHeader("content-type", "text/plain");
    $request->write($body);

    // Make sure the request is ended when you're done with it
    $request->end();

    // Or fluently:

    $client->post("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    })->putHeader("content-length", "1000")->putHeader("content-type", "text/plain")->write($body)->end();

    // Or event more simply:

    $client->post("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    })->putHeader("content-type", "text/plain")->end($body);

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    // Write string encoded in UTF-8
    $request->write("some data");

    // Write string encoded in specific encoding
    $request->write("some other data", "UTF-16");

    // Write a buffer
    $buffer = Buffer::buffer();
    $buffer->appendInt(123)->appendLong(245);
    $request->write($buffer);

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    // Write string and end the request (send it) in a single call
    $request->end("some simple data");

    // Write buffer and end the request (send it) in a single call
    $buffer = Buffer::buffer()->appendDouble(12.34)->appendLong(432);
    $request->end($buffer);

<?php

    // Write some headers using the headers() multimap

    $headers = $request->headers();
    $headers->set("content-type", "application/json")->set("other-header", "foo");

<?php

    // Write some headers using the putHeader method

    $request->putHeader("content-type", "application/json")->putHeader("other-header", "foo");

<?php
    $request->end();

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    // End the request with a string
    $request->end("some-data");

    // End it with a buffer
    $buffer = Buffer::buffer()->appendFloat(12.3)->appendInt(321);
    $request->end($buffer);

<?php

    $request->setChunked(true);

    // Write some chunks
    for ($i = 0; $i < 10; $i++) {
        $request->write("this-is-chunk-".$i);
    };

    $request->end();

<?php

    $request = $client->post("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });
    $request->exceptionHandler(function ($e) {
        echo "Received exception: ".$e->getMessage()."\n";
        $e->printStackTrace();
    });

<?php
    $request = $client->post("some-uri", function ($response) {
        if ($response->statusCode() == 200) {
            echo "Everything fine\n";
            return;
        };
        if ($response->statusCode() == 500) {
            echo "Unexpected behavior on the server side\n";
            return;
        };
    });
    $request->end();

<?php

    $request = $client->post("some-uri");
    $request->handler(function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });

<?php
    use io\vertx\jphp\core\streams\Pump;

    $request->setChunked(true);
    $pump = Pump::pump($file, $request);
    $file->endHandler(function ($v) {
        $request->end();
    });
    $pump->start();

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    $frameType = 40;
    $frameStatus = 10;
    $payload = Buffer::buffer("some data");

    // Sending a frame to the server
    $request->writeCustomFrame($frameType, $frameStatus, $payload);

<?php

    $request->reset();

<?php

    $request->reset(8);

<?php

    $request->exceptionHandler(function ($err) {
        if ($err.getClass().getSimpleName() == 'StreamResetException') {
            $reset = $err;
            echo "Stream reset ".$reset->getCode()."\n";
        };
    });

<?php

    $contentType = $response->headers()->get("content-type");
    $contentLength = $response->headers()->get("content-lengh");

<?php

    $client->getNow("some-uri", function ($response) {

        $response->handler(function ($buffer) {
            echo "Received a part of the response body: ".$buffer."\n";
        });
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    $client->getNow("some-uri", function ($response) {

        // Create an empty buffer
        $totalBuffer = Buffer::buffer();

        $response->handler(function ($buffer) {
            echo "Received a part of the response body: ".$buffer->length()."\n";

            $totalBuffer->appendBuffer($buffer);
        });

        $response->endHandler(function ($v) {
            // Now all the body has been read
            echo "Total response body length is ".$totalBuffer->length()."\n";
        });
    });

<?php

    $client->getNow("some-uri", function ($response) {

        $response->bodyHandler(function ($totalBuffer) {
            // Now all the body has been read
            echo "Total response body length is ".$totalBuffer->length()."\n";
        });
    });

<?php

    $client->get("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    })->setFollowRedirects(true)->end();

<?php

    $client = $vertx->createHttpClient(array(
        "maxRedirects" => 32
    ));

    $client->get("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    })->setFollowRedirects(true)->end();

<?php
    use io\vertx\jphp\core\Future;

    $client->redirectHandler(function ($response) {

        // Only follow 301 code
        if ($response->statusCode() == 301 && $response->getHeader("Location") != null) {

            // Compute the redirect URI
            $absoluteURI = resolveURI($response->request()->absoluteURI(), $response->getHeader("Location"));

            // Create a new ready to use request that the client will use
            return Future::succeededFuture($client->getAbs($absoluteURI));
        };

        // We don't redirect
        return null;
    });

<?php

    $request = $client->put("some-uri", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });

    $request->putHeader("Expect", "100-Continue");

    $request->continueHandler(function ($v) {
        // OK to send rest of body
        $request->write("Some data");
        $request->write("Some more data");
        $request->end();
    });

<?php

    $httpServer->requestHandler(function ($request) {
        if ($request->getHeader("Expect")->equalsIgnoreCase("100-Continue")) {

            // Send a 100 continue response
            $request->response()->writeContinue();

            // The client should send the body when it receives the 100 response
            $request->bodyHandler(function ($body) {
                // Do something with body
            });

            $request->endHandler(function ($v) {
                $request->response()->end();
            });
        };
    });

<?php

    $httpServer->requestHandler(function ($request) {
        if ($request->getHeader("Expect")->equalsIgnoreCase("100-Continue")) {

            //
            $rejectAndClose = true;
            if ($rejectAndClose) {

                // Reject with a failure code and close the connection
                // this is probably best with persistent connection
                $request->response()->setStatusCode(405)->putHeader("Connection", "close")->end();
            } else {

                // Reject with a failure code and ignore the body
                // this may be appropriate if the body is small
                $request->response()->setStatusCode(405)->end();
            };
        };
    });

<?php

    $request = $client->get("/index.html", function ($response) {
        // Process index.html response
    });

    // Set a push handler to be aware of any resource pushed by the server
    $request->pushHandler(function ($pushedRequest) {

        // A resource is pushed for this request
        echo "Server pushed ".$pushedRequest->path()."\n";

        // Set an handler for the response
        $pushedRequest->handler(function ($pushedResponse) {
            echo "The response for the pushed request\n";
        });
    });

    // End the request
    $request->end();

<?php
    $request->pushHandler(function ($pushedRequest) {
        if ($pushedRequest->path() == "/main.js") {
            $pushedRequest->reset();
        } else {
            // Handle it
        };
    });

<?php
    $response->customFrameHandler(function ($frame) {

        echo "Received a frame type=".$frame->type()." payload".$frame->payload()->toString()."\n";
    });

<?php
    $connection = $request->connection();

<?php
    $server = $vertx->createHttpServer($http2Options);

    $server->connectionHandler(function ($connection) {
        echo "A client connected\n";
    });

<?php
    $connection = $request->connection();

<?php
    $request->connectionHandler(function ($connection) {
        echo "Connected to the server\n";
    });

<?php
    $connection->updateSettings(array(
        "maxConcurrentStreams" => 100
    ));

<?php
    $connection->updateSettings(array(
        "maxConcurrentStreams" => 100
    ), function ($ar, $ar_err) {
        if ($ar != null) {
            echo "The settings update has been acknowledged \n";
        };
    });

<?php
    $connection->remoteSettingsHandler(function ($settings) {
        echo "Received new settings\n";
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    $data = Buffer::buffer();
    for ($i = 0; $i < 8; $i++) {
        $data->appendByte($i);
    };
    $connection->ping($data, function ($pong, $pong_err) {
        echo "Remote side replied\n";
    });

<?php
    $connection->pingHandler(function ($ping) {
        echo "Got pinged by remote side\n";
    });

<?php
    $connection->shutdown();

<?php
    $connection->goAway(0);

<?php
    $connection->goAwayHandler(function ($goAway) {
        echo "Received a go away frame\n";
    });

<?php
    $connection->goAway(0);
    $connection->shutdownHandler(function ($v) {

        // All streams are closed, close the connection
        $connection->close();
    });

<?php
    $client->websocket("/some-uri", function ($websocket) {
        echo "Connected!\n";
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    // Write a simple binary message
    $buffer = Buffer::buffer()->appendInt(123)->appendFloat(1.23);
    $websocket->writeBinaryMessage($buffer);

    // Write a simple text message
    $message = "hello";
    $websocket->writeTextMessage($message);

<?php
    use io\vertx\jphp\core\http\WebSocketFrame;

    $frame1 = WebSocketFrame::binaryFrame($buffer1, false);
    $websocket->writeFrame($frame1);

    $frame2 = WebSocketFrame::continuationFrame($buffer2, false);
    $websocket->writeFrame($frame2);

    // Write the final frame
    $frame3 = WebSocketFrame::continuationFrame($buffer2, true);
    $websocket->writeFrame($frame3);

<?php
    use io\vertx\jphp\core\buffer\Buffer;

    // Send a websocket messages consisting of a single final text frame:

    $websocket->writeFinalTextFrame("Geronimo!");

    // Send a websocket messages consisting of a single final binary frame:

    $buff = Buffer::buffer()->appendInt(12)->appendString("foo");

    $websocket->writeFinalBinaryFrame($buff);

<?php

    $websocket->frameHandler(function ($frame) {
        echo "Received a frame of size!\n";
    });

<?php

    $options = array(
        "proxyOptions" => array(
            "type" => "HTTP"
        )
    );
    $client = $vertx->createHttpClient($options);
    $client->getAbs("ftp://ftp.gnu.org/gnu/", function ($response) {
        echo "Received response with status code ".$response->statusCode()."\n";
    });

<?php

    $map->put("foo", "bar", function ($resPut, $resPut_err) {
        if ($resPut != null) {
            // Successfully put the value
        } else {
            // Something went wrong!
        };
    });

<?php

    $map->get("foo", function ($resGet, $resGet_err) {
        if ($resGet != null) {
            // Successfully got the value
            $val = $resGet;
        } else {
            // Something went wrong!
        };
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    $vertx->fileSystem()->open("target/classes/hello.txt", array(
    ), function ($result, $result_err) {
        if ($result != null) {
            $file = $result;
            $buff = Buffer::buffer("foo");
            for ($i = 0; $i < 5; $i++) {
                $file->write($buff, $buff->length() * $i, function ($ar, $ar_err) {
                    if ($ar != null) {
                        echo "Written ok!\n";
                        // etc
                    } else {
                        echo "Failed to write: ".$ar_err."\n";
                    };
                });
            };
        } else {
            echo "Cannot open file ".$result_err."\n";
        };
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    $vertx->fileSystem()->open("target/classes/les_miserables.txt", array(
    ), function ($result, $result_err) {
        if ($result != null) {
            $file = $result;
            $buff = Buffer::buffer(1000);
            for ($i = 0; $i < 10; $i++) {
                $file->read($buff, $i * 100, $i * 100, 100, function ($ar, $ar_err) {
                    if ($ar != null) {
                        echo "Read ok!\n";
                    } else {
                        echo "Failed to write: ".$ar_err."\n";
                    };
                });
            };
        } else {
            echo "Cannot open file ".$result_err."\n";
        };
    });

<?php
    use io\vertx\jphp\core\streams\Pump;
    $output = $vertx->fileSystem()->openBlocking("target/classes/plagiary.txt", array(
    ));

    $vertx->fileSystem()->open("target/classes/les_miserables.txt", array(
    ), function ($result, $result_err) {
        if ($result != null) {
            $file = $result;
            Pump::pump($file, $output)->start();
            $file->endHandler(function ($r) {
                echo "Copy done\n";
            });
        } else {
            echo "Cannot open file ".$result_err."\n";
        };
    });

<?php
    use io\vertx\jphp\core\buffer\Buffer;
    $socket = $vertx->createDatagramSocket(array(
    ));
    $buffer = Buffer::buffer("content");
    // Send a Buffer to a multicast address
    $socket->send($buffer, 1234, "230.0.0.1", function ($asyncResult, $asyncResult_err) {
        echo "Send succeeded? ".$asyncResult != null."\n";
    });

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

io.vertx.core.net.impl.ConnectionBase
SEVERE: java.io.IOException: Connection reset by peer

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("some-name")->setSummary("A command line interface illustrating the options valuation.")->addOption(array(
        "longName" => "flag",
        "shortName" => "f",
        "flag" => true,
        "description" => "a flag"
    ))->addOption(array(
        "longName" => "single",
        "shortName" => "s",
        "description" => "a single-valued option"
    ))->addOption(array(
        "longName" => "multiple",
        "shortName" => "m",
        "multiValued" => true,
        "description" => "a multi-valued option"
    ));

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("some-name")->addOption(array(
        "longName" => "mandatory",
        "required" => true,
        "description" => "a mandatory option"
    ));

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("some-name")->addOption(array(
        "longName" => "optional",
        "defaultValue" => "hello",
        "description" => "an optional option with a default value"
    ));

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("some-name")->addOption(array(
        "longName" => "color",
        "defaultValue" => "green",
        "choices" => [
            "blue",
            "red",
            "green"
        ],
        "description" => "a color"
    ));

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("some-name")->addArgument(array(
        "index" => 0,
        "description" => "the first argument",
        "argName" => "arg1"
    ))->addArgument(array(
        "index" => 1,
        "description" => "the second argument",
        "argName" => "arg2"
    ));

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("some-name")->addArgument(array(
        "description" => "the first argument",
        "argName" => "arg1"
    ))->addArgument(array(
        "description" => "the second argument",
        "argName" => "arg2"
    ));

<?php
    use io\vertx\jphp\core\cli\CLI;
    $cli = CLI::create("copy")->setSummary("A command line interface to copy files.")->addOption(array(
        "longName" => "directory",
        "shortName" => "R",
        "description" => "enables directory support",
        "flag" => true
    ))->addArgument(array(
        "index" => 0,
        "description" => "The source",
        "argName" => "source"
    ))->addArgument(array(
        "index" => 0,
        "description" => "The destination",
        "argName" => "target"
    ));

    $builder = Java::type("java.lang.StringBuilder").newInstance();
    $cli->usage($builder);

Usage: copy [-R] source target

A command line interface to copy files.

 -R,--directory   enables directory support