haveapi-fs 0.1.0

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

@@ -0,0 +1,92 @@
+require 'yaml'
+
+module HaveAPI::Fs::Components
+  # This file serves as an IPC between the file system and outer processes,
+  # mainly executables from the file system itself.
+  #
+  # It does not behave like a regular file, it's more like a local socket.
+  # The process opens the file, writes a message with a command and then reads
+  # a message with a response.
+  #
+  # Messages are formatted in YAML and separated by {MSG_DELIMITER}.
+  class RemoteControlFile < File
+    MSG_DELIMITER = "\nMSG_OVER\n"
+
+    class FileHandle
+      attr_accessor :read_buf
+      attr_accessor :write_buf
+
+      def initialize
+        @read_buf = ''
+        @write_buf = ''
+      end
+
+      def read(offset, size)
+        @read_buf[offset, size]
+      end
+
+      def write(offset, size, buf)
+        @write_buf[offset, size] = buf
+      end
+
+      def complete?
+        @write_buf.end_with?(MSG_DELIMITER)
+      end
+
+      def parse
+        cmd = YAML.load(@write_buf[0..(-1 - MSG_DELIMITER.size)])
+        @write_buf.clear
+        cmd
+      end
+    end
+
+    def writable?
+      true
+    end
+
+    def size
+      # The size limits the maximum amount of data that can be read from this file
+      4096
+    end
+
+    def raw_open(path, mode, rfusefs = nil)
+      FileHandle.new
+    end
+
+    def raw_read(path, offset, size, handle = nil)
+      handle.read(offset, size)
+    end
+
+    def raw_write(path, offset, size, buf, handle = nil)
+      handle.write(offset, size, buf)
+
+      if handle.complete?
+        cmd = handle.parse
+
+        case cmd[:action]
+        when :execute
+          ret = HaveAPI::Fs::RemoteControl.execute(context, cmd[:path])
+
+        else
+          raise Errno::EIO, "unsupported action '#{cmd[:action]}'"
+        end
+
+        handle.read_buf = YAML.dump(ret)
+      end
+
+      size
+    end
+
+    def raw_sync(path, datasync, handle = nil)
+      nil
+    end
+
+    def raw_truncate(path, offset, handle = nil)
+      true
+    end
+    
+    def raw_close(path, handle = nil)
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module HaveAPI::Fs::Components
+  class ResourceActionDir < Directory
+    component :resource_action_dir
+    attr_reader :resource
+
+    def initialize(r)
+      @resource = r
+      @instance = r.is_a?(HaveAPI::Client::ResourceInstance)
+
+      super()
+    end
+
+    def contents
+      super + relevant_actions.map(&:to_s)
+    end
+
+    def relevant_actions
+      return @actions if @actions
+      @actions = []
+
+      @resource.actions.each do |name, a|
+        pos = a.url.index(":#{@resource._name}_id")
+
+        if @instance
+          cond = pos
+
+        else
+          cond = pos.nil?
+        end
+
+        @actions << name if cond
+      end
+
+      @actions
+    end
+
+    def instance?
+      @instance
+    end
+
+    def title
+      'Actions'
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+      
+      elsif @resource.actions.has_key?(name)
+        klass = case name
+        when :create
+          CreateActionDir
+
+        when :update
+          instance? ? UpdateActionDir : ActionDir
+
+        when :delete
+          DeleteActionDir
+
+        else
+          ActionDir
+        end
+        
+        [klass, @resource, @resource.actions[name]]
+
+      else
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+module HaveAPI::Fs::Components
+  class ResourceDir < Directory
+    component :resource_dir
+    attr_reader :resource
+
+    def initialize(resource)
+      super()
+      @resource = resource
+    end
+
+    def setup
+      super
+      @index = use(:actions, :index)
+      @data = nil
+    end
+
+    def contents
+      load_contents if @index && (!@data || @refresh)
+
+      ret = super + %w(actions) + subresources.map(&:to_s)
+      ret.concat(@data.map { |v| v.id.to_s }) if @data
+      ret << 'create.yml' if find(:actions).find(:create)
+
+      if @index
+        ret.concat(@index.action.input_params.keys.map { |v| "by-#{v}" })
+      end
+
+      ret
+    end
+
+    def refresh
+      @refresh = true
+    end
+
+    def delete(id)
+      return unless @data
+      i = @data.index { |v| v.id == id }
+      @data.delete_at(i) if i
+    end
+
+    def title
+      "Resource #{@resource._name.to_s.capitalize}"
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+      
+      elsif name == :actions
+        [ResourceActionDir, @resource]
+
+      elsif subresources.include?(name)
+        [ResourceDir, @resource.send(name)]
+
+      elsif /^\d+$/ =~ name
+        id = name.to_s.to_i
+
+        if @data
+          r = @data.detect { |v| v.id == id }
+          [ResourceInstanceDir, r] if r
+
+        else
+          # The directory contents have not been loaded yet. We don't necessarily
+          # need to load it all, a single query should be sufficient.
+          begin
+            obj = @resource.show(id, meta: meta_params)
+            [ResourceInstanceDir, obj]
+
+          rescue HaveAPI::Client::ActionFailed
+            # Not found
+          end
+        end
+
+      elsif name == :'create.yml' && create_dir = use(:actions, :create)
+        [InstanceCreate, create_dir]
+      
+      elsif @index && name.to_s.start_with?('by-')
+        by_param = name.to_s[3..-1].to_sym
+        return nil unless @index.action.input_params.has_key?(by_param)
+
+        [IndexFilter, self, by_param]
+
+      else
+        nil
+      end
+    end
+
+    def subresources
+      return @subresources if @subresources
+      @subresources = []
+
+      @resource.resources.each do |r_name, r|
+        r.actions.each do |a_name, a|
+          if a.url.index(":#{@resource._name}_id").nil?
+            @subresources << r_name
+            break
+          end
+        end
+      end
+
+      @subresources
+    end
+
+    def meta_params
+      {
+          includes: @resource.actions[:show].params.select do |n, p|
+            p[:type] == 'Resource'
+          end.map do |n, p|
+            n
+          end.join(',')
+      }
+    end
+
+    def load_contents
+      if context.opts[:index_limit] && file = @index.find(:input).find(:limit)
+        limit = context.opts[:index_limit].to_i
+        v = file.value
+        param = @index.action.input_params[:limit]
+
+        if (!v && !param[:default]) \
+            || (v && v > limit) \
+            || (param[:default] && param[:default] > limit)
+          file.write_safe(limit)
+        end
+      end
+
+      @index.exec(meta: meta_params)
+      new_data = @index.output.data
+
+      if @data
+        current_map = id_map(@data)
+        res = []
+
+        new_data.each do |v|
+          if current_map.has_key?(v.id)
+            # TODO: if old object is not modified, use the new object instead
+            res << current_map[v.id]
+
+          else
+            res << v
+          end
+        end
+
+        @data = res
+
+      else
+        @data = new_data
+      end
+
+      changed
+      @refresh = false
+    end
+
+    def id_map(list)
+      ret = {}
+      list.each { |v| ret[v.id] = v }
+      ret
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module HaveAPI::Fs::Components
+  class ResourceId < Parameter
+    def initialize(resource_dir, *args)
+      super(*args)
+
+      @resource_dir = resource_dir
+    end
+
+    def write(str)
+      super(str)
+
+      @resource_dir.replace_association(@name, value)
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+module HaveAPI::Fs::Components
+  class ResourceInstanceDir < ResourceDir
+    component :resource_instance_dir
+
+    def setup
+      super
+     
+      @show = use(:actions, :show)
+      @update = use(:actions, :update)
+      children[:save] = [SaveInstance, self, bound: true] if @update
+
+      # Disable object listing from ResourceDir.contents
+      @index = false
+    end
+
+    def contents
+      ret = super - %w(create.yml)
+      ret.concat(attributes)
+      ret.concat(%w(save edit.yml)) if @update
+      ret
+    end
+
+    def save
+      ret = @update.exec
+      self.mtime = Time.now
+      ret
+    end
+
+    def replace_association(name, id)
+      return unless children.has_key?(name)
+
+      children[name].invalidate
+      context.cache.drop_below(path)
+
+      @resource.send("#{name}_id=", id)
+      children[name] = [ResourceInstanceDir, @resource.send(name)]
+    end
+
+    def update_association(name)
+      children[name].invalidate
+      context.cache.drop_below(path)
+
+      children[name] = [ResourceInstanceDir, @resource.send(name)]
+    end
+
+    def subresources
+      return @subresources if @subresources
+      @subresources = []
+
+      @resource.resources.each do |r_name, r|
+        r.actions.each do |a_name, a|
+          if a.url.index(":#{@resource._name}_id")
+            @subresources << r_name
+            break
+          end
+        end
+      end
+
+      @subresources
+    end
+
+    def attributes
+      ret = []
+      params = @resource.actions[:show].params
+
+      @resource.attributes.each do |k, v|
+        next if k == :_meta
+
+        if params[k][:type] == 'Resource'
+          ret << "#{k}_id"
+          ret << k.to_s if v
+
+        else
+          ret << k.to_s
+        end
+      end
+
+      ret
+    end
+
+    def title
+      "#{@resource._name.to_s.capitalize} ##{@resource.id}"
+    end
+
+    protected
+    def new_child(name)
+      if child = Directory.instance_method(:new_child).bind(self).call(name)
+        child
+      
+      elsif name == :actions
+        [ResourceActionDir, @resource]
+
+      elsif subresources.include?(name)
+        [ResourceDir, @resource.send(name)]
+
+      elsif @resource.attributes.has_key?(name)
+        if @show.action.params[name][:type] == 'Resource'
+          instance = @resource.send(name)
+
+          if instance
+            [ResourceInstanceDir, instance]
+
+          else
+            nil
+          end
+
+        else
+          editable = @update.nil? ? false : @update.action.input_params.has_key?(name)
+
+          [
+              Parameter,
+              @resource.actions[:show],
+              name,
+              :output,
+              @resource,
+              editable: editable,
+              mirror: editable && @update.find(:input).find(name),
+          ]
+        end
+
+      elsif name.to_s.end_with?('_id')
+        real_name = name[0..-4].to_sym
+        return nil unless @resource.attributes.has_key?(real_name)
+
+        editable = @update.nil? ? false : @update.action.input_params.has_key?(real_name)
+
+        [
+            ResourceId,
+            self,
+            @resource.actions[:show],
+            real_name,
+            :output,
+            @resource,
+            editable: editable,
+            mirror: editable && @update.find(:input).find(real_name),
+        ]
+
+      elsif name == :'edit.yml' && @update
+        [InstanceEdit, @update]
+
+      else
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module HaveAPI::Fs::Components
+  class RFuseCheck < File ; end
+end

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

