vagrant-bindfs 0.4.14 → 1.0.0

data/lib/vagrant-bindfs/bindfs/validators.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Bindfs
+    module Validators
+      autoload :Config,   'vagrant-bindfs/bindfs/validators/config'
+      autoload :Runtime,  'vagrant-bindfs/bindfs/validators/runtime'
+    end
+  end
+end

data/lib/vagrant-bindfs/bindfs/validators/config.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Bindfs
+    module Validators
+      class Config
+        attr_reader :folder
+        attr_reader :errors
+
+        extend Forwardable
+        def_delegator :@folder, :source
+        def_delegator :@folder, :destination
+        def_delegator :@folder, :options
+
+        def initialize(folder)
+          @folder   = folder
+          @errors   = []
+        end
+
+        def valid?
+          @errors = []
+          validate_source!
+          validate_destination!
+          validate_options!
+          @errors.empty?
+        end
+
+        protected
+
+        def validate_source!
+          @errors << I18n.t('vagrant-bindfs.validations.source_path_required')                if source.empty?
+          @errors << I18n.t('vagrant-bindfs.validations.path_must_be_absolute', path: source) if relative_path?(source)
+        end
+
+        def validate_destination!
+          @errors << I18n.t('vagrant-bindfs.validations.destination_path_required')                     if destination.empty?
+          @errors << I18n.t('vagrant-bindfs.validations.path_must_be_absolute', path: destination)      if relative_path?(destination)
+          @errors << I18n.t('vagrant-bindfs.validations.destination_path_reserved', path: destination)  if reserved_path?(destination)
+        end
+
+        def validate_options!
+          invalid_options = folder.options.invalid_options.keys
+          @errors << I18n.t('vagrant-bindfs.deprecations.disabled')           if invalid_options.include?('disabled')
+          @errors << I18n.t('vagrant-bindfs.deprecations.skip_verify_user')   if invalid_options.include?('skip-verify-user')
+          @errors << I18n.t('vagrant-bindfs.deprecations.skip_verify_group')  if invalid_options.include?('skip-verify-group')
+          @errors << I18n.t('vagrant-bindfs.deprecations.hook')               if invalid_options.include?('hook')
+        end
+
+        def relative_path?(path)
+          Pathname.new(path).relative?
+        end
+
+        def reserved_path?(path)
+          !Pathname.new(path).to_path.match(%r{^\/vagrant\/}).nil?
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/bindfs/validators/runtime.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Bindfs
+    module Validators
+      class Runtime < Config
+        attr_reader :machine
+
+        def initialize(folder, machine)
+          super(folder)
+          @machine = machine
+        end
+
+        protected
+
+        def validate_source!
+          super
+
+          @errors << I18n.t('vagrant-bindfs.validations.source_path_does_not_exist', path: source) unless directory_exists?(source)
+        end
+
+        def validate_destination!
+          super
+
+          @errors << I18n.t('vagrant-bindfs.validations.destination_already_mounted', dest: destination) if mount_exists?(destination)
+        end
+
+        def validate_options!
+          super
+
+          validate_user
+          validate_group
+        end
+
+        def directory_exists?(path)
+          machine.guest.capability(:bindfs_exists_directory, path)
+        end
+
+        def mount_exists?(path)
+          machine.guest.capability(:bindfs_exists_mount, path)
+        end
+
+        def validate_user
+          return if machine.config.bindfs.skip_validations.include?(:user)
+          return if machine.guest.capability(:bindfs_exists_user, options['force-user'])
+          @errors << I18n.t('vagrant-bindfs.validations.user_does_not_exist', user: options['force-user'])
+        end
+
+        def validate_group
+          return if machine.config.bindfs.skip_validations.include?(:group)
+          return if machine.guest.capability(:bindfs_exists_group, options['force-group'])
+          @errors << I18n.t('vagrant-bindfs.validations.group_does_not_exist', group: options['force-group'])
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    autoload :Plugin,       'vagrant-bindfs/vagrant/plugin'
+    autoload :Config,       'vagrant-bindfs/vagrant/config'
+    autoload :Capabilities, 'vagrant-bindfs/vagrant/capabilities'
+    autoload :Actions,      'vagrant-bindfs/vagrant/actions'
+
+    autoload :Error,        'vagrant-bindfs/vagrant/errors'
+    autoload :ConfigError,  'vagrant-bindfs/vagrant/errors'
+  end
+end

