async-ruby-zip 1.0.0

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.3)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler (~> 1.8.3)
+  rdoc (~> 3.12)
+  rspec

data/README.md

@@ -0,0 +1,30 @@
+async-ruby-zip
+==============
+
+Non-blocking zip reading and writing for Ruby
+
+
+## Requirements.
+
+  * OS X or Linux
+  * MRI 1.9.2
+  * libzip >=0.10.1
+
+## Example.
+
+```ruby
+require 'rubygems'
+require 'async_zip'
+include AsyncZip
+
+
+# Non-blocking zip-file creation:
+AsyncZip.create(files, './output.zip') do |task|
+  puts task.inspect
+end
+
+# Non-blocking zip-file extraction:
+AsyncZip.extract('./output.zip', './extracted') do |task|
+  puts task.inspect
+end
+

data/async-ruby-zip.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "async-ruby-zip"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Grigoriy Chudnov"]
+  s.date = "2012-08-04"
+  s.description = "Non-blocking zip reading and writing for Ruby."
+  s.email = "g.chudnov@gmail.com"
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile.lock",
+    "README.md",
+    "async-ruby-zip-1.0.0.gem",
+    "async-ruby-zip.gemspec",
+    "ext/LICENSE",
+    "ext/archive.c",
+    "ext/archive.h",
+    "ext/archive_data.c",
+    "ext/archive_data.h",
+    "ext/archive_data_fwd.h",
+    "ext/async_zip.c",
+    "ext/async_zip.h",
+    "ext/callback.c",
+    "ext/callback.h",
+    "ext/carchive.c",
+    "ext/carchive.h",
+    "ext/carray.c",
+    "ext/carray.h",
+    "ext/cerror.c",
+    "ext/cerror.h",
+    "ext/cfilesystem.c",
+    "ext/cfilesystem.h",
+    "ext/extconf.rb",
+    "ext/task.c",
+    "ext/task.h",
+    "ext/writer.c",
+    "ext/writer.h",
+    "lib/async_zip.rb",
+    "lib/async_zip/version.rb"
+  ]
+  s.homepage = "https://github.com/gchudnov/async-ruby-zip"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "async-ruby-zip is a ruby extension that zip files asynchronously."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/ext/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Grigoriy Chudnov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/archive.c

@@ -0,0 +1,106 @@
+#include "archive.h"
+#include "carchive.h"
+#include "cerror.h"
+#include "carray.h"
+#include "archive_data.h"
+#include "callback.h"
+#include "writer.h"
+
+
+static VALUE az_create(VALUE self, VALUE zip_path, VALUE files);
+static VALUE az_extract(VALUE self, VALUE zip_path, VALUE dest_path);
+
+
+static void* az_archive_thread_func(void* data)
+{
+    archive_data_t* adata = (archive_data_t*)data;
+    if(!adata)
+        return NULL;
+
+    cerror_t err = { 0 };
+
+    if(adata->zip_path && !adata->dst_path) // create
+    {
+        err = carchive_create(adata->zip_path, adata->files_arr);
+    }
+    else if(adata->zip_path && adata->dst_path) // extract
+    {
+        err = carchive_extract(adata->zip_path, adata->dst_path, &adata->files_arr);
+    }
+
+    // error
+    if(cerror_is_error(&err))
+    {
+        adata->err_str = strdup(err.message);
+    }
+    cerror_free_message(&err);
+
+    az_add_to_event_qeueue(adata);
+
+    return NULL;
+}
+
+
+/* Add files to archive */
+static VALUE az_create(VALUE self, VALUE files, VALUE zip_path)
+{
+    rb_need_block();
+    VALUE proc = rb_block_proc();
+
+    int len = RARRAY_LEN(files);
+    if(len > 0)
+    {
+        carray_str_t* parr = carray_str_create(len);
+
+        int i;
+        for(i = 0; i != len; ++i)
+        {
+            VALUE current = rb_ary_entry(files, i);
+            if(rb_respond_to(current, rb_intern("to_s")))
+            {
+                VALUE name = rb_funcall(current, rb_intern("to_s"), 0);
+
+                carray_str_set(parr, i, StringValuePtr(name));
+            }
+            else
+            {
+                carray_str_set(parr, i, NULL);
+            }
+        }
+
+        archive_data_t* adata = az_make_archive_data(StringValuePtr(zip_path), NULL, parr);
+        adata->proc = proc;
+
+        rb_gc_register_address(&adata->proc);
+
+        //
+        az_enqueue_task(az_archive_thread_func, adata);
+    }
+
+    return self;
+}
+
+/* Extract files from archive */
+static VALUE az_extract(VALUE self, VALUE zip_path, VALUE dest_path)
+{
+    rb_need_block();
+    VALUE proc = rb_block_proc();
+
+    archive_data_t* adata = az_make_archive_data(StringValuePtr(zip_path), StringValuePtr(dest_path), NULL);
+    adata->proc = proc;
+
+    rb_gc_register_address(&adata->proc);
+
+    //
+    az_enqueue_task(az_archive_thread_func, adata);
+
+    return self;
+}
+
+
+/* Initialize zip pipeline */
+void init_async_zip_archive(void)
+{
+    rb_define_singleton_method(mAsyncZip, "create", az_create, 2);
+    rb_define_singleton_method(mAsyncZip, "extract", az_extract, 2);
+}

data/ext/archive.h

@@ -0,0 +1,8 @@
+#ifndef ASYNC_ZIP_ARCHIVE_H
+#define ASYNC_ZIP_ARCHIVE_H
+
+#include "async_zip.h"
+
+void init_async_zip_archive();
+
+#endif

data/ext/archive_data.c

@@ -0,0 +1,61 @@
+#include "archive_data.h"
+
+// Create a new archive-data structure
+archive_data_t* az_make_archive_data(const char* zip_path, const char* dst_path, carray_str_t* files_arr)
+{
+    archive_data_t* adata = (archive_data_t*)malloc(sizeof(archive_data_t));
+    if(adata)
+    {
+        memset(adata, 0, sizeof(archive_data_t));
+
+        if(zip_path)
+        {
+            adata->zip_path = strdup(zip_path);
+        }
+
+        if(dst_path)
+        {
+            adata->dst_path = strdup(dst_path);
+        }
+
+        if(files_arr)
+        {
+            adata->files_arr = files_arr;
+        }
+    }
+
+    return adata;
+}
+
+// Free archive-data structure
+void az_free_archive_data(archive_data_t* adata)
+{
+    if(!adata)
+        return;
+
+    if(adata->zip_path)
+    {
+        free(adata->zip_path);
+        adata->zip_path = NULL;
+    }
+
+    if(adata->dst_path)
+    {
+        free(adata->dst_path);
+        adata->dst_path = NULL;
+    }
+
+    if(adata->err_str)
+    {
+        free(adata->err_str);
+        adata->err_str = NULL;
+    }
+
+    if(adata->files_arr)
+    {
+        carray_str_destroy(adata->files_arr);
+        adata->files_arr = NULL;
+    }
+
+    free(adata);
+}

data/ext/archive_data.h

@@ -0,0 +1,25 @@
+#ifndef ASYNC_ZIP_ARCHIVE_DATA_H
+#define ASYNC_ZIP_ARCHIVE_DATA_H
+
+#include "ruby.h"
+#include "carray.h"
+
+typedef struct _archive_data_t
+{
+    char* zip_path; // source zip-file
+    char* dst_path; // destination folder to extract zip-file { used only for extraction }
+
+    carray_str_t* files_arr; // array of files to archive or files that were extracted
+
+    VALUE proc;
+    char* err_str;
+
+    struct _archive_data_t* next;
+} archive_data_t;
+
+
+archive_data_t* az_make_archive_data(const char* zip_path, const char* dst_path, carray_str_t* files_arr);
+void az_free_archive_data(archive_data_t* adata);
+
+#endif
+

data/ext/archive_data_fwd.h

@@ -0,0 +1,6 @@
+#ifndef ASYNC_ZIP_ARCHIVE_DATA_FWD_H
+#define ASYNC_ZIP_ARCHIVE_DATA_FWD_H
+
+struct archive_data_t;
+
+#endif

data/ext/async_zip.c

@@ -0,0 +1,18 @@
+#include "async_zip.h"
+#include "archive.h"
+#include "task.h"
+#include "callback.h"
+
+VALUE mAsyncZip, eZipError;
+
+/* Initialize extension */
+void Init_async_zip_ext()
+{
+    mAsyncZip = rb_define_module("AsyncZip");
+    eZipError = rb_define_class_under(mAsyncZip, "Error", rb_eStandardError);
+
+    //
+    init_async_zip_archive();
+    init_async_zip_task();
+    init_async_zip_event_thread();
+}

data/ext/async_zip.h

@@ -0,0 +1,8 @@
+#ifndef ASYNC_ZIP_H
+#define ASYNC_ZIP_H
+
+#include "ruby.h"
+
+extern VALUE mAsyncZip, eZipError;
+
+#endif

data/ext/callback.c

@@ -0,0 +1,121 @@
+#include "callback.h"
+#include "async_zip.h"
+#include "task.h"
+#include "archive_data.h"
+#include <pthread.h>
+
+
+typedef struct _adata_wait_t
+{
+    archive_data_t* adata;
+    int abort;
+} adata_wait_t;
+
+
+/* Queue of callbacks; each one invoked on a ruby thread */
+pthread_mutex_t az_proc_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t az_proc_cond = PTHREAD_COND_INITIALIZER;
+archive_data_t* az_proc_queue = NULL;
+
+/* Push new callback to front of the queue */
+static void az_proc_queue_push(archive_data_t* adata)
+{
+    adata->next = az_proc_queue;
+    az_proc_queue = adata;
+}
+
+/* Pop next callback from the queue; Returns NULL, when the queue is empty */
+static archive_data_t* az_proc_queue_pop(void)
+{
+    archive_data_t* adata = az_proc_queue;
+    if(adata)
+    {
+        az_proc_queue = adata->next;
+    }
+
+    return adata;
+}
+
+/* Callback executed by Ruby Thread */
+static VALUE az_handle_proc(void *d)
+{
+    archive_data_t* adata = (archive_data_t*)d;
+
+    // Invoke callback with task argument
+    VALUE proc = (VALUE)adata->proc;
+
+    int is_create = ((adata->zip_path && !adata->dst_path) ? 1 : 0);
+
+    VALUE task = rb_class_new_instance(0, NULL, cTask);
+    az_task_init(task, (is_create ? NULL : adata->zip_path), (is_create ? adata->zip_path : adata->dst_path), adata->err_str, adata->files_arr);
+    rb_funcall2(proc, rb_intern("call"), 1, &task);
+    rb_gc_unregister_address(&adata->proc);
+
+    az_free_archive_data(adata);
+
+    return Qnil;
+}
+
+
+/* Wait until we have some callbacks to process  */
+static VALUE az_wait_for_adata(void* w)
+{
+    adata_wait_t* waiter = (adata_wait_t*)w;
+
+    pthread_mutex_lock(&az_proc_mutex);
+    while (!waiter->abort && (waiter->adata = az_proc_queue_pop()) == NULL)
+    {
+        pthread_cond_wait(&az_proc_cond, &az_proc_mutex);
+    }
+    pthread_mutex_unlock(&az_proc_mutex);
+
+    return Qnil;
+}
+
+/* Stop waiting for callbacks */
+static void az_stop_waiting_for_adata(void* w)
+{
+    adata_wait_t* waiter = (adata_wait_t*)w;
+
+    pthread_mutex_lock(&az_proc_mutex);
+    waiter->abort = 1;
+    pthread_mutex_unlock(&az_proc_mutex);
+    pthread_cond_signal(&az_proc_cond);
+}
+
+
+/* ruby event thread, waiting for processed archives to invoke a callback */
+static VALUE az_event_thread(void *unused)
+{
+    adata_wait_t waiter = { .adata = NULL, .abort = 0 };
+    while (!waiter.abort)
+    {
+        rb_thread_blocking_region(az_wait_for_adata, &waiter, az_stop_waiting_for_adata, &waiter);
+        if (waiter.adata)
+        {
+            rb_thread_create(az_handle_proc, waiter.adata);
+        }
+    }
+
+    return Qnil;
+}
+
+/* Initialize Ruby Event Thread for invokation of user-provider callbacks */
+void az_create_event_thread(void)
+{
+    rb_thread_create(az_event_thread, NULL);
+}
+
+/* Add the archive data to the event queue */
+void az_add_to_event_qeueue(archive_data_t* adata)
+{
+    pthread_mutex_lock(&az_proc_mutex);
+    az_proc_queue_push(adata);
+    pthread_mutex_unlock(&az_proc_mutex);
+    pthread_cond_signal(&az_proc_cond);
+}
+
+void init_async_zip_event_thread(void)
+{
+    az_create_event_thread();
+}