vagrant-cloudstack 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 065d4c664b0264e9b6ed28dbeb4795923e3d0a7b
-  data.tar.gz: d975ba10d423c87128bb87defe72da057ac250d5
+  metadata.gz: 41759a933a26fc03edb1e84909cf4dc04f63c46a
+  data.tar.gz: f77c0919074fd8a7c9694b8c8f55b1b672fcaa0f
 SHA512:
-  metadata.gz: 511d4d6baf9eb3d4de13c83558e9bd8bd65a851ba2466cd1aac9b524714ede49367e2af24f2275747ac6d632cd73c25e5c5f350acfe0f86ab733a72dc9493aef
-  data.tar.gz: 278f00212ded80fb43f03e4894af1f5888e01094fbf20fbe4c476b48ce4a275eeb5306aafde1df5e8fac1df70d0c2ca6cbd801cb071095bbb410c9174c39c35a
+  metadata.gz: 2a9d4dc84e206fc45e88647629858245be3e37d3c5be0a9a98a6b68727aaf5774019e17fb0482fa6abb8d733fc2a82f5b824e562c479b09f80955b8890898b73
+  data.tar.gz: 8001d1b9bddc343a9113a6c279693a4d810ffb72d4b501ae118ff1ddd5523038a5611fbd1a51e1192eb14b7ad50060dfbd2e82956c4c857af9cb6fb7ef191979

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.10.0 (Sep 11, 2014)
+* Clean up code base DRY
+* Improve documentation
+* Use URL safe base 64 encoding
+
 # 0.9.1 (Jun 29, 2014)
 * Fixed a bug intrcduced in 0.9.0, where we failed to fetch correct
   name because we didn't pass the correct parameters.

data/README.md

@@ -204,6 +204,69 @@ supported with `vagrant-cloudstack`, currently. If any of these are
 specified, Vagrant will emit a warning, but will otherwise boot
 the Cloudstack machine.
 
