virtfs-camcorderfs 0.0.1

data/lib/virtfs/camcorderfs/cc_delegate/file_instance_methods.rb

@@ -0,0 +1,145 @@
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  #
+  # File instance methods - called by CamcorderFS::File instances.
+  # Methods are wraped in delegate class for camcorder interposition.
+  #
+  class CcDelegate
+    module FileInstanceMethods
+      #
+      # File instance methods - implementation.
+      #
+      def file_i_atime(instance_handle)
+        instance_call(:atime, instance_handle)
+      end
+
+      def file_i_chmod(instance_handle, permission)
+        instance_call(:chmod, instance_handle, permission)
+      end
+
+      def file_i_chown(instance_handle, owner, group)
+        instance_call(:chown, instance_handle, owner, group)
+      end
+
+      def file_i_ctime(instance_handle)
+        instance_call(:ctime, instance_handle)
+      end
+
+      def file_i_flock(instance_handle, locking_constant)
+        instance_call(:flock, instance_handle, locking_constant)
+      end
+
+      def file_i_lstat(instance_handle)
+        VirtFS::Stat.new(instance_call(:lstat, instance_handle))
+      end
+
+      def file_i_mtime(instance_handle)
+        instance_call(:mtime, instance_handle)
+      end
+
+      def file_i_size(instance_handle)
+        instance_call(:size, instance_handle)
+      end
+
+      def file_i_truncate(instance_handle, to_size)
+        instance_call(:truncate, instance_handle, to_size)
+      end
+
+      #
+      # IO instance methods.
+      #
+      def file_i_close(instance_handle)
+        instance_call(:close, instance_handle)
+      end
+
+      def file_i_close_on_exec?(instance_handle)
+        instance_call(:close_on_exec?, instance_handle)
+      end
+
+      def file_i_close_on_exec=(instance_handle, bool_val)
+        instance_call(:close_on_exec=, instance_handle, bool_val)
+      end
+
+      def file_i_close_read(instance_handle)
+        instance_call(:close_read, instance_handle)
+      end
+
+      def file_i_close_write(instance_handle)
+        instance_call(:close_write, instance_handle)
+      end
+
+      def file_i_fcntl(instance_handle, cmd, arg)
+        instance_call(:fcntl, instance_handle, cmd, arg)
+      end
+
+      def file_i_fdatasync(instance_handle)
+        instance_call(:fdatasync, instance_handle)
+      end
+
+      def file_i_fileno(instance_handle)
+        instance_call(:fileno, instance_handle)
+      end
+
+      def file_i_flush(instance_handle)
+        instance_call(:flush, instance_handle)
+      end
+
+      def file_i_fsync(instance_handle)
+        instance_call(:fsync, instance_handle)
+      end
+
+      def file_i_ioctl(instance_handle, cms, arg)
+        instance_call(:ioctl, instance_handle, cms, arg)
+      end
+
+      def file_i_isatty(instance_handle)
+        instance_call(:isatty, instance_handle)
+      end
+
+      def file_i_pid(instance_handle)
+        instance_call(:pid, instance_handle)
+      end
+
+      def file_i_raw_read(instance_handle, start_byte, num_bytes)
+        instance_handle.sysseek(start_byte, IO::SEEK_SET)
+        instance_handle.sysread(num_bytes)
+      end
+
+      def file_i_raw_write(instance_handle, start_byte, buf)
+        instance_handle.sysseek(start_byte, IO::SEEK_SET)
+        instance_handle.syswrite(buf)
+      end
+
+      def file_i_readpartial(instance_handle, limit, result)
+        instance_call(:readpartial, instance_handle, limit, result)
+      end
+
+      def file_i_read_nonblock(instance_handle, limit, result)
+        instance_call(:read_nonblock, instance_handle, limit, result)
+      end
+
+      def file_i_stat(instance_handle)
+        VirtFS::Stat.new(instance_call(:stat, instance_handle))
+      end
+
+      def file_i_sync(instance_handle)
+        instance_call(:sync, instance_handle)
+      end
+
+      def file_i_sync=(instance_handle, bool_val)
+        instance_call(:sync=, instance_handle, bool_val)
+      end
+
+      def file_i_to_i(instance_handle)
+        instance_call(:to_i, instance_handle)
+      end
+
+      def file_i_tty?(instance_handle)
+        instance_call(:tty?, instance_handle)
+      end
+
+      def file_i_write_nonblock(instance_handle, buf)
+        instance_call(:write_nonblock, instance_handle, buf)
+      end
+    end
+  end
+end

