Vert.x Core 手册

var timerID = vertx.setTimer(1000, function (id) {
  console.log("And one second later this is printed");
});

console.log("First this is printed");

var timerID = vertx.setPeriodic(1000, function (id) {
  console.log("And every second this is printed");
});

console.log("First this is printed");

vertx.cancelTimer(timerID);

var eb = vertx.eventBus();

var eb = vertx.eventBus();

eb.consumer("news.uk.sport", function (message) {
  console.log("I have received a message: " + message.body());
});

var eb = vertx.eventBus();

var consumer = eb.consumer("news.uk.sport");
consumer.handler(function (message) {
  console.log("I have received a message: " + message.body());
});

consumer.completionHandler(function (res, res_err) {
  if (res_err == null) {
    console.log("The handler registration has reached all nodes");
  } else {
    console.log("Registration failed!");
  }
});

consumer.unregister(function (res, res_err) {
  if (res_err == null) {
    console.log("The handler un-registration has reached all nodes");
  } else {
    console.log("Un-registration failed!");
  }
});

eventBus.publish("news.uk.sport", "Yay! Someone kicked a ball");

eventBus.send("news.uk.sport", "Yay! Someone kicked a ball");

var options = {
headers: {
  "some-header" : "some-value"
}
}
vertx.eventBus().send("news.uk.sport", "Yay! Someone kicked a ball", options);

vertx.eventBus().consumer("news.uk.sport", function(e) {
console.log(e.headers().get("some-header"));
});

var consumer = eventBus.consumer("news.uk.sport");
consumer.handler(function (message) {
  console.log("I have received a message: " + message.body());
  message.reply("how interesting!");
});

eventBus.send("news.uk.sport", "Yay! Someone kicked a ball across a patch of grass", function (ar, ar_err) {
  if (ar_err == null) {
    console.log("Received reply: " + ar.body());
  }
});

var Vertx = require("vertx-js/vertx");
var options = {
};
Vertx.clusteredVertx(options, function (res, res_err) {
  if (res_err == null) {
    var vertx = res;
    var eventBus = vertx.eventBus();
    console.log("We now have a clustered event bus: " + eventBus);
  } else {
    console.log("Failed: " + res_err);
  }
});

var Buffer = require("vertx-js/buffer");
var buff = Buffer.buffer();

buff.appendInt(123).appendString("hello\n");

socket.write(buff);

var Buffer = require("vertx-js/buffer");
var buff = Buffer.buffer();

buff.setInt(1000, 123);
buff.setString(0, "hello");

var options = {
  "ssl" : true,
  "keyStoreOptions" : {
    "path" : "/path/to/your/server-keystore.jks",
    "password" : "password-of-your-keystore"
  }
};
var server = vertx.createNetServer(options);

var myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-keystore.jks");
var jksOptions = {
  "value" : myKeyStoreAsABuffer,
  "password" : "password-of-your-keystore"
};
var options = {
  "ssl" : true,
  "keyStoreOptions" : jksOptions
};
var server = vertx.createNetServer(options);

var options = {
  "ssl" : true,
  "pfxKeyCertOptions" : {
    "path" : "/path/to/your/server-keystore.pfx",
    "password" : "password-of-your-keystore"
  }
};
var server = vertx.createNetServer(options);

var myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-keystore.pfx");
var pfxOptions = {
  "value" : myKeyStoreAsABuffer,
  "password" : "password-of-your-keystore"
};
var options = {
  "ssl" : true,
  "pfxKeyCertOptions" : pfxOptions
};
var server = vertx.createNetServer(options);

var options = {
  "ssl" : true,
  "pemKeyCertOptions" : {
    "keyPath" : "/path/to/your/server-key.pem",
    "certPath" : "/path/to/your/server-cert.pem"
  }
};
var server = vertx.createNetServer(options);

var myKeyAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-key.pem");
var myCertAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-cert.pem");
var pemOptions = {
  "keyValue" : myKeyAsABuffer,
  "certValue" : myCertAsABuffer
};
var options = {
  "ssl" : true,
  "pemKeyCertOptions" : pemOptions
};
var server = vertx.createNetServer(options);

var options = {
  "ssl" : true,
  "clientAuth" : "REQUIRED",
  "trustStoreOptions" : {
    "path" : "/path/to/your/truststore.jks",
    "password" : "password-of-your-truststore"
  }
};
var server = vertx.createNetServer(options);

var myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.jks");
var options = {
  "ssl" : true,
  "clientAuth" : "REQUIRED",
  "trustStoreOptions" : {
    "value" : myTrustStoreAsABuffer,
    "password" : "password-of-your-truststore"
  }
};
var server = vertx.createNetServer(options);

var options = {
  "ssl" : true,
  "clientAuth" : "REQUIRED",
  "pfxTrustOptions" : {
    "path" : "/path/to/your/truststore.pfx",
    "password" : "password-of-your-truststore"
  }
};
var server = vertx.createNetServer(options);

var myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.pfx");
var options = {
  "ssl" : true,
  "clientAuth" : "REQUIRED",
  "pfxTrustOptions" : {
    "value" : myTrustStoreAsABuffer,
    "password" : "password-of-your-truststore"
  }
};
var server = vertx.createNetServer(options);

var options = {
  "ssl" : true,
  "clientAuth" : "REQUIRED",
  "pemTrustOptions" : {
    "certPaths" : [
      "/path/to/your/server-ca.pem"
    ]
  }
};
var server = vertx.createNetServer(options);

var myCaAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-ca.pfx");
var options = {
  "ssl" : true,
  "clientAuth" : "REQUIRED",
  "pemTrustOptions" : {
    "certValues" : [
      myCaAsABuffer
    ]
  }
};
var server = vertx.createNetServer(options);

var options = {
  "ssl" : true,
  "trustAll" : true
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "hostnameVerificationAlgorithm" : "HTTPS"
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "trustStoreOptions" : {
    "path" : "/path/to/your/truststore.jks",
    "password" : "password-of-your-truststore"
  }
};
var client = vertx.createNetClient(options);

var myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.jks");
var options = {
  "ssl" : true,
  "trustStoreOptions" : {
    "value" : myTrustStoreAsABuffer,
    "password" : "password-of-your-truststore"
  }
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "pfxTrustOptions" : {
    "path" : "/path/to/your/truststore.pfx",
    "password" : "password-of-your-truststore"
  }
};
var client = vertx.createNetClient(options);

var myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.pfx");
var options = {
  "ssl" : true,
  "pfxTrustOptions" : {
    "value" : myTrustStoreAsABuffer,
    "password" : "password-of-your-truststore"
  }
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "pemTrustOptions" : {
    "certPaths" : [
      "/path/to/your/ca-cert.pem"
    ]
  }
};
var client = vertx.createNetClient(options);

var myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/ca-cert.pem");
var options = {
  "ssl" : true,
  "pemTrustOptions" : {
    "certValues" : [
      myTrustStoreAsABuffer
    ]
  }
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "keyStoreOptions" : {
    "path" : "/path/to/your/client-keystore.jks",
    "password" : "password-of-your-keystore"
  }
};
var client = vertx.createNetClient(options);

var myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-keystore.jks");
var jksOptions = {
  "value" : myKeyStoreAsABuffer,
  "password" : "password-of-your-keystore"
};
var options = {
  "ssl" : true,
  "keyStoreOptions" : jksOptions
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "pfxKeyCertOptions" : {
    "path" : "/path/to/your/client-keystore.pfx",
    "password" : "password-of-your-keystore"
  }
};
var client = vertx.createNetClient(options);

var myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-keystore.pfx");
var pfxOptions = {
  "value" : myKeyStoreAsABuffer,
  "password" : "password-of-your-keystore"
};
var options = {
  "ssl" : true,
  "pfxKeyCertOptions" : pfxOptions
};
var client = vertx.createNetClient(options);

var options = {
  "ssl" : true,
  "pemKeyCertOptions" : {
    "keyPath" : "/path/to/your/client-key.pem",
    "certPath" : "/path/to/your/client-cert.pem"
  }
};
var client = vertx.createNetClient(options);

var myKeyAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-key.pem");
var myCertAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-cert.pem");
var pemOptions = {
  "keyValue" : myKeyAsABuffer,
  "certValue" : myCertAsABuffer
};
var options = {
  "ssl" : true,
  "pemKeyCertOptions" : pemOptions
};
var client = vertx.createNetClient(options);

var SelfSignedCertificate = require("vertx-js/self_signed_certificate");
var certificate = SelfSignedCertificate.create();

var serverOptions = {
  "ssl" : true,
  "keyCertOptions" : certificate.keyCertOptions(),
  "trustOptions" : certificate.trustOptions()
};

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

