iodine 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f2f657fb4dfe53dba0db85aa2b84685287e0d1e
-  data.tar.gz: '04085f50a4e1dcb50f960ea32a62717aed58b77c'
+  metadata.gz: d9f26da78f47f0d2d44534b5a0930862ac5c1092
+  data.tar.gz: 13b1d9adfa9e1df5f4544448ec551f879c6a32ac
 SHA512:
-  metadata.gz: e464440c9fdaf6dba8ca6ae60e7d29d7d90cd6a3a31557573b558296ded54b83d373542777697e0b41cdde863d6131b73bbd8a9da9ca7d9f1b8a6a738ff66dc8
-  data.tar.gz: a2a1e275c0754427e4f6efce6e1111976d9fb87a1c4710dd2be5d46627f3ee6476de8b7fa82e134a039ce50454bd981ba36aa96bd76dc69a9d8ba36852648af1
+  metadata.gz: '0381cd3d98e09b440636e7d4fd53a60139d7673b9595a2b7c9e2c6050d593f4920294496b462cf8661cd7cb3af464077664a78d6ba7afa27143b73bc16087678'
+  data.tar.gz: bb0f81ea6a19da939cf733a3a934c7d2396b9bc980abdff4331fb0c2e03c65a96918341df0ff41fb50e5379de758fa75e4df31e0f8db15b3d3b41bd38e5fcdb6

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.4.6
+
+**Update**: Now using `facil.io` v.0.5.2.
+
+**Fix**: (from `facil.io`) fix `SIGTERM` handling, make sure sibling processes exit when a sibling dies.
+
 #### Change log v.0.4.5
 
 **Fix**: fix static file service for `X-Sendfile` as well as static error file fallback pages (404.html etc').

data/ext/iodine/defer.c

@@ -30,24 +30,33 @@ Compile time settings
 Data Structures
 ***************************************************************************** */
 
+/* task node data */
 typedef struct {
   void (*func)(void *, void *);
   void *arg1;
   void *arg2;
 } task_s;
 
+/* a single linked list for tasks */
 typedef struct task_node_s {
   task_s task;
   struct task_node_s *next;
 } task_node_s;
 
+/* static memory allocation for a task node buffer */
 static task_node_s tasks_buffer[DEFER_QUEUE_BUFFER];
 
+/* the state machine - this holds all the data about the task queue and pool */
 static struct {
+  /* the next task to be performed */
   task_node_s *first;
+  /* a pointer to the linked list's tail, where the next task will be stored */
   task_node_s **last;
+  /* a linked list for task nodes (staticly allocated) */
   task_node_s *pool;
+  /* a lock for the state machine, used for multi-threading support */
   spn_lock_i lock;
+  /* a flag indicating whether the task pool was initialized */
   unsigned char initialized;
 } deferred = {.first = NULL,
               .last = &deferred.first,
@@ -61,9 +70,11 @@ API
 
 /** Defer an execution of a function for later. */
 int defer(void (*func)(void *, void *), void *arg1, void *arg2) {
+  /* must have a task to defer */
   if (!func)
     goto call_error;
   task_node_s *task;
+  /* lock the state machine, to grab/create a task and place it at the tail */
   spn_lock(&deferred.lock);
   if (deferred.pool) {
     task = deferred.pool;
@@ -74,6 +85,7 @@ int defer(void (*func)(void *, void *), void *arg1, void *arg2) {
       goto error;
   } else
     goto initialize;
+
 schedule:
   *deferred.last = task;
   deferred.last = &task->next;
@@ -83,13 +95,18 @@ schedule:
   task->next = NULL;
   spn_unlock(&deferred.lock);
   return 0;
+
 error:
   spn_unlock(&deferred.lock);
   perror("ERROR CRITICAL: defer can't allocate task");
   kill(0, SIGINT), exit(errno);
+
 call_error:
   return -1;
+
 initialize:
+  /* initialize the task pool using all the items in the static buffer */
+  /* also assign `task` one of the tasks from the pool and schedule the task */
   deferred.initialized = 1;
   task = tasks_buffer;
   deferred.pool = tasks_buffer + 1;
@@ -105,7 +122,7 @@ void defer_perform(void) {
   task_node_s *tmp;
   task_s task;
 restart:
-  spn_lock(&deferred.lock);
+  spn_lock(&deferred.lock); /* remember never to perform tasks within a lock! */
   tmp = deferred.first;
   if (tmp) {
     deferred.first = tmp->next;
@@ -119,7 +136,9 @@ restart:
       free(tmp);
     }
     spn_unlock(&deferred.lock);
+    /* perform the task outside the lock. */
     task.func(task.arg1, task.arg2);
+    /* I used `goto` to optimize assembly instruction flow. maybe it helps. */
     goto restart;
   }
   spn_unlock(&deferred.lock);
@@ -136,6 +155,8 @@ Thread Pool Support
     defined(DEBUG)
 #include <pthread.h>
 
+/* `weak` functions can be overloaded to change the thread implementation. */
+
 #pragma weak defer_new_thread
 void *defer_new_thread(void *(*thread_func)(void *), pool_pt arg) {
   pthread_t *thread = malloc(sizeof(*thread));
@@ -161,7 +182,7 @@ void defer_thread_throttle(unsigned long microsec) {
   throttle_thread(microsec);
 }
 
-#else /* No pthreads... BYO thread implementation. */
+#else /* No pthreads... BYO thread implementation. This one simply fails. */
 
 #pragma weak defer_new_thread
 void *defer_new_thread(void *(*thread_func)(void *), void *arg) {
@@ -186,13 +207,17 @@ struct defer_pool {
   void *threads[];
 };
 
+/* a thread's cycle. This is what a worker thread does... repeatedly. */
 static void *defer_worker_thread(void *pool_) {
   volatile pool_pt pool = pool_;
   signal(SIGPIPE, SIG_IGN);
+  /* the throttle replaces conditional variables for better performance */
   size_t throttle = (pool->count) * DEFER_THROTTLE;
   if (!throttle || throttle > 1572864UL)
     throttle = 1572864UL;
+  /* perform any available tasks */
   defer_perform();
+  /* as long as the flag is true, wait for and perform tasks. */
   do {
     throttle_thread(throttle);
     defer_perform();
@@ -200,10 +225,13 @@ static void *defer_worker_thread(void *pool_) {
   return NULL;
 }
 
+/** Signals a running thread pool to stop. Returns immediately. */
 void defer_pool_stop(pool_pt pool) { pool->flag = 0; }
 
+/** Returns TRUE (1) if the pool is hadn't been signaled to finish up. */
 int defer_pool_is_active(pool_pt pool) { return pool->flag; }
 
+/** Waits for a running thread pool, joining threads and finishing all tasks. */
 void defer_pool_wait(pool_pt pool) {
   while (pool->count) {
     pool->count--;
@@ -211,6 +239,7 @@ void defer_pool_wait(pool_pt pool) {
   }
 }
 
+/** The logic behind `defer_pool_start`. */
 static inline pool_pt defer_pool_initialize(unsigned int thread_count,
                                             pool_pt pool) {
   pool->flag = 1;
@@ -226,6 +255,7 @@ static inline pool_pt defer_pool_initialize(unsigned int thread_count,
   return NULL;
 }
 
+/** Starts a thread pool that will run deferred tasks in the background. */
 pool_pt defer_pool_start(unsigned int thread_count) {
   if (thread_count == 0)
     return NULL;
@@ -239,22 +269,23 @@ pool_pt defer_pool_start(unsigned int thread_count) {
 Child Process support (`fork`)
 ***************************************************************************** */
 
+/* forked `defer` workers use a global thread pool object. */
 static pool_pt forked_pool;
 
+/* handles the SIGINT and SIGTERM signals by shutting down workers */
 static void sig_int_handler(int sig) {
-  if (sig != SIGINT)
+  if (sig != SIGINT && sig != SIGTERM)
     return;
   if (!forked_pool)
     return;
   defer_pool_stop(forked_pool);
 }
 
-/* *
+/*
 Zombie Reaping
 With thanks to Dr Graham D Shaw.
 http://www.microhowto.info/howto/reap_zombie_processes_using_a_sigchld_handler.html
 */
-
 void reap_child_handler(int sig) {
   (void)(sig);
   int old_errno = errno;
@@ -263,6 +294,7 @@ void reap_child_handler(int sig) {
   errno = old_errno;
 }
 
+/* initializes zombie reaping for the process */
 inline static void reap_children(void) {
   struct sigaction sa;
   sa.sa_handler = reap_child_handler;
@@ -274,7 +306,9 @@ inline static void reap_children(void) {
   }
 }
 
+/* a global process identifier (0 == root) */
 static int defer_fork_pid_id = 0;
+
 /**
  * Forks the process, starts up a thread pool and waits for all tasks to run.
  * All existing tasks will run in all processes (multiple times).
@@ -287,8 +321,12 @@ int defer_perform_in_fork(unsigned int process_count,
   if (forked_pool)
     return -1; /* we're already running inside an active `fork` */
 
+  /* we use a placeholder while initializing the forked thread pool, so calls to
+   * `defer_fork_is_active` don't fail.
+   */
   static struct defer_pool pool_placeholder = {.count = 1, .flag = 1};
 
+  /* setup signal handling */
   struct sigaction act, old, old_term, old_pipe;
   pid_t *pids = NULL;
   int ret = 0;
@@ -302,20 +340,26 @@ int defer_perform_in_fork(unsigned int process_count,
     perror("couldn't set signal handler");
     goto finish;
   };
+
   if (sigaction(SIGTERM, &act, &old_term)) {
     perror("couldn't set signal handler");
     goto finish;
   };
+
   act.sa_handler = SIG_IGN;
   if (sigaction(SIGPIPE, &act, &old_pipe)) {
     perror("couldn't set signal handler");
     goto finish;
   };
+
+  /* setup zomie reaping */
   reap_children();
 
   if (!process_count)
     process_count = 1;
   --process_count;
+
+  /* for `process_count == 0` nothing happens */
   pids = calloc(process_count, sizeof(*pids));
   if (process_count && !pids)
     goto finish;
@@ -334,12 +378,16 @@ int defer_perform_in_fork(unsigned int process_count,
       goto finish;
     }
   }
+
   pids_count++;
   forked_pool = &pool_placeholder;
   forked_pool = defer_pool_start(thread_count);
+
   defer_pool_wait(forked_pool);
   forked_pool = NULL;
+
   defer_perform();
+
 finish:
   if (pids) {
     for (size_t j = 0; j < pids_count; j++) {

data/ext/iodine/facil.c

@@ -326,6 +326,7 @@ static void listener_ping(intptr_t uuid, protocol_s *plistener) {
   (void)plistener;
 }
 
+/* called asynchronously after a new connection was opened */
 static void listener_deferred_on_open(void *uuid_, void *srv_uuid_) {
   intptr_t uuid = (intptr_t)uuid_;
   intptr_t srv_uuid = (intptr_t)srv_uuid_;
@@ -468,6 +469,7 @@ struct ConnectProtocol {
   int opened;
 };
 
+/* The first `ready` signal is fired when a connection was established */
 static void connector_on_ready(intptr_t uuid, protocol_s *_connector) {
   struct ConnectProtocol *connector = (void *)_connector;
   // fprintf(stderr, "connector_on_ready called\n");
@@ -486,11 +488,13 @@ error:
   sock_close(uuid);
 }
 
+/* If data events reach this protocol, delay their execution. */
 static void connector_on_data(intptr_t uuid, protocol_s *connector) {
   (void)connector;
-  defer(deferred_on_data, (void *)uuid, NULL);
+  facil_force_event(uuid, FIO_EVENT_ON_DATA);
 }
 
+/* Failed to connect */
 static void connector_on_close(intptr_t uuid, protocol_s *pconnector) {
   struct ConnectProtocol *connector = (void *)pconnector;
   if (connector->opened == 0 && connector->on_fail)
@@ -521,11 +525,12 @@ intptr_t facil_connect(struct facil_connect_args opt) {
       .opened = 0,
   };
   intptr_t uuid = connector->uuid = sock_connect(opt.address, opt.port);
+  /* check for errors, always invoke the on_fail if required */
   if (uuid == -1)
     goto error;
   if (facil_attach(uuid, &connector->protocol) == -1) {
     sock_close(uuid);
-    return -1;
+    goto error;
   }
   return uuid;
 error:
@@ -710,6 +715,22 @@ static void facil_cluster_on_close(intptr_t uuid, protocol_s *pr_) {
   (void)uuid;
 }
 
+/* React when a sibling process closes / crashes */
+static void facil_cluster_on_sibling_close(intptr_t uuid, protocol_s *pr_) {
+  if (facil_cluster_data.pipes[defer_fork_pid()].in == uuid)
+    return;
+  if (defer_fork_is_active()) {
+    kill(getpid(), SIGINT);
+#if DEBUG
+    fprintf(stderr,
+            "* Sibling death detected, signaling self exit process %d\n",
+            getpid());
+#endif
+  }
+  (void)uuid;
+  (void)pr_;
+}
+
 /* cluster protocol on_data callback */
 static void facil_cluster_on_data(intptr_t uuid, protocol_s *pr_) {
   struct facil_cluster_protocol *pr = (struct facil_cluster_protocol *)pr_;
@@ -755,12 +776,22 @@ static void facil_cluster_register(void *arg1, void *arg2) {
   (void)arg2;
   if (facil_cluster_data.count < 2)
     return;
-  // for (size_t i = 0; i < facil_cluster_data.count; i++) {
-  //   if (i == (size_t)defer_fork_pid())
-  //     continue;
-  //   sock_close(facil_cluster_data.pipes[i].in);
-  // }
-  // sock_close(facil_cluster_data.pipes[defer_fork_pid()].out);
+
+  /* used to watch for sibling crashes and prevent other events from firing */
+  static protocol_s sentinel_protocol = {
+      .service = NULL,
+      .ping = listener_ping,
+      .on_close = facil_cluster_on_sibling_close,
+  };
+  /* close what we don't need and watch the connections we do need */
+  for (size_t i = 0; i < facil_cluster_data.count; i++) {
+    if (i == (size_t)defer_fork_pid())
+      continue;
+    sock_close(facil_cluster_data.pipes[i].in);
+    facil_attach(facil_cluster_data.pipes[i].out, &sentinel_protocol);
+  }
+  sock_close(facil_cluster_data.pipes[defer_fork_pid()].out);
+
   struct facil_cluster_protocol *pr = malloc(sizeof(*pr));
   if (!pr)
     perror("ERROR: (critical) cannot allocate memory for cluster."),
@@ -787,7 +818,10 @@ static void facil_cluster_init(uint16_t count) {
   if (!facil_cluster_data.pipes)
     goto error;
 
-  static protocol_s stub_protocol = {.service = NULL, .ping = listener_ping};
+  /* used to prevent any events from firing  */
+  static protocol_s stub_protocol = {
+      .service = NULL, .ping = listener_ping,
+  };
   stub_protocol.service = facil_cluster_protocol_id;
 
   facil_cluster_data.count = count;
@@ -799,8 +833,8 @@ static void facil_cluster_init(uint16_t count) {
     sock_set_non_block(p_tmp[0]);
     sock_set_non_block(p_tmp[1]);
     facil_cluster_data.pipes[i].in = sock_open(p_tmp[0]);
-    facil_cluster_data.pipes[i].out = sock_open(p_tmp[1]);
     facil_attach(facil_cluster_data.pipes[i].in, &stub_protocol);
+    facil_cluster_data.pipes[i].out = sock_open(p_tmp[1]);
     facil_attach(facil_cluster_data.pipes[i].out, &stub_protocol);
   }
   defer(facil_cluster_register, NULL, NULL);

data/ext/iodine/facil.h

@@ -8,14 +8,10 @@ Feel free to copy, use and enjoy according to the license provided.
 /**
 "facil.h" is the main header for the facil.io server platform.
 */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #define H_FACIL_H
 #define FACIL_VERSION_MAJOR 0
 #define FACIL_VERSION_MINOR 5
-#define FACIL_VERSION_PATCH 0
+#define FACIL_VERSION_PATCH 2
 
 #ifndef FACIL_PRINT_STATE
 /**
@@ -30,6 +26,11 @@ Required facil libraries
 #include "defer.h"
 #include "sock.h"
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* *****************************************************************************
 Core object types
 ***************************************************************************** */

data/ext/iodine/fio_dict.h

@@ -21,6 +21,11 @@ the key "hello1" will cost only 272 bytes... brrr.
 #include <stdint.h>
 #include <stdlib.h>
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct fio_dict_s {
   struct fio_dict_s *parent;
   struct fio_dict_s *trie[16];
@@ -87,4 +92,8 @@ int fio_glob_match(uint8_t *data, size_t data_len, uint8_t *pattern,
      (dict)->trie[12] || (dict)->trie[13] || (dict)->trie[14] ||               \
      (dict)->trie[15]))
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/ext/iodine/http.h

@@ -54,6 +54,11 @@ Hard Coded Settings
 #define HTTP_DEFAULT_BODY_LIMIT (1024 * 1024 * 50)
 #endif
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* *****************************************************************************
 HTTP Core API & data structure
 */
@@ -200,4 +205,8 @@ ssize_t http_decode_path_unsafe(char *dest, const char *url_data);
  */
 ssize_t http_decode_path(char *dest, const char *url_data, size_t length);
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/ext/iodine/http_request.h

@@ -10,6 +10,11 @@ typedef struct http_request_s http_request_s;
 
 #include "http.h"
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 struct http_request_s {
   /** the HTTP version, also controlls the `http_request_s` flavor. */
   enum HTTP_VERSION http_version;
@@ -90,4 +95,8 @@ http_header_s http_request_header_first(http_request_s *request);
  * Header itteration is NOT thread-safe. */
 http_header_s http_request_header_next(http_request_s *request);
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif /* H_HTTP_REQUEST_H */

data/ext/iodine/http_response.h

@@ -10,6 +10,11 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <stdio.h>
 #include <time.h>
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
   /** The protocol version family (HTTP/1.1 / HTTP/2 etc'). */
   enum HTTP_VERSION http_version;
@@ -238,4 +243,8 @@ const char *http_response_ext2mime(const char *ext);
 /** Starts counting miliseconds for log results. */
 void http_response_log_start(http_response_s *);
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/ext/iodine/pubsub.c

@@ -266,8 +266,7 @@ const pubsub_engine_s PUBSUB_PROCESS_ENGINE_S = {
 };
 const pubsub_engine_s *PUBSUB_PROCESS_ENGINE = &PUBSUB_PROCESS_ENGINE_S;
 
-pubsub_engine_s *PUBSUB_DEFAULT_ENGINE =
-    (pubsub_engine_s *)&PUBSUB_CLUSTER_ENGINE_S;
+const pubsub_engine_s *PUBSUB_DEFAULT_ENGINE = &PUBSUB_CLUSTER_ENGINE_S;
 
 /* *****************************************************************************
 External Engine Bridge

data/ext/iodine/pubsub.h

@@ -20,6 +20,11 @@ between all of an application's processes, enhancing overall performance.
 #define H_FACIL_PUBSUB_H
 #include "facil.h"
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #ifndef FIO_PUBBSUB_MAX_CHANNEL_LEN
 #define FIO_PUBBSUB_MAX_CHANNEL_LEN 1024
 #endif
@@ -191,7 +196,7 @@ extern const pubsub_engine_s *PUBSUB_CLUSTER_ENGINE;
 extern const pubsub_engine_s *PUBSUB_PROCESS_ENGINE;
 
 /** Allows process wide changes to the default Pub/Sub Engine. */
-extern pubsub_engine_s *PUBSUB_DEFAULT_ENGINE;
+extern const pubsub_engine_s *PUBSUB_DEFAULT_ENGINE;
 
 /**
  * The function used by engines to distribute received messages.
@@ -212,4 +217,8 @@ void pubsub_engine_distribute(pubsub_message_s msg);
  */
 void pubsub_engine_resubscribe(pubsub_engine_s *eng);
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif /* H_FACIL_PUBSUB_H */

data/ext/iodine/redis_connection.h

@@ -10,6 +10,11 @@ Feel free to copy, use and enjoy in accordance with to the license(s).
 #include "facil.h"
 #include "resp.h"
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* *****************************************************************************
 Connectivity
 ***************************************************************************** */
@@ -74,4 +79,8 @@ protocol_s *redis_create_server_protocol(intptr_t uuid, void *settings);
  */
 void redis_protocol_cleanup(intptr_t uuid, void *settings);
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/ext/iodine/redis_engine.c

@@ -346,7 +346,7 @@ See the {pubsub.h} file for documentation about engines.
 
 function names speak for themselves ;-)
 */
-void redis_engine_destroy(pubsub_engine_s *engine) {
+void redis_engine_destroy(const pubsub_engine_s *engine) {
   redis_engine_s *r = (redis_engine_s *)engine;
 
   spn_lock(&r->lock);

data/ext/iodine/redis_engine.h

@@ -17,6 +17,11 @@ subscription or publication... it will simply try until successful.
 #include "pubsub.h"
 #include "resp.h"
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** possible arguments for the `redis_engine_create` function call */
 struct redis_engine_create_args {
   /** Redis server's address */
@@ -64,5 +69,10 @@ See the {pubsub.h} file for documentation about engines.
 
 function names speak for themselves ;-)
 */
-void redis_engine_destroy(pubsub_engine_s *engine);
+void redis_engine_destroy(const pubsub_engine_s *engine);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/ext/iodine/resp.h

@@ -14,6 +14,11 @@ This is a neive implementation of the RESP protocol for Redis.
 #include <stdint.h>
 #include <stdlib.h>
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** The RESP Parser Type */
 typedef struct resp_parser_s *resp_parser_pt;
 
@@ -250,4 +255,8 @@ void resp_enable_duplex_pubsub(resp_parser_pt parser);
 void resp_test(void);
 #endif
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/ext/iodine/websockets.h

@@ -9,6 +9,11 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include "http.h"
 
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* *****************************************************************************
 Upgrading from HTTP to Websockets
 ***************************************************************************** */
@@ -342,4 +347,8 @@ int websocket_write_each(struct websocket_write_each_args_s args);
 #define websocket_write_each(...)                                              \
   websocket_write_each((struct websocket_write_each_args_s){__VA_ARGS__})
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.5'.freeze
+  VERSION = '0.4.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-28 00:00:00.000000000 Z
+date: 2017-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack