slyphon-zookeeper 0.8.4 → 0.9.0

data/CHANGELOG

@@ -1,8 +1,18 @@
-v0.8.4 fix NameError, require 'forwardable'
-  
-  * Really not sure why this didn't come up in tests
+v0.9.0 RELEASE THE KRAK..er, GIL!!
+
+  * In >= 1.9.2 the ruby interpreter allows you to release the GIL when
+    calling into native code, sounds like a good idea.
+    
+    This release makes use of that code by parsing the zookeeper.h header file
+    and extracting the method signatures of all relevant zoo_* functions, then
+    generating boilerplate that allows us to call those functions via the
+    rb_thread_blocking_region function.
+
+    1.8.7 compatibility is maintained by stubbing out that functionality if built
+    under 1.8.7. 
 
-  * issue here https://github.com/slyphon/zk/issues/22
+  * 1.8.7 is deprecated! I will continue to support 1.8.7 for the near future
+    but sometime soon, you're gonna have to upgrade.
 
 v0.8.3 fix NonLocalJump exception in event delivery thread shutdown code
 

data/Rakefile

@@ -50,7 +50,7 @@ gemset_name = 'zookeeper'
     sh "rvm #{ruby_with_gemset} do bundle exec rspec spec --fail-fast"
   end
 
-  task "mb:test_all_rubies" => rspec_task_name
+  task "mb:test_all" => rspec_task_name
 end
 
 namespace :build do

data/ext/Rakefile

@@ -7,6 +7,28 @@ task :clean do
   end
 end
 
+GENERATE_GVL_CODE_RB = 'generate_gvl_code.rb'
+
+file 'c' do
+  if tarball = Dir['zkc-*.tar.gz'].first
+    sh "tar -zxf #{tarball}"
+  else
+    raise "couldn't find the tarball! wtf?!"
+  end
+end
+
+file GENERATE_GVL_CODE_RB => 'c'
+
+file 'zkrb_wrapper.c' => GENERATE_GVL_CODE_RB do
+  sh "ruby generate_gvl_code.rb code"
+end
+
+file 'zkrb_wrapper.h' => GENERATE_GVL_CODE_RB do
+  sh "ruby generate_gvl_code.rb headers"
+end
+
+ZKRB_WRAPPER = %w[zkrb_wrapper.c zkrb_wrapper.h]
+
 task :clobber => :clean do
   rm_rf %w[Makefile c lib bin include]
 end
@@ -17,7 +39,7 @@ end
 
 file 'Makefile' => :build_zkc
 
-task :build => 'Makefile' do
+task :build => [ZKRB_WRAPPER, 'Makefile'].flatten do
   sh 'make'
 end
 

data/ext/depend

@@ -1,3 +1,5 @@
 zookeeper_lib.c:	zookeeper_lib.h
-zookeeper_c.c:	zookeeper_lib.c zookeeper_lib.h dbg.h
+zkrb_wrapper_compat.c:  zkrb_wrapper_compat.h
+zkrb_wrapper.c:		zkrb_wrapper_compat.c zkrb_wrapper.h
+zookeeper_c.c:	zookeeper_lib.c zookeeper_lib.h zkrb_wrapper.c zkrb_wrapper.h dbg.h
 

data/ext/extconf.rb

@@ -19,6 +19,10 @@ $LDFLAGS = "#{$LDFLAGS}".gsub("$(ldflags)", "").gsub("-arch ppc", "")
 $CXXFLAGS = " -std=gnu++98 #{$CFLAGS}"
 $CPPFLAGS = $ARCH_FLAG = $DLDFLAGS = ""
 
+if RUBY_VERSION == '1.8.7'
+  $CFLAGS << ' -DZKRB_RUBY_187'
+end
+
 ZK_DEBUG = (ENV['DEBUG'] or ARGV.any? { |arg| arg == '--debug' })
 DEBUG_CFLAGS = " -O0 -ggdb3 -DHAVE_DEBUG"
 

data/ext/generate_gvl_code.rb

@@ -0,0 +1,332 @@
+#!/usr/bin/env ruby
+
+=begin
+the idea here is to take each zoo_* function declaration in the header file, and turn it into
+a calling arguments struct, a wrapper function and a macro for packing the values.
+
+so for:
+
+  ZOOAPI int zoo_acreate(zhandle_t *zh, const char *path, const char *value, 
+          int valuelen, const struct ACL_vector *acl, int flags,
+          string_completion_t completion, const void *data);
+
+we want
+
+  typedef struct {
+    zhandle_t *zh;
+    const char *path;
+    const char *value;
+    int valuelen;
+    const struct ACL_vector *acl;
+    int flags;
+    string_completion_t completion;
+    const void *data;
+  } zkrb_zoo_acreate_args_t;
+
+  static VALUE zkrb_gvl_zoo_acreate(void *data) {
+    zkrb_zoo_acreate_args_t *a = (zkrb_zoo_acreate_args_t *)data;
+  
+    a->rc = zoo_acreate(a->zh, a->path, a->value, a->valuelen, a->acl, a->flags, a->completion, a->data);
+  
+    return Qnil;
+  }
+
+  static int zkrb_call_zoo_acreate(zhandle_t *zh, const char *path, const char *value, 
+                int valuelen, const struct ACL_vector *acl, int flags,
+                string_completion_t completion, const void *data) {
+
+      int rc;
+      zkrb_zoo_acreate_args_t *ptr = malloc(sizeof(zkrb_zoo_acreate_args_t)); 
+      check_mem(ptr);
+
+      ptr->rc = 0; 
+      ptr->zh = zh; 
+      ptr->path = path; 
+      ptr->value = value;
+      ptr->valuelen = valuelen;
+      ptr->acl = acl;
+      ptr->flags = flags;
+      ptr->completion = completion;
+      ptr->data = data; 
+
+      rb_thread_blocking_region(zkrb_gvl_zoo_acreate, (void *)ptr, RUBY_UBF_IO, 0);
+
+      rc = ptr->rc;
+      free(ptr);
+      return rc;
+
+    error:
+      free(ptr); 
+      return -1;
+  }
+
+=end
+
+REGEXP = /^ZOOAPI int (zoo_[^(]+)\(([^)]+)\);$/m
+
+require 'forwardable'
+require 'stringio'
+
+ZKRB_WRAPPER_H_PATH = File.expand_path('../zkrb_wrapper.h', __FILE__)
+ZKRB_WRAPPER_C_PATH = File.expand_path('../zkrb_wrapper.c', __FILE__)
+
+# the struct that holds the call args for zoo_fn_name
+class CallStruct
+  attr_reader :zoo_fn_name, :typed_args, :name
+
+  def initialize(zoo_fn_name, typed_args)
+    @zoo_fn_name, @typed_args = zoo_fn_name, typed_args
+    @name = "zkrb_#{zoo_fn_name}_args_t"
+  end
+
+  def body
+    @body ||= (
+      lines = ["typedef struct {"]
+      lines += typed_args.map{|n| "  #{n};"}
+      lines << "  int rc;"
+      lines << "} #{name};"
+      lines.join("\n")
+    )
+  end
+end
+
+module MemberNames
+  def member_names
+    @member_names ||= typed_args.map { |n| n.split(/[ *]/).last }
+  end
+end
+
+# the zkrb_gvl_zoo_* function
+class WrapperFunction
+  extend Forwardable
+  include MemberNames
+
+  PREFIX = 'zkrb_gvl'
+
+  def_delegators :struct, :typed_args
+
+  attr_reader :struct, :name, :zoo_fn_name
+
+  def initialize(zoo_fn_name, struct)
+    @zoo_fn_name = zoo_fn_name
+    @struct = struct
+    @name = "#{PREFIX}_#{zoo_fn_name}"
+  end
+
+  def fn_signature
+    @fn_signature ||= "static VALUE #{name}(void *data)"
+  end
+
+  def body
+    @body ||= (
+      lines = ["#{fn_signature} {"]
+      lines << "  #{struct.name} *a = (#{struct.name} *)data;"
+
+      funcall = "  a->rc = #{zoo_fn_name}("
+      funcall << member_names.map { |m| "a->#{m}" }.join(', ')
+      funcall << ');'
+
+      lines << funcall
+
+      lines << "  return Qnil;"
+      lines << "}"
+      lines.join("\n")
+    )
+  end
+end
+
+# the zkrb_call_zoo_* function
+class CallingFunction
+  extend Forwardable
+  include MemberNames
+  
+  PREFIX = 'zkrb_call'
+
+  def_delegators :struct, :typed_args
+
+  attr_reader :struct, :wrapper_fn, :zoo_fn_name, :name
+
+  def initialize(zoo_fn_name, struct, wrapper_fn)
+    @zoo_fn_name, @struct, @wrapper_fn = zoo_fn_name, struct, wrapper_fn
+
+    @name = "#{PREFIX}_#{zoo_fn_name}"
+  end
+
+  def fn_signature
+    @fn_signature ||= "int #{name}(#{typed_args.join(', ')})"
+  end
+
+  def ptr_lines
+    @ptr_lines = (
+      lines = ["ptr->rc = rc;"]
+      lines += member_names.map { |n| "ptr->#{n} = #{n};" }
+      lines.map! { |n| "  #{n}" }
+      lines.join("\n")
+    )
+  end
+
+  def top
+    <<-EOS
+// wrapper that calls #{zoo_fn_name} via #{wrapper_fn.name} inside rb_thread_blocking_region
+#{fn_signature} {
+  int rc = ZKRB_FAIL;
+  #{struct.name} *ptr = malloc(sizeof(#{struct.name}));
+  check_mem(ptr);
+    EOS
+  end
+
+  def rb_thread_blocking_region_call
+    "  zkrb_thread_blocking_region(#{wrapper_fn.name}, (void *)ptr);"
+  end
+
+  def bottom
+    <<-EOS
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+    EOS
+  end
+
+  def body
+    @body ||= [top, ptr_lines, nil, rb_thread_blocking_region_call, bottom].join("\n")
+  end
+end
+
+class GeneratedCode < Struct.new(:structs, :wrapper_fns, :calling_fns)
+  def initialize(*a)
+    super
+
+    self.structs     ||= []
+    self.wrapper_fns ||= []
+    self.calling_fns ||= []
+  end
+
+  def self.from_zookeeper_h(text)
+    new.tap do |code|
+      while true
+        break unless text =~ REGEXP
+        zoo_fn_name, argstr = $1
+        argstr = $2
+
+        typed_args = argstr.split(',').map(&:strip)
+
+        # gah, fix up zoo_aset_acl which has a void_completion_t with no name assigned
+        if zoo_fn_name == 'zoo_aset_acl'
+          if idx = typed_args.index('void_completion_t')
+            typed_args[idx] = 'void_completion_t completion'
+          end
+        end
+
+        struct = CallStruct.new(zoo_fn_name, typed_args)
+        wrapper_fn = WrapperFunction.new(zoo_fn_name, struct)
+        calling_fn = CallingFunction.new(zoo_fn_name, struct, wrapper_fn)
+
+        code.structs << struct
+        code.wrapper_fns << wrapper_fn
+        code.calling_fns << calling_fn
+
+        text = $~.post_match
+      end
+    end
+  end
+end
+
+def render_header_file(code)
+  StringIO.new('zkrb_wrapper.h', 'w').tap do |fp|
+    fp.puts <<-EOS
+#ifndef ZKRB_WRAPPER_H
+#define ZKRB_WRAPPER_H
+#if 0
+
+  AUTOGENERATED BY #{File.basename(__FILE__)} 
+
+#endif
+
+#include "ruby.h"
+#include "c-client-src/zookeeper.h"
+#include "zkrb_wrapper_compat.h"
+#include "dbg.h"
+
+#define ZKRB_FAIL -1
+
+    EOS
+
+    code.structs.each do |struct|
+      fp.puts(struct.body)
+      fp.puts
+    end
+
+    code.calling_fns.each do |cf|
+      fp.puts "#{cf.fn_signature};"
+    end
+
+    fp.puts <<-EOS
+
+#endif /* ZKRB_WRAPPER_H */
+    EOS
+
+  end.string
+end
+
+def render_c_file(code)
+  StringIO.new('zkrb_wrapper.c', 'w').tap do |fp|
+    fp.puts <<-EOS
+/*
+
+Autogenerated boilerplate wrappers around zoo_* function calls necessary for using
+rb_thread_blocking_region to release the GIL when calling native code.
+
+generated by ext/#{File.basename(__FILE__)}
+
+*/
+
+#include "ruby.h"
+#include "zkrb_wrapper.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+    EOS
+
+    code.wrapper_fns.zip(code.calling_fns) do |wrap_fn, call_fn|
+      fp.puts "#{wrap_fn.body}\n\n"
+      fp.puts "#{call_fn.body}\n\n"
+    end
+
+  end.string
+end
+
+
+def help!
+  $stderr.puts "usage: #{File.basename(__FILE__)} {all|headers|code}"
+  exit 1
+end
+
+def main
+  help! if ARGV.empty?
+  
+  text = File.read('c/include/zookeeper.h')
+  code = GeneratedCode.from_zookeeper_h(text)
+
+  cmd = ARGV.first
+
+  help! unless %w[headers all code].include?(cmd)
+
+  if %w[headers all].include?(cmd)
+    $stderr.puts "writing #{ZKRB_WRAPPER_H_PATH}"
+    File.open(ZKRB_WRAPPER_H_PATH, 'w') { |fp| fp.write(render_header_file(code)) }
+  end
+
+  if %w[code all].include?(cmd)
+    $stderr.puts "writing #{ZKRB_WRAPPER_C_PATH}"
+    File.open(ZKRB_WRAPPER_C_PATH, 'w') { |fp| fp.write(render_c_file(code)) }
+  end
+
+end
+
+main
+