var clientOptions = {
  "ssl" : true,
  "keyCertOptions" : certificate.keyCertOptions(),
  "trustOptions" : certificate.trustOptions()
};

var client = vertx.createNetClient(clientOptions);
client.connect(1234, "localhost", function (ar, ar_err) {
  if (ar_err == null) {
    ar.handler(function (buffer) {
      console.log(buffer);
    });
  } else {
    console.error("Woops: " + ar_err.getMessage());
  }
});

var clientOptions = {
  "ssl" : true,
  "trustAll" : true
};

var SelfSignedCertificate = require("vertx-js/self_signed_certificate");
var certificate = SelfSignedCertificate.create();

vertx.createHttpServer({
  "ssl" : true,
  "keyCertOptions" : certificate.keyCertOptions(),
  "trustOptions" : certificate.trustOptions()
}).requestHandler(function (req) {
  req.response().end("Hello!");
}).listen(8080);

var options = {
  "ssl" : true,
  "trustStoreOptions" : trustOptions,
  "crlPaths" : [
    "/path/to/your/crl.pem"
  ]
};
var client = vertx.createNetClient(options);

var myCrlAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/crl.pem");
var options = {
  "ssl" : true,
  "trustStoreOptions" : trustOptions,
  "crlValues" : [
    myCrlAsABuffer
  ]
};
var client = vertx.createNetClient(options);

var options = {
  "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"
  ]
};
var server = vertx.createNetServer(options);

Code not translatable

// Use JDK SSL engine
var options = {
  "ssl" : true,
  "keyStoreOptions" : keyStoreOptions
};

// Use JDK SSL engine explicitly
options = {
  "ssl" : true,
  "keyStoreOptions" : keyStoreOptions,
  "jdkSslEngineOptions" : {
  }
};

// Use OpenSSL engine
options = {
  "ssl" : true,
  "keyStoreOptions" : keyStoreOptions,
  "openSslEngineOptions" : {
  }
};

var keyCertOptions = {
  "path" : "keystore.jks",
  "password" : "wibble"
};

var netServer = vertx.createNetServer({
  "keyStoreOptions" : keyCertOptions,
  "ssl" : true,
  "sni" : true
});

var keyCertOptions = {
  "keyPaths" : ["default-key.pem", "host1-key.pem", "etc..."],
  "certPaths" : ["default-cert.pem", "host2-key.pem", "etc..."]
};

var netServer = vertx.createNetServer({
  "pemKeyCertOptions" : keyCertOptions,
  "ssl" : true,
  "sni" : true
});

var client = vertx.createNetClient({
  "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_err == null) {
    console.log("Connected!");
    var socket = res;
  } else {
    console.log("Failed to connect: " + res_err.getMessage());
  }
});

var headers = request.headers();

// Get the User-Agent:
console.log("User agent is " + headers.get("user-agent"));

// You can also do this and get the same result:
console.log("User agent is " + headers.get("User-Agent"));

param1: 'abc'
param2: 'xyz

request.handler(function (buffer) {
  console.log("I have received a chunk of the body of length " + buffer.length());
});

var Buffer = require("vertx-js/buffer");

// Create an empty buffer
var totalBuffer = Buffer.buffer();

request.handler(function (buffer) {
  console.log("I have received a chunk of the body of length " + buffer.length());
  totalBuffer.appendBuffer(buffer);
});

request.endHandler(function (v) {
  console.log("Full body received, length = " + totalBuffer.length());
});

request.bodyHandler(function (totalBuffer) {
  console.log("Full body received, length = " + totalBuffer.length());
});

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

server.requestHandler(function (request) {
  request.setExpectMultipart(true);
  request.uploadHandler(function (upload) {
    console.log("Got a file upload " + upload.name());
  });
});

request.uploadHandler(function (upload) {
  upload.handler(function (chunk) {
    console.log("Received a chunk of the upload of length " + chunk.length());
  });
});

request.uploadHandler(function (upload) {
  upload.streamToFileSystem("myuploads_directory/" + upload.filename());
});

request.customFrameHandler(function (frame) {

  console.log("Received a frame type=" + frame.type() + " payload" + frame.payload().toString());
});

var response = request.response();
response.write(buffer);

var response = request.response();
response.write("hello world!");

var response = request.response();
response.write("hello world!", "UTF-16");

var response = request.response();
response.write("hello world!");
response.end();

