async-ruby-zip 1.0.0

data/ext/cfilesystem.c

@@ -0,0 +1,107 @@
+#include "cfilesystem.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+
+// Recursive directory creation
+static void _mkdir(const char *dir, mode_t mode) {
+
+    char tmp[512];
+    char *p = NULL;
+    size_t len;
+
+    snprintf(tmp, sizeof(tmp),"%s",dir);
+    len = strlen(tmp);
+    if(tmp[len - 1] == '/')
+            tmp[len - 1] = 0;
+    for(p = tmp + 1; *p; p++)
+            if(*p == '/') {
+                    *p = 0;
+                    mkdir(tmp, mode);
+                    *p = '/';
+            }
+    mkdir(tmp, S_IRWXU);
+}
+
+
+// Remove file or directory
+void cfilesystem_remove(const char* filepath)
+{
+    remove(filepath);
+}
+
+// Returns a positive value if path is found, otherwise 0
+int cfilesystem_exists(const char* filepath)
+{
+    return (access(filepath, F_OK) == 0 ? 1 : 0);
+}
+
+// Get the filename for the given file path
+char* cfilesystem_filename(const char* filepath)
+{
+    char* result = NULL;
+    char* last = strrchr(filepath, '/');
+    if(last)
+    {
+        result = strdup(last);
+    }
+
+    return result;
+}
+
+// Create directories
+void cfilesystem_create_directories(const char* filepath)
+{
+    _mkdir(filepath, S_IRWXU | S_IRWXG | S_IRWXO);
+}
+
+// Get a temporary filename.
+char* cfilesystem_tempfilename()
+{
+    char buffer[L_tmpnam];
+    tmpnam(buffer);
+    return strdup(buffer);
+}
+
+// Append one path to the other.
+// Returns the combined path
+char* cfilesystem_combine(const char* path1, const char* path2)
+{
+    char* result = NULL;
+
+    if(!path1 && !path2) {
+        // no-op
+    }
+    else if(!path2 || !path2[0]) {
+        result = strdup(path1);
+    }
+    else if(!path1 || !path1[0]) {
+        result = strdup(path2);
+    }
+    else {
+        char* ptr;
+        size_t len1 = strlen(path1);
+        size_t len2 = strlen(path2);
+
+        size_t newlen = len1 + len2 + 1 + ((path1[len1 - 1] != '/' && path2[0] != '/') ? 1 : 0);
+        result = (char*)malloc(newlen);
+        ptr = result;
+
+        strcpy(ptr, path1);
+        ptr += len1;
+
+        if((ptr[-1] != '/') && (path2[0] != '/'))
+        {
+            ptr[0] = '/';
+            ++ptr;
+        }
+
+        strcpy(ptr, path2);
+    }
+
+    return result;
+}

data/ext/cfilesystem.h

@@ -0,0 +1,11 @@
+#ifndef EXTRA_CFILESYSTEM_H
+#define EXTRA_CFILESYSTEM_H
+
+void cfilesystem_remove(const char* filepath);
+int cfilesystem_exists(const char* filepath);
+char* cfilesystem_filename(const char* filepath);
+void cfilesystem_create_directories(const char* filepath);
+char* cfilesystem_tempfilename();
+char* cfilesystem_combine(const char* path1, const char* path2);
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require "mkmf"
+
+File::unlink("Makefile") if (File::exist?("Makefile"))
+
+pkg_config("libzip")
+
+have_header('zip.h')
+create_makefile('async_zip_ext')

data/ext/task.c

@@ -0,0 +1,62 @@
+#include "task.h"
+#include "carray.h"
+
+VALUE cTask;
+
+/* Get the source parameter */
+static VALUE az_task_src(VALUE self)
+{
+    return rb_iv_get(self, "@src");
+}
+
+/* Get the destination parameter */
+static VALUE az_task_dst(VALUE self)
+{
+    return rb_iv_get(self, "@dst");
+}
+
+/* Get the error parameter */
+static VALUE az_task_error(VALUE self)
+{
+    return rb_iv_get(self, "@error");
+}
+
+/* Get the files */
+static VALUE az_task_files(VALUE self)
+{
+    return rb_iv_get(self, "@files");
+}
+
+
+/* Initialize the object, called before the callback is invoked */
+void az_task_init(VALUE self, const char* src_path, const char* dst_path, const char* err_str, const carray_str_t* files_arr)
+{
+    rb_iv_set(self, "@src", (src_path ? rb_str_new2(src_path) : Qnil));
+    rb_iv_set(self, "@dst", (dst_path ? rb_str_new2(dst_path) : Qnil));
+    rb_iv_set(self, "@error", (err_str ? rb_str_new2(err_str) : Qnil));
+
+    // create an array
+    VALUE arr = rb_ary_new();
+    size_t len = carray_str_size(files_arr);
+    if(len > 0)
+    {
+        size_t i;
+        for(i = 0; i != len; ++i)
+        {
+            const char* s = carray_str_get(files_arr, i);
+            rb_ary_push(arr, rb_str_new2(s));
+        }
+    }
+    rb_iv_set(self, "@files", arr);
+}
+
+
+void init_async_zip_task()
+{
+    cTask = rb_define_class_under(mAsyncZip, "Task", rb_cObject);
+
+    rb_define_method(cTask, "src", az_task_src, 0);
+    rb_define_method(cTask, "dst", az_task_dst, 0);
+    rb_define_method(cTask, "error", az_task_error, 0);
+    rb_define_method(cTask, "files", az_task_files, 0);
+}