@@ -0,0 +1,75 @@
+module HaveAPI::Fs::Components
+  # The root of the filesystem. There is only one instance of this object.
+  #
+  # This directory contains some special hidden files:
+  #  
+  #  - `.remote_control` is used for IPC between the file system and executables
+  #  - `.cache` contains some statistics about the cache
+  #  - `.assets/` contains static files for HTML help files
+  class Root < Directory
+    component :root
+    
+    def initialize()
+      super()
+    end
+
+    def setup
+      super
+      @api = context.fs.api
+    end
+
+    def contents
+      super + %w(.client_version .fs_version .protocol_version) + \
+        @api.resources.keys.map(&:to_s)
+    end
+
+    def resources
+      @api.resources
+    end
+
+    def title
+      context.url
+    end
+
+    protected
+    def new_child(name)
+      if child = super
+        child
+      
+      elsif @api.resources.has_key?(name)
+        [ResourceDir, @api.resources[name]]
+
+      else
+        case name
+        when :'.remote_control'
+          RemoteControlFile
+
+        when :'.assets'
+          [
+              MetaDir, 
+              ::File.join(
+                  ::File.realpath(::File.dirname(__FILE__)),
+                  '..', '..', '..', '..',
+                  'assets'
+              ),
+          ]
+
+        when :'.client_version'
+          ClientVersion
+
+        when :'.fs_version'
+          FsVersion
+
+        when :'.protocol_version'
+          ProtocolVersion
+
+        when :'.cache'
+          CacheStats
+
+        else
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module HaveAPI::Fs::Components
+  class SaveInstance < Executable
+    def initialize(resource_dir, *args)
+      super(*args)
+      @resource_dir = resource_dir
+    end
+    def exec
+      @resource_dir.save
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module HaveAPI::Fs::Components
+  class UnsavedList < File
+    def read
+      str = list_unsaved.join("\n")
+      str += "\n" unless str.empty?
+      str
+    end
+
+    protected
+    def list_unsaved(component = nil)
+      component ||= parent
+      ret = []
+
+      component.send(:children).each do |_, c|
+        next unless c.unsaved?
+
+        ret << c.path
+        ret.concat(list_unsaved(c))
+      end
+      
+      ret
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module HaveAPI::Fs::Components
+  class UpdateActionDir < ActionDir
+    help_file :action_dir
+
+    def exec
+      ret = super
+
+      return ret if !ret.is_a?(HaveAPI::Client::Response) || !ret.ok?
+
+      data = children[:output].data
+      return ret unless data.is_a?(HaveAPI::Client::ResourceInstance)
+
+      params = @resource.actions[:show].params
+      attrs = @resource.attributes
+
+      data.attributes.each do |k, v|
+        next if %i(id _meta).include?(k) || !attrs.has_key?(k)
+
+        if params[k][:type] == 'Resource'
+          @resource.send("#{k}=", data.send(k))
+          context[:resource_instance_dir].update_association(k)
+
+        else
+          @resource.send("#{k}=", v)
+        end
+      end
+
+      ret
+    end
+  end
+end

data/lib/haveapi/fs/context.rb

@@ -0,0 +1,43 @@
+module HaveAPI::Fs
+  # Every component has its own Context instance and passes it along to its
+  # children. Context is used to pass information from the root of the tree
+  # to all its branches and leaves. Using the context, every component knows
+  # all its parents and can relate to them. It also contains a reference
+  # to the global {Cache} instance.
+  class Context
+    attr_accessor :object_path, :file_path, :opts, :url, :mountpoint, :cache
+
+    def initialize
+      @object_path = []
+      @file_path = []
+    end
+
+    def clone
+      c = super
+      c.object_path = c.object_path.clone
+      c.file_path = c.file_path.clone
+      c
+    end
+
+    def set(name, value)
+      @object_path << [name, value]
+    end
+
+    def []=(name, value)
+      set(name, value)
+    end
+
+    def [](name)
+      item = @object_path.reverse.detect { |v| v[0] == name }
+      item && item[1]
+    end
+
+    def last
+      @object_path.last[1]
+    end
+
+    def method_missing(name, *args)
+      self[name] || super
+    end
+  end
+end