sgfa 0.1.0 → 0.1.1

data/lib/sgfa/cli/binder.rb

@@ -31,25 +31,6 @@ class Binder < Thor
     desc: 'Path to the binder',
   }
 
-  class_option :user, {
-    type: :string,
-    desc: 'User name.',
-    default: Etc.getpwuid(Process.euid).name,
-  }
-
-  class_option :body, {
-    type: :string,
-    desc: 'Body of an entry.',
-    default: '!! No body provided using CLI tool !!',
-  }
-
-  class_option :title, {
-    type: :string,
-    desc: 'Title of an entry.',
-    default: '!! No title provided using CLI tool !!',
-  }
-
-
 
   #####################################
   # info
@@ -57,17 +38,7 @@ class Binder < Thor
   def info
 
     # open binder
-    if !options[:fs_path]
-      puts 'Binder type and location required.'
-      return
-    end
-    bnd = ::Sgfa::BinderFs.new
-    begin
-      bnd.open(options[:fs_path])
-    rescue ::Sgfa::Error::Limits, ::Sgfa::Error::NonExistent => exp
-      puts exp.message
-      return
-    end
+    return if !(bnd = _open_binder)
 
     # print info 
     tr = {
@@ -87,6 +58,21 @@ class Binder < Thor
   #####################################
   # create
   desc 'create <id_text> <type_json>', 'Create a new Binder'
+  method_option :user, {
+    type: :string,
+    desc: 'User name.',
+    default: Etc.getpwuid(Process.euid).name,
+  }
+  method_option :body, {
+    type: :string,
+    desc: 'Body of an entry.',
+    default: '!! No body provided using CLI tool !!',
+  }
+  method_option :title, {
+    type: :string,
+    desc: 'Title of an entry.',
+    default: '!! No title provided using CLI tool !!',
+  }
   def create(id_text, init_json)
 
     if !options[:fs_path]
@@ -152,7 +138,238 @@ class Binder < Thor
       :BindAddress => options[:addr],
       })
 