data/ext/task.h

@@ -0,0 +1,13 @@
+#ifndef ASYNC_ZIP_TASK_H
+#define ASYNC_ZIP_TASK_H
+
+#include "async_zip.h"
+#include "carray.h"
+
+extern VALUE cTask;
+
+void az_task_init(VALUE self, const char* src_path, const char* dst_path, const char* err_str, const carray_str_t* files_arr);
+
+void init_async_zip_task();
+
+#endif

data/ext/writer.c

@@ -0,0 +1,96 @@
+#include "writer.h"
+#include "archive_data.h"
+#include <memory.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+pthread_t az_writer_thread;
+pthread_once_t qt_once = PTHREAD_ONCE_INIT;
+
+typedef struct _az_write_task_t
+{
+    archive_func_t func;
+    void* data;
+    struct _az_write_task_t* next;
+} az_write_task_t;
+
+
+/* Queue of tasks for processing. */
+pthread_mutex_t az_writer_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t az_writer_cond = PTHREAD_COND_INITIALIZER;
+az_write_task_t* az_writer_queue = NULL;
+
+
+/* Push new task to front of the queue */
+static void az_write_task_queue_push(az_write_task_t* wtask)
+{
+    wtask->next = az_writer_queue;
+    az_writer_queue = wtask;
+}
+
+/* Pop next task from the queue; Returns NULL, when the queue is empty */
+static az_write_task_t* az_write_task_queue_pop(void)
+{
+    az_write_task_t* wtask = az_writer_queue;
+    if(wtask)
+    {
+        az_writer_queue = wtask->next;
+    }
+
+    return wtask;
+}
+
+
+/* Task processing queue */
+static void* az_writer_thread_func(void* data)
+{
+    int is_running = 1;
+    az_write_task_t* wtask = NULL;
+
+    while(is_running)
+    {
+        pthread_mutex_lock(&az_writer_mutex);
+        while (is_running && (wtask = az_write_task_queue_pop()) == NULL)
+        {
+            pthread_cond_wait(&az_writer_cond, &az_writer_mutex);
+        }
+        pthread_mutex_unlock(&az_writer_mutex);
+
+        if(wtask)
+        {
+            if(wtask->func)
+            {
+                wtask->func(wtask->data);
+            }
+
+            free(wtask);
+        }
+    }
+
+    return NULL;
+}
+
+
+/* Initialize the writer thread. The thread will wait for tasks to process */
+static void az_init_writer_thread(void)
+{
+    pthread_create(&az_writer_thread, NULL, az_writer_thread_func, NULL);
+    pthread_detach(az_writer_thread);
+}
+
+/* asynchronously invoke the func with the provided data */
+void az_enqueue_task(archive_func_t func, void* data)
+{
+  pthread_once(&qt_once, az_init_writer_thread);
+
+  pthread_mutex_lock(&az_writer_mutex);
+
+  az_write_task_t* wtask = (az_write_task_t*)malloc(sizeof(az_write_task_t));
+  memset(wtask, 0, sizeof(az_write_task_t));
+  wtask->func = func;
+  wtask->data = data;
+  az_write_task_queue_push(wtask);
+
+  pthread_mutex_unlock(&az_writer_mutex);
+  pthread_cond_signal(&az_writer_cond);
+}

data/ext/writer.h

@@ -0,0 +1,7 @@
+#ifndef ASYNC_ZIP_WRITER_H
+#define ASYNC_ZIP_WRITER_H
+
+typedef void* (*archive_func_t)(void*);
+void az_enqueue_task(archive_func_t func, void* data);
+
+#endif

data/lib/async_zip.rb

@@ -0,0 +1,5 @@
+# Vips will print warnings to stdout unless this is set
+ENV['IM_WARNING'] = "0"
+
+require 'async_zip_ext'
+require 'async_zip/version'

data/lib/async_zip/version.rb

@@ -0,0 +1,3 @@
+module AsyncZip
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: async-ruby-zip
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Grigoriy Chudnov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Non-blocking zip reading and writing for Ruby.
+email: g.chudnov@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- README.md
+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
+homepage: https://github.com/gchudnov/async-ruby-zip
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: async-ruby-zip is a ruby extension that zip files asynchronously.
+test_files: []