+### Basic Networking
+
+If you set the `network_type` to `basic`, you can use Security 
+Groups and associate rules in your Vagrantfile.
+
+If you already have Security Groups, you can associate them to your
+instance, with their IDs:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :cloudstack do |cloudstack|
+    cloudstack.api_key = "foo"
+    cloudstack.secret_key = "bar"
+    cloudstack.network_type = "basic"
+    cloudstack.security_group_ids = ['aaaa-bbbb-cccc-dddd', '1111-2222-3333-4444']
+  end
+end
+```
+
+or their names:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :cloudstack do |cloudstack|
+    cloudstack.api_key = "foo"
+    cloudstack.secret_key = "bar"
+    cloudstack.network_type = "basic"
+    cloudstack.security_group_names = ['
+min_fantastiska_security_group', 'another_security_grupp']
+  end
+end
+```
+
+But you can also create your Security Groups in the Vagrantfile:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :cloudstack do |cloudstack|
+    cloudstack.api_key = "foo"
+    cloudstack.secret_key = "bar"
+    cloudstack.network_type = "basic"
+    cloudstack.security_groups = [
+      { 
+        :name         => "Awesome_security_group",
+        :description  => "Created from the Vagrantfile",
+    		:rules 				=> [
+				  {:type => "ingress", :protocol => "TCP", :startport => 22, :endport => 22, :cidrlist => "0.0.0.0/0"},
+				  {:type => "ingress", :protocol => "TCP", :startport => 80, :endport => 80, :cidrlist => "0.0.0.0/0"},
+          {:type => "egress",  :protocol => "TCP", :startport => 81, :endport => 82, :cidrlist => "1.2.3.4/24"},
+			  ]
+      }
+    ]
+  end
+end
+```
+
+
 ## Synced Folders
 
 There is minimal support for synced folders. Upon `vagrant up`,

data/build_rpm.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-VERSION=0.9.1
+VERSION=0.10.0
 mkdir -p /tmp/vagrant-cloudstack-build_rpm.$$/vagrant-cloudstack-$VERSION
 cp -r . /tmp/vagrant-cloudstack-build_rpm.$$/vagrant-cloudstack-$VERSION/
 tar -C /tmp/vagrant-cloudstack-build_rpm.$$/ -czf ~/rpmbuild/SOURCES/vagrant-cloudstack-$VERSION.tar.gz vagrant-cloudstack-$VERSION

data/lib/vagrant-cloudstack/action/run_instance.rb

@@ -74,6 +74,24 @@ module VagrantPlugins
                                                                       'templatefilter' => 'executable'})
           end
 
+          # Can't use Security Group IDs and Names at the same time
+          # Let's use IDs by default...
+          if security_group_ids.empty? and !security_group_names.empty?
+            security_group_ids = security_group_names.map { |name| name_to_id(env, name, "security_group") }
+          elsif !security_group_ids.empty?
+            security_group_names = security_group_ids.map { |id| id_to_name(env, id, "security_group") }
+          end
+
+          # Still no security group ids huh?
+          # Let's try to create some security groups from specifcation, if provided.
+          if !security_groups.empty? and security_group_ids.empty?
+            security_groups.each do |security_group|
+              sgname, sgid = create_security_group(env, security_group)
+              security_group_names.push(sgname)
+              security_group_ids.push(sgid)
+            end
+          end
+
           # If there is no keypair then warn the user
           if !keypair
             env[:ui].warn(I18n.t("vagrant_cloudstack.launch_no_keypair"))
@@ -87,25 +105,6 @@ module VagrantPlugins
             display_name = local_user + "_" + prefix + "_#{Time.now.to_i}"
           end
 
-          # Can't use Security Group IDs and Names at the same time
-          # Let's use IDs by default...
-          if !security_group_ids.nil?
-            if !security_group_names.nil?
-              env[:ui].warn("Security Group Names won't be used since Security Group IDs are declared")
-              security_group_names = nil
-            end
-
-            if !security_groups.nil?
-              env[:ui].warn("Security Groups defined in Vagrantfile won't be used since Security Group IDs are declared")
-              security_groups = nil
-            end
-          else # security_group_ids is nil
-            if !security_group_names.nil? && !security_groups.nil?
-              env[:ui].warn("Security Groups defined in Vagrantfile won't be used since Security Group Names are declared")
-              security_groups = nil
-            end
-          end
-
           # Launch!
           env[:ui].info(I18n.t("vagrant_cloudstack.launching_instance"))
           env[:ui].info(" -- Display Name: #{display_name}")
@@ -117,99 +116,30 @@ module VagrantPlugins
           env[:ui].info(" -- Network: #{network_name} (#{network_id})") if !network_id.nil? or !network_name.nil?
           env[:ui].info(" -- Keypair: #{keypair}") if keypair
           env[:ui].info(" -- User Data: Yes") if user_data
-          if !security_group_ids.nil?
-            security_group_ids.each do |security_group_id|
-              env[:ui].info(" -- Security Group ID: #{security_group_id}")
-            end
-          end
-
-          if !security_group_names.nil? && security_group_ids.nil?
-            security_group_ids = []
-            security_group_names.each do |security_group_name|
-              env[:ui].info(" -- Security Group Name: #{security_group_name}")
-              # since we can't access Security Groups by name, we grab the ID and add it to the security_group_ids
-              sg = env[:cloudstack_compute].list_security_groups["listsecuritygroupsresponse"]["securitygroup"].select { |sgrp| sgrp["name"] == security_group_name }
-              security_group_ids.push(sg[0]["id"])
-            end
-          end
-
-          if !security_groups.nil? && security_group_names.nil? && security_group_ids.nil?
-            security_group_ids = []
-            security_groups.each do |sg|
-              # Creating the security group and retrieving it's ID
-              sgid = nil
-              begin
-                sgid = env[:cloudstack_compute].create_security_group(:name        => sg[:name],
-                                                                      :description => sg[:description])["createsecuritygroupresponse"]["securitygroup"]["id"]
-                env[:ui].info(" -- Security Group #{sg[:name]} created with ID: #{sgid}")
-              rescue Exception => e
-                if e.message =~ /already exis/
-                  existingGroup = env[:cloudstack_compute].list_security_groups["listsecuritygroupsresponse"]["securitygroup"].select { |secgrp| secgrp["name"] == sg[:name] }
-                  sgid          = existingGroup[0]["id"]
-                  env[:ui].info(" -- Security Group #{sg[:name]} found with ID: #{sgid}")
-                end
-              end
-
-              # security group is created and we have it's ID
-              # so we add the rules... Does it really matter if they already exist ? CLoudstack seems to take care of that!
-              sg[:rules].each do |rule|
-                case rule[:type]
-                  when "ingress"
-                    env[:cloudstack_compute].authorize_security_group_ingress(:securityGroupId => sgid,
-                                                                              :protocol        => rule[:protocol],
-                                                                              :startport       => rule[:startport],
-                                                                              :endport         => rule[:endport],
-                                                                              :cidrlist        => rule[:cidrlist])
-                    env[:ui].info(" --- Ingress Rule added: #{rule[:protocol]} from #{rule[:startport]} to #{rule[:endport]} (#{rule[:cidrlist]})")
-                  when "egress"
-                    env[:cloudstack_compute].authorize_security_group_egress(:securityGroupId => sgid,
-                                                                             :protocol        => rule[:protocol],
-                                                                             :startport       => rule[:startport],
-                                                                             :endport         => rule[:endport],
-                                                                             :cidrlist        => rule[:cidrlist])
-                    env[:ui].info(" --- Egress Rule added: #{rule[:protocol]} from #{rule[:startport]} to #{rule[:endport]} (#{rule[:cidrlist]})")
-                end
-              end
-
-              # We want to use the Security groups we created
-              security_group_ids.push(sgid)
-
-              # and record the security group ids for future deletion (of rules and groups if possible)
-              security_groups_file = env[:machine].data_dir.join('security_groups')
-              security_groups_file.open('a+') do |f|
-                f.write("#{sgid}\n")
-              end
-            end
+          security_group_names.zip(security_group_ids).each do |security_group_name, security_group_id|
+              env[:ui].info(" -- Security Group: #{security_group_name} (#{security_group_id})")
           end
 
           begin
-            case network_type
-              when "Advanced"
-                options = {
-                    :display_name => display_name,
-                    :group        => group,
-                    :zone_id      => zone_id,
-                    :flavor_id    => service_offering_id,
-                    :image_id     => template_id,
-                    :network_ids  => [network_id]
-                }
-              when "Basic"
-                options = {
-                    :display_name       => display_name,
-                    :group              => group,
-                    :zone_id            => zone_id,
-                    :flavor_id          => service_offering_id,
-                    :image_id           => template_id,
-                    :security_group_ids => security_group_ids
-                }
+            options = {
+                :display_name => display_name,
+                :group        => group,
+                :zone_id      => zone_id,
+                :flavor_id    => service_offering_id,
+                :image_id     => template_id
+            }
+
+            if network_type == "Advanced"
+              options['network_ids'] = [network_id]
+            elsif network_type == "Basic"
+              options['security_group_ids'] = security_group_ids
             end
-
             options['project_id'] = project_id if project_id != nil
             options['key_name']   = keypair if keypair != nil
             options['name']       = hostname if hostname != nil
 
             if user_data != nil
-              options['user_data'] = Base64.encode64(user_data)
+              options['user_data'] = Base64.urlsafe_encode64(user_data)
               if options['user_data'].length > 2048
                 raise Errors::UserdataError,
                       :userdataLength => options['user_data'].length
@@ -288,6 +218,43 @@ module VagrantPlugins
           @app.call(env)
         end
 
+        def create_security_group(env, security_group)
+          begin
+            sgid = env[:cloudstack_compute].create_security_group(:name        => security_group[:name],
+                                                                  :description => security_group[:description])["createsecuritygroupresponse"]["securitygroup"]["id"]
+            env[:ui].info(" -- Security Group #{security_group[:name]} created with ID: #{sgid}")
+          rescue Exception => e
+            if e.message =~ /already exis/
+              sgid = name_to_id(env, security_group[:name], "security_group")
+              env[:ui].info(" -- Security Group #{security_group[:name]} found with ID: #{sgid}")
+            end
+          end
+
+          # security group is created and we have it's ID
+          # so we add the rules... Does it really matter if they already exist ? CLoudstack seems to take care of that!
+          security_group[:rules].each do |rule|
+            rule_options = {
+                :securityGroupId => sgid,
+                :protocol        => rule[:protocol],
+                :startport       => rule[:startport],
+                :endport         => rule[:endport],
+                :cidrlist        => rule[:cidrlist]
+            }
+
+            # The rule[:type] is either ingress or egress, but the method call looks the same.
+            # We build a dynamic method name and then send it off.
+            env[:cloudstack_compute].send("authorize_security_group_#{rule[:type]}".to_sym, rule_options)
+            env[:ui].info(" --- #{rule[:type].capitalize} Rule added: #{rule[:protocol]} from #{rule[:startport]} to #{rule[:endport]} (#{rule[:cidrlist]})")
+          end
+
+          # and record the security group ids for future deletion (of rules and groups if possible)
+          security_groups_file = env[:machine].data_dir.join('security_groups')
+          security_groups_file.open('a+') do |f|
+            f.write("#{sgid}\n")
+          end
+          [security_group[:name], sgid]
+        end
+
         def recover(env)
           return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
 

data/lib/vagrant-cloudstack/config.rb

@@ -327,13 +327,13 @@ module VagrantPlugins
         @pf_private_port        = nil if @pf_private_port == UNSET_VALUE
 
         # Security Group IDs must be nil, since we can't default that
-        @security_group_ids     = nil if @security_group_ids == UNSET_VALUE
+        @security_group_ids     = [] if @security_group_ids == UNSET_VALUE
 
         # Security Group Names must be nil, since we can't default that
-        @security_group_names   = nil if @security_group_names == UNSET_VALUE
+        @security_group_names   = [] if @security_group_names == UNSET_VALUE
 
         # Security Groups must be nil, since we can't default that
-        @security_groups        = nil if @security_groups == UNSET_VALUE
+        @security_groups        = [] if @security_groups == UNSET_VALUE
 
         # Display name must be nil, since we can't default that
         @display_name           = nil if @display_name == UNSET_VALUE

data/lib/vagrant-cloudstack/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Cloudstack
-    VERSION = "0.9.1"
+    VERSION = "0.10.0"
   end
 end

data/spec/vagrant-cloudstack/config_spec.rb

@@ -35,11 +35,11 @@ describe VagrantPlugins::Cloudstack::Config do
     its("pf_ip_address_id")       { should be_nil }
     its("pf_public_port")         { should be_nil }
     its("pf_private_port")        { should be_nil }
-    its("security_group_ids")     { should be_nil }
+    its("security_group_ids")     { should == []  }
     its("display_name")           { should be_nil }
     its("group")                  { should be_nil }
-    its("security_group_names")   { should be_nil }
-    its("security_groups")        { should be_nil }
+    its("security_group_names")   { should == []  }
+    its("security_groups")        { should == []  }
     its("user_data")              { should be_nil }
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-cloudstack
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Mitchell Hashimoto
@@ -18,7 +18,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-29 00:00:00.000000000 Z
+date: 2014-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog