├── .gitignore
├── Gemfile
├── Gemfile.lock
├── LICENSE.txt
├── README.md
├── Rakefile
├── Vagrantfile
├── box
    └── centos-6-x86_64
    │   ├── VagrantFile
    │   ├── centos-6-x86_64.box
    │   ├── make_box.sh
    │   └── metadata.json
├── lib
    ├── vagrant-openvz.rb
    └── vagrant-openvz
    │   ├── action.rb
    │   ├── action
    │       ├── boot.rb
    │       ├── check_created.rb
    │       ├── check_running.rb
    │       ├── create.rb
    │       ├── created.rb
    │       ├── destroy.rb
    │       ├── destroy_confirm.rb
    │       ├── fetch_ip.rb
    │       ├── forced_halt.rb
    │       ├── is_running.rb
    │       ├── message.rb
    │       └── share_folders.rb
    │   ├── command
    │       └── version.rb
    │   ├── config.rb
    │   ├── driver.rb
    │   ├── driver
    │       └── cli.rb
    │   ├── errors.rb
    │   ├── plugin.rb
    │   ├── provider.rb
    │   ├── sudo_wrapper.rb
    │   └── version.rb
├── vagrant-openvz.gemspec
└── vg.sh


/.gitignore:
--------------------------------------------------------------------------------
1 | .vagrant/
2 | pkg/
3 | solo-setup.sh
4 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | 
3 | # Specify your gem's dependencies in vagrant-openvz.gemspec
4 | gemspec
5 | 
6 | group :development do
7 |   gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
8 | end
9 | 


--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
 1 | GIT
 2 |   remote: git://github.com/mitchellh/vagrant.git
 3 |   revision: 2c8cc95e7928f8d25fb76dbbd9e9132ef08b7649
 4 |   specs:
 5 |     vagrant (1.3.4.dev)
 6 |       childprocess (~> 0.3.7)
 7 |       erubis (~> 2.7.0)
 8 |       i18n (~> 0.6.0)
 9 |       log4r (~> 1.1.9)
