vagrant-persistent-storage 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: 5610de0834a33052cd9cfaaab79837b01261e7f2
+  metadata.gz: ce4f88ee39f8753b7d3e06bbcffb961d9a8e630b
+SHA512: 
+  data.tar.gz: 465b23d43aebeb08ea1db75b56ad48dfd0c53a7f9b33f19e1442a51fbf94e44163ee6999c5375863f24209369862e3f34685c3b5623df83b0a0a5283a770fab0
+  metadata.gz: 277497dfe4b13ffdab71adade10e74872e66557d204a8e874d6df26d164c270121be216abb3bbfecfa113f3906d1d1215c30db54f1ec7d72c7feaefe03e6577e

data/README.md

@@ -5,68 +5,37 @@ A Vagrant plugin that creates a persistent storage and attaches it to guest mach
 
 ## Installation
 
-    gem 'vagrant-persistent-storage'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install vagrant-persistent-storage
+    $ vagrant plugin install vagrant-persistent-storage
 
 ## Usage
 
 After installing you can set the location and size of the persistent storage.
 
-The following options will create a persistent storage with 5000 MB:
+The following options will create a persistent storage with 5000 MB, named mysql,
+mounted on /var/lib/mysql, in a volume group called 'vagrant'
 ```ruby
+config.persistent_storage.enabled = true
 config.persistent_storage.location = "~/development/sourcehdd.vdi"
 config.persistent_storage.size = 5000
+config.persistent_storage.mountname = 'mysql'
+config.persistent_storage.filesystem = 'ext4'
+config.persistent_storage.mountpoint = '/var/lib/mysql'
+config.persistent_storage.volgroupname = 'myvolgroup'
 ```
 
+Device defaults to /dev/sdb
+
 Every `vagrant up` will attach this file as hard disk to the guest machine.
