virtfs-camcorderfs 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be77d1b97712695378353a6e7647dfce34c16305
+  data.tar.gz: 4e77cf4c7197d43e9b3b988aaa1192e655b2488d
+SHA512:
+  metadata.gz: 0dd365a9cd7eaa04a64703394bf45c9b44192ce8748e1e26cf0d7cadbacb2e42b01d625f6ad825194437b136cbceac1d1196b61b4793f9b18aae6205c4156b28
+  data.tar.gz: df2bd25adeb9af45c9356b76772d52fe461d59674493ccbb9ded91b9c3b4fd25dcd37d112f679a91908e4f9b4431eaaaeca32777ffd2383dae75ba4566fc3672

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.10.3

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'virtfs', "~> 0.0.1", :git => "https://github.com/ManageIQ/virtfs.git", :branch => "master"
+
+# Specify your gem's dependencies in comcorderfs.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Richard Oliveri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# VirtFS/CamcorderFS
+
+A pseudo filesystem plugin for the **VirtFS** infrastructure, that provides the ability to record/playback all filesystem activity that is performed through a given mount point.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'virtfs-camcorderfs'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install virtfs-camcorderfs
+
+## Usage
+
+The **virtfs-camcorderfs** enables the user to _mount_ a given directory of the native filesystem on a virtual mount point within the **virtfs** infrastructure. Once mounted, all filesystem operations performed through the virtual mount point are recorded or played back as follows:
+
+When a `VirtFS::CamcorderFS::FS` instance is instantiated, it is passed the loaction of the recording (cassette) file to be used.
+
+* When the cassette file doesn't exist, the `VirtFS::CamcorderFS::FS` instance is in **record** mode. Once mounted, the instance will **record** all filesystem activity performed through the virtual mount point.
+
+* When the cassette file does exist `VirtFS::CamcorderFS::FS` instance is in **playback** mode. Once mounted, the instance will **playback** all filesystem activity recorded to the cassette file, bypassing native file system access.
+
+This capability is very useful in developing automated tests that rely on specific aspects of the filesystem that may not be available in the automated test environment (like Travis).
+
+For example, say your tests require access to an NFS share or a block special file. Chances are, the share or special file in question will not be accessible in the Travis environment. The **virtfs-camcorderfs** plugin provides a solution to this problem similar to the solutions provided by the [**VCR**](https://github.com/vcr/vcr) and [**camcorder**](https://github.com/ghempton/camcorder) gems. In fact, as the name implies, **virtfs-camcorderfs** uses the **camcorder** gem to perform record/playback.
+
+So, the tests are first run in the base test environemnt, the cassette files are recorded and committed along with the tests. When the tests are run within the Travis environemnt, the filesystem interactions are played back from the cassette files, eliminating the need to access the aspects of the filesystem that are not available in the Travis environemnt.
+
+```ruby
+require "virtfs-nativefs-thick"
+require "virtfs-camcorderfs"
+
+# Instantiate an instance of the native filesystem.
+native_fs = VirtFS::NativeFS::Thick.new
+
+# Mount the native filesystem on root "/"
+VirtFS.mount(native_fs, "/")
+
+# Instantiate an instance of CamcorderFS, specifying the cassette file.
+cc_fs = VirtFS::CamcorderFS::FS.new(@recording_file)
+
+#
+# Mount /dev of the native filesystem on /dev of
+# the VirtFS namespace, through CamcorderFS.
+#
+cc_fs.root = "/dev"
+VirtFS.mount(cc_fs, "/dev")
+
+VirtFS.with do
+  #
+  # Access files under /dev as needed.
+  # Interactions are recorded/played back.
+  #
+end
+
+VirtFS.umount("/dev")
+```
+
+## Contributing 
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "comcorderfs"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/virtfs-camcorderfs.rb

@@ -0,0 +1 @@
+require_relative "virtfs/camcorderfs"

data/lib/virtfs/camcorderfs.rb

@@ -0,0 +1,13 @@
+require 'openssl'
+require 'camcorder'
+
+require_relative "camcorderfs/version"
+
+require_relative "camcorderfs/real_dir"
+require_relative "camcorderfs/real_file"
+
+require_relative "camcorderfs/cc_delegate"
+require_relative "camcorderfs/fs"
+
+require_relative "camcorderfs/dir"
+require_relative "camcorderfs/file"

data/lib/virtfs/camcorderfs/cc_delegate.rb

@@ -0,0 +1,18 @@
+require_relative 'cc_delegate/dir_class_methods'
+require_relative 'cc_delegate/dir_instance_methods'
+require_relative 'cc_delegate/file_class_methods'
+require_relative 'cc_delegate/file_instance_methods'
+
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  class CcDelegate
+    include DirClassMethods
+    include DirInstanceMethods
+    include FileClassMethods
+    include FileInstanceMethods
+
+    def instance_call(method, instance_handle, *args)
+      instance_handle.send(method, *args)
+    end
+    private :instance_call
+  end
+end

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

@@ -0,0 +1,51 @@
+#
+# Dir class methods - are instance methods of filesystem instance.
+#
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  #
+  # Directory class methods - called by CamcorderFS::FS.
+  # Methods are wraped in delegate class for camcorder interposition.
+  #
+  class CcDelegate
+    module DirClassMethods
+      def dir_chdir(_p)
+        0 # needed for side effects.
+      end
+
+      def dir_delete(p)
+        VfsRealDir.delete(p)
+      end
+
+      def dir_entries(p)
+        VfsRealDir.entries(p)
+      end
+
+      def dir_exist?(p)
+        VfsRealDir.exist?(p)
+      end
+
+      def dir_foreach(p)
+        VfsRealDir.foreach(p).to_a
+      end
+
+      def dir_mkdir(p, permissions)
+        VfsRealDir.mkdir(p, permissions)
+      end
+
+      def dir_new(fs_rel_path, hash_args, _open_path, cwd)
+        owd = VfsRealDir.getwd
+        begin
+          VfsRealDir.chdir(cwd)
+          return marshallable_dir(RealDir.new(fs_rel_path, hash_args))
+        ensure
+          VfsRealDir.chdir(owd)
+        end
+      end
+
+      def marshallable_dir(dir)
+        dir.instance_variable_set(:@__cc_id, dir.object_id)
+        dir
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  #
+  # Directory instance methods - called by CamcorderFS::Dir instances.
+  # Methods are wraped in delegate class for camcorder interposition.
+  #
+  class CcDelegate
+    module DirInstanceMethods
+      #
+      # Dir instance methods - implementation.
+      #
+      def dir_i_close(instance_handle)
+        instance_call(:close, instance_handle)
+      end
+
+      def dir_i_each(instance_handle)
+        instance_call(:each, instance_handle).to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+#
+# File class methods - are instance methods of filesystem instance.
+#
+module VirtFS::CamcorderFS # rubocop:disable Style/ClassAndModuleChildren
+  #
+  # File class methods - called by CamcorderFS::FS.
+  # Methods are wraped in delegate class for camcorder interposition.
+  #
+  class CcDelegate
+    module FileClassMethods
+      def file_atime(p)
+        VfsRealFile.atime(p)
+      end
+
+      def file_blockdev?(p)
+        VfsRealFile.blockdev?(p)
+      end
+
+      def file_chardev?(p)
+        VfsRealFile.chardev?(p)
+      end
+
+      def file_chmod(permission, p)
+        VfsRealFile.chmod(permission, p)
+      end
+
+      def file_chown(owner, group, p)
+        VfsRealFile.chown(owner, group, p)
+      end
+
+      def file_ctime(p)
+        VfsRealFile.ctime(p)
+      end
+
+      def file_delete(p)
+        VfsRealFile.delete(p)
+      end
+
+      def file_directory?(p)
+        VfsRealFile.directory?(p)
+      end
+
+      def file_executable?(p)
+        VfsRealFile.executable?(p)
+      end
+
+      def file_executable_real?(p)
+        VfsRealFile.executable_real?(p)
+      end
+
+      def file_exist?(p)
+        VfsRealFile.exist?(p)
+      end
+
+      def file_file?(p)
+        VfsRealFile.file?(p)
+      end
+
+      def file_ftype(p)
+        VfsRealFile.ftype(p)
+      end
+
+      def file_grpowned?(p)
+        VfsRealFile.grpowned?(p)
+      end
+
+      def file_identical?(p1, p2)
+        VfsRealFile.identical?(p1, p2)
+      end
+
+      def file_lchmod(permission, p)
+        VfsRealFile.lchmod(permission, p)
+      end
+
+      def file_lchown(owner, group, p)
+        VfsRealFile.lchown(owner, group, p)
+      end
+
+      def file_link(p1, p2)
+        VfsRealFile.link(p1, p2)
+      end
+
+      def file_lstat(p)
+        VirtFS::Stat.new(VfsRealFile.lstat(p))
+      end
+
+      def file_mtime(p)
+        VfsRealFile.mtime(p)
+      end
+
+      def file_owned?(p)
+        VfsRealFile.owned?(p)
+      end
+
+      def file_pipe?(p)
+        VfsRealFile.pipe?(p)
+      end
+
+      def file_readable?(p)
+        VfsRealFile.readable?(p)
+      end
+
+      def file_readable_real?(p)
+        VfsRealFile.readable_real?(p)
+      end
+
+      def file_readlink(p)
+        VfsRealFile.readlink(p)
+      end
+
+      def file_rename(p1, p2)
+        VfsRealFile.rename(p1, p2)
+      end
+
+      def file_setgid?(p)
+        VfsRealFile.setgid?(p)
+      end
+
+      def file_setuid?(p)
+        VfsRealFile.setuid?(p)
+      end
+
+      def file_size(p)
+        VfsRealFile.size(p)
+      end
+
+      def file_socket?(p)
+        VfsRealFile.socket?(p)
+      end
+
+      def file_stat(p)
+        VirtFS::Stat.new(VfsRealFile.stat(p))
+      end
+
+      def file_sticky?(p)
+        VfsRealFile.sticky?(p)
+      end
+
+      def file_symlink(oname, p)
+        VfsRealFile.symlink(oname, p)
+      end
+
+      def file_symlink?(p)
+        VfsRealFile.symlink?(p)
+      end
+
+      def file_truncate(p, len)
+        VfsRealFile.truncate(p, len)
+      end
+
+      def file_utime(atime, mtime, p)
+        VfsRealFile.utime(atime, mtime, p)
+      end
+
+      def file_world_readable?(p)
+        VfsRealFile.world_readable?(p)
+      end
+
+      def file_world_writable?(p)
+        VfsRealFile.world_writable?(p)
+      end
+
+      def file_writable?(p)
+        VfsRealFile.writable?(p)
+      end
+
+      def file_writable_real?(p)
+        VfsRealFile.writable_real?(p)
+      end
+
+      def file_new(fs_rel_path, parsed_args, _open_path, cwd)
+        owd = VfsRealDir.getwd
+        begin
+          VfsRealDir.chdir(cwd)
+          fobj = RealFile.new(fs_rel_path, parsed_args.mode_bits & ~VfsRealFile::APPEND, :binmode => true)
+          return marshallable_file(fobj)
+        ensure
+          VfsRealDir.chdir(owd)
+        end
+      end
+
+      def marshallable_file(file)
+        file.instance_variable_set(:@__cc_id, file.object_id)
+        file
+      end
+    end
+  end
+end