haveapi-fs 0.1.0

data/lib/haveapi/fs/component.rb

@@ -0,0 +1,237 @@
+module HaveAPI::Fs
+  # All built-in components are stored in this module.
+  module Components ; end
+
+  # The basic building block of the file system. Every directory and file is
+  # represented by a subclass of this class.
+  class Component
+    # An encapsulation of a Hash to store child components.
+    class Children
+      attr_accessor :context
+
+      # @param [HaveAPI::Fs::Context] ctx
+      def initialize(ctx)
+        @context = ctx
+        @store = {}
+      end
+
+      def [](k)
+        @store[k]
+      end
+
+      # Replace a child named `k` by a new child represented by `v`. The old
+      # child, if present, is invalidated and dropped from the cache.
+      # {Factory} is used to create an instance of `v`.
+      # 
+      # @param [Symbol] k
+      # @param [Array] v
+      def []=(k, v)
+        if @store.has_key?(k)
+          @store[k].invalidate
+          @store[k].context.cache.drop_below(@store[k].path)
+        end
+
+        @store[k] = Factory.create(@context, k, *v)
+      end
+
+      def set(k, v)
+        @store[k] = v
+      end
+
+      %i(has_key? clear each select detect delete_if).each do |m|
+        define_method(m) do |*args, &block|
+          @store.send(m, *args, &block)
+        end
+      end
+    end
+
+    class << self
+      # Define reader methods for child components.
+      def children_reader(*args)
+        args.each do |arg|
+          define_method(arg) { children[arg] }
+        end
+      end
+
+      # Set or get a component name. Component name is used for finding
+      # components within a {Context}.
+      #
+      # @param [Symbol] name
+      # @return [nil] if name is set
+      # @return [Symbol] if name is nil
+      def component(name = nil)
+        if name
+          @component = name
+
+        else
+          @component
+        end
+      end
+
+      # Pass component name to the subclass.
+      def inherited(subclass)
+        subclass.component(@component)
+      end
+    end
+
+    attr_accessor :context, :atime, :mtime, :ctime
+
+    # @param [Boolean] bound
+    def initialize(bound: false)
+      @bound = bound
+      @atime = @mtime = @ctime = Time.now
+    end
+
+    # Called by {Factory} when the instance is prepared. Subclasses must call
+    # this method.
+    def setup
+      @children = Children.new(context)
+    end
+
+    # Attempt to find a child component with `name`.
+    #
+    # @return [HaveAPI::Fs::Component] if found
+    # @return [nil] if not found
+    def find(name)
+      return @children[name] if @children.has_key?(name)
+      c = new_child(name)
+
+      @children.set(name, Factory.create(context, name, *c)) if c
+    end
+
+    # Attempt to find and use nested components with `names`. Each name is for
+    # the next descendant. If the target component is found, it and all
+    # components in its path will be bound. Bound components are not
+    # automatically deleted when not in use.
+    def use(*names)
+      ret = self
+      path = []
+
+      names.each do |n|
+        ret = ret.find(n)
+        return if ret.nil?
+        path << ret
+      end
+
+      path.each { |c| c.bound = true }
+
+      ret
+    end
+
+    def bound?
+      @bound
+    end
+
+    def bound=(b)
+      @bound = b
+    end
+
+    def directory?
+      !file?
+    end
+
+    def file?
+      !directory?
+    end
+
+    def readable?
+      true
+    end
+
+    def writable?
+      false
+    end
+
+    def executable?
+      false
+    end
+
+    def contents
+      raise NotImplementedError
+    end
+
+    def times
+      [@atime, @mtime, @ctime]
+    end
+
+    # Shortcut for {#drop_children} and {#setup}.
+    def reset
+      drop_children
+      setup
+    end
+
+    def title
+      self.class.name
+    end
+
+    # @return [String] path of this component in the tree without the leading /
+    def path
+      context.file_path.join('/')
+    end
+
+    # @return [String] absolute path of this component from the system root
+    def abspath
+      File.join(
+          context.mountpoint,
+          path
+      )
+    end
+
+    def parent
+      context.object_path[-2][1]
+    end
+
+    # A component is unsaved if it or any of its descendants has been modified
+    # and not saved.
+    #
+    # @param [Integer] n used to determine the result just once per the same `n`
+    # @return [Boolean]
+    def unsaved?(n = nil)
+      return @is_unsaved if n && @last_unsaved == n
+
+      child = @children.detect { |_, c| c.unsaved? }
+
+      @last_unsaved = n
+      @is_unsaved = !child.nil?
+    end
+
+    # Mark the component and all its descendats as invalid. Invalid components
+    # can still be in the cache and are dropped on hit.
+    def invalidate
+      @invalid = true
+
+      children.each { |_, c| c.invalidate }
+    end
+
+    def invalid?
+      @invalid
+    end
+
+    protected
+    attr_accessor :children
+
+    # Called to create a component for a child with `name` if this child is not
+    # yet or not anymore in memory. All subclasses should extend this method to
+    # add their own custom contents.
+    #
+    # @param [Symbol] name
+    # @return [Array] the array describes the new child to be created by
+    #                 {Factory}. The first item is a class name and
+    #                 the rest are arguments to its constructor.
+    # @return [nil] if the child does not exist
+    def new_child(name)
+      raise NotImplementedError
+    end
+
+    # Drop all children from the memory and clear them from the cache.
+    def drop_children
+      @children.clear
+      context.cache.drop_below(path)
+    end
+
+    # Update the time of last modification.
+    def changed
+      self.mtime = Time.now
+    end
+  end
+end

