vagrant-openstack-plugin 0.1.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.vagrant
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Vagrantfile

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 (March 14, 2013)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  #gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
+end

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 Mitchell Hashimoto
+Copyright (c) 2013 cloudbau GmbH
+
+MIT License
+
+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,160 @@
+# Vagrant OpenStack Cloud Provider
+
+This is a [Vagrant](http://www.vagrantup.com) 1.1+ plugin that adds a
+[OpenStack Cloud](http://www.openstack.org) provider to Vagrant,
+allowing Vagrant to control and provision machines within an OpenStack
+cloud.
+
+This plugin started as a fork of the Vagrant RackSpace provider.
+
+**Note:** This plugin requires Vagrant 1.1+.
+
+## Features
+
+* Boot OpenStack Cloud instances.
+* SSH into the instances.
+* Provision the instances with any built-in Vagrant provisioner.
+* Minimal synced folder support via `rsync`.
+
+## Usage
+
+Install using standard Vagrant 1.1+ plugin installation methods. After
+installing, `vagrant up` and specify the `openstack` provider. An example is
+shown below.
+
+```
+$ vagrant plugin install vagrant-openstack
+...
+$ vagrant up --provider=openstack
+...
+```
+
+Of course prior to doing this, you'll need to obtain an OpenStack-compatible
+box file for Vagrant.
+
+## Quick Start
+
+After installing the plugin (instructions above), the quickest way to get
+started is to actually use a dummy OpenStack box and specify all the details
+manually within a `config.vm.provider` block. So first, add the dummy
+box using any name you want:
+
+```
+$ vagrant box add dummy https://github.com/cloudbau/vagrant-openstack/raw/master/dummy.box
+...
+```
+
+And then make a Vagrantfile that looks like the following, filling in
+your information where necessary.
+
+```
+require 'vagrant-openstack'
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "dummy"
+
+  config.vm.provider :openstack do |os|    # e.g.
+    os.username = "YOUR USERNAME"          # "#{ENV['OS_USERNAME']}"
+    os.api_key  = "YOUR API KEY"           # "#{ENV['OS_PASSWORD']}" 
+    os.flavor   = /m1.tiny/
+    os.image    = /Ubuntu/
+    os.endpoint = "KEYSTONE AUTH URL"      # "#{ENV['OS_AUTH_URL']}/tokens"  
+    os.keypair_name = "YOUR KEYPAIR NAME"
+    os.ssh_username = "SSH USERNAME"
+  end
+end
+```
+
+And then run `vagrant up --provider=openstack`.
+
+This will start a tiny Ubuntu instance in your OpenStack installation within
+your tenant. And assuming your SSH information was filled in properly
+within your Vagrantfile, SSH and provisioning will work as well.
+
+Note that normally a lot of this boilerplate is encoded within the box
+file, but the box file used for the quick start, the "dummy" box, has
+no preconfigured defaults.
+
+## Box Format
+
+Every provider in Vagrant must introduce a custom box format. This
+provider introduces `openstack` boxes. You can view an example box in
+the [example_box/ directory](https://github.com/cloudbau/vagrant-openstack/tree/master/example_box).
+That directory also contains instructions on how to build a box.
+
+The box format is basically just the required `metadata.json` file
+along with a `Vagrantfile` that does default settings for the
+provider-specific configuration for this provider.
+
+## Configuration
+
+This provider exposes quite a few provider-specific configuration options:
+
+* `api_key` - The API key for accessing OpenStack.
+* `flavor` - The server flavor to boot. This can be a string matching
+  the exact ID or name of the server, or this can be a regular expression
+  to partially match some server flavor.
+* `image` - The server image to boot. This can be a string matching the
+  exact ID or name of the image, or this can be a regular expression to
+  partially match some image.
+* `endpoint` - The keystone authentication URL of your OpenStack installation.
+* `server_name` - The name of the server within the OpenStack Cloud. This
+  defaults to the name of the Vagrant machine (via `config.vm.define`), but
+  can be overridden with this.
+* `username` - The username with which to access OpenStack.
+* `keypair_name` - The name of the keypair to access the machine.
+* `ssh_username` - The username to access the machine.
+
+These can be set like typical provider-specific configuration:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :openstack do |rs|
+    rs.username = "mitchellh"
+    rs.api_key  = "foobarbaz"
+  end
+end
+```
+
+## Networks
+
+Networking features in the form of `config.vm.network` are not
+supported with `vagrant-openstack`, currently. If any of these are
+specified, Vagrant will emit a warning, but will otherwise boot
+the OpenStack server.
+
+## Synced Folders
+
+There is minimal support for synced folders. Upon `vagrant up`,
+`vagrant reload`, and `vagrant provision`, the OpenStack provider will use
+`rsync` (if available) to uni-directionally sync the folder to
+the remote machine over SSH.
+
+This is good enough for all built-in Vagrant provisioners (shell,
+chef, and puppet) to work!
+
+## Development
+
+To work on the `vagrant-openstack` plugin, clone this repository out, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+```
+$ bundle
+```
+
+Once you have the dependencies, verify the unit tests pass with `rake`:
+
+```
+$ bundle exec rake
+```
+
+If those pass, you're ready to start developing the plugin. You can test
+the plugin without installing it into your Vagrant environment by just
+creating a `Vagrantfile` in the top level of this directory (it is gitignored)
+that uses it, and uses bundler to execute Vagrant:
+
+```
+$ bundle exec vagrant up --provider=openstack
+```

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks
+
+# Install the `spec` task so that we can run tests.
+RSpec::Core::RakeTask.new
+
+# Default task is to run the unit tests
+task :default => "spec"

data/example_box/README.md

@@ -0,0 +1,13 @@
+# Vagrant OpenStack Cloud Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `openstack` provider.
+To turn this into a box:
+
+```
+$ tar cvzf openstack.box ./metadata.json ./Vagrantfile
+```
+
+This box works by using Vagrant's built-in Vagrantfile merging to setup
+defaults for OpenStack. These defaults can easily be overwritten by higher-level
+Vagrantfiles (such as project root Vagrantfiles).

data/example_box/metadata.json

@@ -0,0 +1,3 @@
+{
+    "provider": "openstack"
+}

data/lib/vagrant-openstack.rb

@@ -0,0 +1,53 @@
+require "pathname"
+
+require "vagrant-openstack/plugin"
+
+module VagrantPlugins
+  module OpenStack
+    lib_path = Pathname.new(File.expand_path("../vagrant-openstack", __FILE__))
+    autoload :Errors, lib_path.join("errors")
+
+    # This initializes the i18n load path so that the plugin-specific
+    # translations work.
+    def self.init_i18n
+      I18n.load_path << File.expand_path("locales/en.yml", source_root)
+      I18n.reload!
+    end
+
+    # This initializes the logging so that our logs are outputted at
+    # the same level as Vagrant core logs.
+    def self.init_logging
+      # Initialize logging
+      level = nil
+      begin
+        level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+      rescue NameError
+        # This means that the logging constant wasn't found,
+        # which is fine. We just keep `level` as `nil`. But
+        # we tell the user.
+        level = nil
+      end
+
+      # Some constants, such as "true" resolve to booleans, so the
+      # above error checking doesn't catch it. This will check to make
+      # sure that the log level is an integer, as Log4r requires.
+      level = nil if !level.is_a?(Integer)
+
+      # Set the logging level on all "vagrant" namespaced
+      # logs as long as we have a valid level.
+      if level
+        logger = Log4r::Logger.new("vagrant_openstack")
+        logger.outputters = Log4r::Outputter.stderr
+        logger.level = level
+        logger = nil
+      end
+    end
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/lib/vagrant-openstack/action.rb

@@ -0,0 +1,110 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to destroy the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectOpenStack
+            b2.use DeleteServer
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenStack
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenStack
+          b.use ReadState
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+              b2.use MessageAlreadyCreated
+              next
+            end
+
+            b2.use ConnectOpenStack
+            b2.use Provision
+            b2.use SyncFolders
+            b2.use WarnNetworks
+            b2.use CreateServer
+          end
+        end
+      end
+
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncFolders
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectOpenStack, action_root.join("connect_openstack")
+      autoload :CreateServer, action_root.join("create_server")
+      autoload :DeleteServer, action_root.join("delete_server")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :SyncFolders, action_root.join("sync_folders")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+    end
+  end
+end

data/lib/vagrant-openstack/action/connect_openstack.rb

@@ -0,0 +1,36 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action connects to OpenStack, verifies credentials work, and
+      # puts the OpenStack connection object into the `:openstack_compute` key
+      # in the environment.
+      class ConnectOpenStack
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::connect_openstack")
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+          api_key  = config.api_key
+          endpoint = config.endpoint
+          username = config.username
+
+          @logger.info("Connecting to OpenStack...")
+          env[:openstack_compute] = Fog::Compute.new({
+            :provider => :openstack,
+            :openstack_username => username,
+            :openstack_api_key => api_key,
+            :openstack_auth_url => endpoint
+          })
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/create_server.rb

@@ -0,0 +1,117 @@
+require "fog"
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This creates the OpenStack server.
+      class CreateServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::create_server")
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+
+          # Find the flavor
+          env[:ui].info(I18n.t("vagrant_openstack.finding_flavor"))
+          flavor = find_matching(env[:openstack_compute].flavors.all, config.flavor)
+          raise Errors::NoMatchingFlavor if !flavor
+
+          # Find the image
+          env[:ui].info(I18n.t("vagrant_openstack.finding_image"))
+          image = find_matching(env[:openstack_compute].images, config.image)
+          raise Errors::NoMatchingImage if !image
+
+          # Figure out the name for the server
+          server_name = config.server_name || env[:machine].name
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_openstack.launching_server"))
+          env[:ui].info(" -- Flavor: #{flavor.name}")
+          env[:ui].info(" -- Image: #{image.name}")
+          env[:ui].info(" -- Name: #{server_name}")
+
+          # Build the options for launching...
+          options = {
+            :flavor_ref  => flavor.id,
+            :image_ref   => image.id,
+            :name        => server_name,
+            :key_name    => config.keypair_name,
+            :user_data_encoded => Base64.encode64(config.user_data)
+          }
+
+          # Create the server
+          server = env[:openstack_compute].servers.create(options)
+
+          # Store the ID right away so we can track it
+          env[:machine].id = server.id
+
+          # Wait for the server to finish building
+          env[:ui].info(I18n.t("vagrant_openstack.waiting_for_build"))
+          retryable(:on => Timeout::Error, :tries => 200) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # Set the progress
+            env[:ui].clear_line
+            env[:ui].report_progress(server.progress, 100, false)
+
+            # Wait for the server to be ready
+            begin
+              server.wait_for(5) { ready? }
+            rescue RuntimeError => e
+              # If we don't have an error about a state transition, then
+              # we just move on.
+              raise if e.message !~ /should have transitioned/
+              raise Errors::CreateBadState, :state => server.state
+            end
+          end
+
+          if !env[:interrupted]
+            # Clear the line one more time so the progress is removed
+            env[:ui].clear_line
+
+            # Wait for SSH to become available
+            env[:ui].info(I18n.t("vagrant_openstack.waiting_for_ssh"))
+            while true
+              begin
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+              rescue Errno::ENETUNREACH
+              end
+              sleep 2
+            end
+
+            env[:ui].info(I18n.t("vagrant_openstack.ready"))
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # This method finds a matching _thing_ in a collection of
+        # _things_. This works matching if the ID or NAME equals to
+        # `name`. Or, if `name` is a regexp, a partial match is chosen
+        # as well.
+        def find_matching(collection, name)
+          collection.each do |single|
+            return single if single.id == name
+            return single if single.name == name
+            return single if name.is_a?(Regexp) && name =~ single.name
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/delete_server.rb

@@ -0,0 +1,26 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This deletes the running server, if there is one.
+      class DeleteServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::delete_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.deleting_server"))
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            server.destroy
+            env[:machine].id = nil
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/is_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/read_ssh_info.rb

@@ -0,0 +1,46 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:openstack_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(openstack, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = openstack.servers.get(machine.id)
+          if server.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          config = machine.provider_config
+
+          host = server.addresses['public'].last['addr'] rescue nil
+          # Read the DNS info
+          return {
+            # Usually there should only be one public IP
+            :host => host,
+            :port => 22,
+            :username => config.ssh_username
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/read_state.rb

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:openstack_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(openstack, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = openstack.servers.get(machine.id)
+          if server.nil? || server.state == "DELETED"
+            # The machine can't be found
+            @logger.info("Machine not found or deleted, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          return server.state.downcase.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/sync_folders.rb

@@ -0,0 +1,57 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # remote instance.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            env[:ui].info(I18n.t("vagrant_openstack.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "-e", "ssh -p #{ssh_info[:port]} -i '#{ssh_info[:private_key_path]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_openstack.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/config.rb

@@ -0,0 +1,92 @@
+require "vagrant"
+
+module VagrantPlugins
+  module OpenStack
+    class Config < Vagrant.plugin("2", :config)
+      # The API key to access OpenStack.
+      #
+      # @return [String]
+      attr_accessor :api_key
+
+      # The endpoint to access OpenStack. If nil, it will default
+      # to DFW.
+      #
+      # @return [String]
+      attr_accessor :endpoint
+
+      # The flavor of server to launch, either the ID or name. This
+      # can also be a regular expression to partially match a name.
+      attr_accessor :flavor
+
+      # The name or ID of the image to use. This can also be a regular
+      # expression to partially match a name.
+      attr_accessor :image
+
+      # The name of the server. This defaults to the name of the machine
+      # defined by Vagrant (via `config.vm.define`), but can be overriden
+      # here.
+      attr_accessor :server_name
+
+      # The username to access OpenStack.
+      #
+      # @return [String]
+      attr_accessor :username
+      
+      # The name of the keypair to use.
+      #
+      # @return [String]
+      attr_accessor :keypair_name
+
+      # The SSH username to use with this OpenStack instance. This overrides
+      # the `config.ssh.username` variable.
+      #
+      # @return [String]
+      attr_accessor :ssh_username
+
+      # User data to be sent to the newly created OpenStack instance. Use this
+      # e.g. to inject a script at boot time.
+      #
+      # @return [String]
+      attr_accessor :user_data
+
+      def initialize
+        @api_key  = UNSET_VALUE
+        @endpoint = UNSET_VALUE
+        @flavor   = UNSET_VALUE
+        @image    = UNSET_VALUE
+        @server_name = UNSET_VALUE
+        @username = UNSET_VALUE
+        @keypair_name = UNSET_VALUE
+        @ssh_username = UNSET_VALUE
+        @user_data = UNSET_VALUE
+      end
+
+      def finalize!
+        @api_key  = nil if @api_key == UNSET_VALUE
+        @endpoint = nil if @endpoint == UNSET_VALUE
+        @flavor   = /m1.tiny/ if @flavor == UNSET_VALUE
+        @image    = /cirros/ if @image == UNSET_VALUE
+        @server_name = nil if @server_name == UNSET_VALUE
+        @username = nil if @username == UNSET_VALUE
+
+        # Keypair defaults to nil
+        @keypair_name = nil if @keypair_name == UNSET_VALUE
+        
+        # The SSH values by default are nil, and the top-level config
+        # `config.ssh` values are used.
+        @ssh_username = nil if @ssh_username == UNSET_VALUE
+        
+        @user_data = "" if @user_data == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << I18n.t("vagrant_openstack.config.api_key_required") if !@api_key
+        errors << I18n.t("vagrant_openstack.config.username_required") if !@username
+        
+        { "OpenStack Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/errors.rb

@@ -0,0 +1,27 @@
+require "vagrant"
+
+module VagrantPlugins
+  module OpenStack
+    module Errors
+      class VagrantOpenStackError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_openstack.errors")
+      end
+
+      class CreateBadState < VagrantOpenStackError
+        error_key(:create_bad_state)
+      end
+
+      class NoMatchingFlavor < VagrantOpenStackError
+        error_key(:no_matching_flavor)
+      end
+
+      class NoMatchingImage < VagrantOpenStackError
+        error_key(:no_matching_image)
+      end
+
+      class RsyncError < VagrantOpenStackError
+        error_key(:rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/plugin.rb

@@ -0,0 +1,37 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The OpenStack Cloud provider must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.1.0"
+  raise "OpenStack Cloud provider is only compatible with Vagrant 1.1+"
+end
+
+module VagrantPlugins
+  module OpenStack
+    class Plugin < Vagrant.plugin("2")
+      name "OpenStack Cloud"
+      description <<-DESC
+      This plugin enables Vagrant to manage machines in OpenStack Cloud.
+      DESC
+
+      config(:openstack, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:openstack) do
+        # Setup some things
+        OpenStack.init_i18n
+        OpenStack.init_logging
+
+        # Load the actual provider
+        require_relative "provider"
+        Provider
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/provider.rb

@@ -0,0 +1,50 @@
+require "vagrant"
+
+require "vagrant-openstack/action"
+
+module VagrantPlugins
+  module OpenStack
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_openstack.states.short_#{state_id}")
+        long  = I18n.t("vagrant_openstack.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        "OpenStack Cloud"
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module OpenStack
+    VERSION = "0.1.1"
+  end
+end

data/locales/en.yml

@@ -0,0 +1,73 @@
+en:
+  vagrant_openstack:
+    already_created: |-
+      The server is already created.
+    deleting_server: |-
+      Deleting server...
+    finding_flavor: |-
+      Finding flavor for server...
+    finding_image: |-
+      Finding image for server...
+    launching_server: |-
+      Launching a server with the following settings...
+    not_created: |-
+      The server hasn't been created yet. Run `vagrant up` first.
+    ready: |-
+      The server is ready!
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    waiting_for_build: |-
+      Waiting for the server to be built...
+    waiting_for_ssh: |-
+      Waiting for SSH to become available...
+    warn_networks: |-
+      Warning! The OpenStack provider doesn't support any of the Vagrant
+      high-level network configurations (`config.vm.network`). They
+      will be silently ignored.
+
+    config:
+      api_key_required: |-
+        An API key is required.
+      username_required: |-
+        A username is required.
+
+    errors:
+      create_bad_state: |-
+        While creating the server, it transitioned to an unexpected
+        state: '%{state}', instead of properly booting. Run `vagrant status`
+        to find out what can be done about this state, or `vagrant destroy`
+        if you want to start over.
+      no_matching_flavor: |-
+        No matching flavor was found! Please check your flavor setting
+        to make sure you have a valid flavor chosen.
+      no_matching_image: |-
+        No matching image was found! Please check your image setting to
+        make sure you have a valid image chosen.
+      rsync_error: |-
+        There was an error when attemping to rsync a share folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+
+    states:
+      short_active: |-
+        active
+      long_active: |-
+        The server is up and running. Run `vagrant ssh` to access it.
+      short_build: |-
+        building
+      long_build: |-
+        The server is currently being built. You must wait for this to
+        complete before you can access it. You can delete the server, however,
+        by running `vagrant destroy`.
+      short_error: |-
+        error
+      long_error: |-
+        The server is in an erroneous state. Destroy the machine with
+        `vagrant destroy`.
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The server is not created. Run `vagrant up` to create it.

data/spec/vagrant-openstack/config_spec.rb

@@ -0,0 +1,67 @@
+require "vagrant-openstack/config"
+
+describe VagrantPlugins::OpenStack::Config do
+  describe "defaults" do
+    let(:vagrant_public_key) { Vagrant.source_root.join("keys/vagrant.pub") }
+
+    subject do
+      super().tap do |o|
+        o.finalize!
+      end
+    end
+
+    its(:api_key)  { should be_nil }
+    its(:endpoint) { should be_nil }
+    its(:flavor)   { should eq(/m1.tiny/) }
+    its(:image)    { should eq(/cirros/) }
+    its(:server_name) { should be_nil }
+    its(:username) { should be_nil }
+    its(:keypair_name) { should be_nil }
+    its(:ssh_username) { should be_nil }
+  end
+
+  describe "overriding defaults" do
+    [:api_key,
+      :endpoint,
+      :flavor,
+      :image,
+      :server_name,
+      :username,
+      :keypair_name,
+      :ssh_username].each do |attribute|
+      it "should not default #{attribute} if overridden" do
+        subject.send("#{attribute}=".to_sym, "foo")
+        subject.finalize!
+        subject.send(attribute).should == "foo"
+      end
+    end
+  end
+
+  describe "validation" do
+    let(:machine) { double("machine") }
+
+    subject do
+      super().tap do |o|
+        o.finalize!
+      end
+    end
+
+    context "with good values" do
+      it "should validate"
+    end
+
+    context "the API key" do
+      it "should error if not given"
+    end
+
+    context "the public key path" do
+      it "should have errors if the key doesn't exist"
+      it "should not have errors if the key exists with an absolute path"
+      it "should not have errors if the key exists with a relative path"
+    end
+
+    context "the username" do
+      it "should error if not given"
+    end
+  end
+end

data/vagrant-openstack.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-openstack/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "vagrant-openstack-plugin"
+  gem.version       = VagrantPlugins::OpenStack::VERSION
+  gem.authors       = ["Mitchell Hashimoto"]
+  gem.email         = ["mitchell@hashicorp.com"]
+  gem.description   = "Enables Vagrant to manage machines in OpenStack Cloud."
+  gem.summary       = "Enables Vagrant to manage machines in OpenStack Cloud."
+  gem.homepage      = "http://www.vagrantup.com"
+
+  gem.add_runtime_dependency "fog", "~> 1.6.0"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec", "~> 2.13.0"
+
+  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"]
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-openstack-plugin
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Mitchell Hashimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: Enables Vagrant to manage machines in OpenStack Cloud.
+email:
+- mitchell@hashicorp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dummy.box
+- example_box/README.md
+- example_box/metadata.json
+- lib/vagrant-openstack.rb
+- lib/vagrant-openstack/action.rb
+- lib/vagrant-openstack/action/connect_openstack.rb
+- lib/vagrant-openstack/action/create_server.rb
+- lib/vagrant-openstack/action/delete_server.rb
+- lib/vagrant-openstack/action/is_created.rb
+- lib/vagrant-openstack/action/message_already_created.rb
+- lib/vagrant-openstack/action/message_not_created.rb
+- lib/vagrant-openstack/action/read_ssh_info.rb
+- lib/vagrant-openstack/action/read_state.rb
+- lib/vagrant-openstack/action/sync_folders.rb
+- lib/vagrant-openstack/action/warn_networks.rb
+- lib/vagrant-openstack/config.rb
+- lib/vagrant-openstack/errors.rb
+- lib/vagrant-openstack/plugin.rb
+- lib/vagrant-openstack/provider.rb
+- lib/vagrant-openstack/version.rb
+- locales/en.yml
+- spec/vagrant-openstack/config_spec.rb
+- vagrant-openstack.gemspec
+homepage: http://www.vagrantup.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -650629708573648818
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -650629708573648818
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Enables Vagrant to manage machines in OpenStack Cloud.
+test_files:
+- spec/vagrant-openstack/config_spec.rb