sgfa 0.1.0

data/lib/sgfa/binder_fs.rb

@@ -0,0 +1,203 @@
+#
+# Simple Group of Filing Applications
+# Binder implemented using filesystem storage and locking
+#
+# Copyright (C) 2015 by Graham A. Field.
+#
+# See LICENSE.txt for licensing information.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+require 'json'
+require 'tempfile'
+
+require_relative 'error'
+require_relative 'binder'
+require_relative 'jacket_fs'
+require_relative 'lock_fs'
+
+module Sgfa
+
+
+#####################################################################
+# An implementation of {Binder} using file system storage, {LockFs},
+# and {JacketFs}.
+class BinderFs < Binder
+
+  #####################################
+  # Create a new binder
+  #
+  # @param path [String] Path to the binder
+  # @param tr (see Binder#jacket_create)
+  # @param init [Hash] The binder initialization options
+  # @return [String] The hash ID of the new binder
+  def create(path, tr, init)
+    raise Error::Sanity, 'Binder already open' if @path
+    Binder.limits_create(init)
+
+    # create directory
+    begin
+      Dir.mkdir(path)
+    rescue Errno::EEXIST
+      raise Error::Conflict, 'Binder path already exists'
+    end
+
+    # create control binder
+    dn_ctrl = File.join(path, '0')
+    id_hash = JacketFs.create(dn_ctrl, init[:id_text])
+    jck = JacketFs.new(dn_ctrl)
+
+    # do the common creation
+    @path = path
+    @id_hash = id_hash
+    @jackets = {}
+    @users = {}
+    @values = {}
+    _create(jck, tr, init)
+    jck.close
+    _cache_write
+    @path = nil
+    @id_hash = nil
+
+    # write info
+    info = {
+      'sgfa_binder_ver' => 1,
+      'id_hash' => id_hash,
+      'id_text' => init[:id_text],
+    }
+    json = JSON.pretty_generate(info) + "\n"
+    fn_info = File.join(path, 'sgfa_binder.json')
+    File.open(fn_info, 'w', :encoding => 'utf-8'){|fi| fi.write json }
+    
+    return id_hash
+  end # def create()
+
+
+  #####################################
+  # Open a binder
+  # 
+  # @param path [String] Path to the binder
+  # @return [BinderFs] self
+  def open(path)
+    raise Error::Sanity, 'Binder already open' if @path
+
+    @lock = LockFs.new
+    begin
+      json = @lock.open(File.join(path, 'sgfa_binder.json'))
+    rescue Errno::ENOENT
+      raise Error::NonExistent, 'Binder does not exist'
+    end
+    begin
+      info = JSON.parse(json, :symbolize_names => true)
+    rescue JSON::NestingError, JSON::ParserError
+      @lock.close
+      @lock = nil
+      raise Error::Corrupt, 'Binder info corrupt'
+    end
+
+    @id_hash = info[:id_hash]
+    @id_text = info[:id_text]
+    @path = path.dup
+    
+    return self
+  end # def open()
+
+
+  #####################################
+  # Close the binder
+  #
+  # @return [BinderFs] self
+  def close()
+    raise Error::Sanity, 'Binder not open' if !@path
+    @lock.close
+    @lock = nil
+    @id_hash = nil
+    @id_text = nil
+    @path = nil
+    return self
+  end # def close()
+
+
+  #####################################
+  # Temporary file to write attachments to
+  #
+  # @return [Tempfile] Temporary file
+  def temp()
+    raise Error::Sanity, 'Binder not open' if !@path
+    Tempfile.new('blob', @path, :encoding => 'utf-8')
+  end # def temp()
+
+
+  private
+
+
+  #####################################
+  # Create a jacket
+  def _jacket_create(num)
+    jp = File.join(@path, num.to_s)
+    id_text = 'binder %s jacket %d %s' % 
+      [@id_hash, num, Time.now.utc.strftime('%F %T')]
+    id_hash = JacketFs.create(jp, id_text)
+    [id_text, id_hash]
+  end # def _jacket_create()
+
+
+  #####################################
+  # Open a jacket
+  def _jacket_open(num)
+    jck = JacketFs.new
+    jck.open(File.join(@path, num.to_s))
+    return jck
+  end # def _jacket_open()
+
+
+  #####################################
+  # Write cache
+  def _cache_write
+    jck = []
+    @jackets.each{|nam, hash| jck.push hash}
+    vals = []
+    @values.each{|val, sta| vals.push [val, sta]}
+    usrs = []
+    @users.each{|un, pl| usrs.push({name: un, perms: pl}) }
+    info = {
+      jackets: jck,
+      values: vals,
+      users: usrs,
+    }
+    json = JSON.pretty_generate(info) + "\n"
+    
+    fnc = File.join(@path, 'cache.json')
+    File.open(fnc, 'w', :encoding => 'utf-8'){|fi| fi.write json}
+  end # def _cache_write
+
+
+  #####################################
+  # Read cache
+  def _cache_read
+    fnc = File.join(@path, 'cache.json')
+    json = nil
+    info = nil
+    
+    begin
+      json = File.read(fnc, :encoding => 'utf-8')
+      info = JSON.parse(json, :symbolize_names => true)
+    rescue Error::ENOENT
+      raise Error::Corrupt, 'Binder cache does not exist'
+    rescue JSON::NestingError, JSON::ParserError
+      raise Error::Corrupt, 'Binder cache does not parse'
+    end
+
+    @jackets = {}
+    info[:jackets].each{|hash| @jackets[hash[:name]] = hash }
+    @users = {}
+    info[:users].each{|ha| @users[ha[:name]] = ha[:perms] }
+    @values = {}
+    info[:values].each{|val, sta| @values[val] = sta }
+  end # def _cache_read
+
+
+end # class BinderFS
+
+end # module Sgfa