data/lib/haveapi/fs/components/action_dir.rb

@@ -0,0 +1,106 @@
+module HaveAPI::Fs::Components
+  class ActionDir < Directory
+    component :action_dir
+    attr_reader :resource, :action
+    children_reader :status, :input, :output
+
+    def initialize(resource, action)
+      super()
+      
+      @resource = resource
+      @action = action
+    end
+
+    def setup
+      super
+
+      children[:status] = [ActionStatus, self, bound: true]
+      children[:message] = [ActionMessage, self, bound: true]
+      children[:errors] = [ActionErrors, self, bound: true]
+      children[:input] = [ActionInput, self, bound: true]
+      children[:output] = [ActionOutput, self, bound: true]
+      children[:exec] = [ActionExec, self, bound: true]
+      children[:reset] = [DirectoryReset, bound: true]
+    end
+
+    def contents
+      ret = super + %w(input output status message errors exec reset)
+      ret << 'exec.yml' if @action.input_params.any?
+      ret
+    end
+
+    def exec(meta: {})
+      @action.provide_args(*@resource.prepared_args)
+      ret = HaveAPI::Client::Response.new(
+          @action,
+          @action.execute(
+              children[:input].values.update({meta: meta})
+          )
+      )
+
+      children[:status].set(ret.ok?)
+
+      if ret.ok?
+        case @action.output_layout
+        when :object
+          res = HaveAPI::Client::ResourceInstance.new(
+              @resource.instance_variable_get('@client'),
+              @resource.instance_variable_get('@api'),
+              @resource,
+              action: @action,
+              response: ret,
+          )
+
+        when :object_list
+          res = HaveAPI::Client::ResourceInstanceList.new(
+              @resource.instance_variable_get('@client'),
+              @resource.instance_variable_get('@api'),
+              @resource,
+              @action,
+              ret,
+          )
+
+        else
+          res = ret
+        end
+
+        children[:output].data = res
+
+      else
+        children[:message].set(ret.message)
+        children[:errors].set(ret.errors)
+      end
+      
+      ret
+
+    rescue HaveAPI::Client::ValidationError => e
+      children[:status].set(false)
+      children[:message].set(e.message)
+      children[:errors].set(e.errors)
+      e
+
+    rescue HaveAPI::Client::ActionFailed => e
+      children[:status].set(false)
+      children[:message].set(e.response.message)
+      children[:errors].set(e.response.errors)
+      e.response
+    end
+
+    def title
+      @action.name.capitalize
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+
+      elsif name == :'exec.yml' && @action.input_params.any?
+        [ActionExecEdit, self]
+
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/haveapi/fs/components/action_errors.rb

