Parse a JSON string using the iodine lenient parser (it's also faster). */

Parse a JSON string using the iodine lenient parser with a default Symbol rather than String key (this is often faster than the regular {Iodine::JSON.

Calls a C function outside the GVL. */

clang-format off {Iodine.listen} can be used to listen to any incoming connections, including HTTP and raw (tcp/ip and unix sockets) connections.

* Gets the logging level used for Iodine messages. * * Levels range from 0-5, where: * * 0 == Quite (no messages) * 1 == Fatal Errors only. * 2

* Gets the logging level used for Iodine messages. * * Levels range from 0-5, where: * * 0 == Quite (no messages) * 1 == Fatal Errors only. * 2

* Returns `true` if this process is the master / root process, `false` * otherwise. * * Note that the master process might be a worker process as w

Iodine::PubSub::Engine.allocate */

Loads the mustache template found in `:filename`. If `:template` is provided it will be used instead of reading the file's content. Iodine::Musta

Renders the mustache template using the data provided in the `data` argument. Returns a String with the rendered template. Raises an exception on er

Renders the mustache template found in `filename`, using the data provided in the `data` argument. If `template` is provided it will be used instead o

callback for incoming subscription messages */

calls the Ruby block assigned to a pubsub event (within the GVL). */

clang-format off Sets a block of code to run when Iodine's core state is updated. @param [Symbol] event the state event for which the block should ru

callback for subscription closure */

performs a Ruby state callback and clears the Ruby object's memory */

performs a Ruby state callback without clearing the Ruby object's memory */

wrap the function call in exception handling block (uses longjmp) */

calls an engine's `unsubscribe` callback within the GVL */

calls an engine's `subscribe` callback within the GVL */

calls an engine's `unsubscribe` callback within the GVL */

* Attaches an {Iodine::PubSub::Engine} to the pub/sub system (more than a * single engine can be attached at the same time). * * After an engine wa

Iodine::PubSub::Engine.allocate */

a callback for the GC (marking active objects) */

a callback for the GC (marking active objects) */

Returns the default {Iodine::PubSub::Engine} for pub/sub methods. */

* Removes an {Iodine::PubSub::Engine} from the pub/sub system. * * After an {Iodine::PubSub::Engine} was detached, Iodine will no longer call * the

Should return 0 on success and -1 on failure. */

Must subscribe channel. Failures are ignored. */

Must unsubscribe channel. Failures are ignored. */

OVERRIDE this callback - it will be called by {Iodine} whenever the {Iodine.publish} (or {Iodine::Connection#publish}) is called for this engine. If

clang-format off Publishes a message to a channel. Can be used using two Strings: publish(to, message) The method accepts an optional `engine

A callback for Redis commands. */

clang-format off Sends a Redis command. Accepts an optional block that will recieve the response. i.e.: REDIS_URL = "redis://redis:password@loca

Initializes a new {Iodine::PubSub::Redis} engine. Iodine::PubSub::Redis.new(url, opt = {}) use: REDIS_URL = "redis://localhost:6379/" I

* Forces {Iodine} to call the {Iodine::PubSub::Engine#subscribe} callback for * all existing subscriptions (i.e., when reconnecting to a Pub/Sub back

OVERRIDE this callback - it will be called by {Iodine} whenever the process CLUSTER (not just this process) subscribes to a stream / channel. */

clang-format off Subscribes to a Pub/Sub stream / channel or replaces an existing subscription. The method accepts 1-2 arguments and an optional bloc

OVERRIDE this callback - it will be called by {Iodine} whenever the whole process CLUSTER (not just this process) unsubscribes from a stream / channel

clang-format off Unsubscribes from a Pub/Sub stream / channel. The method accepts a single arguments, the name used for the subscription. i.e.:

Takes `time` and returns a faster (though less localized) HTTP Date formatted String. Iodine::Rack.rfc2109(Time.now) => "Sun, 11-Jun-2017 06

Takes `time` and returns a faster (though less localized) HTTP Date formatted String. Iodine::Rack.rfc2822(Time.now) => "Sun, 11 Jun 2017 06

calls the Ruby method within the protection block */

calls the Ruby each method within the protection block */

* Returns `true` if Iodine is currently running a server */

Schedules a single occuring event for the next idle cycle. To schedule a reoccuring event, reschedule the event at the end of it's run. i.e.

Forces the GVL state flag. */

* This will block the calling (main) thread and start the Iodine reactor. * * When using cluster mode (2 or more worker processes), it is important

* This will stop the iodine server, shutting it down. * * If called within a worker process (rather than the root/master process), this * will caus

clang-format off The {attach_fd} method instructs iodine to attach a socket to the server using it's numerical file descriptor. This is faster than a

* The `on_connect` callback should either call `fio_attach` or close the * connection. */

Called when a data is available, but will not run concurrently */

* Converts an iodine_buffer_s pointer to a Ruby string. */

* The `on_fail` is called when a socket fails to connect. The old sock UUID * is passed along. */

called when the listening socket is destroyed */

fio_listen callback, called when a connection opens */

called when the socket is ready to be written to. */

* Called when the server is shutting down, immediately before closing the * connection. */

called when a connection's timeout was reached */

Adds an ALPN protocol callback for the named protocol, the required block must return the handler for that protocol. The first protocol added will be

Iodine::PubSub::Engine.allocate */

Creates a new {Iodine::TLS} object and calles the {#use_certificate} method with the supplied arguments. */

Adds a certificate PEM file to the list of trusted certificates and enforces peer verification. This is extremely important when using {Iodine::TLS}

* Returns `true` if this process is a worker process or if iodine is running in * a single process mode (the master is also a worker), `false` otherw

* The (optional) on_close callback will be called once a websocket connection * is terminated or failed to be established. * * The `uuid` is the co

* The (optional) on_open callback will be called once the websocket * connection is established and before is is registered with `facil`, so no * `o

* The (optional) on_ready callback will be after a the underlying socket's * buffer changes it's state from full to empty. * * If the socket's buff

* The (optional) on_shutdown callback will be called if a websocket * connection is still open while the server is shutting down (called before * `o

@deprecated use {Iodine.listen} with `service: :http`. Sets a block of code to run once a Worker process shuts down (both in single process mode and

Mock Protocol Callbacks and Service Funcions ***************************************************************************** */

* Called when an argument name was detected in the current section. * * A conforming implementation will search for the named argument both in the

* Called for cleanup in case of error. */

* Called when entering a nested section. * * `index` is a zero based index indicating the number of repetitions that * occurred so far (same as the

* Called for nested sections, must return the number of objects in the new * subsection (depending on the argument's name). * * Arrays should retur

* Called when simple template text (string) is detected. * * A conforming implementation will output data as a string (no escaping). */

new object