data/lib/sgfa/cli/binder.rb

@@ -0,0 +1,160 @@
+#
+# Simple Group of Filing Applications
+# Command line interface for Binders
+#
+# Copyright (C) 2015 by Graham A. Field.
+#
+# See LICENSE.txt for licensing information.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+require 'thor'
+require 'json'
+
+require_relative '../binder_fs'
+require_relative '../demo/web_binders'
+require_relative '../demo/web_css'
+
+module Sgfa
+module Cli
+
+#####################################################################
+# Command line interface for {Sgfa::Binder}.  Currently it just supports
+# {Sgfa::BinderFs}.
+# 
+# @todo Needs to be fully implemented.  Currently just a shell.
+class Binder < Thor
+
+  class_option :fs_path, {
+    type: :string,
+    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
+  desc 'info', 'Get basic information about the binder'
+  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
+
+    # print info 
+    tr = {
+      perms: ['info']
+    }
+    info = bnd.binder_info(tr)
+    puts 'Text ID: %s' % info[:id_text]
+    puts 'Hash ID: %s' % info[:id_hash]
+    puts 'Values: %d' % info[:values].size
+    puts 'Jackets: %d' % info[:jackets].size
+    puts 'Users: %d' % info[:users].size
+
+    bnd.close
+  end # def info
+
+
+  #####################################
+  # create
+  desc 'create <id_text> <type_json>', 'Create a new Binder'
+  def create(id_text, init_json)
+
+    if !options[:fs_path]
+      puts 'Binder type and location required.'
+      return
+    end
+    bnd = ::Sgfa::BinderFs.new
+    tr = {
+      user: options[:user],
+      title: options[:title],
+      body: options[:body],
+    }
+    begin
+      init = JSON.parse(File.read(init_json), :symbolize_names => true)
+      init[:id_text] = id_text
+      bnd.create(options[:fs_path], tr, init)
+    rescue Errno::ENOENT
+      puts 'Binder type JSON file not found'
+      return
+    rescue JSON::JSONError
+      puts 'Binder type JSON file did not parse'
+      return
+    rescue ::Sgfa::Error::NonExistent, ::Sgfa::Error::Limits => exp
+      puts exp.message
+      return
+    end
+
+  end # def create()
+
+
+  #####################################
+  # web_demo
+  desc 'web_demo <css>', 'Run a demo web server'
+  method_option :addr, {
+    type: :string,
+    desc: 'Address to bind to',
+    default: 'localhost',
+  }
+  method_option :port, {
+    type: :numeric,
+    desc: 'Port to bind to',
+    default: '8888',
+  }
+  method_option :dir, {
+    type: :string,
+    desc: 'Path to the directory containing binders',
+    default: '.',
+  }
+  def web_demo(css)
+    begin
+      css_str = File.read(css)
+    rescue Errno::ENOENT
+      puts 'CSS file not found'
+      return
+    end
+
+    app_bnd = ::Sgfa::Demo::WebBinders.new(options[:dir], '/sgfa.css')
+    app_auth = Rack::Auth::Basic.new(app_bnd, 'Sgfa Demo'){|name, pass| true}
+    app_css = ::Sgfa::Demo::WebCss.new(css_str, '/sgfa.css', app_auth)
+
+    Rack::Handler::WEBrick.run(app_css, {
+      :Port => options[:port],
+      :BindAddress => options[:addr],
+      })
+
+  end # def web()
+
+end # class Binder
+
+end # module Cli
+end # module Sgfa

data/lib/sgfa/cli/jacket.rb

@@ -0,0 +1,299 @@
+#
+# Simple Group of Filing Applications
+# Command line interface for Jackets
+#
+# Copyright (C) 2015 by Graham A. Field.
+#
+# See LICENSE.txt for licensing information.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+require 'thor'
+
+require_relative '../jacket_fs'
+
+module Sgfa
+module Cli
+
+#####################################################################
+# Command line interface for {Sgfa::Jacket}.  Currently it just supports
+# {Sgfa::JacketFs}.
+# 
+# @todo Needs to be fully implemented.  Currently just a shell.
+class Jacket < Thor
+
+  class_option :fs_path, {
+    type: :string,
+    desc: 'Path to the jacket',
+  }
+
+  #####################################
+  # info
+  desc 'info', 'Get basic information about the jacket'
+  def info
+
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # print info
+    hst = jck.read_history
+    puts 'Text ID: %s' % jck.id_text
+    puts 'Hash ID: %s' % jck.id_hash
+    if hst
+      puts 'Entries: %d' % hst.entry_max
+      puts 'History: %d' % hst.history
+      puts 'Last edit: %s' % hst.time_str
+    else
+      puts 'No history.'
+    end
+    jck.close
+
+  end # def info
+
+
+  #####################################
+  # Print Entry
+  desc 'entry <e-spec>', 'Print entry'
+  method_option :hash, {
+    type: :boolean,
+    desc: 'Display the entry hash or not',
+    default: false,
+  }
+  def entry(spec)
+
+    # get entry and revision nums
+    ma = /^\s*(\d+)(-(\d+))?\s*$/.match(spec)
+    if !ma
+      puts "Entry e-spec must be match format x[-y]\n" +
+        "Where x is the entry number and y is the optional revision number."
+      return
+    end
+    enum = ma[1].to_i
+    rnum = (ma.length == 4) ? ma[3].to_i : 0
+
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # read
+    begin
+      ent = jck.read_entry(enum, rnum)
+    rescue ::Sgfa::Error::NonExistent => exp
+      puts exp.message
+      return
+    end
+    jck.close
+
+    # display
+    tags = ent.tags.join("\n           ")
+    atts = ent.attachments.map{|anum, hnum, hash|
+      '%d-%d-%d %s' % [enum, anum, hnum, hash]}.join("\n           ")
+    if options[:hash]
+      puts "Hash     : %s" % ent.hash
+    end
+    puts "Title    : %s" % ent.title
+    puts "Date/Time: %s" % ent.time.localtime.strftime("%F %T %z")
+    puts "Revision : %d" % ent.revision
+    puts "History  : %d" % ent.history
+    puts "Tags     : %s" % tags
+    puts "Files    : %s" % atts
+    puts "Body     :\n%s" % ent.body
+
+  end # def entry()
+
+
+  #####################################
+  # Display History
+  desc 'history [<hnum>]', 'Display the current or specified History'
+  method_option :hash, {
+    type: :boolean,
+    desc: 'Display the entry hash or not',
+    default: false,
+  }
+  def history(hspec='0')
+
+    # get history num
+    ma = /^\s*(\d+)\s*$/.match(hspec)
+    if !ma
+      hnum = 0
+    else
+      hnum = ma[1].to_i
+    end
+
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # read history
+    begin
+      hst = jck.read_history(hnum)
+    rescue ::Sgfa::Error::NonExistent => exp
+      puts exp.message
+      return
+    end
+    jck.close
+
+    # display
+    hnum = hst.history
+    puts "Hash      : %s" % hst.hash if options[:hash]
+    puts "Previous  : %s" % hst.previous if options[:hash]
+    puts "History   : %d" % hnum
+    puts "Date/Time : %s" % hst.time.localtime.strftime("%F %T %z")
+    puts "User      : %s" % hst.user
+    hst.entries.each do |enum, rnum, hash|
+      puts "Entry     : %d-%d %s" % [enum, rnum, hash]
+    end
+    hst.attachments.each do |enum, anum, hash|
+      puts "Attachment: %d-%d-%d %s" % [enum, anum, hnum, hash]
+    end
+
+  end # def history()
+
+
+  #####################################
+  # Output attachment
+  desc 'attach <a-spec>', 'Output attachment'
+  method_option :output, {
+    type: :string,
+    desc: 'Output file',
+    required: true
+  }
+  def attach(aspec)
+
+    # get attachment spec
+    ma = /^\s*(\d+)-(\d+)-(\d+)\s*$/.match(aspec)
+    if !ma
+      puts "Attachment specification is x-y-z\n" +
+        "x = entry number\ny = attachment number\nz = history number"
+      return
+    end
+    enum, anum, hnum = ma[1,3].map{|st| st.to_i }
+
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # read attachment
+    begin
+      fi = jck.read_attach(enum, anum, hnum)
+    rescue ::Sgfa::Error::NonExistent => exp
+      puts exp.message
+      return
+    end
+    jck.close
+
+    # output
+    begin
+      out = File.open(options[:output], 'wb')
+    rescue
+      fi.close
+      puts "Unable to open output file"
+      return
+    end
+
+    # copy
+    IO.copy_stream(fi, out)
+    fi.close
+    out.close
+
+  end # def attach()
+
+
+  #####################################
+  # Check jacket
+  desc 'check', 'Checks jacket history chain'
+  method_option :max, {
+    type: :numeric,
+    desc: 'Maximum history to check',
+  }
+  method_option :min, {
+    type: :numeric,
+    desc: 'Minimum history to check',
+  }
+  method_option :hash, {
+    type: :string,
+    desc: 'Known good hash of maximum history',
+  }
+  method_option :entry, {
+    type: :boolean,
+    desc: 'Hash entries and validate',
+    default: true,
+  }
+  method_option :attach, {
+    type: :boolean,
+    desc: 'Hash attachments and validate',
+    default: false,
+  }
+  method_option :missing, {
+    type: :numeric,
+    desc: 'Number of missing history items to check',
+    default: 0,
+  }
+  method_option :level, {
+    type: :string,
+    desc: 'Debug level, "debug", "info", "warn", "error"',
+    default: 'error',
+  }
+  def check
+
+    # open jacket
+    jck = _open_jacket
+    return if !jck
+
+    # options
+    opts = {}
+    log = Logger.new(STDOUT)
+    opts[:log] = log
+    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
+    opts[:hash_entry] = options[:entry]
+    opts[:hash_attach] = options[:attach]
+    opts[:miss_history] = options[:missing]
+    opts[:max_history] = options[:max] if options[:max]
+    opts[:min_history] = options[:min] if options[:min]
+    opts[:max_hash] = options[:hash] if options[:hash]
+
+    # check
+    jck.check(opts)
+    jck.close
+
+  end # def check()
+
+
+
+  private
+
+
+  #####################################
+  # Open the jacket
+  def _open_jacket()
+    if !options[:fs_path]
+      puts 'Jacket type and location required.'
+      return false
+    end
+
+    begin
+      jck = ::Sgfa::JacketFs.new(options[:fs_path])
+    rescue ::Sgfa::Error::NonExistent, ::Sgfa::Error::Limits => exp
+      puts exp.message
+      return false
+    end
+
+    return jck
+  end # def _open_jacket
+
+
+end # class Jacket
+
+end # module Cli
+end # module Sgfa

data/lib/sgfa/cli.rb

@@ -0,0 +1,36 @@
+#
+# Simple Group of Filing Applications
+# Command line interface tool
+#
+# Copyright (C) 2015 by Graham A. Field.
+#
+# See LICENSE.txt for licensing information.
+#
+# This program is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+require 'thor'
+
+require_relative 'cli/jacket'
+require_relative 'cli/binder'
+
+module Sgfa
+
+#####################################################################
+# Command line interface for Sgfa tools
+module Cli
+
+#####################################################################
+# Top level CLI
+class Sgfa < Thor
+
+  desc 'jacket ...', 'Jacket CLI tools'
+  subcommand 'jacket', Jacket
+
+  desc 'binder ...', 'Binder CLI tools'
+  subcommand 'binder', Binder
+
+end # class Sgfa
+
+end # module Cli
+end # module Sgfa