data/lib/virtfs/camcorderfs/dir.rb

@@ -0,0 +1,37 @@
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  #
+  # CamcorderFS::Dir class.
+  # Instance methods call into CamcorderFS::FS instance.
+  #
+  class Dir
+    attr_reader :fs
+
+    NS_PFX = "dir_i_"
+
+    def initialize(fs, instance_handle, hash_args)
+      @fs              = fs
+      @instance_handle = instance_handle
+      @hash_args       = hash_args
+      @cache           = nil
+    end
+
+    def close
+      fs_call(__method__)
+    end
+
+    # returns file_name and new position.
+    def read(pos)
+      return cache[pos], pos + 1
+    end
+
+    private
+
+    def cache
+      @cache ||= fs_call(:each, nil, nil).to_a
+    end
+
+    def fs_call(method, *args)
+      @fs.send("#{NS_PFX}#{method}", @instance_handle, *args)
+    end
+  end
+end

data/lib/virtfs/camcorderfs/file.rb

@@ -0,0 +1,157 @@
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  #
+  # CamcorderFS::File class.
+  # Instance methods call into CamcorderFS::FS instance.
+  #
+  class File
+    attr_reader :fs
+
+    NS_PFX = "file_i_"
+
+    def initialize(fs, instance_handle, parsed_args)
+      @fs              = fs
+      @instance_handle = instance_handle
+      @parsed_args     = parsed_args
+    end
+
+    #
+    # File instance methods.
+    #
+    def atime
+      fs_call(__method__)
+    end
+
+    def chmod(permission)
+      fs_call(__method__, permission)
+    end
+
+    def chown(owner, group)
+      fs_call(__method__, owner, group)
+    end
+
+    def ctime
+      fs_call(__method__)
+    end
+
+    def flock(locking_constant)
+      fs_call(__method__, locking_constant)
+    end
+
+    def lstat
+      fs_call(__method__)
+    end
+
+    def mtime
+      fs_call(__method__)
+    end
+
+    def size
+      fs_call(__method__)
+    end
+
+    def truncate(to_size)
+      fs_call(__method__, to_size)
+    end
+
+    #
+    # IO instance methods.
+    #
+    def close
+      fs_call(__method__)
+    end
+
+    def close_on_exec?
+      fs_call(__method__)
+    end
+
+    def close_on_exec=(bool_val)
+      fs_call(__method__, bool_val)
+    end
+
+    def close_read
+      fs_call(__method__)
+    end
+
+    def close_write
+      fs_call(__method__)
+    end
+
+    def fcntl(cmd, arg)
+      fs_call(__method__, cmd, arg)
+    end
+
+    def fdatasync
+      fs_call(__method__)
+    end
+
+    def fileno
+      fs_call(__method__)
+    end
+
+    def flush
+      fs_call(__method__)
+    end
+
+    def fsync
+      fs_call(__method__)
+    end
+
+    def ioctl(cms, arg)
+      fs_call(__method__, cms, arg)
+    end
+
+    def isatty
+      fs_call(__method__)
+    end
+
+    def pid
+      fs_call(__method__)
+    end
+
+    def raw_read(start_byte, num_bytes)
+      fs_call(__method__, start_byte, num_bytes)
+    end
+
+    def raw_write(start_byte, buf)
+      fs_call(__method__, start_byte, buf)
+    end
+
+    def readpartial(limit, result = "")
+      fs_call(__method__, limit, result)
+    end
+
+    def read_nonblock(limit, result = "")
+      fs_call(__method__, limit, result)
+    end
+
+    def stat
+      fs_call(__method__)
+    end
+
+    def sync
+      fs_call(__method__)
+    end
+
+    def sync=(bool_val)
+      fs_call(__method__, bool_val)
+    end
+
+    def to_i
+      fs_call(__method__)
+    end
+
+    def tty?
+      fs_call(__method__)
+    end
+
+    def write_nonblock(buf)
+      fs_call(__method__, buf)
+    end
+
+    private
+
+    def fs_call(method, *args)
+      @fs.send("#{NS_PFX}#{method}", @instance_handle, *args)
+    end
+  end
+end