-  end # def web()
+  end # def web_demo()
+
+
+  #####################################
+  # Backup to AWS S3
+  desc 'backup_s3', 'Backup to AWS S3'
+  method_option :key, {
+    type: :string,
+    desc: 'Path of AWS credentials',
+    required: true,
+  }
+  method_option :bucket, {
+    type: :string,
+    desc: 'S3 bucket name',
+    required: true,
+  }
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  method_option :last, {
+    desc: 'Last backup state file name',
+    type: :string,
+  }
+  method_option :save, {
+    desc: 'Save backup state to file name',
+    type: :string,
+  }
+  def backup_s3()
+
+    return if !(aws = _get_aws)
+    return if !(bnd = _open_binder)
+    log = _get_log
+    last = _get_last
+    s3 = ::Aws::S3::Client.new(aws)
+    sto = ::Sgfa::StoreS3.new
+    sto.open(s3, options[:bucket])
+    last = bnd.backup_push(sto, prev: last, log: log)
+    bnd.close
+    sto.close
+    _put_last(last)
+
+  end # def backup_s3() 
+
+
+  #####################################
+  # Restore from AWS S3
+  desc 'restore_s3 <id_text>', 'Restore from AWS S3'
+  method_option :key, {
+    type: :string,
+    desc: 'Path of AWS credentials',
+    required: true,
+  }
+  method_option :bucket, {
+    type: :string,
+    desc: 'S3 bucket name',
+    required: true,
+  }
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  def restore_s3(id_text)
+    if !options[:fs_path]
+      puts 'Binder type and location required.'
+     return
+    end
+    return if !(aws = _get_aws)
+    log = _get_log
+    s3 = ::Aws::S3::Client.new(aws)
+    sto = ::Sgfa::StoreS3.new
+    sto.open(s3, options[:bucket])
+    bnd = ::Sgfa::BinderFs.new
+    bnd.create_raw(options[:fs_path], id_text)
+    bnd.open(options[:fs_path])
+    bnd.backup_pull(sto, log: log)
+    bnd.close
+    sto.close
+  end # def restore_s3() 
+
+
+  #####################################
+  # backup to filesystem
+  desc 'backup_fs <dir>', 'Backup to file system'
+  method_option :last, {
+    desc: 'Last backup state file name',
+    type: :string,
+  }
+  method_option :save, {
+    desc: 'Save backup state to file name',
+    type: :string,
+  }
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  def backup_fs(dest)
+    return if !(bnd = _open_binder)
+    log = _get_log
+    last = _get_last
+    sto = ::Sgfa::StoreFs.new
+    sto.open(dest)
+    last = bnd.backup_push(sto, prev: last, log: log)
+    bnd.close
+    sto.close
+    _put_last(last)
+  end # def backup_fs()
+
+  
+  #####################################
+  # Restore from filesystem
+  desc 'restore_fs <id_text> <backup_store>', 'Restore from file system'
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  def restore_fs(id_text, bak)
+    if !options[:fs_path]
+      puts 'Binder type and location required.'
+     return
+    end
+    sto = ::Sgfa::StoreFs.new
+    sto.open(bak)
+    log = _get_log
+    bnd = ::Sgfa::BinderFs.new
+    bnd.create_raw(options[:fs_path], id_text)
+    bnd.open(options[:fs_path])
+    bnd.backup_pull(sto, log: log)
+    bnd.close
+    sto.close
+  end # def restore_fs()
+
+
+  no_commands do
+
+
+  # Open the binder
+  def _open_binder()
+    # open binder
+    if !options[:fs_path]
+      puts 'Binder type and location required.'
+      return false
+    end
+    bnd = ::Sgfa::BinderFs.new
+    begin
+      bnd.open(options[:fs_path])
+    rescue ::Sgfa::Error::Limits, ::Sgfa::Error::NonExistent => exp
+      puts exp.message
+      return false
+    end
+    return bnd
+  end # def _open_binder()
+
+
+  # get the log
+  def _get_log
+    log = Logger.new(STDOUT)
+    case options[:level]
+      when 'debug'
+        log.level = Logger::DEBUG
+      when 'info'
+        log.level = Logger::INFO
+      when 'warn'
+        log.level = Logger::WARN
+      else
+        log.level = Logger::ERROR
+    end
+    return log
+  end # def _get_log
+
+
+  # Get AWS creds
+  def _get_aws
+    json = File.read(options[:key])
+    creds = JSON.parse(json)
+    opts = {
+      region: creds['aws_region'],
+      access_key_id: creds['aws_id'],
+      secret_access_key: creds['aws_key'],
+    }
+    return opts
+
+  rescue Errno::ENOENT
+    puts 'AWS keys file not found'
+    return false
+
+  rescue Errno::EACCESS
+    puts 'AWS key file permission denied'
+    return false
+
+  rescue JSON::JSONError
+    puts 'AWS key file JSON parse error'
+    return false
+  end # def get_aws
+
+
+  # Get last option
+  def _get_last()
+    return {} if !options[:last]
+    json = File.read(options[:last])
+    last = JSON.parse(json)
+    return last
+  rescue Errno::ENOENT
+    puts "Last backup state file not found"
+    exit
+  rescue Errno::EACCESS
+    puts "Access denied to last backup state file"
+    exit
+  rescue JSON::JSONError
+    puts "Last backup state file parse failed"
+    exit
+  end # def _get_last()
+  private :_get_last
+
+
+  # Save last
+  def _put_last(last)
+    return if !options[:save]
+    json = JSON.pretty_generate(last) + "\n"
+    File.open(options[:save], 'w', :encoding => 'utf-8'){|fi| fi.write json}
+  rescue Errno::EACCESS
+    puts "Access denied to backup state file"
+    exit
+  end # def _put_last()
+  private :_put_last
+
+  end
+
 
 end # class Binder
 

data/lib/sgfa/cli/jacket.rb

@@ -9,9 +9,13 @@
 # This program is distributed WITHOUT ANY WARRANTY; without even the
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
+require 'csv'
+
+require 'aws-sdk'
 require 'thor'
 
 require_relative '../jacket_fs'
+require_relative '../store_s3'
 
 module Sgfa
 module Cli
@@ -270,6 +274,208 @@ class Jacket < Thor
   end # def check()
 
 
