haveapi-fs 0.1.0

data/lib/haveapi/fs/factory.rb

@@ -0,0 +1,59 @@
+module HaveAPI::Fs
+  # The Factory is used to create instances of new components and can be used
+  # to replace specific components by different ones, thus allowing to change
+  # their behaviour.
+  class Factory
+    class << self
+      # @!attribute replacements
+      #   @return [Hash] collection of all replacements
+      attr_accessor :replacements
+
+      # Replace a component class by a different class. This method has two
+      # forms. Either call it with a hash of replacements or with two arguments,
+      # where the first is the class to be replaced and the second the class
+      # to replace it with.
+      def replace(*args)
+        @replacements ||= {}
+
+        if args.size == 2
+          @replacements[args[0]] = args[1]
+
+        else
+          @replacements.update(args.first)
+        end
+      end
+
+      # Resolves the class for component `klass`, i.e. it checks if there is a
+      # replacement for `klass` to return instead.
+      #
+      # @return [Class]
+      def component(klass)
+        if @replacements && @replacements.has_key?(klass)
+          @replacements[klass]
+
+        else
+          klass
+        end
+      end
+
+      # Create a new component with `klass` and its constructor's arguments
+      # in `args`.
+      #
+      # @param [HaveAPI::Fs::Context] context
+      # @param [Symbol] name
+      # @param [Class] klass
+      # @param [Array] args
+      # @return [Component]
+      def create(context, name, klass, *args)
+        child = component(klass).new(*args)
+        c_name = klass.component || klass.name.split('::').last.underscore.to_sym
+
+        child.context = context.clone
+        child.context[c_name] = child
+        child.context.file_path << name.to_s if name
+        child.setup
+        child
+      end
+    end
+  end
+end

data/lib/haveapi/fs/fs.rb

