openstack-vagrant 1.1.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjUzZWU1ZjcyOTgwZTg2Yjg1NjMwN2IwNzE0NGM1ZjRmOTY5NThhOA==
+  data.tar.gz: !binary |-
+    ZTJjMjk1MzcxOWZlOGViODVlNjJmMjA4NDBlOTNmNTIzNjlmYmZhNQ==
+SHA512:
+  metadata.gz: !binary |-
+    YzM2MWU5NDUxODEzYjhkZDk2YjRhYmJhZTk1YzkxMTIxZTBkZjlhNmE3M2E1
+    ZDgwMzgxNzMzYmNkYTQ4MGZhZmI3MzViZjQzYWU1ZWRlZTg0ZjMyODUxY2Zm
+    OTQxNTBlYzkxZDVlODhjMTAzN2U0ZTBhMjlhZmU0ZmQyNzkxY2M=
+  data.tar.gz: !binary |-
+    NTU5ZmNlODNmNjkzMmFkMmZlNGViYWNiZDNlMmZiZjQ1MWVjMDM2YThhNTY4
+    Y2JiMTU1YWIwZmZlOThhZDMzMDQwMzk1NGEwNDNjMmYwYjBjNTA2YWUzZTQ0
+    MzU1NDc2MDYxMzMxNDYxZGYyMjhkMjMwYzM3YjVhYzhhY2U0YzA=

data/.gitignore

@@ -0,0 +1,23 @@
+.rspec
+.idea
+*.iml
+*.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
+vendor/

data/.travis.yml

@@ -0,0 +1,11 @@
+sudo: false
+rvm:
+- 2.0.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: D4lNAf8yFYcAJH0A6pmDjSMKxNgYZI2etr1dWeK/IWUOY21Q+G9+QkgeDFvIIzWxyKRCg8ONAmDw5Sav74CJsY+8uDNqxTvfnaJ+l3fRGHJiOpLWvBY/uRh8jGdgtuPf+cVqwYKYZxE2siHh7NI8pOBdAqLVou9CSO1Ab8ZVJdc=
+  gem: openstack-vagrant
+  on:
+    tags: true
+    repo: mat128/openstack-vagrant

data/Gemfile