+  #####################################
+  # Get stats
+  desc 'stats', 'Get stats for each entry in csv format'
+  method_option :header, {
+    type: :boolean,
+    desc: 'Include a header row',
+    default: true
+  }
+  method_option :title, {
+    type: :boolean,
+    desc: 'Include the entry title',
+    default: false
+  }
+  method_option :time, {
+    type: :boolean,
+    desc: 'Include the entry date and time',
+    default: false
+  }
+  method_option :output, {
+    type: :string,
+    desc: 'File name for CSV, if not provided, STDOUT is used'
+  }   
+  def stats()
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    do_time = options[:time]
+    do_title = options[:title]
+
+    # CSV setup
+    if options[:output]
+      csv = ::CSV.open(options[:output], 'w', :encoding => 'utf-8')
+    else
+      csv = ::CSV.new(STDOUT, :encoding => 'utf-8')
+    end
+
+    # do the header row
+    if options[:header]
+      ha = [
+        'Stat name',
+        'Value', 
+        'Account',
+        'Entry',
+        'Revision'
+      ]
+      ha.push 'Date Time' if do_time
+      ha.push 'Title' if do_title
+      csv << ha
+    end
+
+    # read each entry and provide stats
+    hst = jck.read_history
+    hst.entry_max.times do |ix|
+      enum = ix + 1
+      ent = jck.read_entry(enum)
+      stats = ent.stats
+      next if stats.empty?
+
+      rnum = ent.revision
+      time = ent.time_str if do_time
+      title = ent.title if do_title
+
+      stats.each do |stat|
+        typ, val, accts = stat
+        if accts.empty?
+          ln = [typ, val, nil, enum, rnum]
+          ln.push time if do_time
+          ln.push title if do_title
+          csv << ln
+          next
+        end
+        accts.each do |acct|
+          ln = [typ, val, acct, enum, rnum]
+          ln.push time if do_time
+          ln.push title if do_title
+          csv << ln
+        end
+      end
+    end
+
+    jck.close
+    csv.close
+
+  end # def stats()
+
+
+  #####################################
+  # Backup to aws
+  desc 'backup_s3', 'Backup to AWS S3'
+  method_option :key, {
+    type: :string,
+    desc: 'Path of AWS credentials',
+    required: true,
+  }
+  method_option :bucket, {
+    type: :string,
+    desc: 'S3 bucket name',
+    required: true,
+  }
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  def backup_s3()
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # read in JSON config
+    json = File.read(options[:key])
+    creds = JSON.parse(json)
+    opts = {
+      region: creds['aws_region'],
+      access_key_id: creds['aws_id'],
+      secret_access_key: creds['aws_key'],
+    }
+    log = Logger.new(STDOUT)
+    case options[:level]
+      when 'debug'
+        log.level = Logger::DEBUG
+      when 'info'
+        log.level = Logger::INFO
+      when 'warn'
+        log.level = Logger::WARN
+      else
+        log.level = Logger::ERROR
+    end
+
+    puts 'id: %s' % creds['aws_id']
+    puts 'secret: %s' % creds['aws_key']
+    puts 'bucket: %s' % options[:bucket]
+    
+    # client
+    s3 = ::Aws::S3::Client.new(opts)
+    sto = ::Sgfa::StoreS3.new
+    sto.open(s3, options[:bucket])
+    
+    # backup
+    jck.backup(sto, log: log)
+    jck.close
+
+  end # def backup_s3()
+
+
+  #####################################
+  # Restore from AWS S3
+  desc 'restore_s3', 'Backup to AWS S3'
+  method_option :key, {
+    type: :string,
+    desc: 'Path of AWS credentials',
+    required: true,
+  }
+  method_option :bucket, {
+    type: :string,
+    desc: 'S3 bucket name',
+    required: true,
+  }
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  def restore_s3()
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # read in JSON config
+    json = File.read(options[:key])
+    creds = JSON.parse(json)
+    opts = {
+      region: creds['aws_region'],
+      access_key_id: creds['aws_id'],
+      secret_access_key: creds['aws_key'],
+    }
+    log = Logger.new(STDOUT)
+    case options[:level]
+      when 'debug'
+        log.level = Logger::DEBUG
+      when 'info'
+        log.level = Logger::INFO
+      when 'warn'
+        log.level = Logger::WARN
+      else
+        log.level = Logger::ERROR
+    end
+
+    puts 'id: %s' % creds['aws_id']
+    puts 'secret: %s' % creds['aws_key']
+    puts 'bucket: %s' % options[:bucket]
+
+    # client
+    s3 = ::Aws::S3::Client.new(opts)
+    sto = ::Sgfa::StoreS3.new
+    sto.open(s3, options[:bucket])
+
+    # backup
+    jck.restore(sto, log: log)
+    jck.close
+  end # def restore_s3
 
   private