@@ -0,0 +1,198 @@
+require 'thread'
+require 'rfusefs'
+require 'haveapi/client'
+
+module HaveAPI::Fs
+  # Interface with RFuseFS API. Methods called by RFuseFS are redirected to
+  # appropriate components.
+  class Fs
+    CHECK_FILE = FuseFS::Fuse::Root::CHECK_FILE[1..-1].to_sym
+
+    attr_reader :api
+
+    def initialize(api, opts)
+      @api = api
+
+      @mutex = Mutex.new
+
+      @path_cache = Cache.new(self)
+      @context = Context.new
+      @context.opts = opts
+      @context.url = opts[:device]
+      @context.mountpoint = ::File.realpath(opts[:mountpoint])
+      @context.cache = @path_cache
+      @context[:fs] = self
+
+      @root = Factory.create(@context, nil, Components::Root)
+#      @root.context = @context.clone
+#      @root.context[:root] = @root
+      @root.setup
+
+      Thread.abort_on_exception = true
+      @cleaner = Cleaner.new(self, @root)
+      @cleaner.start
+      @path_cache.start
+    end
+
+    def contents(path)
+      puts "contents"
+      p path
+
+      guard { find_component(path).contents }
+    end
+
+    def directory?(path)
+      puts "directory?"
+      p path
+    
+      guard { find_component(path).directory? }
+    end
+
+    def file?(path)
+      puts "file?"
+      p path
+    
+      guard {find_component(path).file? }
+    end
+
+    def can_read?(path)
+      puts "can_read?"
+      p path
+
+      guard { find_component(path).readable? }
+    end
+
+    def can_write?(path)
+      puts "can_write?"
+      p path
+
+      guard { find_component(path).writable? }
+    end
+
+    def executable?(path)
+      puts "executable?"
+      p path
+
+      guard { find_component(path).executable? }
+    end
+
+    def times(path)
+      puts "times"
+      p path
+
+      guard { find_component(path).times }
+    end
+
+    def size(path)
+      puts "size"
+      p path
+    
+      guard { find_component(path).size }
+    end
+
+    def read_file(path)
+      puts "read_file"
+      p path
+    
+      guard { find_component(path).read }
+    end
+
+    def write_to(path, str)
+      puts "write_to"
+      p path
+
+      guard { find_component(path).write(str) }
+    end
+
+    def raw_open(path, *args)
+      puts "raw_open"
+      p path
+
+      guard { find_component(path).raw_open(path, *args) }
+    end
+
+    def raw_read(path, *args)
+      puts "raw_read"
+      p path
+
+      guard { find_component(path).raw_read(path, *args) }
+    end
+
+    def raw_write(path, *args)
+      puts "raw_write"
+      p path
+
+      guard { find_component(path).raw_write(path, *args) }
+    end
+
+    def raw_sync(path, *args)
+      puts "raw_sync"
+      p path
+
+      guard { find_component(path).raw_sync(path, *args) }
+    end
+
+    def raw_truncate(path, *args)
+      puts "raw_truncate"
+      p path
+
+      guard { find_component(path).raw_truncate(path, *args) }
+    end
+    
+    def raw_close(path, *args)
+      puts "raw_close"
+      p path
+
+      guard { find_component(path).raw_close(path, *args) }
+    end
+
+    def unmounted
+      puts "unmounted"
+
+      @cleaner.stop
+      @path_cache.stop
+    end
+
+    def synchronize
+      @mutex.synchronize { yield }
+    end
+
+    protected
+    def find_component(path)
+      @path_cache.get(path) do
+        t = Time.now
+
+        names = path.split('/').map { |v| v.to_sym }[1..-1]
+        tmp = @root
+
+        next(tmp) unless names
+
+        names.each do |n|
+          tmp = tmp.find(n)
+          
+          if tmp.nil?
+            raise Errno::ENOENT, "'#{path}' not found"
+
+          else
+            tmp.atime = t
+          end
+        end
+
+        next(tmp)
+      end
+    end
+
+    def guard
+      synchronize { yield }
+
+    rescue => e
+      raise e if e.is_a?(::SystemCallError)
+
+      warn "Exception #{e.class}"
+      warn e.backtrace.join("\n")
+      warn e.message
+
+      raise Errno::EIO, e.message
+    end
+  end
+end

data/lib/haveapi/fs/help.rb

@@ -0,0 +1,91 @@
+module HaveAPI::Fs
+  # Included this module to a {Component} to provide help files. All components
+  # based on {Components::Directory} already have this module included.
+  module Help
+    # When searching for a help file, all directories in this list are checked.
+    # Add paths to this list for help files of third-party components.
+    SEARCH_PATH = [
+        ::File.realpath(::File.join(
+            ::File.dirname(__FILE__),
+            '..', '..', '..',
+            'templates',
+            'help',
+        ))
+    ]
+
+    module ClassMethods
+      # Specify a name of a help file for this component. By default, the class
+      # name is used.
+      # @param [Symbol, nil] name
+      # @return [Symbol] if name is nil
+      def help_file(name = nil)
+        if name
+          @help_file = name
+
+        else
+          @help_file
+        end
+      end
+    end
+
+    module InstanceMethods
+      protected
+      # List of help files in all formats as symbols.
+      # @return [Array<Symbol>]
+      def help_files
+        %i(html txt md man).map { |v| :"help.#{v}" }
+      end
+
+      # List of help files in all formats as strings.
+      # @return [Array<String>]
+      def help_contents
+        help_files.map(&:to_s)
+      end
+
+      # Check if `name` is a help file.
+      # @param [Symbol] name
+      def help_file?(name)
+        help_files.include?(name)
+      end
+
+      # @return [Components::HelpFile] the recipe for a subclass, as
+      #                                {Component#new_child}
+      def help_file(name)
+        format = name.to_s.split('.').last.to_sym
+
+        case format
+        when :html
+          [Components::HtmlHelpFile, self, format]
+
+        when :txt, :md
+          [Components::MdHelpFile, self, :md]
+
+        when :man
+          [Components::GroffHelpFile, self, :md]
+
+        else
+          return nil
+        end
+      end
+    end
+
+    class << self
+      def included(klass)
+        klass.send(:extend, ClassMethods)
+        klass.send(:include, InstanceMethods)
+      end
+
+      # Search for `name` in paths defined in {SEARCH_PATH}.
+      # @return [String]
+      def find!(name)
+        SEARCH_PATH.each do |s|
+          path = ::File.join(s, name)
+
+          return path if ::File.exists?(path)
+        end
+
+        raise Errno::ENOENT, "help file '#{name}' not found"
+      end
+    end
+  end
+end

