cjscp-vagrant-persistent-storage 0.0.27

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 345c86f292ea94b18c956ab28c5c1395e1480660
+  data.tar.gz: 5ffa2334fa1e443182b970fd4743f50dbad0b944
+SHA512:
+  metadata.gz: 9cdcd702ae04f959032f4179a89a9bd5c1cba39397f6a591fd81d94cd37c822260ac482adf2e58b06d8d70c7f2e2b97fee4683196bf18f18df6e87a6ca13d577
+  data.tar.gz: 397da654e0091fa52babae060ddcb1e59044c7a839140dc0442e8a98a477f7a625b16a67fe38268290f4b8db8d4d931bc50ac210941f98c29aaa4261f86998c1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-persistent-storage.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sebastian Kusnier
+
+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,92 @@
+# Vagrant::Persistent-Storage
+
+A Vagrant plugin that creates a persistent storage and attaches it to guest machine.
+
+Requires Virtualbox 5
+
+## Installation
+
+    $ 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, 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'
+```
+
+With `config.persistent_storage.mountoptions` you can change the mount options (default: defaults).  
+A example which sets `prjquota` option with xfs.
+```ruby
+config.persistent_storage.mountname    = 'xfs'
+config.persistent_storage.filesystem   = 'xfs'
+config.persistent_storage.mountpoint   = '/mnt/xfs'
+config.persistent_storage.mountoptions = ['defaults', 'prjquota']
+```
+
+Device defaults to `/dev/sdb`. For boxes with multiple disks, make sure you increment the drive:
+```
+config.persistent_storage.diskdevice = '/dev/sdc'
+```
+
+Every `vagrant up` will attach this file as hard disk to the guest machine.
+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
+
+## Windows Guests
+
+Windows Guests must use the WinRM communicator by setting `vm.communicator = 'winrm'`.  An additional option is provided to 
+allow you to set the drive letter using:
+
+```
+config.persistent_storage.drive_letter = 'Z'
+```
+
+Options that are irrelevent to Windows are ignored, such as `mountname`, `filesystem`, `mountpoint` and `volgroupname`.
+
+## Troubleshooting
+
+If your box are not using LVM you must set `config.persistent_storage.use_lvm = false`.
+
+## Supported Providers
+
+* Only the VirtualBox provider is supported.
+
+## Contributors
+
+* [madAndroid](https://github.com/madAndroid)
+* [Jeremiah Snapp](https://github.com/jeremiahsnapp)
+* [Hiroya Ito](https://github.com/hiboma)
+* [joshuata](https://github.com/joshuata)
+* [Ciprian Zaharie](https://github.com/bucatzel)
+* [aishahalim](https://github.com/aishahalim)
+* [Dick Tang](https://github.com/dictcp)
+* [dsmaher](https://github.com/dsmaher)
+* [Marsup](https://github.com/Marsup)
+* [k2s](https://github.com/k2s)
+* [vvavrychuk](https://github.com/vvavrychuk)
+* [Lars Hupfeldt Nielsen](https://github.com/lhupfeldt)
+* [Chen Yu Pao](https://github.com/windperson)
+* [Kris Reese](https://github.com/ktreese)
+* [Henry N.](https://github.com/HenryNe)
+
+## TODO
+
+* There's Always Something to Do
+* Add more options (controller, port, etc.)
+
+
+[vboxmanage_delete]: http://www.virtualbox.org/manual/ch08.html#vboxmanage-registervm "VBoxManage registervm / unregistervm"

data/Rakefile

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

data/lib/vagrant-persistent-storage.rb

@@ -0,0 +1,13 @@
+require 'vagrant-persistent-storage/plugin'
+require 'vagrant-persistent-storage/version'
+
+module VagrantPlugins
+  module PersistentStorage
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+
+    I18n.load_path << File.expand_path('locales/en.yml', source_root)
+    I18n.reload!
+  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/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 or up
+          return @app.call(env) if @machine.state.id == :poweroff && [:resume, :up].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 '** 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?(File.expand_path(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/config.rb

@@ -0,0 +1,152 @@
+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 :mountoptions
+      attr_accessor :diskdevice
+      attr_accessor :filesystem
+      attr_accessor :volgroupname
+	  attr_accessor :drive_letter
+
+      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
+        @mountoptions = UNSET_VALUE
+        @diskdevice = UNSET_VALUE
+        @filesystem = UNSET_VALUE
+        @volgroupname = UNSET_VALUE
+		@drive_letter = 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
+        @mountoptions = 0 if @mountoptions == UNSET_VALUE
+        @diskdevice = 0 if @diskdevice == UNSET_VALUE
+        @filesystem = 0 if @filesystem == UNSET_VALUE
+        @volgroupname = 0 if @volgroupname == UNSET_VALUE
+		@drive_letter = 0 if @drive_letter == 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,149 @@
+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
+        mnt_options = m.config.persistent_storage.mountoptions
+        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
+
+		## windows filesystem options
+		drive_letter = m.config.persistent_storage.drive_letter
+
+		if m.config.vm.communicator == :winrm
+			os = "windows"
+		else
+			os = "linux"
+		end
+
+        vg_name = 'vps' unless vg_name != 0
+        disk_dev = '/dev/sdb' unless disk_dev != 0
+        mnt_name = 'vps' unless mnt_name != 0
+        mnt_options = ['defaults'] unless mnt_options != 0
+        fs_type = 'ext3' unless fs_type != 0
+        if use_lvm
+          device = "/dev/#{vg_name}/#{mnt_name}"
+        else
+          device = "#{disk_dev}1"
+        end
+		if drive_letter == 0
+			drive_letter = ""
+		else
+			drive_letter = "letter=#{drive_letter}"
+		end
+		
+		if os == "windows"
+			## shell script for windows to create NTFS partition and assign drive letter
+			disk_operations_template = ERB.new <<-EOF
+			<% if format == true %>
+			foreach ($disk in get-wmiobject Win32_DiskDrive -Filter "Partitions = 0"){
+				$disk.DeviceID
+				$disk.Index
+				"select disk "+$disk.Index+"`r clean`r create partition primary`r format fs=ntfs unit=65536 quick`r active`r assign #{drive_letter}" | diskpart >> disk_operation_log.txt
+			}
+			<% end %>
+			EOF
+		else
+		## 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:
+re='[0-9][.][0-9.]*[0-9.]*'; [[ $(sfdisk --version) =~ $re ]] && version="${BASH_REMATCH}"
+if ! awk -v ver="$version" 'BEGIN { if (ver < 2.26 ) exit 1; }'; then
+	[ -b #{disk_dev}1 ] || echo 0,,8e | sfdisk #{disk_dev}
+else
+	[ -b #{disk_dev}1 ] || echo ,,8e | sfdisk #{disk_dev}
+fi
+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}` ]] || vgcreate #{vg_name} #{disk_dev}1
+echo "vgcreate returned:  $?" >> disk_operation_log.txt
+# Create the logical volume if it doesn't already exist:
+[[ `lvs #{vg_name} | grep #{mnt_name}` ]] || lvcreate -l 100%FREE -n #{mnt_name} #{vg_name}
+echo "lvcreate returned:  $?" >> disk_operation_log.txt
+# Activate the volume group if it's inactive:
+[[ `lvs #{vg_name} --noheadings --nameprefixes | grep LVM2_LV_ATTR | grep "wi\-a"` ]] || vgchange #{vg_name} -a y
+echo "vg activation returned:  $?" >> disk_operation_log.txt
+<% end %>
+
+<% if format == true  %>
+# Create the filesytem if it doesn't already exist
+MNT_NAME=#{mnt_name}
+[[ `blkid | grep ${MNT_NAME:0:16} | grep #{fs_type}` ]] || mkfs.#{fs_type} -L #{mnt_name} #{device}
+echo "#{fs_type} creation return:  $?" >> disk_operation_log.txt
+<% if mount == true %>
+# if directory already exists, then copy over the contents into the new directory
+[ -d #{mnt_point} ] && mv #{mnt_point} #{mnt_point}_orig
+# 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} #{mnt_options.join(',')} 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
+# if we copied over the orig directory then copy its contents back
+[ -d #{mnt_point}_orig ] && cp -frp #{mnt_point}_orig/* #{mnt_point}/ && rm -fr #{mnt_point}_orig
+<% end %>
+<% end %>
+exit $?
+        EOF
+		end
+
+        buffer = disk_operations_template.result(binding)
+		tmp_script = Tempfile.new("disk_operations_#{mnt_name}.sh")
+
+		if os == 'windows'
+			target_script = "disk_operations_#{mnt_name}.ps1"
+		else
+			target_script = "/tmp/disk_operations_#{mnt_name}.sh"
+		end
+
+        File.open("#{tmp_script.path}", 'wb') do |f|
+            f.write buffer
+        end
+        m.communicate.upload(tmp_script.path, target_script)
+		unless os == 'windows'
+			m.communicate.sudo("chmod 755 #{target_script}")
+		end
+      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
+		if m.config.vm.communicator == :winrm
+			target_script = "disk_operations_#{mnt_name}.ps1"
+			m.communicate.sudo("powershell -executionpolicy bypass -file #{target_script}")
+		else
+			target_script = "/tmp/disk_operations_#{mnt_name}.sh"
+			m.communicate.sudo("#{target_script}")
+		end
+
+      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,104 @@
+require "log4r"
+require 'pathname'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      class Base
+
+        def create_adapter
+          controller_name = get_controller_name
+          if controller_name.nil?
+            controller_name = "SATA Controller"
+            execute("storagectl", @uuid, "--name", controller_name, "--" + ((@version.start_with?("4.3") || @version.start_with?("5.")) ? "" : "sata") + "portcount", "2", "--add", "sata")
+          else
+            execute("storagectl", @uuid, "--name", controller_name, "--" + ((@version.start_with?("4.3") || @version.start_with?("5.")) ? "" : "sata") + "portcount", "2")
+          end
+        end
+
+        def create_storage(location, size)
+          execute("createhd", "--filename", File.expand_path(location), "--size", "#{size}")
+        end
+
+        def attach_storage(location)
+          controller_name = get_controller_name
+          if controller_name.nil?
+            controller_name = "SATA Controller"
+          end
+
+          location_realpath = File.expand_path(location)
+
+          if controller_name.start_with?("IDE")
+              execute("storageattach", @uuid, "--storagectl", get_controller_name, "--port", "1", "--device", "0", "--type", "hdd", "--medium", "#{location_realpath}")
+          elsif controller_name.start_with?("SCSI")
+              execute("storageattach", @uuid, "--storagectl", get_controller_name, "--port", "15", "--device", "0", "--type", "hdd", "--medium", "#{location_realpath}")
+          else
+              execute("storageattach", @uuid, "--storagectl", get_controller_name, "--port", "4", "--device", "0", "--type", "hdd", "--medium", "#{location_realpath}", "--hotpluggable", "on")
+          end
+
+
+        end
+
+        def detach_storage(location)
+          location_realpath = File.expand_path(location)
+          persistent_storage_data = read_persistent_storage(location_realpath)
+          if location and persistent_storage_data and identical_files(persistent_storage_data.location, location_realpath)
+              execute("storageattach", @uuid, "--storagectl", persistent_storage_data.controller, "--port", persistent_storage_data.port, "--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
+          storage_data = nil
+          controller_name = get_controller_name
+          info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+              tmp_storage_data = nil
+              tmp_storage_data = PersistentStorageData.new(controller_name, $1, $3) if line =~ /^"#{controller_name}-(\d+)-(\d+)"="(.*)"/
+
+              if !tmp_storage_data.nil? and tmp_storage_data.location != 'none' and identical_files(File.expand_path(location), tmp_storage_data.location)
+                  storage_data = tmp_storage_data
+              end
+          end
+          return storage_data
+        end
+
+        def identical_files(file1, file2)
+          return (File.exist?(file1) and File.exist?(file2) and File.identical?(Pathname.new(file1).realpath, Pathname.new(file2).realpath))
+        end
+
+        def get_controller_name
+        controller_number = nil
+          controllers = Hash.new
+          info = execute("showvminfo", @uuid, "--machinereadable", :retryable => true)
+          info.split("\n").each do |line|
+            controllers[$1] = $2 if line =~ /^storagecontrollername(\d+)="(.*)"/
+            controller_number = $1 if line =~ /^storagecontrollertype(\d+)="(IntelAhci|PIIX4|LsiLogic)"/
+          end
+
+          if controller_number.nil?
+            return nil
+          end
+
+          return controllers[controller_number]
+        end
+
+        class PersistentStorageData
+
+          attr_accessor :controller
+          attr_accessor :port
+          attr_accessor :location
+
+          def initialize(controller,port,location)
+            @controller = controller
+            @port = port
+            @location = location
+          end
+        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

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module PersistentStorage
+    VERSION = "0.0.27"
+  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/sample-vm/.gitignore

@@ -0,0 +1 @@
+.vagrant

data/sample-vm/Vagrantfile

@@ -0,0 +1,25 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "precise32"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://files.vagrantup.com/precise32.box"
+
+  # configure a persistent storage for mysql data
+  config.persistent_storage.enabled = true
+  config.persistent_storage.location = "virtualdrive.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'
+
+end

data/sample-win-vm/Vagrantfile

@@ -0,0 +1,22 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "myWindowsBox"
+
+  # These are required for Windows machines running under vagrant
+  config.vm.communicator = "winrm"
+  config.winrm.username = "Administrator"
+  config.winrm.password = "Password!"
+
+  # configure a persistent storage for mysql data
+  config.persistent_storage.enabled = true
+  config.persistent_storage.location = "virtualdrive.vdi"
+  config.persistent_storage.size = 5000
+
+end

data/vagrant-persistent-storage.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-persistent-storage/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cjscp-vagrant-persistent-storage"
+  gem.version       = VagrantPlugins::PersistentStorage::VERSION
+  gem.authors       = ["Sebastian Kusnier","Nayeem Syed"]
+  gem.email         = ["sebastian@kusnier.net","developerinlondon@gmail.com"]
+  gem.description   = "A Vagrant plugin that creates a persistent storage and attaches it to guest machine. (cjscp version)"
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/CJSCommonPlatform/vagrant-persistent-storage"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: cjscp-vagrant-persistent-storage
+version: !ruby/object:Gem::Version
+  version: 0.0.27
+platform: ruby
+authors:
+- Sebastian Kusnier
+- Nayeem Syed
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Vagrant plugin that creates a persistent storage and attaches it to
+  guest machine. (cjscp version)
+email:
+- sebastian@kusnier.net
+- developerinlondon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- 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/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
+- locales/en.yml
+- sample-vm/.gitignore
+- sample-vm/Vagrantfile
+- sample-win-vm/Vagrantfile
+- vagrant-persistent-storage.gemspec
+homepage: https://github.com/CJSCommonPlatform/vagrant-persistent-storage
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A Vagrant plugin that creates a persistent storage and attaches it to guest
+  machine. (cjscp version)
+test_files: []