@@ -0,0 +1,49 @@
+module HaveAPI::Fs::Components
+  class ActionErrors < Directory
+    component :action_errors
+
+    class ActionError < File
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def read
+        @errors.join("\n") + "\n"
+      end
+    end
+
+    def initialize(action_dir, *args)
+      super(*args)
+      @action_dir = action_dir
+    end
+
+    def contents
+      ret = super
+      return ret unless @errors
+      ret.concat(@errors.keys.map(&:to_s))
+      ret
+    end
+
+    def set(errors)
+      changed
+      @errors = errors
+    end
+
+    def title
+      'Errors'
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+
+      elsif @errors && @errors.has_key?(name)
+        [ActionError, @errors[name]]
+
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/haveapi/fs/components/action_exec.rb

@@ -0,0 +1,12 @@
+module HaveAPI::Fs::Components
+  class ActionExec < Executable
+    def initialize(action_dir, *args)
+      super(*args)
+      @action_dir = action_dir
+    end
+
+    def exec
+      @action_dir.exec
+    end
+  end
+end

data/lib/haveapi/fs/components/action_exec_edit.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+
+module HaveAPI::Fs::Components
+  class ActionExecEdit < File
+    def initialize(action_dir)
+      super()
+      @action_dir = action_dir
+    end
+
+    def writable?
+      true
+    end
+
+    def read
+      ret = header + "\n"
+
+      @action_dir.action.input_params.each do |name, p|
+        param_file = @action_dir.find(:input).find(name)
+
+        if param_file.set?
+          v = param_file.new_value
+        
+        elsif p[:default].nil?
+          v = nil
+
+        else
+          v = p[:default]
+        end
+
+        ret += "# #{p[:label]}; #{p[:type]}\n"
+        ret += "# #{p[:description]}\n"
+        ret += "# Defaults to '#{p[:default]}'\n" unless p[:default].nil?
+
+        if p[:required] || param_file.set?
+          ret += "#{name}: #{v}"
+
+        else
+          ret += "##{name}: #{v}"
+        end
+
+        ret += "\n\n"
+      end
+
+      ret
+    end
+
+    def write(str)
+      return if str.strip.empty?
+
+      data = YAML.load(str)
+      raise Errno::EIO, 'invalid yaml document' unless data.is_a?(::Hash)
+      return unless save?(data)
+
+      params = @action_dir.action.input_params
+
+      data.each do |k, v|
+        p = @action_dir.find(:input).find(k.to_sym)
+        next if p.nil?
+
+        # Type coercion is done later by the client during action call
+        p.write_safe(v)
+      end
+
+      save
+    end
+
+    def header
+      <<END
+# This file is in YAML format. Lines beginning with a hash (#) are comments and
+# are ignored. The action will be executed once this file is saved and closed.
+# The success of this operation can be later checked in
+# actions/#{@action_dir.action.name}/status.
+# 
+# Only required parameters that need to be set are uncommented by default.
+# Parameters that are not specified when this file is closed will not be sent
+# to the API.
+#
+# To cancel the operation, either do not save the file or save it empty.
+END
+    end
+
+    def save?(data)
+      true
+    end
+
+    def save
+      @action_dir.exec
+    end
+  end
+end

data/lib/haveapi/fs/components/action_input.rb

@@ -0,0 +1,40 @@
+module HaveAPI::Fs::Components
+  class ActionInput < Directory
+    component :action_input
+    attr_reader :action_dir
+
+    def initialize(action_dir, *args)
+      super(*args)
+      @action_dir = action_dir
+    end
+
+    def contents
+      super + parameters.keys.map(&:to_s)
+    end
+
+    def parameters
+      @action_dir.action.input_params
+    end
+
+    def values
+      Hash[children.select { |n, c| c.is_a?(Parameter) && c.set? }.map { |n, c| [n, c.value] }]
+    end
+
+    def title
+      'Input parameters'
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+
+      elsif @action_dir.action.input_params.has_key?(name)
+        [Parameter, @action_dir.action, name, :input]
+
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/haveapi/fs/components/action_message.rb