var response = request.response();
response.end("hello world!");

var response = request.response();
var headers = response.headers();
headers.set("content-type", "text/html");
headers.set("other-header", "wibble");

var response = request.response();
response.putHeader("content-type", "text/html").putHeader("other-header", "wibble");

var response = request.response();
response.setChunked(true);

var response = request.response();
response.setChunked(true);
var trailers = response.trailers();
trailers.set("X-wibble", "woobble").set("X-quux", "flooble");

var response = request.response();
response.setChunked(true);
response.putTrailer("X-wibble", "woobble").putTrailer("X-quux", "flooble");

vertx.createHttpServer().requestHandler(function (request) {
  var file = "";
  if (request.path() == "/") {
    file = "index.html";
  } else if (!request.path().contains("..")) {
    file = request.path();
  }
  request.response().sendFile("web/" + file);
}).listen(8080);

vertx.createHttpServer().requestHandler(function (request) {
  var offset = 0;
  try {
    offset = Java.type("java.lang.Long").parseLong(request.getParam("start"));
  } catch(err) {
    // error handling...
  }


  var end = Java.type("java.lang.Long").MAX_VALUE;
  try {
    end = Java.type("java.lang.Long").parseLong(request.getParam("end"));
  } catch(err) {
    // error handling...
  }


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

vertx.createHttpServer().requestHandler(function (request) {
  var offset = 0;
  try {
    offset = Java.type("java.lang.Long").parseLong(request.getParam("start"));
  } catch(err) {
    // error handling...
  }


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

var Pump = require("vertx-js/pump");
vertx.createHttpServer().requestHandler(function (request) {
  var 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);

var Buffer = require("vertx-js/buffer");

var frameType = 40;
var frameStatus = 10;
var payload = Buffer.buffer("some data");

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

// Reset the stream
request.response().reset();

// Cancel the stream
request.response().reset(8);

request.response().exceptionHandler(function (err) {
  if (err.getClass().getSimpleName() == 'StreamResetException') {
    var reset = err;
    console.log("Stream reset " + reset.getCode());
  }
});

var response = request.response();

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

  if (ar_err == null) {

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

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

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

var client = vertx.createHttpClient();

// Send a GET request
client.getNow("/some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
});

// Send a GET request
client.headNow("/other-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
});

var client = vertx.createHttpClient();

client.request('GET', "some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
}).end();

client.request('POST', "foo-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
}).end("some-data");

var client = vertx.createHttpClient();

var request = client.post("some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
});

// 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) {
  console.log("Received response with status code " + response.statusCode());
}).putHeader("content-length", "1000").putHeader("content-type", "text/plain").write(body).end();

// Or event more simply:

client.post("some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
}).putHeader("content-type", "text/plain").end(body);

var Buffer = require("vertx-js/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
var buffer = Buffer.buffer();
buffer.appendInt(123).appendLong(245);
request.write(buffer);

var Buffer = require("vertx-js/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
var buffer = Buffer.buffer().appendDouble(12.34).appendLong(432);
request.end(buffer);

// Write some headers using the headers() multimap

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

// Write some headers using the putHeader method

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

request.end();

var Buffer = require("vertx-js/buffer");
// End the request with a string
request.end("some-data");

// End it with a buffer
var buffer = Buffer.buffer().appendFloat(12.3).appendInt(321);
request.end(buffer);

request.setChunked(true);

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

request.end();

var request = client.post("some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
});
request.exceptionHandler(function (e) {
  console.log("Received exception: " + e.getMessage());
  e.printStackTrace();
});

var request = client.post("some-uri", function (response) {
  if (response.statusCode() === 200) {
    console.log("Everything fine");
    return
  }
  if (response.statusCode() === 500) {
    console.log("Unexpected behavior on the server side");
    return
  }
});
request.end();

var request = client.post("some-uri");
request.handler(function (response) {
  console.log("Received response with status code " + response.statusCode());
});

var Pump = require("vertx-js/pump");

request.setChunked(true);
var pump = Pump.pump(file, request);
file.endHandler(function (v) {
  request.end();
});
pump.start();

var Buffer = require("vertx-js/buffer");

var frameType = 40;
var frameStatus = 10;
var payload = Buffer.buffer("some data");

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

request.reset();

request.reset(8);

request.exceptionHandler(function (err) {
  if (err.getClass().getSimpleName() == 'StreamResetException') {
    var reset = err;
    console.log("Stream reset " + reset.getCode());
  }
});

var contentType = response.headers().get("content-type");
var contentLength = response.headers().get("content-lengh");

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

  response.handler(function (buffer) {
    console.log("Received a part of the response body: " + buffer);
  });
});