data/lib/virtfs/camcorderfs/fs.rb

@@ -0,0 +1,106 @@
+require_relative 'fs/dir_class_methods'
+require_relative 'fs/dir_instance_methods'
+require_relative 'fs/file_class_methods'
+require_relative 'fs/file_instance_methods'
+
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  class FS
+    attr_accessor :mount_point, :name, :root
+    attr_reader   :recording_path
+
+    include DirClassMethods
+    include DirInstanceMethods
+    include FileClassMethods
+    include FileInstanceMethods
+
+    def initialize(recording_path = nil, root = VfsRealFile::SEPARATOR)
+      @mount_point  = nil
+      @name         = self.class.name
+      @root         = root
+
+      if recording_path.nil?
+        @cc_delegate = CcDelegate.new
+      else
+        start_recorder(recording_path)
+      end
+    end
+
+    def start_recorder(recording_path)
+      @recording_path = recording_path
+      @recorder       = Camcorder::Recorder.new(@recording_path)
+
+      @cc_delegate = Camcorder.proxy_class(CcDelegate, @recorder) do
+        #
+        # Dir class methods.
+        #
+        methods_with_side_effects :dir_chdir, :dir_delete, :dir_mkdir, :dir_new
+
+        #
+        # Dir instance methods.
+        #
+        methods_with_side_effects :dir_i_close, :dir_i_each
+
+        #
+        # File class methods.
+        #
+        methods_with_side_effects :file_atime,  :file_chmod,    :file_chown,    :file_ctime,
+                                  :file_delete, :file_lchmod,   :file_lchown,   :file_link,
+                                  :file_lstat,  :file_mtime,    :file_new,      :file_rename,
+                                  :file_stat,   :file_symlink?, :file_symlink,  :file_truncate,
+                                  :file_utime
+
+        #
+        # File instance methods.
+        #
+        methods_with_side_effects :file_i_atime,          :file_i_chmod,       :file_i_chown,
+                                  :file_i_ctime,          :file_i_flock,       :file_i_lstat,
+                                  :file_i_mtime,          :file_i_truncate,    :file_i_close,
+                                  :file_i_close_on_exec=, :file_i_close_read,  :file_i_close_write,
+                                  :file_i_fcntl,          :file_i_ioctl,       :file_i_raw_read,
+                                  :file_i_raw_write,      :file_i_readpartial, :file_i_read_nonblock,
+                                  :file_i_write_nonblock
+      end.new
+
+      @recorder.start
+    end
+
+    def thin_interface?
+      true
+    end
+
+    def umount
+      @recorder.commit unless @recorder.nil?
+      @mount_point = nil
+    end
+
+    def apply_root(path)
+      VfsRealFile.join(@root, path)
+    end
+    private :apply_root
+
+    def ccd_call(method, *args)
+      @cc_delegate.send(method, *args)
+    rescue SystemCallError => scerr
+      #
+      # The errno is lost when the exception is YAML.dump'd but the
+      # sub-class is correct. We get the errno from the sub-class
+      # and instantiate a new exception to raise.
+      #
+      # Passing the whole message from the original exception isn't
+      # the right thing to do. We need to find a way to extract the
+      # target name from the original message.
+      #
+      raise SystemCallError.new(scerr.message, scerr.class::Errno)
+    rescue
+      raise
+    end
+    private :ccd_call
+
+    def return_enum(array, block, rv = nil)
+      return array.each if block.nil? # return Enumerator.
+      array.each(&block)
+      rv
+    end
+    private :return_enum
+  end
+end