data/lib/haveapi/fs/main.rb

@@ -0,0 +1,134 @@
+require 'uri'
+require 'yaml'
+
+module HaveAPI::Fs
+  # A list of accepted mount options
+  OPTIONS = %i(api version auth_method user password token nodaemonize log
+                index_limit)
+  USAGE = <<END
+    version=VERSION        API version to use
+    auth_method=METHOD     Authentication method (basic, token, noauth)
+    user                   Username
+    password               Password
+    token                  Authentication token
+    nodaemonize            Stay in the foreground
+    log                    Enable logging while daemonized
+    index_limit=LIMIT      Limit number of objects in resource directory
+END
+
+
+  # Every authentication provider must register using this method.
+  # @param [Symbol] name
+  # @param [Class] klass
+  def self.register_auth(name, klass)
+    @auth_methods ||= {}
+    @auth_methods[name] = klass
+  end
+
+  # Return authentication method based on mount options or return the default
+  # one.
+  # @param [Hash] opts mount options
+  # @param [Symbol] default name of the default authentication method
+  def self.auth_method(opts, default)
+    return @auth_methods[opts[:auth_method].to_sym] if opts[:auth_method]
+
+    @auth_methods.each_value do |m|
+      return m if m.use?(opts)
+    end
+
+    default ? @auth_methods[default] : @auth_methods.values.first
+  end
+
+  # @return [Hash] if the config exists
+  # @return [nil] if the config does not exist
+  def self.read_config
+    config_path = "#{Dir.home}/.haveapi-client.yml"
+
+    if File.exists?(config_path)
+      YAML.load_file(config_path)
+
+    else
+      nil
+    end
+  end
+
+  # Return configuration of a particular server from the config hash.
+  # @param [String] url URL of the API server
+  def self.server_config(url)
+    cfg = read_config
+    return nil if cfg.nil? || cfg[:servers].nil?
+
+    cfg[:servers].detect { |s| s[:url] == url }
+  end
+
+  # Perform a double-fork to make the process independent. Stdout and stderr
+  # are redirected either to a log file or to /dev/null.
+  #
+  # @param [Hash] opts mount options
+  def self.daemonize(opts)
+    home = ::File.join(Dir.home, '.haveapi-fs', URI(opts[:device]).host)
+    FileUtils.mkpath(home)
+    
+    pid = Process.fork
+
+    if pid
+      exit # Parent 1
+
+    else
+      pid = Process.fork
+      exit if pid # Parent 2
+    end
+
+    # Only the child gets here
+    STDIN.close
+    
+    f = File.open(
+        opts[:log] ? File.join(home, 'haveapi-fs.log') : '/dev/null',
+        'w'
+    )
+
+    STDOUT.reopen(f)
+    STDERR.reopen(f)
+  end
+
+  # Create and setup an instance of HaveAPI::Client::Client based on the mount
+  # options, calls self.daemonize if not configured otherwise.
+  #
+  # @param [Hash] opts mount options
+  # @return [HaveAPI::Client::Client]
+  def self.client(opts)
+    cfg = server_config(opts[:device])
+    client = HaveAPI::Client::Client.new(
+        opts[:device],
+        opts[:version],
+        identity: 'haveapi-fs',
+    )
+
+    auth_klass = auth_method(opts, cfg && cfg[:last_auth])
+
+    auth = auth_klass.new(
+        (cfg && cfg[:auth][auth_klass.method_name]) || {},
+        opts,
+    )
+    auth.validate
+    auth.authenticate(client)
+
+    # Fetch API description, must be done especially after authentication
+    client.setup
+
+    # Verify that authentication works
+    auth.check(client)
+
+    daemonize(opts) unless opts[:nodaemonize]
+    client
+  end
+
+  # Calls FuseFS.main with an instance of {HaveAPI::Fs::Fs}.
+  def self.main(options = OPTIONS, usage = USAGE)
+    FuseFS.main(ARGV, OPTIONS, USAGE, 'api_url') do |opts|
+      fail "provide argument 'api_url'" unless opts[:device]
+
+      HaveAPI::Fs.new(client(opts), opts)
+    end
+  end
+end