var Buffer = require("vertx-js/buffer");

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

  // Create an empty buffer
  var totalBuffer = Buffer.buffer();

  response.handler(function (buffer) {
    console.log("Received a part of the response body: " + buffer.length());

    totalBuffer.appendBuffer(buffer);
  });

  response.endHandler(function (v) {
    // Now all the body has been read
    console.log("Total response body length is " + totalBuffer.length());
  });
});

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

  response.bodyHandler(function (totalBuffer) {
    // Now all the body has been read
    console.log("Total response body length is " + totalBuffer.length());
  });
});

client.get("some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
}).setFollowRedirects(true).end();

var client = vertx.createHttpClient({
  "maxRedirects" : 32
});

client.get("some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
}).setFollowRedirects(true).end();

var Future = require("vertx-js/future");

client.redirectHandler(function (response) {

  // Only follow 301 code
  if (response.statusCode() === 301 && (response.getHeader("Location") !== null && response.getHeader("Location") !== undefined)) {

    // Compute the redirect URI
    var 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
});

var request = client.put("some-uri", function (response) {
  console.log("Received response with status code " + response.statusCode());
});

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();
});

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();
    });
  }
});

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

    //
    var 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();
    }
  }
});

var 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
  console.log("Server pushed " + pushedRequest.path());

  // Set an handler for the response
  pushedRequest.handler(function (pushedResponse) {
    console.log("The response for the pushed request");
  });
});

// End the request
request.end();

request.pushHandler(function (pushedRequest) {
  if (pushedRequest.path() == "/main.js") {
    pushedRequest.reset();
  } else {
    // Handle it
  }
});

response.customFrameHandler(function (frame) {

  console.log("Received a frame type=" + frame.type() + " payload" + frame.payload().toString());
});

var connection = request.connection();

var server = vertx.createHttpServer(http2Options);

server.connectionHandler(function (connection) {
  console.log("A client connected");
});

var connection = request.connection();

request.connectionHandler(function (connection) {
  console.log("Connected to the server");
});

connection.updateSettings({
  "maxConcurrentStreams" : 100
});

connection.updateSettings({
  "maxConcurrentStreams" : 100
}, function (ar, ar_err) {
  if (ar_err == null) {
    console.log("The settings update has been acknowledged ");
  }
});

connection.remoteSettingsHandler(function (settings) {
  console.log("Received new settings");
});

var Buffer = require("vertx-js/buffer");
var data = Buffer.buffer();
for (var i = 0;i < 8;i++) {
  data.appendByte(i);
}
connection.ping(data, function (pong, pong_err) {
  console.log("Remote side replied");
});

connection.pingHandler(function (ping) {
  console.log("Got pinged by remote side");
});

connection.shutdown();

connection.goAway(0);

connection.goAwayHandler(function (goAway) {
  console.log("Received a go away frame");
});

connection.goAway(0);
connection.shutdownHandler(function (v) {

  // All streams are closed, close the connection
  connection.close();
});

client.websocket("/some-uri", function (websocket) {
  console.log("Connected!");
});

var Buffer = require("vertx-js/buffer");
// Write a simple binary message
var buffer = Buffer.buffer().appendInt(123).appendFloat(1.23);
websocket.writeBinaryMessage(buffer);

// Write a simple text message
var message = "hello";
websocket.writeTextMessage(message);

var WebSocketFrame = require("vertx-js/web_socket_frame");

var frame1 = WebSocketFrame.binaryFrame(buffer1, false);
websocket.writeFrame(frame1);

var frame2 = WebSocketFrame.continuationFrame(buffer2, false);
websocket.writeFrame(frame2);

// Write the final frame
var frame3 = WebSocketFrame.continuationFrame(buffer2, true);
websocket.writeFrame(frame3);