-An `vagrant destory` will detach the storage to avoid deletion of the storage by vagrant.
-A `vagrant destory` generally destroys all attached drives. See [VBoxMange unregistervm --delete option][vboxmanage_delete].
-
-### How to initialize the disk with puppet
-
-This is a sample puppet setup to create a partition on the guest system:
-
-```puppet
-class sources::persistent {
-  exec { "fdisk-sourcehd":
-    command => "/sbin/fdisk /dev/sdb << EOF
-o
-n
-p
-1
-
-
-w
-EOF",
-    unless => "/bin/grep sdb1 /proc/partitions",
-  }
-
-  exec { "mkfs-sourcehd":
-    command     => "/sbin/mkfs.ext3 -L sources -b 4096 /dev/sdb1",
-    unless      => "/sbin/dumpe2fs /dev/sdb1"
-  }
-  
-  exec { 'fstab-sourcehd':
-    command => '/bin/echo "/dev/disk/by-label/sources /mnt/sources ext3 defaults 0 2" >> /etc/fstab',
-    unless  => '/bin/grep ^/dev/disk/by-label/sources /etc/fstab',
-  }
-  
-  exec { 'mount-sourcehd':
-    command     => '/bin/mkdir -p /mnt/sources; /bin/mount /mnt/sources',
-    subscribe   => Exec['fstab-sourcehd'],
-    refreshonly => true,
-  }
-
-  Exec['fdisk-sourcehd'] -> Exec['mkfs-sourcehd'] -> Exec['fstab-sourcehd'] -> Exec['mount-sourcehd']
-}
-```
+An `vagrant destroy` will detach the storage to avoid deletion of the storage by vagrant.
+A `vagrant destroy` generally destroys all attached drives. See [VBoxMange unregistervm --delete option][vboxmanage_delete].
+
+The disk is initialized and added to it's own volume group as specfied in the config; 
+this defaults to 'vagrant'. An ext4 filesystem is created and the disk mounted appropriately,
+with entries added to fstab ... subsequent runs will mount this disk with the options specified
+
+## Contributors
+
+* [madAndroid](https://github.com/madAndroid)
 
 ## TODO
 

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+

data/lib/vagrant-persistent-storage/action/attach_storage.rb

@@ -0,0 +1,36 @@
+require "log4r"
+
+module VagrantPlugins
+  module PersistentStorage
+    module Action
+      class AttachStorage
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @global_env = @machine.env
+          @provider = env[:provider]
+          @logger = Log4r::Logger.new('vagrant::persistentstorage::action::attachstorage')
+        end
+
+        def call(env)
+          # skip if machine is not running and the action is destroy, halt or suspend
+          return @app.call(env) if @machine.state.id != :running && [:destroy, :halt, :suspend].include?(env[:machine_action])
+          # skip if machine is saved
+          return @app.call(env) if @machine.state.id == :saved
+
+          return @app.call(env) unless env[:machine].config.persistent_storage.enabled?
+          @logger.info '** Attaching Persistent Storage **'
+
+          env[:ui].info I18n.t("vagrant_persistent_storage.action.attach_storage")
+          location = env[:machine].config.persistent_storage.location
+          env[:machine].provider.driver.attach_storage(location)
+
+          @app.call(env)
+
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-persistent-storage/action/create_adapter.rb

@@ -0,0 +1,39 @@
+require "log4r"
+
+module VagrantPlugins
+  module PersistentStorage
+    module Action
+      class CreateAdapter
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @global_env = @machine.env
+          @provider = env[:provider]
+          @logger = Log4r::Logger.new('vagrant::persistent_storage::action::create_adapter')
+        end
+
+        def call(env)
+          # skip if machine is not running and the action is destroy, halt or suspend
+          return @app.call(env) if @machine.state.id != :running && [:destroy, :halt, :suspend].include?(env[:machine_action])
+          # skip if machine is not saved and the action is resume
+          return @app.call(env) if @machine.state.id != :saved && env[:machine_action] == :resume
+          # skip if machine is powered off and the action is resume
+          return @app.call(env) if @machine.state.id == :poweroff && env[:machine_action] == :resume
+          # skip if machine is saved
+          return @app.call(env) if @machine.state.id == :saved
+
+          return @app.call(env) unless env[:machine].config.persistent_storage.enabled?
+          @logger.info '** Creating Persistent Storage Adapter **'
+
+          env[:ui].info I18n.t("vagrant_persistent_storage.action.create_adapter")
+          env[:machine].provider.driver.create_adapter
+
+          @app.call(env)
+
+       end
+
+      end
+    end
+  end
+end

data/lib/vagrant-persistent-storage/action/create_storage.rb

@@ -0,0 +1,50 @@
+require "log4r"
+
+module VagrantPlugins
+  module PersistentStorage
+    module Action
+      class CreateStorage
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @global_env = @machine.env
+          @provider = env[:provider]
+          @logger = Log4r::Logger.new('vagrant::persistent_storage::action::create_storage')
+        end
+
+        def call(env)
+          # skip if machine is not running and the action is destroy, halt or suspend
+          return @app.call(env) if @machine.state.id != :running && [:destroy, :halt, :suspend].include?(env[:machine_action])
+          # skip if machine is not saved and the action is resume
+          return @app.call(env) if @machine.state.id != :saved && env[:machine_action] == :resume
+          # skip if machine is powered off and the action is resume
+          return @app.call(env) if @machine.state.id == :poweroff && env[:machine_action] == :resume
+          # skip if machine is saved
+          return @app.call(env) if @machine.state.id == :saved
+
+          return @app.call(env) unless env[:machine].config.persistent_storage.enabled?
+
+          # check config to see if the disk should be created
+          return @app.call(env) unless env[:machine].config.persistent_storage.create?
+
+          if File.exists?(env[:machine].config.persistent_storage.location)
+            @logger.info '** Persistent Storage Volume exists, not creating **'
+            env[:ui].info I18n.t("vagrant_persistent_storage.action.not_creating")
+            @app.call(env)
+
+          else
+            @logger.info '** Creating Persistent Storage **'
+            env[:ui].info I18n.t("vagrant_persistent_storage.action.create_storage")
+            location = env[:machine].config.persistent_storage.location
+            size = env[:machine].config.persistent_storage.size
+            env[:machine].provider.driver.create_storage(location, size)
+            @app.call(env)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-persistent-storage/action/detach_storage.rb

@@ -0,0 +1,34 @@
+require "log4r"
+
+module VagrantPlugins
+  module PersistentStorage
+    module Action
+      class DetachStorage
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @global_env = @machine.env
+          @provider = env[:provider]
+          @logger = Log4r::Logger.new('vagrant::persistent_storage::action::detach_adapter')
+        end
+
+        def call(env)
+          # skip if machine is not saved and the action is resume
+          return @app.call(env) if @machine.state.id != :saved && env[:machine_action] == :resume
+
+          return @app.call(env) unless env[:machine].config.persistent_storage.enabled?
+          @logger.info '** Detaching Persistent Storage **'
+
+          env[:ui].info I18n.t("vagrant_persistent_storage.action.detach_storage")
+          location = env[:machine].config.persistent_storage.location
+          env[:machine].provider.driver.detach_storage(location)
+
+          @app.call(env)
+
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-persistent-storage/action/manage_storage.rb

@@ -0,0 +1,44 @@
+require "log4r"
+require 'vagrant-persistent-storage/manage_storage'
+
+module VagrantPlugins
+  module PersistentStorage
+    module Action
+      class ManageAll
+
+        include ManageStorage
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @global_env = @machine.env
+          @provider = @machine.provider_name
+          @logger = Log4r::Logger.new('vagrant::persistent_storage::action::manage_storage')
+        end
+
+        def call(env)
+          # skip if machine is not running and the action is destroy, halt or suspend
+          return @app.call(env) if @machine.state.id != :running && [:destroy, :halt, :suspend].include?(env[:machine_action])
+          # skip if machine is not saved and the action is resume
+          return @app.call(env) if @machine.state.id != :saved && env[:machine_action] == :resume
+          # skip if machine is powered off and the action is resume
+          return @app.call(env) if @machine.state.id == :poweroff && env[:machine_action] == :resume
+          # skip if machine is powered off and the action is resume
+          return @app.call(env) if @machine.state.id == :saved && env[:machine_action] == :resume
+          
+          return @app.call(env) unless env[:machine].config.persistent_storage.enabled?
+          return @app.call(env) unless env[:machine].config.persistent_storage.manage?
+          @logger.info '** Managing Persistent Storage **'
+
+          env[:ui].info I18n.t('vagrant_persistent_storage.action.manage_storage')
+          machine = env[:machine]
+          manage_volumes(machine)
+
+          @app.call(env)
+
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-persistent-storage/action.rb

@@ -0,0 +1,53 @@
+require "vagrant/action/builder"
+require "vagrant-persistent-storage/action"
+require "vagrant-persistent-storage/action/manage_storage"
+
+module VagrantPlugins
+  module PersistentStorage
+    module Action
+      include Vagrant::Action::Builtin
+
+      autoload :CreateAdapter,             File.expand_path("../action/create_adapter.rb", __FILE__)
+      autoload :CreateStorage,             File.expand_path("../action/create_storage.rb", __FILE__)
+      autoload :AttachStorage,             File.expand_path("../action/attach_storage.rb", __FILE__)
+      autoload :DetachStorage,             File.expand_path("../action/detach_storage.rb", __FILE__)
+      autoload :ManageStorage,             File.expand_path("../action/manage_storage.rb", __FILE__)
+
+      def self.create_adapter
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use CreateAdapter
+        end
+      end
+
+      def self.create_storage
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use CreateStorage
+        end
+      end
+
+      def self.attach_storage
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use AttachStorage
+        end
+      end
+
+      def self.detach_storage
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use DetachStorage
+        end
+      end
+
+      def self.manage_storage
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use ManageAll
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-persistent-storage/config.rb

@@ -1,7 +1,146 @@
-module VagrantPersistentStorage
-  class Config < Vagrant::Config::Base
-    attr_accessor :location
-    attr_accessor :size
+require 'pathname'
+
+module VagrantPlugins
+  module PersistentStorage
+    class Config < Vagrant.plugin('2', :config)
+
+      attr_accessor :size
+      attr_accessor :create
+      attr_accessor :mount
+      attr_accessor :manage
+      attr_accessor :format
+      attr_accessor :enabled
+      attr_accessor :use_lvm
+      attr_accessor :location
+      attr_accessor :mountname
+      attr_accessor :mountpoint
+      attr_accessor :diskdevice
+      attr_accessor :filesystem
+      attr_accessor :volgroupname
+
+      alias_method :create?, :create
+      alias_method :mount?, :mount
+      alias_method :manage?, :manage
+      alias_method :format?, :format
+      alias_method :use_lvm?, :use_lvm
+      alias_method :enabled?, :enabled
+
+      def initialize
+        @size = UNSET_VALUE
+        @create = true
+        @mount = true
+        @manage = true
+        @format = true
+        @use_lvm = true
+        @enabled = false
+        @location = UNSET_VALUE
+        @mountname = UNSET_VALUE
+        @mountpoint = UNSET_VALUE
+        @diskdevice = UNSET_VALUE
+        @filesystem = UNSET_VALUE
+        @volgroupname = UNSET_VALUE
+      end
+
+      def finalize!
+        @size = 0 if @size == UNSET_VALUE
+        @create = true if @create == UNSET_VALUE
+        @mount = true if @mount == UNSET_VALUE
+        @manage = true if @manage == UNSET_VALUE
+        @format = true if @format == UNSET_VALUE
+        @use_lvm = true if @use_lvm == UNSET_VALUE
+        @enabled = false if @enabled == UNSET_VALUE
+        @location = 0 if @location == UNSET_VALUE
+        @mountname = 0 if @mountname == UNSET_VALUE
+        @mountpoint = 0 if @mountpoint == UNSET_VALUE
+        @diskdevice = 0 if @diskdevice == UNSET_VALUE
+        @filesystem = 0 if @filesystem == UNSET_VALUE
+        @volgroupname = 0 if @volgroupname == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << validate_bool('persistent_storage.create', @create)
+        errors << validate_bool('persistent_storage.mount', @mount)
+        errors << validate_bool('persistent_storage.mount', @manage)
+        errors << validate_bool('persistent_storage.mount', @format)
+        errors << validate_bool('persistent_storage.mount', @use_lvm)
+        errors << validate_bool('persistent_storage.mount', @enabled)
+        errors.compact!
+
+        if !machine.config.persistent_storage.size.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.size',
+            :is_class   => size.class.to_s,
+          })
+        end
+        if !machine.config.persistent_storage.location.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.location',
+            :is_class   => location.class.to_s,
+          })
+        end
+        if !machine.config.persistent_storage.mountname.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.mountname',
+            :is_class   => mountname.class.to_s,
+          })
+        end
+        if !machine.config.persistent_storage.mountpoint.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.mountpoint',
+            :is_class   => mountpoint.class.to_s,
+          })
+        end
+        if !machine.config.persistent_storage.diskdevice.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.diskdevice',
+            :is_class   => diskdevice.class.to_s,
+          })
+        end
+        if !machine.config.persistent_storage.filesystem.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.filesystem',
+            :is_class   => filesystem.class.to_s,
+          })
+        end
+        if !machine.config.persistent_storage.volgroupname.kind_of?(String)
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_string', {
+            :config_key => 'persistent_storage.volgroupname',
+            :is_class   => volgroupname.class.to_s,
+          })
+        end
+        
+        mount_point_path = Pathname.new("#{machine.config.persistent_storage.location}")
+        if ! mount_point.path.absolute?
+          errors << I18n.t('vagrant_persistent_storage.config.not_a_path', {
+            :config_key => 'persistent_storage.location',
+            :is_path   => location.class.to_s,
+          })
+        end
+
+        { 'Persistent Storage configuration' => errors }
+
+        if ! File.exists?@location.to_s and ! @create == "true"
+            return { "location" => ["file doesn't exist, and create set to false"] }
+        end
+        {}
+      end
+
+      private
+
+      def validate_bool(key, value)
+        if ![TrueClass, FalseClass].include?(value.class) &&
+           value != UNSET_VALUE
+          I18n.t('vagrant_persistent_storage.config.not_a_bool', {
+            :config_key => key,
+            :value      => value.class.to_s
+          })
+        else
+          nil
+        end
+      end
+
+    end
   end
 end