data/lib/haveapi/fs/remote_control.rb

@@ -0,0 +1,29 @@
+module HaveAPI::Fs
+  # The purpose of this class is to handle commands received via the
+  # {Components::RemoteControlFile}.
+  class RemoteControl
+    # Call method #exec of a component at `path`.
+    #
+    # @param [Context] context
+    # @param [String] path
+    def self.execute(context, path)
+      c = context.fs.send(:find_component, path)
+
+      ret = c.exec
+
+      case ret
+      when true
+        {status: true}
+
+      when HaveAPI::Client::Response
+        {status: ret.ok?, message: ret.message, errors: ret.errors}
+
+      when HaveAPI::Client::ValidationError
+        {status: false, message: ret.message, errors: ret.errors}
+
+      else
+        {status: false, message: 'unknown response'}
+      end
+    end
+  end
+end

data/lib/haveapi/fs/version.rb

@@ -0,0 +1,5 @@
+module HaveAPI
+  module Fs
+    VERSION = '0.1.0'
+  end
+end

data/lib/haveapi/fs/worker.rb

@@ -0,0 +1,77 @@
+require 'thread'
+
+module HaveAPI::Fs
+  # Base class for classes that perform some regular work in a separate thread.
+  class Worker
+    attr_reader :runs
+
+    # @param [HaveAPI::Fs::Fs] fs
+    def initialize(fs)
+      @fs = fs
+      @run = true
+      @pipe_r, @pipe_w = IO.pipe
+      @runs = 0
+      @mutex = Mutex.new
+    end
+
+    # Start the work thread.
+    def start
+      @thread = Thread.new do
+        @mutex.synchronize { @next_time = Time.now + start_delay }
+        wait(start_delay)
+
+        while @run do
+          @fs.synchronize { work }
+
+          @runs += 1
+          @mutex.synchronize do
+            @last_time = Time.now
+            @next_time = @last_time + work_period
+          end
+
+          wait(work_period)
+        end
+      end
+    end
+
+    # Stop and join the work thread.
+    def stop
+      @run = false
+      @pipe_w.write('CLOSE')
+      @thread.join
+
+      @pipe_r.close
+      @pipe_w.close
+    end
+
+    # The time when the work method was last run.
+    def last_time
+      @mutex.synchronize { @last_time }
+    end
+
+    # The time when the work method will be run next.
+    def next_time
+      @mutex.synchronize { @next_time }
+    end
+
+    protected
+    def wait(n)
+      IO.select([@pipe_r], [], [], n)
+    end
+
+    # @return [Integer] number of seconds to wait before the first work
+    def start_delay
+      raise NotImplementedError
+    end
+
+    # @return [Integer] number of seconds to wait between working
+    def work_period
+      raise NotImplementedError
+    end
+    
+    # This method is regularly called to perform the work.
+    def work
+      raise NotImplementedError
+    end
+  end
+end

data/lib/haveapi/fs.rb