10 |       net-scp (~> 1.1.0)
11 |       net-ssh (~> 2.6.6)
12 | 
13 | PATH
14 |   remote: .
15 |   specs:
16 |     vagrant-openvz (0.0.7)
17 | 
18 | GEM
19 |   remote: https://rubygems.org/
20 |   specs:
21 |     childprocess (0.3.9)
22 |       ffi (~> 1.0, >= 1.0.11)
23 |     erubis (2.7.0)
24 |     ffi (1.9.0)
25 |     i18n (0.6.5)
26 |     log4r (1.1.10)
27 |     net-scp (1.1.2)
28 |       net-ssh (>= 2.6.5)
29 |     net-ssh (2.6.8)
30 |     rake (10.1.0)
31 | 
32 | PLATFORMS
33 |   ruby
34 | 
35 | DEPENDENCIES
36 |   bundler (~> 1.3)
37 |   rake
38 |   vagrant!
39 |   vagrant-openvz!
40 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 Aslan Brooke
 2 | 
 3 | MIT License
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining
 6 | a copy of this software and associated documentation files (the
 7 | "Software"), to deal in the Software without restriction, including
 8 | without limitation the rights to use, copy, modify, merge, publish,
 9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # vagrant-openvz
 2 | 
 3 | [![Gem Version](https://badge.fury.io/rb/vagrant-openvz.png)](http://badge.fury.io/rb/vagrant-openvz)
 4 | 
 5 | #### LINUX ONLY TECHNOLOGY.
 6 | 
 7 | This is a provider plugin for vagrant. The provider integrates [OpenVZ](http://openvz.org/Main_Page) with the normal actions associated with vagrant including: up, ssh, halt, destroy.
 8 | 
 9 | Successfully used in combination with the following vagrant plugins:
10 | 
11 | - vagrant-omnibus
12 | - agrant-berkshelf
13 | 
14 | ## Tested Platform 
15 | ##### (vagrant + vagrant-openvz + OpenVZ)
16 | 
17 | - Centos 6.4
18 | - Others may work, though usability unknown as of now.
19 | 
20 | ## Installation through vagrant
21 | 
22 | The plugin requires that you openvz and vagrant be installed. Then run the following from the command line which will install it from rubygems.org:
23 | 
24 | ```shell
25 | vagrant plugin install vagrant-openvz
26 | ```
27 | 
28 | ## Boxes
29 | 
30 | Boxes are bare bones and currently depend on the templates provided by OpenVZ. You can download the one tested box from "box/centos-6-x86_64/centos-6-x86_64.box" in this source repository, however on first usage the actual template for the box will be downloaded through openvz.  Subsequent usages will use the cached template. This means that the second and subsequent usages will be significantly faster.
31 | 
32 | ## Building the plugin
33 | 
34 | 1. Download the source code (if your going to contribute see next section) 
35 | 2. Install bundler
36 | 3. Navigate to the downloaded source code, and within the same folder as the "Gemfile" file run "bundle" to get depedencies.
37 | 
38 | ##### Helpful Reference:
39 | * Book: Vagrant, up and running; Chapter 7; Section "Plugi-In Development Basics"
40 | 
41 | ## Contributing
42 | 
43 | During development on Centos 6(.4), in order to use: "bundle exec vagrant box add" I had to download the latest version of vagrant. Track down "bsdtar" and put it in a new folder, then add the folder path to the PATH. Then export it. This way the functionality would work properly.
44 | 
45 | 1. Fork it
46 | 2. Create your feature branch (`git checkout -b my-new-feature`)
47 | 3. Commit your changes (`git commit -am 'Add some feature'`)
48 | 4. Push to the branch (`git push origin my-new-feature`)
49 | 5. Create new Pull Request
50 | 
51 | ## ROADMAP (Features not yet added).
52 | 
53 | * OpenVZ focused: [Virtual Ethernet devices](http://openvz.org/Virtual_Ethernet_device).
54 | * Vagrant focused: Port Forwarding.
55 | * Vagrant focuused: Improve usage of env[:ui] logging. 
56 | * Vagrant focused: Tokenize all hardcoded text.
57 | 
58 | ## Credits
59 | 
60 | Two other code bases were studied during the creation of this plugin: 
61 | 
62 | - [mitchellh/vagrant](https://github.com/mitchellh/vagrant)
63 | - [fgrehm/vagrant-lxc](https://github.com/fgrehm/vagrant-lxc)
64 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | require "bundler/gem_tasks"
2 | 


--------------------------------------------------------------------------------
/Vagrantfile:
--------------------------------------------------------------------------------
 1 | Vagrant.require_plugin "vagrant-openvz"
 2 | 
 3 | $script = <<SCRIPT
 4 | echo I am provisioning...
 5 | date > /etc/vagrant_provisioned_at
 6 | SCRIPT
 7 |  
 8 | Vagrant.configure('2') do |config|
 9 | 
10 |   config.vm.box = "centos-6-x86_64"
11 | 
12 |   config.vm.define "vz1" do |vm_vz1|
13 |     vm_vz1.vm.provider :openvz do |openvz| 
14 | 	  openvz.vzctid="1"
15 | 	  openvz.physpages="0:1G"
16 | 	  openvz.hostname="vz1"
17 | 	  openvz.ipadd="192.168.101.1"
18 |       #openvz.netadapter="eth1" #Allow this line to give the container complete control over a network adapter.
19 | 	  openvz.nameserver="8.8.8.8"
20 | 	  openvz.diskspace="1000000:1100000"
21 | 	  openvz.diskinodes="100000:101000"
22 | 	  openvz.quotatime="600"
23 | 	  openvz.pubkey="ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key"
24 | 		  end
25 | 		 
26 |     vm_vz1.vm.provision "shell", inline: $script
27 | 
28 |   end
29 | 
30 | 
31 | end
32 | 


--------------------------------------------------------------------------------
/box/centos-6-x86_64/VagrantFile:
--------------------------------------------------------------------------------
 1 | Vagrant.configure("2") do |config|
 2 |   config.vm.provider :openvz do |ovz|
 3 |     ovz.template = "centos-6-x86_64.tar.gz"
 4 |     ovz.physpages = "0:512MB"
 5 |     ovz.nameserver = "8.8.8.8"
 6 |     ovz.diskspace = "2000000:2100000"
 7 |     ovz.diskinodes = "150000:1510000"
 8 |     ovz.quotatime = "600"
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/box/centos-6-x86_64/centos-6-x86_64.box:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/abrooke/vagrant-openvz/be7b8aca4f545843e360f075bc9cb7c592c2961f/box/centos-6-x86_64/centos-6-x86_64.box


--------------------------------------------------------------------------------
/box/centos-6-x86_64/make_box.sh:
--------------------------------------------------------------------------------
1 | tar czf centos-6-x86_64.box VagrantFile metadata.json 
2 | 


--------------------------------------------------------------------------------
/box/centos-6-x86_64/metadata.json:
--------------------------------------------------------------------------------
1 | {
2 |   "provider": "openvz"
3 | }
4 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz.rb:
--------------------------------------------------------------------------------
 1 | begin
 2 |   require "vagrant"
 3 | rescue LoadError
 4 |   raise "This plugin must run within Vagrant."
 5 | end
 6 | 
 7 | require "vagrant-openvz/version"
 8 | require "vagrant-openvz/plugin"
 9 | 
10 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action.rb:
--------------------------------------------------------------------------------
  1 | require 'vagrant-openvz/action/boot'
  2 | require 'vagrant-openvz/action/created'
  3 | require 'vagrant-openvz/action/create'
  4 | require 'vagrant-openvz/action/is_running.rb'
  5 | require 'vagrant-openvz/action/destroy'
  6 | require 'vagrant-openvz/action/destroy_confirm.rb'
  7 | require 'vagrant-openvz/action/forced_halt.rb'
  8 | require 'vagrant-openvz/action/message.rb'
  9 | require 'vagrant-openvz/action/fetch_ip.rb'
 10 | require 'vagrant-openvz/action/check_running.rb'
 11 | require 'vagrant-openvz/action/check_created.rb'
 12 | require 'vagrant-openvz/action/share_folders.rb'
 13 | 
 14 | require "log4r"
 15 | 
 16 | begin
 17 |   require "vagrant/action/builder"
 18 | rescue LoadError
 19 |   raise "This plugin must run within Vagrant."
 20 | end
 21 | 
 22 | module VagrantPlugins
 23 |   module Openvz
 24 | 	module Action
 25 | 	  
 26 | 	  # This action brings the machine up from nothing, including creating the
 27 | 	  # container, and booting.
 28 | 	  def self.action_up
 29 | 		Vagrant::Action::Builder.new.tap do |bldr|
 30 | 		  bldr.use Vagrant::Action::Builtin::ConfigValidate
 31 | 		  bldr.use Vagrant::Action::Builtin::Call, Created do |env, intern_bldr|
 32 | 			# If the VM is NOT created yet, then do the setup steps
 33 | 			if !env[:result]
 34 | 			  intern_bldr.use Vagrant::Action::Builtin::HandleBoxUrl
 35 | 			  intern_bldr.use Create
 36 | 			end
 37 | 		  end
 38 | 		  bldr.use action_start
 39 | 		end
 40 | 	  end
 41 | 
 42 | 	  # This action starts a container, assuming it is already created and exists.
 43 | 	  # A precondition of this action is that the container exists.
 44 | 	  def self.action_start
 45 | 		Vagrant::Action::Builder.new.tap do |bldr|
 46 | 		  bldr.use Vagrant::Action::Builtin::ConfigValidate
 47 | 		  bldr.use Vagrant::Action::Builtin::Call, IsRunning do |env, intern_bldr|
 48 | 			# If the VM is running, then our work here is done, exit
 49 | 			next if env[:result]
 50 | 			intern_bldr.use action_boot
 51 | 		  end
 52 | 		end
 53 | 	  end
 54 | 
 55 | 	  # This action boots the VM, assuming the VM is in a state that requires
 56 | 	  # a bootup (i.e. not saved).
 57 | 	  def self.action_boot
 58 | 		Vagrant::Action::Builder.new.tap do |bldr|
 59 | 		  bldr.use Vagrant::Action::Builtin::Provision
 60 | 		  bldr.use Vagrant::Action::Builtin::EnvSet, :port_collision_repair => true
 61 | 		  bldr.use Vagrant::Action::Builtin::HandleForwardedPortCollisions
 62 | 		  bldr.use ShareFolders
 63 | 		  bldr.use Vagrant::Action::Builtin::SetHostname
 64 | 		  #TODO: Port forwarding.
 65 | 		  bldr.use Boot
 66 | 		  bldr.use Vagrant::Action::Builtin::WaitForCommunicator
 67 | 		end
 68 | 	  end
 69 | 
 70 | 	  # This is the action that is primarily responsible for halting
 71 | 	  # the virtual machine, gracefully or by force.
 72 | 	  def self.action_halt
 73 |         logger = Log4r::Logger.new("vagrant::provider::openvz")
 74 | 		Vagrant::Action::Builder.new.tap do |bldr|
 75 | 		  bldr.use Vagrant::Action::Builtin::Call, Created do |env, intern_bldr|
 76 |             logger.debug("In Action::action_halt, env[:result]=#{env[:result]}") 
 77 | 			if env[:result]
 78 | 			  #TODO: Clear forwarded ports.
 79 | 			  #TODO: Remove Temporary Files
 80 | 			  #TODO: Graceful halt
 81 | 			  intern_bldr.use ForcedHalt
 82 | 			else
 83 | 			  intern_bldr.use Message, :not_created
 84 | 			end
 85 | 		  end
 86 | 		end
 87 | 	  end
 88 | 
 89 | 	  # This is the action that is primarily responsible for completely
 90 | 	  # freeing the resources of the underlying virtual machine.
 91 | 	  def self.action_destroy
 92 | 		Vagrant::Action::Builder.new.tap do |bldr|
 93 | 		  bldr.use Vagrant::Action::Builtin::Call, Created do |env1, intern_bldr|
 94 | 			if !env1[:result]
 95 | 			  intern_bldr.use Message, :not_created
 96 | 			  next
 97 | 			end
 98 | 
 99 | 			intern_bldr.use Vagrant::Action::Builtin::Call, DestroyConfirm do |env2, intern2_bldr|
100 | 			  if env2[:result]
101 | 				intern2_bldr.use Vagrant::Action::Builtin::ConfigValidate
102 | 				intern2_bldr.use Vagrant::Action::Builtin::EnvSet, :force_halt => true
103 | 				intern2_bldr.use action_halt
104 | 				intern2_bldr.use Destroy
105 | 				#TODO: Use Vagrant::Action::Builtin::ProvisionerCleanup (vagrant 1.3+)
106 | 			  else
107 | 			    intern2_bldr.use Message, :will_not_destroy
108 | 			  end
109 | 			end
110 | 		  end
111 | 		end
112 | 	  end
113 | 
114 | 	  # This action is called to read the IP of the container. The IP found
115 |       # is expected to be put into the `:machine_ip` key.
116 |       def self.action_fetch_ip
117 |         Vagrant::Action::Builder.new.tap do |bldr|
118 |           bldr.use Vagrant::Action::Builtin::ConfigValidate
119 |           bldr.use FetchIp
120 |         end
121 |       end
122 |  
123 | 	  # This is the action that will exec into an SSH shell.
124 |       def self.action_ssh
125 |         Vagrant::Action::Builder.new.tap do |bldr|
126 |           bldr.use CheckCreated
127 |           bldr.use CheckRunning
128 |           bldr.use Vagrant::Action::Builtin::SSHExec
129 |         end
130 |       end
131 | 
132 | 	  # This is the action that will run a single SSH command.
133 |       def self.action_ssh_run
134 |         Vagrant::Action::Builder.new.tap do |bldr|
135 |           bldr.use CheckCreated
136 |           bldr.use CheckRunning
137 |           bldr.use Vagrant::Action::Builtin::SSHRun
138 |         end
139 |       end
140 | 
141 | 	  # This action just runs the provisioners on the machine.
142 |       def self.action_provision
143 |         Vagrant::Action::Builder.new.tap do |bldr|
144 |           bldr.use Vagrant::Action::Builtin::ConfigValidate
145 |           bldr.use Vagrant::Action::Builtin::Call, Created do |env1, intern_bldr|
146 |             if !env1[:result]
147 |               intern_bldr.use Message, :not_created
148 |               next
149 |             end
150 | 
151 |             intern_bldr.use Vagrant::Action::Builtin::Call, IsRunning do |env2, intern2_bldr|
152 |               if !env2[:result]
153 |                 intern2_bldr.use Message, :not_running
154 |                 next
155 |               end
156 | 
157 |               intern2_bldr.use Vagrant::Action::Builtin::Provision
158 |             end
159 |           end
160 |         end
161 |       end
162 | 
163 | 	end
164 |   end
165 | end
166 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/boot.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 | 	module Action
 4 | 	  class Boot
 5 | 		def initialize(app, env)
 6 | 		  @app = app
 7 | 		end
 8 | 
 9 | 		def call(env)
10 | 		  @env = env
11 | 
12 | 		  config = env[:machine].provider_config
13 | 
14 | 		  env[:machine].provider.driver.start(config.vzctid,config.pubkey)
15 | 
16 | 		  if ! config.netadapter.nil?
17 | 			env[:machine].provider.driver.set_netadapter(
18 | 			  config.vzctid,config.netadapter
19 | 			)
20 | 		  end
21 | 
22 | 		  @app.call env
23 | 		end
24 | 	  end
25 | 	end
26 |   end
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/check_created.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class CheckCreated
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 |           if env[:machine].state.id == :not_created
11 |             raise Vagrant::Errors::VMNotCreatedError
12 |           end
13 | 
14 |           @app.call(env)
15 |         end
16 |       end
17 |     end
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/check_running.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class CheckRunning
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 |           if env[:machine].state.id != :exist_mounted_running
11 |             raise Vagrant::Errors::VMNotRunningError
12 |           end
13 | 
14 |           @app.call(env)
15 |         end
16 |       end
17 |     end
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/create.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class Create
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 | 		  config = env[:machine].provider_config
11 |           box = env[:machine].box
12 | 
13 |           container_name = "vz#{config.vzctid}"
14 |         
15 | 		  settings={}
16 | 		  settings.merge!(:physpages => config.physpages)
17 |           settings.merge!(:hostname => container_name)
18 | 		  settings.merge!(:ipadd => config.ipadd)
19 |           settings.merge!(:nameserver => config.nameserver)
20 | 		  settings.merge!(:diskspace => config.diskspace)
21 | 		  settings.merge!(:diskinodes => config.diskinodes)
22 | 		  settings.merge!(:quotatime => config.quotatime)
23 |           settings.merge!(:template_name => "#{box.name}")
24 | 
25 |           env[:machine].provider.driver.create(
26 |             container_name,config.vzctid,settings
27 |           )
28 | 
29 |           env[:machine].id = container_name
30 | 
31 |           @app.call env
32 |         end
33 |       end
34 |     end
35 |   end
36 | end
37 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/created.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz 
 3 |     module Action
 4 |       class Created
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 | 
11 |           # Set the result to be true if the machine is created.
12 | 	      env[:result] = true 
13 | 		  env[:result] = false if env[:machine].state.id == :not_created
14 | 
15 |           @app.call(env)
16 |         end
17 |       end
18 |     end
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/destroy.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class Destroy
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 |           config = env[:machine].provider_config
11 | 
12 |           env[:ui].info "Destroying!" 
13 |           env[:machine].provider.driver.destroy(config.vzctid)
14 | 
15 |           env[:machine].id = nil
16 |           @app.call env
17 |         end
18 |       end
19 |     end
20 |   end
21 | end
22 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/destroy_confirm.rb:
--------------------------------------------------------------------------------
 1 | require "vagrant/action/builtin/confirm"
 2 | 
 3 | module VagrantPlugins
 4 |   module Openvz
 5 |     module Action
 6 |       class DestroyConfirm < Vagrant::Action::Builtin::Confirm
 7 |         def initialize(app, env)
 8 |           force_key = :force_confirm_destroy
 9 |           message   = "Destory Confirmation? [y/n] "
10 |           super(app, env, message, force_key)
11 |         end
12 |       end
13 |     end
14 |   end
15 | end
16 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/fetch_ip.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class FetchIp
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 | 		  config = env[:machine].provider_config
11 |          
12 | 		  if config.netadapter.nil?		  
13 |              env[:machine_ip] ||= env[:machine].provider.driver.fetch_ip(config.vzctid)
14 | 		  else
15 | 			 env[:machine_ip] ||= env[:machine].provider.driver.fetch_ip_netadapter(config.vzctid,config.netadapter)
16 |           end
17 | 
18 |           @app.call(env)
19 |         end
20 |       end
21 |     end
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/forced_halt.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class ForcedHalt
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 | 		  config = env[:machine].provider_config
11 | 
12 |           if env[:machine].provider.state.id == :exist_mounted_running
13 | 			env[:machine].provider.driver.forced_halt(config.vzctid)
14 |           end
15 | 
16 |           @app.call(env)
17 |         end
18 |       end
19 |     end
20 |   end
21 | end
22 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/is_running.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class IsRunning
 5 |         def initialize(app, env)
 6 |           @app = app
 7 |         end
 8 | 
 9 |         def call(env)
10 | 
11 |           env[:result] = env[:machine].state.id == :exist_mounted_running
12 | 
13 |           @app.call(env)
14 |         end
15 |       end
16 |     end
17 |   end
18 | end
19 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/message.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     module Action
 4 |       class Message
 5 |         def initialize(app, env, msg_key, type = :info)
 6 |           @app     = app
 7 |           @msg_key = msg_key
 8 |           @type    = type
 9 |         end
10 | 
11 |         def call(env)
12 |           machine = env[:machine]
13 |           message = "#{machine.name}: #{@msg_key}"
14 | 
15 |           env[:ui].send @type, message
16 | 
17 |           @app.call env
18 |         end
19 |       end
20 |     end
21 |   end
22 | end
23 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/action/share_folders.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 | 	module Action
 4 | 	  class ShareFolders
 5 | 		def initialize(app, env)
 6 | 		  @app = app
 7 | 		end
 8 | 
 9 | 		def call(env)
10 | 		  @env = env
11 | 		  prepare_folders
12 | 		  @app.call env
13 | 		  add_folders
14 | 		end
15 | 
16 | 		def shared_folders
17 | 		  {}.tap do |result|
18 | 			@env[:machine].config.vm.synced_folders.each do |id, data|
19 | 			  # This to prevent overwriting the actual shared folders data
20 | 			  result[id] = data.dup
21 | 			end
22 | 		  end
23 | 		end
24 | 
25 | 		# Prepares the shared folders by verifying they exist and creating them
26 | 		# if they don't.
27 | 		def prepare_folders
28 | 		  shared_folders.each do |id, options|
29 | 			hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
30 | 			if !hostpath.directory? && options[:create]
31 | 			  # Host path doesn't exist, so let's create it.
32 | 			  begin
33 | 				hostpath.mkpath
34 | 			  rescue Errno::EACCES
35 | 				raise Vagrant::Errors::SharedFolderCreateFailed,
36 | 				  :path => hostpath.to_s
37 | 			  end
38 | 			end
39 | 		  end
40 | 		end
41 | 
42 | 		def add_folders
43 | 		  folders = []
44 | 		  shared_folders.each do |id, data|
45 | 			folders << {
46 | 			  :name      => id,
47 | 			  :hostpath  => File.expand_path(data[:hostpath], @env[:root_path]),
48 | 			  :guestpath => data[:guestpath]
49 | 			}
50 | 		  end
51 | 		  @env[:machine].provider.driver.share_folders(folders,@env[:machine].provider_config.vzctid)
52 | 		end
53 | 	  end
54 | 	end
55 |   end
56 | end
57 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/command/version.rb:
--------------------------------------------------------------------------------
 1 | 
 2 | module VagrantPlugins
 3 |   module  Openvz
 4 | 	class VzctlVersion < Vagrant.plugin("2", "command")
 5 | 	  def execute
 6 | 		puts `vzctl --version`
 7 | 		return 0
 8 | 	  end
 9 | 	end
10 |   end
11 | end
12 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/config.rb:
--------------------------------------------------------------------------------
 1 | require "vagrant"
 2 | 
 3 | module VagrantPlugins
 4 |   module Openvz
 5 | 	class Config < Vagrant.plugin("2", :config)
 6 | 	  attr_accessor :physpages
 7 | 	  attr_accessor :hostname
 8 | 	  attr_accessor :ipadd
 9 | 	  attr_accessor :netadapter
10 | 	  attr_accessor :nameserver
11 | 	  attr_accessor :vzctid
12 | 	  attr_accessor :pubkey
13 | 	  attr_accessor :diskspace
14 | 	  attr_accessor :diskinodes
15 | 	  attr_accessor :quotatime
16 | 
17 | 	  # A String that points to a file that acts as a wrapper for sudo commands.
18 | 	  # This allows us to have a single entry when whitelisting NOPASSWD commands
19 | 	  # on /etc/sudoers
20 | 	  attr_accessor :sudo_wrapper
21 | 
22 | 	  def initialize
23 | 		@customizations = []
24 | 		@sudo_wrapper   = UNSET_VALUE
25 | 	  end
26 | 
27 | 	  def finalize!
28 | 		@sudo_wrapper = nil if @sudo_wrapper == UNSET_VALUE
29 | 	  end
30 | 
31 | 	  def validate(machine)
32 | 		errors = []
33 | 
34 | 		errors << "config.physpages" if physpages.nil?
35 | 		errors << "config.hostname" if hostname.nil?
36 | 		errors << "config.ipadd or config.netadapter" if ipadd.nil? && netadapter.nil?
37 | 		errors << "config.nameserver" if nameserver.nil?
38 | 		errors << "config.vzctid" if vzctid.nil?
39 | 		errors << "config.pubkey" if pubkey.nil?
40 | 		errors << "config.diskspace" if diskspace.nil?
41 | 		errors << "config.diskinodes" if diskinodes.nil?
42 | 		errors << "config.quotatime" if quotatime.nil?
43 | 
44 | 		if @sudo_wrapper
45 | 		  hostpath = Pathname.new(@sudo_wrapper).expand_path(machine.env.root_path)
46 | 		  if ! hostpath.file?
47 | 			errors << 'vagrant_openvz.sudo_wrapper_not_found'
48 | 		  elsif ! hostpath.executable?
49 | 			errors << 'vagrant_openvz.sudo_wrapper_not_executable'
50 | 		  end
51 | 		end
52 | 
53 | 		{ "openvz provider" => errors }
54 | 	  end
55 | 	end
56 |   end
57 | end
58 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/driver.rb:
--------------------------------------------------------------------------------
  1 | require "vagrant-openvz/errors"
  2 | require "vagrant-openvz/driver/cli"
  3 | require "etc"
  4 | 
  5 | require "log4r"
  6 | 
  7 | 
  8 | module VagrantPlugins
  9 |   module Openvz
 10 | 	class Driver
 11 | 	  
 12 | 	  # This is raised if the container can't be found when initializing it with
 13 | 	  # a name.
 14 | 	  class ContainerNotFound < StandardError; end
 15 | 
 16 | 	  # Root folder where container configs are stored
 17 | 	  CONTAINERS_PATH = '/vz/root/' 
 18 | 
 19 | 	  attr_reader :container_name, :customizations
 20 | 
 21 | 	  def generate_guest_path(path,vzctlid)
 22 |         Pathname.new("#{CONTAINERS_PATH}#{vzctlid}").join(path.gsub(/^\//, ''))
 23 | 	  end
 24 | 
 25 | 	  def initialize(container_name, sudo_wrapper, cli = nil)
 26 |         @logger    = Log4r::Logger.new("vagrant::provider::openvz")
 27 | 		@container_name = container_name
 28 |         @logger.debug("In Driver::initialize, @container_name=#{@container_name}")
 29 | 		@sudo_wrapper   = sudo_wrapper
 30 | 		@cli            = cli || CLI.new(sudo_wrapper, container_name)
 31 | 		# @logger         = Log4r::Logger.new("vagrant::provider::lxc::driver")
 32 | 		@customizations = []
 33 | 	  end
 34 | 
 35 | 	  def share_folders(folders,vzctlid)
 36 |         folders.each do |folder|
 37 |           guestpath = generate_guest_path(folder[:guestpath],vzctlid) 
 38 |           @logger.debug("In Driver::share_folders, guestpath=#{guestpath}")
 39 |           @logger.debug("In Driver::create, guestpath.directory?=#{guestpath.directory?}")
 40 | 		  unless guestpath.directory?
 41 |             begin
 42 |               @logger.debug("Guest path doesn't exist, creating: #{guestpath}")
 43 |               @sudo_wrapper.run("mkdir", '-p', guestpath.to_s)
 44 |             rescue Errno::EACCES
 45 |               raise Vagrant::Errors::SharedFolderCreateFailed, :path => guestpath.to_s
 46 |             end
 47 |           end
 48 |           @cli.share_folder(folder[:hostpath],guestpath)
 49 |         end
 50 |       end
 51 | 
 52 | 	  def validate!
 53 | 		raise ContainerNotFound if @container_name && ! @cli.list.include?(@container_name)
 54 | 	  end
 55 | 
 56 | 	  def create(name,vzctlid,settings={})
 57 |         @logger.debug("In Driver::create, parameter name=#{name}")
 58 | 		@cli.name = @container_name = name
 59 | 		@logger.debug("In Driver::create, @container_name=#{@container_name}")
 60 | 
 61 | 		@cli.create vzctlid, settings 
 62 | 	  end
 63 | 
 64 | 	  def set_netadapter(vzctlid,netadapter)
 65 | 		@logger.info("Adding network adapter: #{netadapter}")
 66 | 		@cli.set_netadapter(vzctlid,netadapter)
 67 | 	  end
 68 | 	
 69 | 	  def start(vzctlid,pubkey)
 70 | 		@logger.info('Starting container...')
 71 | 		@cli.start(vzctlid,pubkey)
 72 | 	  end
 73 | 	  
 74 |       def forced_halt(vzctlid)
 75 |         @logger.info('Shutting down container...')
 76 | 		@cli.stop(vzctlid)
 77 | 	  end
 78 | 
 79 | 	  def destroy(vzctlid)
 80 |         @cli.destroy(vzctlid)
 81 |       end
 82 |     
 83 | 	  def state(vzctlid)
 84 |         if @container_name
 85 |            @cli.status(vzctlid)
 86 |         end
 87 |       end
 88 | 
 89 | 	  def fetch_ip(vzctlid)
 90 | 		@cli.fetch_ip(vzctlid)
 91 | 	  end
 92 | 
 93 | 	  def fetch_ip_netadapter(vzctlid,netadapter)
 94 | 		@cli.fetch_ip_netadapter(vzctlid,netadapter)
 95 | 	  end
 96 | 
 97 | 	end
 98 |   end
 99 | end
100 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/driver/cli.rb:
--------------------------------------------------------------------------------
 1 | 
 2 | module VagrantPlugins
 3 |   module Openvz
 4 | 	class Driver
 5 | 	  class CLI
 6 | 		attr_accessor :name
 7 | 
 8 | 		def initialize(sudo_wrapper, name = nil)
 9 | 		  @sudo_wrapper = sudo_wrapper
10 | 		  @name         = name
11 | 		end
12 | 
13 | 		def list
14 | 		  run(:vzlist,"-a").split(/\s+/).uniq
15 | 		end
16 | 
17 | 		def fetch_ip(vzctlid)
18 | 		  run(:vzlist,"-a","-H","-t","-o","ip","#{vzctlid}")
19 | 		end
20 | 
21 | 		def fetch_ip_netadapter(vzctlid,netadapter)
22 |           run(:vzctl,"exec","#{vzctlid}","ip -4 addr show #{netadapter} | egrep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}' | grep -v 255")
23 | 		end
24 | 		
25 | 		def create(vzctlid,settings={})
26 | 
27 | 		  # run :rsync, settings[:box_location],settings[:template_location] 
28 | 
29 | 		  run :vzctl, 'create', vzctlid, '--ostemplate', settings[:template_name]
30 | 
31 | 		  settings.delete(:box_location)
32 | 		  settings.delete(:template_location)
33 | 		  settings.delete(:template_name)
34 | 
35 | 		  settings.each do |key,value|
36 | 			run :vzctl,'set',vzctlid,"--#{key}","#{value}","--save"  
37 | 		  end
38 | 
39 | 		end
40 | 
41 | 		def set_netadapter(vzctlid,netadapter) 
42 | 		  run :vzctl,'set',vzctlid,"--netdev_add","#{netadapter}","--save"
43 |           run :vzctl,'exec',vzctlid,"ifconfig","#{netadapter}","up"
44 |           run :vzctl,'exec',vzctlid,"dhclient","#{netadapter}"
45 | 		end
46 | 
47 | 		def start(vzctlid,pubkey)
48 | 		  run :vzctl, 'start', "#{vzctlid}"
49 | 		  add_vagrant_user(vzctlid,pubkey)
50 | 		end
51 | 
52 | 		def destroy(vzctlid)
53 | 		  run :vzctl, 'destroy', "#{vzctlid}"
54 | 		end
55 | 
56 | 		def stop(vzctlid)
57 | 		  run :vzctl, 'stop',  "#{vzctlid}"
58 | 		end
59 | 
60 | 		def status(vzctlid)
61 | 		  if @name && run(:vzctl, 'status', "#{vzctlid}") =~ /[a-z]+\s[0-9]+\s([a-z]+)\s([a-z]+)\s([a-z]+)/i
62 | 			status = "#{$1}_#{$2}_#{$3}".downcase.to_sym
63 | 			status
64 | 		  elsif @name
65 | 			:unknown
66 | 		  end
67 | 		end
68 | 
69 | 		def share_folder(source,destination) 
70 |           run :mount, "-o", "bind", "#{source}", "#{destination}"
71 | 		end
72 | 
73 | 		private
74 | 
75 | 		def add_vagrant_user(vzctlid,pubkey)
76 | 		  run :vzctl, "exec",  "#{vzctlid}", "if [[ ! \`grep vagrant /etc/passwd\` ]]; then adduser vagrant; fi"
77 | 		  run :vzctl, "exec",  "#{vzctlid}", "echo 'vagrant:vagrant' | chpasswd"
78 | 		  run :vzctl, "exec",  "#{vzctlid}", "mkdir -p /home/vagrant/.ssh" 
79 | 		  run :vzctl, "exec",  "#{vzctlid}", "echo '#{pubkey}' > /home/vagrant/.ssh/authorized_keys"
80 | 		  run :vzctl, "exec",  "#{vzctlid}", "chown -R vagrant:vagrant /home/vagrant/.ssh"
81 | 		  run :vzctl, "exec",  "#{vzctlid}", "echo 'vagrant    ALL=NOPASSWD:   ALL' > /etc/sudoers.d/vagrant"
82 | 		  run :vzctl, "exec",  "#{vzctlid}", "sed -i -e 's/Defaults    requiretty/#Defaults requiretty/' /etc/sudoers"
83 | 		end
84 | 
85 | 		def run(command, *args)
86 | 		  @sudo_wrapper.run("#{command}", *args)
87 | 		end
88 | 	  end
89 | 	end
90 |   end
91 | end
92 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/errors.rb:
--------------------------------------------------------------------------------
 1 | require 'vagrant/errors'
 2 | 
 3 | module VagrantPlugins
 4 |   module Openvz 
 5 |     module Errors
 6 | 
 7 |       class ExecuteError < Vagrant::Errors::VagrantError
 8 |         error_key(:openvz_execute_error)
 9 |       end
10 | 
11 |       class OpenvzNotInstalled < Vagrant::Errors::VagrantError
12 |         error_key(:openvz_not_installed)
13 |       end
14 | 
15 |       # Box related errors
16 |       class TemplateFileMissing < Vagrant::Errors::VagrantError
17 |         error_key(:openvz_template_file_missing)
18 |       end
19 | 
20 |       class RootFSTarballMissing < Vagrant::Errors::VagrantError
21 |         error_key(:openvz_invalid_box_version)
22 |       end
23 | 
24 |       class IncompatibleBox < Vagrant::Errors::VagrantError
25 |         error_key(:openvz_incompatible_box)
26 |       end
27 |     end
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/plugin.rb:
--------------------------------------------------------------------------------
 1 | require "vagrant"
 2 | 
 3 | module VagrantPlugins
 4 |   module Openvz
 5 | 	class Plugin < Vagrant.plugin("2")
 6 | 
 7 | 	  name "vagrant-openvz"
 8 | 
 9 | 	  description <<-DESC
10 | 	  This plugin installs a provider that allows vagrant to manage
11 | 	  Openvz machine instances.
12 | 	  DESC
13 | 	  
14 | 	  config(:openvz, :provider) do
15 | 		require_relative 'config'
16 | 		Config
17 | 	  end
18 | 
19 | 	  command "vzctl-version" do
20 | 		require_relative "command/version"
21 | 		VzctlVersion	
22 | 	  end
23 | 
24 | 	  provider(:openvz) do
25 | 		require_relative "provider"
26 | 		Provider
27 | 	  end
28 | 
29 | 	end
30 |   end
31 | end
32 | 
33 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/provider.rb:
--------------------------------------------------------------------------------
  1 | begin
  2 |   require "vagrant"
  3 | rescue LoadError
  4 |   raise "This plugin must run within Vagrant."
  5 | end
  6 | 
  7 | require "log4r"
  8 | 
  9 | require "vagrant-openvz/action"
 10 | require "vagrant-openvz/driver"
 11 | require "vagrant-openvz/sudo_wrapper"
 12 | 
 13 | module VagrantPlugins
 14 |   module Openvz
 15 | 	class Provider < Vagrant.plugin("2",:provider)
 16 | 	  attr_reader :driver
 17 | 
 18 | 	  def initialize(machine)
 19 |         @logger    = Log4r::Logger.new("vagrant::provider::openvz")
 20 | 		@machine = machine
 21 | 
 22 | 		ensure_openvz_installed!
 23 | 		machine_id_changed
 24 | 	  end
 25 | 
 26 | 	  def sudo_wrapper
 27 | 		@shell ||= begin
 28 | 	      wrapper = @machine.provider_config.sudo_wrapper
 29 | 	      wrapper = Pathname(wrapper).expand_path(@machine.env.root_path).to_s if wrapper
 30 | 		  SudoWrapper.new(wrapper)
 31 | 		end
 32 | 	  end
 33 | 
 34 | 	  def action(name)
 35 | 		# Attempt to get the action method from the Action class if it
 36 | 		# exists, otherwise return nil to show that we don't support the
 37 | 		# given action.
 38 | 		action_method = "action_#{name}"
 39 | 		return Action.send(action_method) if Action.respond_to?(action_method)
 40 | 		nil
 41 | 	  end
 42 | 
 43 | 	  def ensure_openvz_installed!
 44 | 		unless system("which vzctl > /dev/null")
 45 | 		  raise Errors::OpenvzNotInstalled
 46 | 		end
 47 | 	  end
 48 | 
 49 | 	  # If the machine ID changed, then we need to rebuild our underlying
 50 | 	  # container.
 51 | 	  def machine_id_changed
 52 | 		id = @machine.id
 53 |         @logger.debug("In Provider::machine_id_changed, id=#{id}")
 54 | 
 55 | 		begin
 56 |           @logger.debug("Instantiating the container for: #{id.inspect}")
 57 | 
 58 | 		  @driver = Driver.new(id, self.sudo_wrapper)
 59 | 		  @driver.validate!
 60 | 		rescue Driver::ContainerNotFound
 61 | 		  # The container doesn't exist, so we probably have a stale
 62 | 		  # ID. Just clear the id out of the machine and reload it.
 63 | 		  @logger.debug("Container not found! Clearing saved machine ID and reloading.")
 64 | 		  id = nil
 65 | 		  retry
 66 | 		end
 67 | 	  end
 68 |  
 69 | 	  # Returns the SSH info for accessing the Container.
 70 |       def ssh_info
 71 |         # If the Container is not created then we cannot possibly SSH into it, so
 72 |         # we return nil.
 73 |         return nil if state == :not_created
 74 | 
 75 |         # Run a custom action called "fetch_ip" which does what it says and puts
 76 |         # the IP found into the `:machine_ip` key in the environment.
 77 |         env = @machine.action("fetch_ip")
 78 | 
 79 |         # If we were not able to identify the container's IP, we return nil
 80 |         # here and we let Vagrant core deal with it ;)
 81 |         return nil unless env[:machine_ip]
 82 | 
 83 |         {
 84 |           :host => env[:machine_ip],
 85 |           :port => @machine.config.ssh.guest_port
 86 |         }
 87 |       end
 88 | 
 89 | 	  def state
 90 |         @logger.debug("In Provider::state, @driver.container_name=#{@driver.container_name}")
 91 | 		@logger.debug("In Provider::state, @machine.provider_config.vzctid=#{@machine.provider_config.vzctid}")
 92 | 
 93 |         state_id = nil
 94 | 
 95 |         state_id = :not_created if !@driver.container_name
 96 |         state_id = @driver.state(@machine.provider_config.vzctid) if !state_id
 97 |         state_id = :unknown if !state_id
 98 | 
 99 |         short = state_id.to_s.gsub("_", " ")
100 |         long  = state_id.to_s.gsub("_", " ")
101 | 
102 | 		@logger.debug("In Provider::state, state_id=#{state_id}")
103 |         Vagrant::MachineState.new(state_id, short, long)
104 |       end
105 | 
106 | 	end
107 |   end
108 | end
109 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/sudo_wrapper.rb:
--------------------------------------------------------------------------------
 1 | module VagrantPlugins
 2 |   module Openvz
 3 |     class SudoWrapper
 4 | 
 5 |       # Include this so we can use `Subprocess` more easily.
 6 |       include Vagrant::Util::Retryable
 7 | 
 8 |       def initialize(wrapper_path = nil)
 9 |         @wrapper_path = wrapper_path
10 |         # @logger       = Log4r::Logger.new("vagrant::lxc::shell")
11 |       end
12 | 
13 |       def run(*command)
14 |         command.unshift @wrapper_path if @wrapper_path
15 |         execute *(['sudo'] + command)
16 |       end
17 | 
18 |       def su_c(command)
19 |         su_command = if @wrapper_path
20 |             "#{@wrapper_path} \"#{command}\""
21 |           else
22 |             "su root -c \"#{command}\""
23 |           end
24 |         @logger.debug "Running 'sudo #{su_command}'"
25 |         system "sudo #{su_command}"
26 |       end
27 | 
28 |       private
29 | 
30 |       # TODO: Review code below this line, it was pretty much a copy and
31 |       #       paste from VirtualBox base driver and has no tests
32 |       def execute(*command, &block)
33 |         # Get the options hash if it exists
34 |         opts = {}
35 |         opts = command.pop if command.last.is_a?(Hash)
36 | 
37 |         tries = 0
38 |         tries = 3 if opts[:retryable]
39 | 
40 |         sleep = opts.fetch(:sleep, 1)
41 | 
42 |         # Variable to store our execution result
43 |         r = nil
44 | 
45 |         retryable(:on => Openvz::Errors::ExecuteError, :tries => tries, :sleep => sleep) do
46 |           # Execute the command
47 |           r = raw(*command, &block)
48 | 
49 |           # If the command was a failure, then raise an exception that is
50 |           # nicely handled by Vagrant.
51 |           if r.exit_code != 0
52 |             if @interrupted
53 |               @logger.info("Exit code != 0, but interrupted. Ignoring.")
54 |             else
55 |               raise Openvz::Errors::ExecuteError, :command => command.inspect
56 |             end
57 |           end
58 |         end
59 | 
60 |         # Return the output, making sure to replace any Windows-style
61 |         # newlines with Unix-style.
62 |         r.stdout.gsub("\r\n", "\n")
63 |       end
64 | 
65 |       def raw(*command, &block)
66 |         int_callback = lambda do
67 |           @interrupted = true
68 |           @logger.info("Interrupted.")
69 |         end
70 | 
71 |         # Append in the options for subprocess
72 |         command << { :notify => [:stdout, :stderr] }
73 | 
74 |         Vagrant::Util::Busy.busy(int_callback) do
75 |           Vagrant::Util::Subprocess.execute(*command, &block)
76 |         end
77 |       end
78 |     end
79 |   end
80 | end
81 | 


--------------------------------------------------------------------------------
/lib/vagrant-openvz/version.rb:
--------------------------------------------------------------------------------
1 | module VagrantPlugins
2 |   module Openvz
3 | 	VERSION = "0.0.7"
4 |   end
5 | end
6 | 


--------------------------------------------------------------------------------
/vagrant-openvz.gemspec:
--------------------------------------------------------------------------------
 1 | # coding: utf-8
 2 | lib = File.expand_path('../lib', __FILE__)
 3 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 4 | require 'vagrant-openvz/version'
 5 | 
 6 | Gem::Specification.new do |spec|
 7 |   spec.name          = "vagrant-openvz"
 8 |   spec.version       = VagrantPlugins::Openvz::VERSION
 9 |   spec.authors       = ["Aslan Brooke"]
10 |   spec.email         = ["aslandbrooke@yahoo.com"]
11 |   spec.description   = %q{Vagrant plugin for using OpenVZ as a provider.}
12 |   spec.summary       = %q{Vagrant plugin for using OpenVZ as a provider.}
13 |   spec.homepage      = "https://github.com/abrooke/vagrant-openvz"
14 |   spec.license       = "MIT"
15 | 
16 |   spec.files         = `git ls-files`.split($/)
17 |   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
18 |   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
19 |   spec.require_paths = ["lib"]
20 | 
21 |   spec.add_development_dependency "bundler", "~> 1.3"
22 |   spec.add_development_dependency "rake"
23 | end
24 | 


--------------------------------------------------------------------------------
/vg.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | export VAGRANT_DEFAULT_PROVIDER=openvz
3 | export VAGRANT_LOG=DEBUG
4 | /usr/bin/time bundle exec vagrant $*
5 | 


--------------------------------------------------------------------------------