rubyfb 0.5.2

data/ext/Backup.c

@@ -0,0 +1,783 @@
+/*------------------------------------------------------------------------------
+ * Backup.c
+ *----------------------------------------------------------------------------*/
+/**
+ * Copyright � Peter Wood, 2005
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+ * the specificlanguage governing rights and  limitations under the License.
+ *
+ * The Original Code is the FireRuby extension for the Ruby language.
+ *
+ * The Initial Developer of the Original Code is Peter Wood. All Rights
+ * Reserved.
+ *
+ * @author  Peter Wood
+ * @version 1.0
+ */
+
+/* Includes. */
+#include "Backup.h"
+#include "ibase.h"
+#include "ServiceManager.h"
+#include "Services.h"
+
+/* Function prototypes. */
+static VALUE getBackupFile(VALUE);
+static VALUE setBackupFile(VALUE, VALUE);
+static VALUE getBackupDatabase(VALUE);
+static VALUE setBackupDatabase(VALUE, VALUE);
+static VALUE getBackupBlockingFactor(VALUE);
+static VALUE setBackupBlockingFactor(VALUE, VALUE);
+static VALUE getBackupIgnoreChecksums(VALUE);
+static VALUE setBackupIgnoreChecksums(VALUE, VALUE);
+static VALUE getBackupIgnoreLimbo(VALUE);
+static VALUE setBackupIgnoreLimbo(VALUE, VALUE);
+static VALUE getBackupMetadataOnly(VALUE);
+static VALUE setBackupMetadataOnly(VALUE, VALUE);
+static VALUE getBackupGarbageCollect(VALUE);
+static VALUE setBackupGarbageCollect(VALUE, VALUE);
+static VALUE getBackupNonTransportable(VALUE);
+static VALUE setBackupNonTransportable(VALUE, VALUE);
+static VALUE getBackupConvertTables(VALUE);
+static VALUE setBackupConvertTables(VALUE, VALUE);
+static VALUE executeBackup(VALUE, VALUE);
+static VALUE getBackupLog(VALUE);
+static void createBackupBuffer(VALUE, VALUE, VALUE, char **, short *);
+
+
+/* Globals. */
+VALUE cBackup;
+
+/* Definitions. */
+#define IGNORE_CHECKSUMS      rb_str_new2("IGNORE_CHECKSUMS")
+#define IGNORE_LIMBO          rb_str_new2("IGNORE_LIMBO")
+#define METADATA_ONLY         rb_str_new2("METADATA_ONLY")
+#define NO_GARBAGE_COLLECT    rb_str_new2("NO_GARBAGE_COLLECT")
+#define NON_TRANSPORTABLE     rb_str_new2("NON_TRANSPORTABLE")
+#define CONVERT_TABLES        rb_str_new2("CONVERT_TABLES")
+#define VERBOSE_BACKUP        INT2FIX(isc_spb_verbose)
+#define START_BUFFER_SIZE     1024
+
+
+/**
+ * This function provides the initialize method for the Backup class.
+ *
+ * @param  self      A reference to the Backup object to be initialized.
+ * @param  database  A reference to a File or String containing the server path
+ *                   and name of the primary database file.
+ * @param  file      A reference to a File or String containing the server path
+ *                   and name of the database backup file.
+ *
+ * @return  A reference to the newly initialized Backup object.
+ *
+ */
+VALUE initializeBackup(VALUE self, VALUE database, VALUE file)
+{
+   VALUE path  = Qnil,
+         files = rb_hash_new();
+
+   /* Extract the database file details. */
+   if(TYPE(database) == T_FILE)
+   {
+      path = rb_funcall(database, rb_intern("path"), 0);
+   }
+   else
+   {
+      path = rb_funcall(database, rb_intern("to_s"), 0);
+   }
+
+   /* Get the back file details. */
+   if(TYPE(file) == T_FILE)
+   {
+      rb_hash_aset(files, rb_funcall(file, rb_intern("path"), 0), Qnil);
+   }
+   else
+   {
+      rb_hash_aset(files, rb_funcall(file, rb_intern("to_s"), 0), Qnil);
+   }
+
+   rb_iv_set(self, "@database", path);
+   rb_iv_set(self, "@files", files);
+   rb_iv_set(self, "@options", rb_hash_new());
+   rb_iv_set(self, "@log", Qnil);
+
+   return(self);
+}
+
+
+/**
+ * This function provides the backup_file attribute accessor for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  A reference to a String containing the backup file path/name.
+ *
+ */
+VALUE getBackupFile(VALUE self)
+{
+   VALUE files = rb_iv_get(self, "@files");
+
+   return(rb_ary_entry(rb_funcall(files, rb_intern("keys"), 0), 0));
+}
+
+
+/**
+ * This function provides the backup_file attribute mutator for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ * @param  file  A reference to a File or String containing the path and name
+ *               of the backup file.
+ *
+ */
+VALUE setBackupFile(VALUE self, VALUE file)
+{
+   VALUE files = rb_hash_new();
+
+   if(TYPE(file) == T_FILE)
+   {
+      rb_hash_aset(files, rb_funcall(file, rb_intern("path"), 0), Qnil);
+   }
+   else
+   {
+      rb_hash_aset(files, rb_funcall(file, rb_intern("to_s"), 0), Qnil);
+   }
+   rb_iv_set(self, "@files", files);
+
+   return(self);
+}
+
+
+/**
+ * This function provides the database attribute accessor for the Backup class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  A reference to a String containing the path and name of the main
+ *          database file to be backed up.
+ *
+ */
+VALUE getBackupDatabase(VALUE self)
+{
+   return(rb_iv_get(self, "@database"));
+}
+
+
+/**
+ * This function provides the database attribute mutator for the Backup class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  A reference to a File or String containing the new path and
+ *                  name details of the main database file to be backed up.
+ *
+ * @return  A reference to the Backup object that has been updated.
+ *
+ */
+VALUE setBackupDatabase(VALUE self, VALUE setting)
+{
+   if(TYPE(setting) == T_FILE)
+   {
+      rb_iv_set(self, "@database", rb_funcall(setting, rb_intern("path"), 0));
+   }
+   else
+   {
+      rb_iv_set(self, "@database", rb_funcall(setting, rb_intern("to_s"), 0));
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the blocking_factor attribute accessor for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  A reference to the current backup blocking factor setting for the
+ *          Backup object.
+ *
+ */
+VALUE getBackupBlockingFactor(VALUE self)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   return(rb_hash_aref(options, INT2FIX(isc_spb_bkp_factor)));
+}
+
+
+/**
+ * This function provides the blocking_factor attribute mutator for the Backup
+ * class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  A reference to an integer containing the new blocking factor
+ *                  setting (in bytes).
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupBlockingFactor(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(rb_obj_is_kind_of(setting, rb_cInteger) == Qfalse)
+   {
+      rb_fireruby_raise(NULL, "Invalid blocking factor specified for Backup.");
+   }
+   rb_hash_aset(options, INT2FIX(isc_spb_bkp_factor), setting);
+
+   return(self);
+}
+
+
+/**
+ * This function provides the ignore_checksums attribute accessor for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  Either true or false.
+ *
+ */
+VALUE getBackupIgnoreChecksums(VALUE self)
+{
+   VALUE result  = Qfalse,
+         options = rb_iv_get(self, "@options"),
+         value   = rb_hash_aref(options, IGNORE_CHECKSUMS);
+
+   if(value != Qnil)
+   {
+      result = value;
+   }
+
+   return(result);
+}
+
+
+/**
+ * This function provides the ignore_checksums attribute mutator for the Backup
+ * class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  Either true or false. All other settings are ignored.
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupIgnoreChecksums(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(setting == Qtrue || setting == Qfalse)
+   {
+      rb_hash_aset(options, IGNORE_CHECKSUMS, setting);
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the ignore_limbo attribute accessor for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  Either true or false.
+ *
+ */
+VALUE getBackupIgnoreLimbo(VALUE self)
+{
+   VALUE result  = Qfalse,
+         options = rb_iv_get(self, "@options"),
+         value   = rb_hash_aref(options, IGNORE_LIMBO);
+
+   if(value != Qnil)
+   {
+      result = value;
+   }
+
+   return(result);
+}
+
+
+/**
+ * This function provides the ignore_limbo attribute mutator for the Backup
+ * class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  Either true or false. All other settings are ignored.
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupIgnoreLimbo(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(setting == Qtrue || setting == Qfalse)
+   {
+      rb_hash_aset(options, IGNORE_LIMBO, setting);
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the metadata_only attribute accessor for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  Either true or false.
+ *
+ */
+VALUE getBackupMetadataOnly(VALUE self)
+{
+   VALUE result  = Qfalse,
+         options = rb_iv_get(self, "@options"),
+         value   = rb_hash_aref(options, METADATA_ONLY);
+
+   if(value != Qnil)
+   {
+      result = value;
+   }
+
+   return(result);
+}
+
+
+/**
+ * This function provides the metadata_only attribute mutator for the Backup
+ * class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  Either true or false. All other settings are ignored.
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupMetadataOnly(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(setting == Qtrue || setting == Qfalse)
+   {
+      rb_hash_aset(options, METADATA_ONLY, setting);
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the garbage_collection attribute accessor for the
+ * Backup class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  Either true or false.
+ *
+ */
+VALUE getBackupGarbageCollect(VALUE self)
+{
+   VALUE result  = Qtrue,
+         options = rb_iv_get(self, "@options"),
+         value   = rb_hash_aref(options, NO_GARBAGE_COLLECT);
+
+   if(value != Qnil)
+   {
+      result = value;
+   }
+
+   return(result);
+}
+
+
+/**
+ * This function provides the garbage_collection attribute mutator for the
+ * Backup class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  Either true or false. All other settings are ignored.
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupGarbageCollect(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(setting == Qtrue || setting == Qfalse)
+   {
+      rb_hash_aset(options, NO_GARBAGE_COLLECT, setting);
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the non_transportable attribute accessor for the
+ * Backup class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  Either true or false.
+ *
+ */
+VALUE getBackupNonTransportable(VALUE self)
+{
+   VALUE result  = Qfalse,
+         options = rb_iv_get(self, "@options"),
+         value   = rb_hash_aref(options, NON_TRANSPORTABLE);
+
+   if(value != Qnil)
+   {
+      result = value;
+   }
+
+   return(result);
+}
+
+
+/**
+ * This function provides the non_transportable attribute mutator for the Backup
+ * class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  Either true or false. All other settings are ignored.
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupNonTransportable(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(setting == Qtrue || setting == Qfalse)
+   {
+      rb_hash_aset(options, NON_TRANSPORTABLE, setting);
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the convert_tables attribute accessor for the Backup
+ * class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  Either true or false.
+ *
+ */
+VALUE getBackupConvertTables(VALUE self)
+{
+   VALUE result  = Qfalse,
+         options = rb_iv_get(self, "@options"),
+         value   = rb_hash_aref(options, CONVERT_TABLES);
+
+   if(value != Qnil)
+   {
+      result = value;
+   }
+
+   return(result);
+}
+
+
+/**
+ * This function provides the convert_tables attribute mutator for the Backup
+ * class.
+ *
+ * @param  self     A reference to the Backup object to make the call on.
+ * @param  setting  Either true or false. All other settings are ignored.
+ *
+ * @return  A reference to the newly updated Backup object.
+ *
+ */
+VALUE setBackupConvertTables(VALUE self, VALUE setting)
+{
+   VALUE options = rb_iv_get(self, "@options");
+
+   if(setting == Qtrue || setting == Qfalse)
+   {
+      rb_hash_aset(options, CONVERT_TABLES, setting);
+   }
+
+   return(self);
+}
+
+
+/**
+ * This function provides the execute method for the Backup class.
+ *
+ * @param  self     A reference to the Backup object to be executed.
+ * @param  manager  A reference to the ServiceManager object that will be used
+ *                  to execute the backup.
+ *
+ * @return  A reference to the Backup object executed.
+ *
+ */
+VALUE executeBackup(VALUE self, VALUE manager)
+{
+   ManagerHandle *handle   = NULL;
+   short         length    = 0;
+   char          *buffer   = NULL;
+   ISC_STATUS    status[20];
+
+   /* Check that the service manager is connected. */
+   Data_Get_Struct(manager, ManagerHandle, handle);
+   if(handle->handle == 0)
+   {
+      rb_fireruby_raise(NULL,
+                        "Database backup error. Service manager not connected.");
+   }
+
+   createBackupBuffer(rb_iv_get(self, "@database"), rb_iv_get(self, "@files"),
+                      rb_iv_get(self, "@options"), &buffer, &length);
+
+   /* Start the service request. */
+   if(isc_service_start(status, &handle->handle, NULL, length, buffer))
+   {
+      free(buffer);
+      rb_fireruby_raise(status, "Error performing database backup.");
+   }
+   free(buffer);
+
+   /* Query the service until it has completed. */
+   rb_iv_set(self, "@log", queryService(&handle->handle));
+
+   return(self);
+}
+
+
+/**
+ * This function provides the log attribute accessor for the Backup class.
+ *
+ * @param  self  A reference to the Backup object to make the call on.
+ *
+ * @return  A reference to the current log attribute value.
+ *
+ */
+VALUE getBackupLog(VALUE self)
+{
+   return(rb_iv_get(self, "@log"));
+}
+
+
+/**
+ * This function creates a service parameter buffer for backup service
+ * requests.
+ *
+ * @param  from     A reference to a String containing the path and name of the
+ *                  database file to be backed up.
+ * @param  to       Either a reference to a String containing the path and name
+ *                  of the backup file or a hash matching file path/names to
+ *                  their permitted sizes.
+ * @param  options  A reference to a Hash containing the parameter options to
+ *                  be used.
+ * @param  buffer   A pointer that will be set to the generated parameter
+ *                  buffer.
+ * @param  length   A pointer to a short integer that will be assigned the
+ *                  length of buffer.
+ *
+ */
+void createBackupBuffer(VALUE from, VALUE to, VALUE options, char **buffer,
+                        short *length)
+{
+   ID    id        = rb_intern("key?");
+   VALUE names     = rb_funcall(to, rb_intern("keys"), 0),
+         sizes     = rb_funcall(to, rb_intern("values"), 0),
+         count     = rb_funcall(names, rb_intern("size"), 0);
+   char  *position = NULL;
+   short number,
+         flags     = 0,
+         extras    = 0,
+         blocking  = 0,
+         size      = TYPE(count) == T_FIXNUM ? FIX2INT(count) : NUM2INT(count),
+         i;
+
+   /* Check if extra options have been provided. */
+   if(TYPE(options) != T_NIL)
+   {
+      VALUE temp = rb_funcall(options, rb_intern("size"), 0);
+
+      extras = TYPE(temp) == T_FIXNUM ? FIX2INT(temp) : NUM2INT(temp);
+   }
+
+   /* Calculate the length needed for the buffer. */
+   *length = 2;
+   *length += strlen(STR2CSTR(from)) + 3;
+
+   /* Count file name and length sizes. */
+   for(i = 0; i < size; i++)
+   {
+      *length += strlen(STR2CSTR(rb_ary_entry(names, i))) + 3;
+      if(i != size - 1)
+      {
+         VALUE num = rb_funcall(rb_ary_entry(sizes, i), rb_intern("to_s"), 0);
+
+         *length += strlen(STR2CSTR(num)) + 3;
+      }
+   }
+
+   if(extras)
+   {
+      if(rb_funcall(options, id, 1, INT2FIX(isc_spb_bkp_factor)) == Qtrue)
+      {
+         *length += 5;
+         blocking = 1;
+      }
+
+      if(rb_funcall(options, id, 1, IGNORE_CHECKSUMS) == Qtrue ||
+         rb_funcall(options, id, 1, IGNORE_LIMBO) == Qtrue ||
+         rb_funcall(options, id, 1, METADATA_ONLY) == Qtrue ||
+         rb_funcall(options, id, 1, NO_GARBAGE_COLLECT) == Qtrue ||
+         rb_funcall(options, id, 1, NON_TRANSPORTABLE) == Qtrue ||
+         rb_funcall(options, id, 1, CONVERT_TABLES) == Qtrue)
+      {
+         *length += 5;
+         flags   = 1;
+      }
+   }
+
+   /* Allocate the buffer. */
+   *buffer = position = ALLOC_N(char, *length);
+   if(*buffer == NULL)
+   {
+      rb_raise(rb_eNoMemError,
+               "Memory allocation error preparing database back up.");
+   }
+   memset(*buffer, 0, *length);
+
+   /* Populate the buffer. */
+   *position++ = isc_action_svc_backup;
+
+   *position++ = isc_spb_dbname;
+   number      = strlen(STR2CSTR(from));
+   ADD_SPB_LENGTH(position, number);
+   memcpy(position, STR2CSTR(from), number);
+   position += number;
+
+   for(i = 0; i < size; i++)
+   {
+      VALUE name = rb_ary_entry(names, i);
+
+      *position++ = isc_spb_bkp_file;
+      number      = strlen(STR2CSTR(name));
+      ADD_SPB_LENGTH(position, number);
+      memcpy(position, STR2CSTR(name), number);
+      position += number;
+
+      if(i != size - 1)
+      {
+         VALUE max = rb_ary_entry(sizes, i);
+
+         max         = rb_funcall(max, rb_intern("to_s"), 0);
+         *position++ = isc_spb_bkp_length;
+         number      = strlen(STR2CSTR(max));
+         ADD_SPB_LENGTH(position, number);
+         memcpy(position, STR2CSTR(max), number);
+         position += number;
+      }
+   }
+
+   if(extras && blocking)
+   {
+      VALUE         key  = INT2FIX(isc_spb_bkp_factor),
+                    temp = rb_funcall(options, rb_intern("fetch"), 1, key);
+      unsigned long size = TYPE(temp) == T_FIXNUM ? FIX2INT(temp) : NUM2INT(temp);
+
+      *position++ = isc_spb_bkp_factor;
+      memcpy(position, &size, 4);
+      position += 4;
+   }
+
+   if(extras && flags)
+   {
+      unsigned long mask = 0;
+
+      if(rb_funcall(options, id, 1, IGNORE_CHECKSUMS) == Qtrue)
+      {
+         mask |= isc_spb_bkp_ignore_checksums;
+      }
+
+      if(rb_funcall(options, id, 1, IGNORE_LIMBO) == Qtrue)
+      {
+         mask |= isc_spb_bkp_ignore_limbo;
+      }
+
+      if(rb_funcall(options, id, 1, METADATA_ONLY) == Qtrue)
+      {
+         mask |= isc_spb_bkp_metadata_only;
+      }
+
+      if(rb_funcall(options, id, 1, NO_GARBAGE_COLLECT) == Qtrue)
+      {
+         mask |= isc_spb_bkp_no_garbage_collect;
+      }
+
+      if(rb_funcall(options, id, 1, NON_TRANSPORTABLE) == Qtrue)
+      {
+         mask |= isc_spb_bkp_non_transportable;
+      }
+
+      if(rb_funcall(options, id, 1, CONVERT_TABLES) == Qtrue)
+      {
+         mask |= isc_spb_bkp_convert;
+      }
+
+      *position++ = isc_spb_options;
+      memcpy(position, &mask, 4);
+      position += 4;
+   }
+
+   *position++ = isc_spb_verbose;
+}
+
+
+/**
+ * This function initialize the Backup class in the Ruby environment.
+ *
+ * @param  module  The module to create the new class definition under.
+ *
+ */
+void Init_Backup(VALUE module)
+{
+   cBackup = rb_define_class_under(module, "Backup", rb_cObject);
+   rb_define_method(cBackup, "initialize", initializeBackup, 2);
+   rb_define_method(cBackup, "backup_file", getBackupFile, 0);
+   rb_define_method(cBackup, "backup_file=", setBackupFile, 1);
+   rb_define_method(cBackup, "database", getBackupDatabase, 0);
+   rb_define_method(cBackup, "database=", setBackupDatabase, 1);
+   rb_define_method(cBackup, "blocking_factor", getBackupBlockingFactor, 0);
+   rb_define_method(cBackup, "blocking_factor=", setBackupBlockingFactor, 1);
+   rb_define_method(cBackup, "ignore_checksums", getBackupIgnoreChecksums, 0);
+   rb_define_method(cBackup, "ignore_checksums=", setBackupIgnoreChecksums, 1);
+   rb_define_method(cBackup, "ignore_limbo", getBackupIgnoreLimbo, 0);
+   rb_define_method(cBackup, "ignore_limbo=", setBackupIgnoreLimbo, 1);
+   rb_define_method(cBackup, "metadata_only", getBackupMetadataOnly, 0);
+   rb_define_method(cBackup, "metadata_only=", setBackupMetadataOnly, 1);
+   rb_define_method(cBackup, "garbage_collect", getBackupGarbageCollect, 0);
+   rb_define_method(cBackup, "garbage_collect=", setBackupGarbageCollect, 1);
+   rb_define_method(cBackup, "non_transportable", getBackupNonTransportable, 0);
+   rb_define_method(cBackup, "non_transportable=", setBackupNonTransportable, 1);
+   rb_define_method(cBackup, "convert_tables", getBackupConvertTables, 0);
+   rb_define_method(cBackup, "convert_tables=", setBackupConvertTables, 1);
+   rb_define_method(cBackup, "execute", executeBackup, 1);
+   rb_define_method(cBackup, "log", getBackupLog, 0);
+}