-

data/lib/vagrant-persistent-storage/manage_storage.rb

@@ -0,0 +1,98 @@
+require 'tempfile'
+require 'fileutils'
+require 'erb'
+
+module VagrantPlugins
+  module PersistentStorage
+    module ManageStorage
+
+      def populate_template(m)
+        mnt_name = m.config.persistent_storage.mountname
+        mnt_point = m.config.persistent_storage.mountpoint
+        vg_name = m.config.persistent_storage.volgroupname
+        disk_dev = m.config.persistent_storage.diskdevice
+        fs_type = m.config.persistent_storage.filesystem
+        manage = m.config.persistent_storage.manage
+        use_lvm = m.config.persistent_storage.use_lvm
+        mount = m.config.persistent_storage.mount
+        format = m.config.persistent_storage.format
+
+        vg_name = 'vps' unless vg_name != 0
+        disk_dev = '/dev/sdb' unless disk_dev != 0
+        mnt_name = 'vps' unless mnt_name != 0
+        fs_type = 'ext3' unless fs_type != 0
+        if use_lvm
+          device = "/dev/#{vg_name}-vg1/#{mnt_name}"
+        else
+          device = "#{disk_dev}1"
+        end
+        
+        ## shell script to format disk, create/manage LVM, mount disk
+        disk_operations_template = ERB.new <<-EOF
+#!/bin/bash
+# fdisk the disk if it's not a block device already:
+[ -b #{disk_dev}1 ] || echo 0,,8e | sfdisk #{disk_dev}
+echo "fdisk returned:  $?" >> disk_operation_log.txt
+
+<% if use_lvm == true %>
+# Create the physical volume if it doesn't already exist:
+[[ `pvs #{disk_dev}1` ]] || pvcreate #{disk_dev}1
+echo "pvcreate returned:  $?" >> disk_operation_log.txt
+# Create the volume group if it doesn't already exist:
+[[ `vgs #{vg_name}-vg1` ]] || vgcreate #{vg_name}-vg1 #{disk_dev}1
+echo "vgcreate returned:  $?" >> disk_operation_log.txt
+# Create the logical volume if it doesn't already exist:
+[[ `lvs #{vg_name}-vg1 | grep #{mnt_name}` ]] || lvcreate -l 100%FREE -n #{mnt_name} #{vg_name}-vg1
+echo "lvcreate returned:  $?" >> disk_operation_log.txt
+# Activate the volume group if it's inactive:
+[[ `lvs #{vg_name}-vg1 --noheadings --nameprefixes | grep LVM2_LV_ATTR | grep "wi\-a"` ]] || vgchange #{vg_name}-vg1 -a y
+echo "vg activation returned:  $?" >> disk_operation_log.txt
+<% end %>
+
+<% if format == true  %>
+# Create the filesytem if it doesn't already exist
+[[ `blkid | grep #{mnt_name} | grep #{fs_type}` ]] || mkfs.#{fs_type} #{device}
+echo "#{fs_type} creation return:  $?" >> disk_operation_log.txt
+<% if mount == true %>
+# Create mountpoint #{mnt_point}
+[ -d #{mnt_point} ] || mkdir -p #{mnt_point}
+# Update fstab with new mountpoint name
+[[ `grep -i #{device} /etc/fstab` ]] || echo #{device} #{mnt_point} #{fs_type} defaults 0 0 >> /etc/fstab
+echo "fstab update returned:  $?" >> disk_operation_log.txt
+# Finally, mount the partition
+[[ `mount | grep #{mnt_point}` ]] || mount #{mnt_point}
+echo "#{mnt_point} mounting returned:  $?" >> disk_operation_log.txt
+<% end %>
+<% end %>
+exit $?
+        EOF
+
+        buffer = disk_operations_template.result(binding)
+        tmp_script = "/tmp/disk_operations_#{mnt_name}.sh"
+        target_script = "/tmp/disk_operations_#{mnt_name}.sh"
+
+        File.open("#{tmp_script}", 'w') do |f|
+            f.write buffer
+        end
+        m.communicate.upload(tmp_script, target_script)
+        m.communicate.sudo("chmod 755 #{target_script}")
+      end
+
+      def run_disk_operations(m)
+        return unless m.communicate.ready?
+        mnt_name = m.config.persistent_storage.mountname
+        mnt_name = 'vps' unless mnt_name != 0
+        target_script = "/tmp/disk_operations_#{mnt_name}.sh"
+        m.communicate.sudo("#{target_script}")
+      end
+
+      def manage_volumes(m)
+        populate_template(m)
+        if m.config.persistent_storage.manage?
+          run_disk_operations(m)
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-persistent-storage/plugin.rb

@@ -0,0 +1,62 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module PersistentStorage
+    class Plugin < Vagrant.plugin('2')
+
+      include Vagrant::Action::Builtin
+
+      require_relative "action"
+      require_relative "providers/virtualbox/driver/base"
+      require_relative "providers/virtualbox/driver/meta"
+
+      name "persistent_storage"
+      description <<-DESC
+      This plugin provides config to attach persistent storage
+      DESC
+
+      config "persistent_storage" do
+        require_relative "config"
+        Config
+      end
+
+      ## NB Currently only works with Virtualbox provider, due to hooks being used
+      action_hook(:persistent_storage, :machine_action_up) do |hook|
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::SaneDefaults,
+                  VagrantPlugins::PersistentStorage::Action.create_adapter
+        hook.before VagrantPlugins::ProviderVirtualBox::Action::Boot,
+                  VagrantPlugins::PersistentStorage::Action.create_storage
+        hook.before VagrantPlugins::ProviderVirtualBox::Action::Boot,
+                  VagrantPlugins::PersistentStorage::Action.attach_storage
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::CheckGuestAdditions,
+                  VagrantPlugins::PersistentStorage::Action.manage_storage
+        hook.after VagrantPlugins::PersistentStorage::Action.attach_storage,
+                  VagrantPlugins::PersistentStorage::Action.manage_storage
+      end
+
+      action_hook(:persistent_storage, :machine_action_destroy) do |hook|
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::action_halt,
+                  VagrantPlugins::PersistentStorage::Action.detach_storage
+        hook.before VagrantPlugins::ProviderVirtualBox::Action::Destroy,
+                  VagrantPlugins::PersistentStorage::Action.detach_storage
+      end
+
+      action_hook(:persistent_storage, :machine_action_halt) do |hook|
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::GracefulHalt,
+                  VagrantPlugins::PersistentStorage::Action.detach_storage
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::ForcedHalt,
+                  VagrantPlugins::PersistentStorage::Action.detach_storage
+      end
+
+      action_hook(:persistent_storage, :machine_action_reload) do |hook|
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::GracefulHalt,
+                  VagrantPlugins::PersistentStorage::Action.detach_storage
+        hook.after VagrantPlugins::ProviderVirtualBox::Action::ForcedHalt,
+                  VagrantPlugins::PersistentStorage::Action.detach_storage
+        hook.before VagrantPlugins::ProviderVirtualBox::Action::Boot,
+                  VagrantPlugins::PersistentStorage::Action.attach_storage
+      end
+
+    end
+  end
+end

data/lib/vagrant-persistent-storage/providers/virtualbox/driver/base.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      class Base
+
+        def create_adapter
+          execute("storagectl", @uuid, "--name", "SATA Controller", "--sataportcount", "2")
+        end
+
+        def create_storage(location, size)
+          execute("createhd", "--filename", location, "--size", "#{size}")
+        end
+
+        def attach_storage(location)
+          execute("storageattach", @uuid, "--storagectl", "SATA Controller", "--port", "1", "--device", "0", "--type", "hdd", "--medium", "#{location}")
+        end
+
+        def detach_storage(location)
+          if location and read_persistent_storage(location) == location
+            execute("storageattach", @uuid, "--storagectl", "SATA Controller", "--port", "1", "--device", "0", "--type", "hdd", "--medium", "none")
+          end
+        end
+
+        def read_persistent_storage(location)
+          ## Ensure previous operations are complete - bad practise yes, not sure how to avoid this:
+          sleep 3
+          info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+            return $1.to_s if line =~ /^"SATA Controller-1-0"="(.+?)"$/
+          end
+          nil
+        end
+
+      end
+    end
+  end
+end
+

data/lib/vagrant-persistent-storage/providers/virtualbox/driver/meta.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      class Meta
+
+        def_delegators :@driver, 
+          :create_storage,
+          :attach_storage,
+          :detach_storage,
+          :read_persistent_storage
+ 
+      end
+    end
+  end
+end
+

data/lib/vagrant-persistent-storage/version.rb

@@ -1,3 +1,5 @@
-module VagrantPersistentStorage
-    VERSION = "0.0.2"
+module VagrantPlugins
+  module PersistentStorage
+    VERSION = "0.0.3"
+  end
 end

data/lib/vagrant-persistent-storage.rb

@@ -1,12 +1,13 @@
-require 'vagrant'
-require 'vagrant/action/builder'
-require 'vagrant-persistent-storage/config'
-require 'vagrant-persistent-storage/middleware'
+require 'vagrant-persistent-storage/plugin'
 require 'vagrant-persistent-storage/version'
 
-Vagrant.config_keys.register(:persistent_storage) { VagrantPersistentStorage::Config }
-Vagrant.actions[:start].insert_after(Vagrant::Action::VM::ShareFolders, VagrantPersistentStorage::AttachPersistentStorage)
-Vagrant.actions[:destroy].insert_after(Vagrant::Action::VM::PruneNFSExports, VagrantPersistentStorage::DetachPersistentStorage)
+module VagrantPlugins
+  module PersistentStorage
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
 
-# Add our custom translations to the load path
-#I18n.load_path << File.expand_path("../../locales/en.yml", __FILE__)
+    I18n.load_path << File.expand_path('locales/en.yml', source_root)
+    I18n.reload!
+  end
+end

data/locales/en.yml

@@ -0,0 +1,12 @@
+en:
+  vagrant_persistent_storage:
+    action:
+      create_adapter: "** Creating adapter for persistent storage **"
+      create_storage: "** Creating persistent storage **"
+      not_creating:   "** Persistent Storage Volume exists, not creating **"
+      attach_storage: "** Attaching persistent storage **"
+      detach_storage: "** Detaching persistent storage **"
+      manage_storage: "** Managing persistent storage **"
+    config:
+      not_a_bool: "A value for %{config_key} can only be true or false, not type '%{value}'"
+      not_an_array_or_string: "A value for %{config_key} must be an Array or String, not type '%{is_class}'"

data/vagrant-persistent-storage.gemspec

@@ -5,7 +5,7 @@ require 'vagrant-persistent-storage/version'
 
 Gem::Specification.new do |gem|
   gem.name          = "vagrant-persistent-storage"
-  gem.version       = VagrantPersistentStorage::VERSION
+  gem.version       = VagrantPlugins::PersistentStorage::VERSION
   gem.authors       = ["Sebastian Kusnier"]
   gem.email         = ["sebastian@kusnier.net"]
   gem.description   = "A Vagrant plugin that creates a persistent storage and attaches it to guest machine."
@@ -17,8 +17,6 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'vagrant'
-
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
 end

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: vagrant-persistent-storage
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 2
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Sebastian Kusnier
@@ -15,48 +9,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-04 00:00:00 Z
+date: 2013-09-08 00:00:00 Z
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: vagrant
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - &id002 
+      - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
-  version_requirements: *id002
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    - *id002
   type: :development
   version_requirements: *id003
 description: A Vagrant plugin that creates a persistent storage and attaches it to guest machine.
@@ -72,46 +43,44 @@ files:
 - .gitignore
 - Gemfile
 - README.md
+- Rakefile
 - lib/vagrant-persistent-storage.rb
+- lib/vagrant-persistent-storage/action.rb
+- lib/vagrant-persistent-storage/action/attach_storage.rb
+- lib/vagrant-persistent-storage/action/create_adapter.rb
+- lib/vagrant-persistent-storage/action/create_storage.rb
+- lib/vagrant-persistent-storage/action/detach_storage.rb
+- lib/vagrant-persistent-storage/action/manage_storage.rb
 - lib/vagrant-persistent-storage/config.rb
-- lib/vagrant-persistent-storage/middleware.rb
-- lib/vagrant-persistent-storage/middleware/attachpersistentstorage.rb
-- lib/vagrant-persistent-storage/middleware/detachpersistentstorage.rb
+- lib/vagrant-persistent-storage/manage_storage.rb
+- lib/vagrant-persistent-storage/plugin.rb
+- lib/vagrant-persistent-storage/providers/virtualbox/driver/base.rb
+- lib/vagrant-persistent-storage/providers/virtualbox/driver/meta.rb
 - lib/vagrant-persistent-storage/version.rb
-- lib/vagrant_init.rb
+- locales/en.yml
 - vagrant-persistent-storage.gemspec
 homepage: https://github.com/kusnier/vagrant-persistent-storage
 licenses: []
 
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id002
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id002
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.7
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Vagrant plugin that creates a persistent storage and attaches it to guest machine.
 test_files: []
 

data/lib/vagrant-persistent-storage/middleware/attachpersistentstorage.rb

@@ -1,26 +0,0 @@
-module VagrantPersistentStorage
-  class AttachPersistentStorage
-    def initialize(app, env)
-      @app = app
-      @env = env
-      @vm = env[:vm]
-    end
-
-    def call(env)
-      options = @vm.config.persistent_storage
-      if !options.location  ^ !options.size
-        env[:ui].error "Attach Persistent Storage failed. Location and size must be filled out."
-      elsif options.location
-        if !File.exists?(options.location)
-          @vm.config.vm.customize ["createhd", "--filename", options.location, "--size", options.size]
-          env[:ui].success "Create Persistent Storage."
-        end
-        @vm.config.vm.customize ["storageattach", :id, "--storagectl", "SATA Controller", "--port", 1, "--type", "hdd", "--medium", options.location]
-
-        env[:ui].info "Attach Persistent Storage #{options.location} (Size: #{options.size}MB)"
-      end
-
-      @app.call(env)
-    end
-  end
-end

data/lib/vagrant-persistent-storage/middleware/detachpersistentstorage.rb

@@ -1,29 +0,0 @@
-module VagrantPersistentStorage
-  class DetachPersistentStorage
-    def initialize(app, env)
-      @app = app
-      @env = env
-      @vm = env[:vm]
-    end
-
-    def call(env)
-      options = @vm.config.persistent_storage
-      if options.location and read_persistent_storage() == options.location
-        @vm.driver.execute("storageattach", @vm.uuid, "--storagectl", "SATA Controller", "--port", "1", "--type", "hdd", "--medium", "none")
-        env[:ui].info "Detach Persistent Storage #{options.location} (Size: #{options.size}MB)"
-      end
-
-      @app.call(env)
-    end
-
-    def read_persistent_storage
-      info = @vm.driver.execute("showvminfo", @vm.uuid, "--machinereadable", :retryable => true)
-      info.split("\n").each do |line|
-        return $1.to_s if line =~ /^"SATA Controller-1-0"="(.+?)"$/
-      end
-
-      nil
-    end
-
-  end
-end

data/lib/vagrant-persistent-storage/middleware.rb

@@ -1,3 +0,0 @@
-Dir[File.dirname(__FILE__) + '/middleware/**/*.rb'].each do |file|
-  require file
-end

data/lib/vagrant_init.rb

@@ -1,4 +0,0 @@
-# This file is automatically loaded by Vagrant to load any
-# plugins. This file kicks off this plugin.
-
-require 'vagrant-persistent-storage'