@@ -0,0 +1,65 @@
+module HaveAPI
+  module Fs
+    module Auth ; end
+
+    def self.new(*args)
+      HaveAPI::Fs::Fs.new(*args)
+    end
+  end
+end
+
+require_relative '../core_ext/string'
+require_relative 'fs/main'
+require_relative 'fs/fs'
+require_relative 'fs/context'
+require_relative 'fs/worker'
+require_relative 'fs/cleaner'
+require_relative 'fs/cache'
+require_relative 'fs/component'
+require_relative 'fs/factory'
+require_relative 'fs/help'
+require_relative 'fs/remote_control'
+require_relative 'fs/version'
+require_relative 'fs/auth/base'
+require_relative 'fs/auth/basic'
+require_relative 'fs/auth/token'
+require_relative 'fs/auth/noauth'
+require_relative 'fs/components/directory'
+require_relative 'fs/components/file'
+require_relative 'fs/components/executable'
+require_relative 'fs/components/remote_control_file'
+require_relative 'fs/components/directory_reset'
+require_relative 'fs/components/root'
+require_relative 'fs/components/resource_dir'
+require_relative 'fs/components/index_filter'
+require_relative 'fs/components/resource_instance_dir'
+require_relative 'fs/components/save_instance'
+require_relative 'fs/components/resource_action_dir'
+require_relative 'fs/components/action_dir'
+require_relative 'fs/components/create_action_dir'
+require_relative 'fs/components/delete_action_dir'
+require_relative 'fs/components/update_action_dir'
+require_relative 'fs/components/action_input'
+require_relative 'fs/components/action_output'
+require_relative 'fs/components/list_item'
+require_relative 'fs/components/action_status'
+require_relative 'fs/components/action_message'
+require_relative 'fs/components/action_errors'
+require_relative 'fs/components/action_exec'
+require_relative 'fs/components/action_exec_edit'
+require_relative 'fs/components/parameter'
+require_relative 'fs/components/resource_id'
+require_relative 'fs/components/help_file'
+require_relative 'fs/components/html_help_file'
+require_relative 'fs/components/md_help_file'
+require_relative 'fs/components/groff_help_file'
+require_relative 'fs/components/instance_create'
+require_relative 'fs/components/instance_edit'
+require_relative 'fs/components/unsaved_list'
+require_relative 'fs/components/component_list'
+require_relative 'fs/components/meta_dir'
+require_relative 'fs/components/meta_file'
+require_relative 'fs/components/info_files'
+require_relative 'fs/components/cache_stats'
+require_relative 'fs/components/pry'
+require_relative 'fs/components/rfuse_check'

data/templates/help/html/action_dir.erb

@@ -0,0 +1,33 @@
+<p><%= @c.action.description %></p>
+<h2>Contents</h2>
+<p>
+This directory is used to prepare input parameters, execute the action and retrieve
+output parameters.
+</p>
+<dl>
+    <dt><a href="input/help.html">input/</a></dt>
+    <dd>Stage area for input parameters.</dd>
+
+    <dt><a href="output/help.html">output/</a></dt>
+    <dd>Contains output parameters after the action was executed.</dd>
+
+    <dt>exec</dt>
+    <dd>Write <code>1</code> to this file to execute the action.</dd>
+
+    <dt>exec.yml</dt>
+    <dd>Editable YAML file with input parameters. The action is executed when the file
+        is saved and closed.</dd>
+    
+    <dt>status</dt>
+    <dd>Read action status. <code>1</code> if successful, <code>0</code> if not, empty
+        if not yet run.</dd>
+
+    <dt>message</dt>
+    <dd>Error message returned from the API.</dd>
+
+    <dt><a href="errors/help.html">errors/</a></dt>
+    <dd>List of parameter errors.</dd>
+
+    <dt>reset</dt>
+    <dd>Reset input parameters.</dd>
+</dl>

data/templates/help/html/action_errors.erb

@@ -0,0 +1,4 @@
+<p>
+This directory contains a list of errors for every parameter, where a parameter
+is represented by a file, one error per line.
+</p>