data/lib/vagrant-bindfs/vagrant/actions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Actions
+      autoload :Installer,  'vagrant-bindfs/vagrant/actions/installer'
+      autoload :Mounter,    'vagrant-bindfs/vagrant/actions/mounter'
+
+      autoload :Concerns,   'vagrant-bindfs/vagrant/actions/concerns'
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant/actions/concerns.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Actions
+      module Concerns
+        autoload :Log,      'vagrant-bindfs/vagrant/actions/concerns/log'
+        autoload :Machine,  'vagrant-bindfs/vagrant/actions/concerns/machine'
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant/actions/concerns/log.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Actions
+      module Concerns
+        module Log
+          def logger
+            env[:ui]
+          end
+
+          def debug(message)
+            logger.detail(message) if config.debug
+          end
+
+          def detail(message)
+            logger.detail(message)
+          end
+
+          def info(message)
+            logger.info message
+          end
+
+          def warn(message)
+            logger.warn message
+          end
+
+          def error(message)
+            logger.error message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant/actions/concerns/machine.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Actions
+      module Concerns
+        module Machine
+          def machine
+            env[:machine]
+          end
+
+          def config
+            machine.config.bindfs
+          end
+
+          def binded_folders(hook = nil)
+            @binded_folders ||= begin
+              config.binded_folders.each_with_object({}) do |(id, folder), binded|
+                binded[id] = folder if hook.nil? || folder.hook == hook
+                binded
+              end
+            end
+          end
+
+          def guest
+            machine.guest
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant/actions/installer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Actions
+      class Installer
+        attr_reader :app
+        attr_reader :env
+
+        include Concerns::Machine
+        include Concerns::Log
+
+        def initialize(app, env)
+          @app  = app
+          @env  = env
+        end
+
+        def call(env)
+          @app.call(env)
+          apply!(env)
+        end
+
+        protected
+
+        def apply!(_env)
+          return if binded_folders.empty?
+          ensure_guest_is_ready_to_bind!
+        end
+
+        def ensure_guest_is_ready_to_bind!
+          info(I18n.t('vagrant-bindfs.actions.installer.start'))
+          ensure_package_manager_is_installed!
+          ensure_fuse_is_installed!
+          ensure_fuse_is_loaded!
+          ensure_bindfs_is_installed!
+          info(I18n.t('vagrant-bindfs.actions.installer.end'))
+        end
+
+        def ensure_package_manager_is_installed!
+          unless guest.capability(:bindfs_package_manager_installed)
+            warn(I18n.t('vagrant-bindfs.actions.package_manager.not_installed'))
+            guest.capability(:bindfs_package_manager_install)
+          end
+
+          detail(I18n.t('vagrant-bindfs.actions.package_manager.installed',
+                        name: guest.capability(:bindfs_package_manager_name)))
+        end
+
+        def ensure_fuse_is_installed!
+          unless guest.capability(:bindfs_fuse_installed)
+            warn(I18n.t('vagrant-bindfs.actions.fuse.not_installed'))
+            guest.capability(:bindfs_fuse_install)
+          end
+
+          detail(I18n.t('vagrant-bindfs.actions.fuse.installed'))
+        end
+
+        def ensure_fuse_is_loaded!
+          unless guest.capability(:bindfs_fuse_loaded)
+            warn(I18n.t('vagrant-bindfs.actions.fuse.not_loaded'))
+            guest.capability(:bindfs_fuse_load)
+          end
+
+          detail(I18n.t('vagrant-bindfs.actions.fuse.loaded'))
+        end
+
+        def ensure_bindfs_is_installed!
+          unless guest.capability(:bindfs_bindfs_installed)
+            warn(I18n.t('vagrant-bindfs.actions.bindfs.not_installed'))
+
+            case true
+            when config.install_bindfs_from_source
+              install_bindfs_from_source!
+
+            when config.bindfs_version == :latest
+              guest.capability(:bindfs_bindfs_install)
+
+            when config.bindfs_version != :latest && guest.capability(:bindfs_bindfs_search_version, config.bindfs_version)
+              guest.capability(:bindfs_bindfs_install_version, config.bindfs_version)
+
+            else
+              warn(I18n.t('vagrant-bindfs.actions.bindfs.not_found_in_repository',
+                          version: config.bindfs_version))
+              install_bindfs_from_source!
+            end
+          end
+
+          detail(I18n.t('vagrant-bindfs.actions.bindfs.detected',
+                        version: guest.capability(:bindfs_bindfs_version)))
+        end
+
+        def install_bindfs_from_source!
+          version = (config.bindfs_version == :latest ? VagrantBindfs::Bindfs::SOURCE_VERSION : config.bindfs_version.to_s)
+          guest.capability(:bindfs_bindfs_install_compilation_requirements)
+          guest.capability(:bindfs_bindfs_install_from_source, version)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant/actions/mounter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Actions
+      class Mounter
+        attr_reader :app
+        attr_reader :env
+        attr_reader :hook
+
+        include Concerns::Machine
+        include Concerns::Log
+
+        def initialize(app, env, hook)
+          @app  = app
+          @env  = env
+          @hook = hook
+        end
+
+        def call(env)
+          app.call(env)
+          return if binded_folders(hook).empty?
+          bind_folders!
+        end
+
+        protected
+
+        def bind_folders!
+          info I18n.t('vagrant-bindfs.actions.mounter.start', hook: hook)
+          bindfs_version = guest.capability(:bindfs_bindfs_version)
+
+          binded_folders(hook).each do |_, folder|
+            folder.reverse_merge!(config.default_options)
+            folder.to_version!(bindfs_version)
+
+            validator = VagrantBindfs::Bindfs::Validators::Runtime.new(folder, machine)
+
+            unless validator.valid?
+              error I18n.t(
+                'vagrant-bindfs.validations.errors_found',
+                dest:   folder.destination,
+                source: folder.source,
+                errors: validator.errors.join(' ')
+              )
+              next
+            end
+
+            command = VagrantBindfs::Bindfs::Command.new(folder)
+
+            detail I18n.t(
+              'vagrant-bindfs.actions.mounter.entry',
+              dest: folder.destination,
+              source: folder.source
+            )
+
+            machine.communicate.tap do |comm|
+              comm.sudo("mkdir -p #{folder.destination}")
+              comm.sudo(command.to_s, error_class: VagrantBindfs::Vagrant::Error, error_key: 'bindfs.mount_failed')
+              debug(command.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bindfs/vagrant/capabilities.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+module VagrantBindfs
+  module Vagrant
+    module Capabilities
+      autoload :All,    'vagrant-bindfs/vagrant/capabilities/all'
+
+      autoload :Darwin, 'vagrant-bindfs/vagrant/capabilities/darwin'
+      autoload :Linux,  'vagrant-bindfs/vagrant/capabilities/linux'
+
+      autoload :Debian, 'vagrant-bindfs/vagrant/capabilities/debian'
+      autoload :Ubuntu, 'vagrant-bindfs/vagrant/capabilities/ubuntu'
+
+      autoload :RedHat, 'vagrant-bindfs/vagrant/capabilities/redhat'
+
+      autoload :Suse,   'vagrant-bindfs/vagrant/capabilities/suse'
+
+      class << self
+        def included(base)
+          declare_capabilities_for_system_checks!(base)
+          declare_capabilities_for_package_manager!(base)
+          declare_capabilities_for_fuse!(base)
+          declare_capabilities_for_bindfs!(base)
+        end
+
+        def declare_capabilities_for_system_checks!(base)
+          base.guest_capability('darwin', 'bindfs_exists_user') { Capabilities::Darwin::SystemChecks }
+          base.guest_capability('linux',  'bindfs_exists_user') { Capabilities::Linux::SystemChecks }
+
+          base.guest_capability('darwin', 'bindfs_exists_group') { Capabilities::Darwin::SystemChecks }
+          base.guest_capability('linux',  'bindfs_exists_group') { Capabilities::Linux::SystemChecks }
+
+          base.guest_capability('darwin', 'bindfs_exists_directory') { Capabilities::All::SystemChecks }
+          base.guest_capability('linux',  'bindfs_exists_directory') { Capabilities::All::SystemChecks }
+
+          base.guest_capability('darwin', 'bindfs_exists_mount') { Capabilities::All::SystemChecks }
+          base.guest_capability('linux',  'bindfs_exists_mount') { Capabilities::All::SystemChecks }
+        end
+
+        def declare_capabilities_for_package_manager!(base)
+          base.guest_capability('darwin', 'bindfs_package_manager_name') { Capabilities::Darwin::PackageManager }
+          base.guest_capability('debian', 'bindfs_package_manager_name') { Capabilities::Debian::PackageManager }
+          base.guest_capability('redhat', 'bindfs_package_manager_name') { Capabilities::RedHat::PackageManager }
+          base.guest_capability('suse',   'bindfs_package_manager_name') { Capabilities::Suse::PackageManager }
+
+          base.guest_capability('darwin', 'bindfs_package_manager_installed') { Capabilities::All::PackageManager }
+          base.guest_capability('linux',  'bindfs_package_manager_installed') { Capabilities::All::PackageManager }
+
+          base.guest_capability('darwin', 'bindfs_package_manager_install') { Capabilities::Darwin::PackageManager }
+          base.guest_capability('linux',  'bindfs_package_manager_install') { Capabilities::Linux::PackageManager }
+
+          base.guest_capability('darwin', 'bindfs_package_manager_update') { Capabilities::Darwin::PackageManager }
+          base.guest_capability('debian', 'bindfs_package_manager_update') { Capabilities::Debian::PackageManager }
+          base.guest_capability('redhat', 'bindfs_package_manager_update') { Capabilities::RedHat::PackageManager }
+          base.guest_capability('suse',   'bindfs_package_manager_update') { Capabilities::Suse::PackageManager }
+        end
+
+        def declare_capabilities_for_fuse!(base)
+          base.guest_capability('darwin', 'bindfs_fuse_installed') { Capabilities::Darwin::Fuse }
+          base.guest_capability('linux',  'bindfs_fuse_installed') { Capabilities::Linux::Fuse }
+
+          base.guest_capability('darwin', 'bindfs_fuse_install') { Capabilities::Darwin::Fuse }
+          base.guest_capability('debian', 'bindfs_fuse_install') { Capabilities::Debian::Fuse }
+          base.guest_capability('redhat', 'bindfs_fuse_install') { Capabilities::RedHat::Fuse }
+          base.guest_capability('suse',   'bindfs_fuse_install') { Capabilities::Suse::Fuse }
+
+          base.guest_capability('darwin', 'bindfs_fuse_loaded') { Capabilities::Darwin::Fuse }
+          base.guest_capability('linux',  'bindfs_fuse_loaded') { Capabilities::Linux::Fuse }
+          base.guest_capability('ubuntu', 'bindfs_fuse_loaded') { Capabilities::Ubuntu::Fuse }
+
+          base.guest_capability('darwin', 'bindfs_fuse_load') { Capabilities::Darwin::Fuse }
+          base.guest_capability('linux',  'bindfs_fuse_load') { Capabilities::Linux::Fuse }
+          base.guest_capability('ubuntu', 'bindfs_fuse_load') { Capabilities::Ubuntu::Fuse }
+        end
+
+        def declare_capabilities_for_bindfs!(base)
+          base.guest_capability('darwin', 'bindfs_bindfs_installed') { Capabilities::All::Bindfs }
+          base.guest_capability('linux',  'bindfs_bindfs_installed') { Capabilities::All::Bindfs }
+
+          base.guest_capability('darwin', 'bindfs_bindfs_version') { Capabilities::All::Bindfs }
+          base.guest_capability('linux',  'bindfs_bindfs_version') { Capabilities::All::Bindfs }
+
+          base.guest_capability('darwin', 'bindfs_bindfs_install') { Capabilities::Darwin::Bindfs }
+          base.guest_capability('debian', 'bindfs_bindfs_install') { Capabilities::Debian::Bindfs }
+          base.guest_capability('redhat', 'bindfs_bindfs_install') { Capabilities::RedHat::Bindfs }
+          base.guest_capability('suse',   'bindfs_bindfs_install') { Capabilities::Suse::Bindfs }
+
+          base.guest_capability('darwin', 'bindfs_bindfs_search_version') { Capabilities::Darwin::Bindfs }
+          base.guest_capability('debian', 'bindfs_bindfs_search_version') { Capabilities::Debian::Bindfs }
+          base.guest_capability('redhat', 'bindfs_bindfs_search_version') { Capabilities::RedHat::Bindfs }
+          base.guest_capability('suse',   'bindfs_bindfs_search_version') { Capabilities::Suse::Bindfs }
+
+          base.guest_capability('darwin', 'bindfs_bindfs_install_version') { Capabilities::Darwin::Bindfs }
+          base.guest_capability('debian', 'bindfs_bindfs_install_version') { Capabilities::Debian::Bindfs }
+          base.guest_capability('redhat', 'bindfs_bindfs_install_version') { Capabilities::RedHat::Bindfs }
+          base.guest_capability('suse',   'bindfs_bindfs_install_version') { Capabilities::Suse::Bindfs }
+
+          base.guest_capability('darwin', 'bindfs_bindfs_install_compilation_requirements') { Capabilities::Darwin::Bindfs }
+          base.guest_capability('debian', 'bindfs_bindfs_install_compilation_requirements') { Capabilities::Debian::Bindfs }
+          base.guest_capability('redhat', 'bindfs_bindfs_install_compilation_requirements') { Capabilities::RedHat::Bindfs }
+          base.guest_capability('suse',   'bindfs_bindfs_install_compilation_requirements') { Capabilities::Suse::Bindfs }
+
+          base.guest_capability('darwin', 'bindfs_bindfs_install_from_source') { Capabilities::All::Bindfs }
+          base.guest_capability('linux',  'bindfs_bindfs_install_from_source') { Capabilities::All::Bindfs }
+        end
+      end
+    end
+  end
+end