var Buffer = require("vertx-js/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:

var buff = Buffer.buffer().appendInt(12).appendString("foo");

websocket.writeFinalBinaryFrame(buff);

websocket.frameHandler(function (frame) {
  console.log("Received a frame of size!");
});

var options = {
  "proxyOptions" : {
    "type" : "HTTP"
  }
};
var client = vertx.createHttpClient(options);
client.getAbs("ftp://ftp.gnu.org/gnu/", function (response) {
  console.log("Received response with status code " + response.statusCode());
});

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

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

var Buffer = require("vertx-js/buffer");
vertx.fileSystem().open("target/classes/hello.txt", {
}, function (result, result_err) {
  if (result_err == null) {
    var file = result;
    var buff = Buffer.buffer("foo");
    for (var i = 0;i < 5;i++) {
      file.write(buff, buff.length() * i, function (ar, ar_err) {
        if (ar_err == null) {
          console.log("Written ok!");
          // etc
        } else {
          console.error("Failed to write: " + ar_err);
        }
      });
    }
  } else {
    console.error("Cannot open file " + result_err);
  }
});

var Buffer = require("vertx-js/buffer");
vertx.fileSystem().open("target/classes/les_miserables.txt", {
}, function (result, result_err) {
  if (result_err == null) {
    var file = result;
    var buff = Buffer.buffer(1000);
    for (var i = 0;i < 10;i++) {
      file.read(buff, i * 100, i * 100, 100, function (ar, ar_err) {
        if (ar_err == null) {
          console.log("Read ok!");
        } else {
          console.error("Failed to write: " + ar_err);
        }
      });
    }
  } else {
    console.error("Cannot open file " + result_err);
  }
});

var Pump = require("vertx-js/pump");
var output = vertx.fileSystem().openBlocking("target/classes/plagiary.txt", {
});

vertx.fileSystem().open("target/classes/les_miserables.txt", {
}, function (result, result_err) {
  if (result_err == null) {
    var file = result;
    Pump.pump(file, output).start();
    file.endHandler(function (r) {
      console.log("Copy done");
    });
  } else {
    console.error("Cannot open file " + result_err);
  }
});

var Buffer = require("vertx-js/buffer");
var socket = vertx.createDatagramSocket({
});
var buffer = Buffer.buffer("content");
// Send a Buffer to a multicast address
socket.send(buffer, 1234, "230.0.0.1", function (asyncResult, asyncResult_err) {
  console.log("Send succeeded? " + asyncResult_err == null);
});

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

var CLI = require("vertx-js/cli");
var cli = CLI.create("some-name").setSummary("A command line interface illustrating the options valuation.").addOption({
  "longName" : "flag",
  "shortName" : "f",
  "flag" : true,
  "description" : "a flag"
}).addOption({
  "longName" : "single",
  "shortName" : "s",
  "description" : "a single-valued option"
}).addOption({
  "longName" : "multiple",
  "shortName" : "m",
  "multiValued" : true,
  "description" : "a multi-valued option"
});

var CLI = require("vertx-js/cli");
var cli = CLI.create("some-name").addOption({
  "longName" : "mandatory",
  "required" : true,
  "description" : "a mandatory option"
});

var CLI = require("vertx-js/cli");
var cli = CLI.create("some-name").addOption({
  "longName" : "optional",
  "defaultValue" : "hello",
  "description" : "an optional option with a default value"
});

var CLI = require("vertx-js/cli");
var cli = CLI.create("some-name").addOption({
  "longName" : "color",
  "defaultValue" : "green",
  "choices" : [
    "blue",
    "red",
    "green"
  ],
  "description" : "a color"
});

var CLI = require("vertx-js/cli");
var cli = CLI.create("some-name").addArgument({
  "index" : 0,
  "description" : "the first argument",
  "argName" : "arg1"
}).addArgument({
  "index" : 1,
  "description" : "the second argument",
  "argName" : "arg2"
});

var CLI = require("vertx-js/cli");
var cli = CLI.create("some-name").addArgument({
  "description" : "the first argument",
  "argName" : "arg1"
}).addArgument({
  "description" : "the second argument",
  "argName" : "arg2"
});

var CLI = require("vertx-js/cli");
var cli = CLI.create("copy").setSummary("A command line interface to copy files.").addOption({
  "longName" : "directory",
  "shortName" : "R",
  "description" : "enables directory support",
  "flag" : true
}).addArgument({
  "index" : 0,
  "description" : "The source",
  "argName" : "source"
}).addArgument({
  "index" : 0,
  "description" : "The destination",
  "argName" : "target"
});

var builder = new (Java.type("java.lang.StringBuilder"))();
cli.usage(builder);

Usage: copy [-R] source target

A command line interface to copy files.

 -R,--directory   enables directory support