data/ext/zkrb_wrapper.c

@@ -0,0 +1,917 @@
+/*
+
+Autogenerated boilerplate wrappers around zoo_* function calls necessary for using
+rb_thread_blocking_region to release the GIL when calling native code.
+
+generated by ext/generate_gvl_code.rb
+
+*/
+
+#include "ruby.h"
+#include "zkrb_wrapper.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static VALUE zkrb_gvl_zoo_recv_timeout(void *data) {
+  zkrb_zoo_recv_timeout_args_t *a = (zkrb_zoo_recv_timeout_args_t *)data;
+  a->rc = zoo_recv_timeout(a->zh);
+  return Qnil;
+}
+
+// wrapper that calls zoo_recv_timeout via zkrb_gvl_zoo_recv_timeout inside rb_thread_blocking_region
+int zkrb_call_zoo_recv_timeout(zhandle_t *zh) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_recv_timeout_args_t *ptr = malloc(sizeof(zkrb_zoo_recv_timeout_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_recv_timeout, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_state(void *data) {
+  zkrb_zoo_state_args_t *a = (zkrb_zoo_state_args_t *)data;
+  a->rc = zoo_state(a->zh);
+  return Qnil;
+}
+
+// wrapper that calls zoo_state via zkrb_gvl_zoo_state inside rb_thread_blocking_region
+int zkrb_call_zoo_state(zhandle_t *zh) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_state_args_t *ptr = malloc(sizeof(zkrb_zoo_state_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_state, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_acreate(void *data) {
+  zkrb_zoo_acreate_args_t *a = (zkrb_zoo_acreate_args_t *)data;
+  a->rc = zoo_acreate(a->zh, a->path, a->value, a->valuelen, a->acl, a->flags, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_acreate via zkrb_gvl_zoo_acreate inside rb_thread_blocking_region
+int zkrb_call_zoo_acreate(zhandle_t *zh, const char *path, const char *value, int valuelen, const struct ACL_vector *acl, int flags, string_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_acreate_args_t *ptr = malloc(sizeof(zkrb_zoo_acreate_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->value = value;
+  ptr->valuelen = valuelen;
+  ptr->acl = acl;
+  ptr->flags = flags;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_acreate, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_adelete(void *data) {
+  zkrb_zoo_adelete_args_t *a = (zkrb_zoo_adelete_args_t *)data;
+  a->rc = zoo_adelete(a->zh, a->path, a->version, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_adelete via zkrb_gvl_zoo_adelete inside rb_thread_blocking_region
+int zkrb_call_zoo_adelete(zhandle_t *zh, const char *path, int version, void_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_adelete_args_t *ptr = malloc(sizeof(zkrb_zoo_adelete_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->version = version;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_adelete, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aexists(void *data) {
+  zkrb_zoo_aexists_args_t *a = (zkrb_zoo_aexists_args_t *)data;
+  a->rc = zoo_aexists(a->zh, a->path, a->watch, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aexists via zkrb_gvl_zoo_aexists inside rb_thread_blocking_region
+int zkrb_call_zoo_aexists(zhandle_t *zh, const char *path, int watch, stat_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aexists_args_t *ptr = malloc(sizeof(zkrb_zoo_aexists_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aexists, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_awexists(void *data) {
+  zkrb_zoo_awexists_args_t *a = (zkrb_zoo_awexists_args_t *)data;
+  a->rc = zoo_awexists(a->zh, a->path, a->watcher, a->watcherCtx, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_awexists via zkrb_gvl_zoo_awexists inside rb_thread_blocking_region
+int zkrb_call_zoo_awexists(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, stat_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_awexists_args_t *ptr = malloc(sizeof(zkrb_zoo_awexists_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_awexists, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aget(void *data) {
+  zkrb_zoo_aget_args_t *a = (zkrb_zoo_aget_args_t *)data;
+  a->rc = zoo_aget(a->zh, a->path, a->watch, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aget via zkrb_gvl_zoo_aget inside rb_thread_blocking_region
+int zkrb_call_zoo_aget(zhandle_t *zh, const char *path, int watch, data_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aget_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aget, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_awget(void *data) {
+  zkrb_zoo_awget_args_t *a = (zkrb_zoo_awget_args_t *)data;
+  a->rc = zoo_awget(a->zh, a->path, a->watcher, a->watcherCtx, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_awget via zkrb_gvl_zoo_awget inside rb_thread_blocking_region
+int zkrb_call_zoo_awget(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, data_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_awget_args_t *ptr = malloc(sizeof(zkrb_zoo_awget_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_awget, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aset(void *data) {
+  zkrb_zoo_aset_args_t *a = (zkrb_zoo_aset_args_t *)data;
+  a->rc = zoo_aset(a->zh, a->path, a->buffer, a->buflen, a->version, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aset via zkrb_gvl_zoo_aset inside rb_thread_blocking_region
+int zkrb_call_zoo_aset(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version, stat_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aset_args_t *ptr = malloc(sizeof(zkrb_zoo_aset_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->buffer = buffer;
+  ptr->buflen = buflen;
+  ptr->version = version;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aset, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aget_children(void *data) {
+  zkrb_zoo_aget_children_args_t *a = (zkrb_zoo_aget_children_args_t *)data;
+  a->rc = zoo_aget_children(a->zh, a->path, a->watch, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aget_children via zkrb_gvl_zoo_aget_children inside rb_thread_blocking_region
+int zkrb_call_zoo_aget_children(zhandle_t *zh, const char *path, int watch, strings_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aget_children_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_children_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_children, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_awget_children(void *data) {
+  zkrb_zoo_awget_children_args_t *a = (zkrb_zoo_awget_children_args_t *)data;
+  a->rc = zoo_awget_children(a->zh, a->path, a->watcher, a->watcherCtx, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_awget_children via zkrb_gvl_zoo_awget_children inside rb_thread_blocking_region
+int zkrb_call_zoo_awget_children(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, strings_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_awget_children_args_t *ptr = malloc(sizeof(zkrb_zoo_awget_children_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_awget_children, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aget_children2(void *data) {
+  zkrb_zoo_aget_children2_args_t *a = (zkrb_zoo_aget_children2_args_t *)data;
+  a->rc = zoo_aget_children2(a->zh, a->path, a->watch, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aget_children2 via zkrb_gvl_zoo_aget_children2 inside rb_thread_blocking_region
+int zkrb_call_zoo_aget_children2(zhandle_t *zh, const char *path, int watch, strings_stat_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aget_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_children2_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_children2, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_awget_children2(void *data) {
+  zkrb_zoo_awget_children2_args_t *a = (zkrb_zoo_awget_children2_args_t *)data;
+  a->rc = zoo_awget_children2(a->zh, a->path, a->watcher, a->watcherCtx, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_awget_children2 via zkrb_gvl_zoo_awget_children2 inside rb_thread_blocking_region
+int zkrb_call_zoo_awget_children2(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, strings_stat_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_awget_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_awget_children2_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_awget_children2, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_async(void *data) {
+  zkrb_zoo_async_args_t *a = (zkrb_zoo_async_args_t *)data;
+  a->rc = zoo_async(a->zh, a->path, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_async via zkrb_gvl_zoo_async inside rb_thread_blocking_region
+int zkrb_call_zoo_async(zhandle_t *zh, const char *path, string_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_async_args_t *ptr = malloc(sizeof(zkrb_zoo_async_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_async, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aget_acl(void *data) {
+  zkrb_zoo_aget_acl_args_t *a = (zkrb_zoo_aget_acl_args_t *)data;
+  a->rc = zoo_aget_acl(a->zh, a->path, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aget_acl via zkrb_gvl_zoo_aget_acl inside rb_thread_blocking_region
+int zkrb_call_zoo_aget_acl(zhandle_t *zh, const char *path, acl_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aget_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_aget_acl_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aget_acl, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_aset_acl(void *data) {
+  zkrb_zoo_aset_acl_args_t *a = (zkrb_zoo_aset_acl_args_t *)data;
+  a->rc = zoo_aset_acl(a->zh, a->path, a->version, a->acl, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_aset_acl via zkrb_gvl_zoo_aset_acl inside rb_thread_blocking_region
+int zkrb_call_zoo_aset_acl(zhandle_t *zh, const char *path, int version, struct ACL_vector *acl, void_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_aset_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_aset_acl_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->version = version;
+  ptr->acl = acl;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_aset_acl, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_add_auth(void *data) {
+  zkrb_zoo_add_auth_args_t *a = (zkrb_zoo_add_auth_args_t *)data;
+  a->rc = zoo_add_auth(a->zh, a->scheme, a->cert, a->certLen, a->completion, a->data);
+  return Qnil;
+}
+
+// wrapper that calls zoo_add_auth via zkrb_gvl_zoo_add_auth inside rb_thread_blocking_region
+int zkrb_call_zoo_add_auth(zhandle_t *zh, const char* scheme, const char* cert, int certLen, void_completion_t completion, const void *data) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_add_auth_args_t *ptr = malloc(sizeof(zkrb_zoo_add_auth_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->scheme = scheme;
+  ptr->cert = cert;
+  ptr->certLen = certLen;
+  ptr->completion = completion;
+  ptr->data = data;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_add_auth, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_create(void *data) {
+  zkrb_zoo_create_args_t *a = (zkrb_zoo_create_args_t *)data;
+  a->rc = zoo_create(a->zh, a->path, a->value, a->valuelen, a->acl, a->flags, a->path_buffer, a->path_buffer_len);
+  return Qnil;
+}
+
+// wrapper that calls zoo_create via zkrb_gvl_zoo_create inside rb_thread_blocking_region
+int zkrb_call_zoo_create(zhandle_t *zh, const char *path, const char *value, int valuelen, const struct ACL_vector *acl, int flags, char *path_buffer, int path_buffer_len) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_create_args_t *ptr = malloc(sizeof(zkrb_zoo_create_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->value = value;
+  ptr->valuelen = valuelen;
+  ptr->acl = acl;
+  ptr->flags = flags;
+  ptr->path_buffer = path_buffer;
+  ptr->path_buffer_len = path_buffer_len;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_create, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_delete(void *data) {
+  zkrb_zoo_delete_args_t *a = (zkrb_zoo_delete_args_t *)data;
+  a->rc = zoo_delete(a->zh, a->path, a->version);
+  return Qnil;
+}
+
+// wrapper that calls zoo_delete via zkrb_gvl_zoo_delete inside rb_thread_blocking_region
+int zkrb_call_zoo_delete(zhandle_t *zh, const char *path, int version) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_delete_args_t *ptr = malloc(sizeof(zkrb_zoo_delete_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->version = version;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_delete, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_exists(void *data) {
+  zkrb_zoo_exists_args_t *a = (zkrb_zoo_exists_args_t *)data;
+  a->rc = zoo_exists(a->zh, a->path, a->watch, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_exists via zkrb_gvl_zoo_exists inside rb_thread_blocking_region
+int zkrb_call_zoo_exists(zhandle_t *zh, const char *path, int watch, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_exists_args_t *ptr = malloc(sizeof(zkrb_zoo_exists_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_exists, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_wexists(void *data) {
+  zkrb_zoo_wexists_args_t *a = (zkrb_zoo_wexists_args_t *)data;
+  a->rc = zoo_wexists(a->zh, a->path, a->watcher, a->watcherCtx, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_wexists via zkrb_gvl_zoo_wexists inside rb_thread_blocking_region
+int zkrb_call_zoo_wexists(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_wexists_args_t *ptr = malloc(sizeof(zkrb_zoo_wexists_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_wexists, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_get(void *data) {
+  zkrb_zoo_get_args_t *a = (zkrb_zoo_get_args_t *)data;
+  a->rc = zoo_get(a->zh, a->path, a->watch, a->buffer, a->buffer_len, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_get via zkrb_gvl_zoo_get inside rb_thread_blocking_region
+int zkrb_call_zoo_get(zhandle_t *zh, const char *path, int watch, char *buffer, int* buffer_len, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_get_args_t *ptr = malloc(sizeof(zkrb_zoo_get_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->buffer = buffer;
+  ptr->buffer_len = buffer_len;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_get, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_wget(void *data) {
+  zkrb_zoo_wget_args_t *a = (zkrb_zoo_wget_args_t *)data;
+  a->rc = zoo_wget(a->zh, a->path, a->watcher, a->watcherCtx, a->buffer, a->buffer_len, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_wget via zkrb_gvl_zoo_wget inside rb_thread_blocking_region
+int zkrb_call_zoo_wget(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, char *buffer, int* buffer_len, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_wget_args_t *ptr = malloc(sizeof(zkrb_zoo_wget_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->buffer = buffer;
+  ptr->buffer_len = buffer_len;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_wget, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_set(void *data) {
+  zkrb_zoo_set_args_t *a = (zkrb_zoo_set_args_t *)data;
+  a->rc = zoo_set(a->zh, a->path, a->buffer, a->buflen, a->version);
+  return Qnil;
+}
+
+// wrapper that calls zoo_set via zkrb_gvl_zoo_set inside rb_thread_blocking_region
+int zkrb_call_zoo_set(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_set_args_t *ptr = malloc(sizeof(zkrb_zoo_set_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->buffer = buffer;
+  ptr->buflen = buflen;
+  ptr->version = version;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_set, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_set2(void *data) {
+  zkrb_zoo_set2_args_t *a = (zkrb_zoo_set2_args_t *)data;
+  a->rc = zoo_set2(a->zh, a->path, a->buffer, a->buflen, a->version, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_set2 via zkrb_gvl_zoo_set2 inside rb_thread_blocking_region
+int zkrb_call_zoo_set2(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_set2_args_t *ptr = malloc(sizeof(zkrb_zoo_set2_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->buffer = buffer;
+  ptr->buflen = buflen;
+  ptr->version = version;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_set2, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_get_children(void *data) {
+  zkrb_zoo_get_children_args_t *a = (zkrb_zoo_get_children_args_t *)data;
+  a->rc = zoo_get_children(a->zh, a->path, a->watch, a->strings);
+  return Qnil;
+}
+
+// wrapper that calls zoo_get_children via zkrb_gvl_zoo_get_children inside rb_thread_blocking_region
+int zkrb_call_zoo_get_children(zhandle_t *zh, const char *path, int watch, struct String_vector *strings) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_get_children_args_t *ptr = malloc(sizeof(zkrb_zoo_get_children_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->strings = strings;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_get_children, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_wget_children(void *data) {
+  zkrb_zoo_wget_children_args_t *a = (zkrb_zoo_wget_children_args_t *)data;
+  a->rc = zoo_wget_children(a->zh, a->path, a->watcher, a->watcherCtx, a->strings);
+  return Qnil;
+}
+
+// wrapper that calls zoo_wget_children via zkrb_gvl_zoo_wget_children inside rb_thread_blocking_region
+int zkrb_call_zoo_wget_children(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct String_vector *strings) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_wget_children_args_t *ptr = malloc(sizeof(zkrb_zoo_wget_children_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->strings = strings;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_wget_children, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_get_children2(void *data) {
+  zkrb_zoo_get_children2_args_t *a = (zkrb_zoo_get_children2_args_t *)data;
+  a->rc = zoo_get_children2(a->zh, a->path, a->watch, a->strings, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_get_children2 via zkrb_gvl_zoo_get_children2 inside rb_thread_blocking_region
+int zkrb_call_zoo_get_children2(zhandle_t *zh, const char *path, int watch, struct String_vector *strings, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_get_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_get_children2_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watch = watch;
+  ptr->strings = strings;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_get_children2, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_wget_children2(void *data) {
+  zkrb_zoo_wget_children2_args_t *a = (zkrb_zoo_wget_children2_args_t *)data;
+  a->rc = zoo_wget_children2(a->zh, a->path, a->watcher, a->watcherCtx, a->strings, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_wget_children2 via zkrb_gvl_zoo_wget_children2 inside rb_thread_blocking_region
+int zkrb_call_zoo_wget_children2(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct String_vector *strings, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_wget_children2_args_t *ptr = malloc(sizeof(zkrb_zoo_wget_children2_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->watcher = watcher;
+  ptr->watcherCtx = watcherCtx;
+  ptr->strings = strings;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_wget_children2, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_get_acl(void *data) {
+  zkrb_zoo_get_acl_args_t *a = (zkrb_zoo_get_acl_args_t *)data;
+  a->rc = zoo_get_acl(a->zh, a->path, a->acl, a->stat);
+  return Qnil;
+}
+
+// wrapper that calls zoo_get_acl via zkrb_gvl_zoo_get_acl inside rb_thread_blocking_region
+int zkrb_call_zoo_get_acl(zhandle_t *zh, const char *path, struct ACL_vector *acl, struct Stat *stat) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_get_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_get_acl_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->acl = acl;
+  ptr->stat = stat;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_get_acl, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+
+static VALUE zkrb_gvl_zoo_set_acl(void *data) {
+  zkrb_zoo_set_acl_args_t *a = (zkrb_zoo_set_acl_args_t *)data;
+  a->rc = zoo_set_acl(a->zh, a->path, a->version, a->acl);
+  return Qnil;
+}
+
+// wrapper that calls zoo_set_acl via zkrb_gvl_zoo_set_acl inside rb_thread_blocking_region
+int zkrb_call_zoo_set_acl(zhandle_t *zh, const char *path, int version, const struct ACL_vector *acl) {
+  int rc = ZKRB_FAIL;
+  zkrb_zoo_set_acl_args_t *ptr = malloc(sizeof(zkrb_zoo_set_acl_args_t));
+  check_mem(ptr);
+
+  ptr->rc = rc;
+  ptr->zh = zh;
+  ptr->path = path;
+  ptr->version = version;
+  ptr->acl = acl;
+
+  zkrb_thread_blocking_region(zkrb_gvl_zoo_set_acl, (void *)ptr);
+
+  rc = ptr->rc;
+
+error:
+  free(ptr);
+  return rc;
+}
+
+