@@ -0,0 +1,19 @@
+module HaveAPI::Fs::Components
+  class ActionMessage < File
+    def initialize(action_dir, *args)
+      super(*args)
+      @action_dir = action_dir
+    end
+
+    def read
+      ret = @msg.to_s
+      ret += "\n" unless ret.empty?
+      ret
+    end
+
+    def set(msg)
+      changed
+      @msg = msg
+    end
+  end
+end

data/lib/haveapi/fs/components/action_output.rb

@@ -0,0 +1,79 @@
+module HaveAPI::Fs::Components
+  class ActionOutput < Directory
+    component :action_output
+    attr_reader :action_dir
+    attr_accessor :data
+
+    def initialize(action_dir, *args)
+      super(*args)
+
+      @action_dir = action_dir
+
+      if %i(hash_list object_list).include?(@action_dir.action.output_layout.to_sym)
+        @list = true
+      end
+    end
+
+    def contents
+      ret = super
+
+      return ret unless @data
+
+      if @list
+        if @data.is_a?(HaveAPI::Client::ResourceInstanceList)
+          ret.concat(@data.map { |v| v.id.to_s })
+
+        else
+          ret.concat(@data.response.map { |v| v[:id].to_s })
+        end
+
+      else
+        ret.concat(parameters.keys.map(&:to_s))
+      end
+
+      ret
+    end
+
+    def parameters
+      @action_dir.action.params
+    end
+
+    def title
+      'Output parameters'
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+      
+      elsif !@data
+        nil
+
+      elsif @list
+        id = name.to_s.to_i
+        
+        if @data.is_a?(HaveAPI::Client::ResourceInstanceList)
+          param = @data.detect { |v| v.id == id }
+          [ResourceInstanceDir, param]
+
+        else
+          param = @data.response.detect { |v| v[:id] == id }
+          [ListItem, @action_dir.action, :output, param]
+        end
+
+      elsif @action_dir.action.params.has_key?(name)
+        [
+            Parameter,
+            @action_dir.action,
+            name,
+            :output,
+            @data.is_a?(HaveAPI::Client::ResourceInstance) ? @data : @data.response,
+        ]
+
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/haveapi/fs/components/action_status.rb

@@ -0,0 +1,32 @@
+module HaveAPI::Fs::Components
+  class ActionStatus < File
+    def initialize(action_dir, *args)
+      super(*args)
+      @action_dir = action_dir
+      @v = nil
+    end
+
+    def read
+      value.to_s + "\n"
+    end
+
+    def set(v)
+      changed
+      @v = v
+    end
+
+    protected
+    def value
+      case @v
+      when true
+        1
+
+      when false
+        0
+
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/haveapi/fs/components/cache_stats.rb

@@ -0,0 +1,19 @@
+module HaveAPI::Fs::Components
+  class CacheStats < File
+    def read
+      c = context.cache
+
+      {
+          size: c.size,
+          hits: c.hits,
+          misses: c.misses,
+          invalid: c.invalid,
+          drops: c.drops,
+          hitratio: (c.hits.to_f / (c.hits + c.misses + c.invalid) * 100).round(2),
+          sweeps: c.runs,
+          last_sweep: (c.last_time && c.last_time.iso8601) || '-',
+          next_sweep: c.next_time.iso8601,
+      }.map { |k, v| sprintf('%-15s %s', "#{k}:", v) }.join("\n") + "\n"
+    end
+  end
+end

data/lib/haveapi/fs/components/component_list.rb

@@ -0,0 +1,24 @@
+module HaveAPI::Fs::Components
+  class ComponentList < File
+    def read
+      str = component_list.map do |c|
+        sprintf('%-50s %s', c.class.name, c.path)
+      end.join("\n")
+      str += "\n" unless str.empty?
+      str
+    end
+
+    protected
+    def component_list(component = nil)
+      component ||= parent
+      ret = []
+
+      component.send(:children).each do |_, c|
+        ret << c
+        ret.concat(component_list(c))
+      end
+
+      ret
+    end
+  end
+end