@@ -0,0 +1,11 @@
+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", :tag => 'v1.8.1'
+  gem 'simplecov', :require => false
+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,169 @@
+# Vagrant OpenStack Cloud Provider
+[![Build Status](https://travis-ci.org/mat128/openstack-vagrant.png?branch=master)](https://travis-ci.org/mat128/openstack-vagrant)
+
+This is a [Vagrant](http://www.vagrantup.com) 1.2+ plugin that adds an
+[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.2+. The last version of this plugin supporting Vagrant 1.1 is 0.3.0.
+
+## Features
+
+* Boot OpenStack Cloud instances.
+* SSH into the instances.
+* Provision the instances with any built-in Vagrant provisioner.
+* Minimal synced folder support via `rsync`.
+* Create instances with a specific list of networks
+
+## Usage
+
+```
+$ git clone https://github.com/mat128/openstack-vagrant.git
+$ cd openstack-vagrant
+$ gem build openstack-vagrant.gemspec
+$ vagrant plugin install openstack-vagrant-*.gem
+...
+$ 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/mat128/openstack-vagrant/raw/master/dummy.box
+...
+```
+
+And then make a Vagrantfile that looks like the following, filling in
+your information where necessary.
+
+```
+require 'openstack-vagrant'
+
+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"
+    os.public_network_name = "NAME OF THE PUBLIC NETWORK"
+    os.networks = %w(net1 net2 net3)
+    os.tenant = "NAME OF THE TENANT"
+    os.region = "REGION_NAME"
+  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/mat128/openstack-vagrant/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.
+* `public_network_name` - The name of the public network within your Openstack cluster
+* `networks` - A list -- use %w(net1 net2) -- of networks to configure
+  on your instance.
+* `tenant` - The name of the tenant on which the virtual machine should spawn.
+
+These can be set like typical provider-specific configuration:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :openstack do |os|
+    os.username = "mitchellh"
+    os.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/action/connect_openstack.rb

@@ -0,0 +1,34 @@
+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
+          @logger.info("Connecting to OpenStack Compute...")
+          env[:openstack_compute] = Fog::Compute.new({
+                        :provider => :openstack,
+                        :openstack_region => config.region,
+                        :openstack_username => config.username,
+                        :openstack_api_key => config.api_key,
+                        :openstack_auth_url => config.endpoint,
+                        :openstack_tenant => config.tenant
+                    })
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+require "fog"
+require "log4r"
+require "json"
+
+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 server_to_be_available?(server)
+          raise if server.state == 'ERROR'
+          server.state == 'ACTIVE'
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+
+          if !config.networks.nil? and config.networks.any?
+            @logger.info("Connecting to OpenStack Network...")
+            env[:openstack_network] = Fog::Network.new({
+                          :provider => :openstack,
+                          :openstack_region => config.region,
+                          :openstack_username => config.username,
+                          :openstack_api_key => config.api_key,
+                          :openstack_auth_url => config.endpoint,
+                          :openstack_tenant => config.tenant
+                      })
+          end
+
+          # 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
+
+          # Find the networks
+          effective_networks = []
+          if !config.networks.nil? and config.networks.any?
+            env[:ui].info(I18n.t("vagrant_openstack.finding_network"))
+            available_networks = env[:openstack_network].list_networks[:body]["networks"]
+
+            for network_name in config.networks
+              match = find_matching(available_networks, network_name)
+              unless match
+                raise Errors::NoMatchingNetwork,
+                      :network_name => network_name
+              end
+              effective_networks << match
+            end
+          end
+
+          # 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}")
+          if effective_networks.any?
+            env[:ui].info(' -- Network(s): ')
+            for net in effective_networks
+              env[:ui].info("      - #{net['name']}")
+            end
+          end
+          env[:ui].info(" -- Name: #{server_name}")
+
+          openstack_nics = []
+
+          for net in effective_networks
+            openstack_nics << {'net_id' => net['id']}
+          end
+
+          # 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),
+            :metadata           => config.metadata,
+            :os_scheduler_hints => config.scheduler_hints
+          }
+
+          if openstack_nics.any?
+            options[:nics] = openstack_nics
+          end
+
+          # 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("Instance UUID: #{env[:machine].id}")
+          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]
+
+            # Wait for the server to be ready
+            begin
+              (1..120).each do |n|
+                env[:ui].clear_line
+                env[:ui].report_progress(n, 120, true)
+                server = env[:openstack_compute].servers.get(env[:machine].id)
+                break if self.server_to_be_available?(server)
+                sleep 1
+              end
+              server = env[:openstack_compute].servers.get(env[:machine].id)
+              raise unless self.server_to_be_available?(server)
+            rescue
+              raise Errors::CreateBadState, :state => server.state
+            end
+          end
+
+          env[:machine].data_dir.join("cached_metadata").open("w+") do |f|
+            f.write(server.to_json)
+          end
+
+          unless env[:interrupted]
+            # Clear the line one more time so the progress is removed
+            env[:ui].clear_line
+            ssh_is_responding?(env)
+            env[:ui].info(I18n.t("vagrant_openstack.ready"))
+          end
+
+          @app.call(env)
+        end
+        protected
+
+        def ssh_responding?(env)
+           begin
+             # Wait for SSH to become available
+             env[:ui].info(I18n.t("vagrant_openstack.waiting_for_ssh"))
+             (1..60).each do |n|
+               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
+             raise unless env[:machine].communicate.ready?
+           rescue
+             raise Errors::SshUnavailable
+           end
+        end
+
+        # 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|
+            if single.is_a?(Hash)
+              return single if single['name'] == name
+            else
+              return single if single.id == name
+              return single if single.name == name
+              return single if name.is_a?(Regexp) && name =~ single.name
+            end
+          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_from_api.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 ReadSSHInfoFromAPI
+        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[config.public_network_name].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