vagrant-profitbricks 1.0.0

data/lib/vagrant-profitbricks/action/connect_profitbricks.rb

@@ -0,0 +1,39 @@
+require "fog/profitbricks"
+require "log4r"
+
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      # This action connects to ProfitBricks and verifies that the credentials work
+      class ConnectProfitBricks
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_profitbricks::action::connect_profitbricks")
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+          password  = config.password
+          username = config.username
+
+          params = {
+            :provider => 'ProfitBricks',
+            :profitbricks_password => password,
+            :profitbricks_username => username
+          }
+
+          if config.profitbricks_url
+            @logger.info("Connecting to ProfitBricks profitbricks_url...")
+            params[:profitbricks_url] = config.profitbricks_url
+          end
+
+          env[:profitbricks_compute] = Fog::Compute.new params
+          @logger.info("env[:profitbricks_compute]: " + env[:profitbricks_compute].to_s)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-profitbricks/action/create_image.rb

@@ -0,0 +1,53 @@
+require "fog/profitbricks"
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      # Creates an Image 
+      class CreateImage
+        include Vagrant::Util::Retryable
+        
+        attr_reader :env
+
+        def initialize(app, env)
+          @app, @env = app, env
+        end
+        
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_profitbricks.creating_image"))
+
+          server = env[:profitbricks_compute].servers.get(env[:machine].id)
+
+          config     = env[:machine].provider_config          
+          image_name = config.server_name || env[:machine].name
+
+          image = server.create_image(image_name)
+
+          retryable(:on => Fog::Errors::TimeoutError, :tries => 200) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            env[:ui].clear_line
+            env[:ui].report_progress(image.progress, 100, false)
+            
+            begin
+              image.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
+
+          env[:ui].info(I18n.t("vagrant_profitbricks.image_ready"))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require "fog/profitbricks"
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      # This creates the ProfitBricks server.
+      class CreateServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app     = app
+          @compute = env[:profitbricks_compute]
+          @logger  = Log4r::Logger.new("vagrant_profitbricks::action::create_server")
+        end
+
+        def call(env)
+          # Get the ProfitBricks configs
+          config           = env[:machine].provider_config
+          machine_config   = env[:machine].config
+          begin
+            communicator = machine_config.vm.communicator ||= :ssh
+          rescue NoMethodError
+            communicator = :ssh
+          end
+
+          # Figure out the Data Center ID,
+          datacenter = find_matching(@compute.datacenters, config.datacenter_id)
+          # in case datacenter is not found try to create new one.
+          # New datacenter is created if provided with name that is not regex or id
+          if config.datacenter_id && !datacenter && !config.datacenter_id.is_a?(Regexp) && (config.datacenter_id =~ /[a-fA-F0-9]{8}(-[a-fA-F0-9]{4}){3}-[a-fA-F0-9]{12}/).nil?
+            env[:ui].info(I18n.t("vagrant_profitbricks.creating_datacenter", :name => config.datacenter_id, :location => config.location))
+            datacenter = @compute.datacenters.create(:name => config.datacenter_id, :location => config.location)
+
+          end
+          raise Errors::NoMatchingDatacenter if !datacenter
+
+          # Find the flavor
+          if config.flavor
+            env[:ui].info(I18n.t("vagrant_profitbricks.finding_flavor"))
+            flavor = find_matching(@compute.flavors, config.flavor)
+            raise Errors::NoMatchingFlavor if !flavor
+          end
+
+          # Find the image
+          env[:ui].info(I18n.t("vagrant_profitbricks.finding_image"))
+          env[:ui].info(I18n.t("config.image: #{config.image}"))
+          env[:ui].info(I18n.t("datacenter.location: #{datacenter.location}"))
+          images = @compute.images.all
+          image = find_matching_image(images, config.image, datacenter.location)
+
+          # Figure out the name for the server
+          server_name = config.server_name || env[:machine].name
+
+          # Prepare volume values
+          vol_name = server_name.to_s + "_volume" if server_name
+          vol_size = config.profitbricks_volume_size ? config.profitbricks_volume_size : 5
+          vol_image = image.id if image
+          vol_type = config.volume_type
+          vol_licence_type = config.volume_licence_type if config.volume_licence_type
+          vol_ssh_keys = config.volume_ssh_keys if config.volume_ssh_keys
+          vol_availability_zone = config.volume_availability_zone
+          vol_image_password = config.image_password if config.image_password
+
+          volume = {
+            :name              => vol_name,
+            :size              => vol_size,
+            :type              => vol_type,
+            :availability_zone => vol_availability_zone
+          }
+
+          if vol_image
+            volume[:image] = vol_image
+          elsif vol_licence_type
+            volume[:licence_type] = vol_licence_type
+          else
+            raise Errors::ImageOrLicenceTypeMustBeProvided
+          end
+
+          if vol_ssh_keys
+            volume[:ssh_keys] = vol_ssh_keys
+          elsif vol_image_password
+            volume[:image_password] = vol_image_password
+          else
+            raise Errors::ImageOrLicenceTypeMustBeProvided
+          end
+
+
+
+          # create LAN if it does not exist, and create a NIC on that LAN
+          lan_id = config.lan_id
+          lan = @compute.lans.get(datacenter.id, config.lan_id)
+
+          if !lan || lan.id.end_with?('/lans')
+            lan_name = server_name.to_s + "_lan" if server_name
+            lan = @compute.lans.create(:datacenter_id => datacenter.id, :name => lan_name, :public => true)
+            lan_id = lan.id
+          end
+
+          nic_name = server_name.to_s + "_nic" if server_name
+          nic = {
+            :name => nic_name,
+            :lan => lan_id,
+            :dhcp => true,
+            :nat => config.nat
+          }
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_profitbricks.launching_server"))
+          env[:ui].info(" -- Data Center ID: #{datacenter.id}")
+          env[:ui].info(" -- Name: #{server_name}")
+          env[:ui].info(" -- Volume Name: #{vol_name}")
+          env[:ui].info(" -- Image: #{image.name}") if image
+
+          server_cores = nil
+          server_ram = nil
+
+          if flavor
+            env[:ui].info(" -- Flavor: #{flavor.name}")
+            server_cores = flavor.cores
+            server_ram = flavor.ram
+          elsif config.profitbricks_ram && config.profitbricks_cores
+            env[:ui].info(" -- Server cores: #{config.profitbricks_cores}")
+            env[:ui].info(" -- Server ram: #{config.profitbricks_ram } MB")
+            server_cores = config.profitbricks_cores
+            server_ram = config.profitbricks_ram
+          else
+            raise Errors::NoMatchingFlavor
+          end
+
+          # Create the server
+          env[:ui].info(I18n.t("vagrant_profitbricks.creating_server"))
+          server = @compute.servers.create(:datacenter_id => datacenter.id,
+                                           :name => server_name,
+                                           :cores => server_cores,
+                                           :ram => server_ram,
+                                           :cpu_family => config.cpu_family,
+                                           :volumes => [volume],
+                                           :nics => [nic]
+                                           )
+          server.wait_for { ready? }
+
+          # Store the ID right away so we can track it
+          env[:machine].id = server.id
+
+          env[:ui].info(I18n.t("vagrant_profitbricks.ready"))
+          @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)
+          item = collection.find do |single|
+            single.id == name ||
+            single.name == name ||
+            (name.is_a?(Regexp) && name =~ single.name)
+          end
+
+          item
+        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_image(collection, name, location)
+          location = location ? location : 'us/las'
+          item = collection.find  do |image|
+            image.location  ==  location &&
+            image.image_type    == 'HDD' &&
+            (image.name == name || image.id == name ||
+            (name.is_a?(Regexp) && image.name =~ name))
+          end
+          
+          item
+        end
+
+        # Ported from Vagrant::UI, but scoped to the machine's UI
+        def report_server_progress(machine, progress)
+          machine.ui.clear_line
+          line    = "Progress: #{progress}"
+
+          machine.ui.info(line, new_line: false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      # This deletes the running server, if there is one.
+      class DeleteServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_profitbricks::action::delete_server")
+        end
+
+        def call(env)
+          compute = env[:profitbricks_compute]
+          server_id = env[:machine].id
+          server = begin
+                     compute.servers.get(server_id)
+                   rescue
+                     nil
+                   end
+
+          if server.nil?
+            @logger.warn "Unable to find server #{server_id}..."
+            env[:ui].warn(I18n.t('vagrant_profitbricks.errors.server_not_found'))
+            env[:machine].id = nil
+          else
+            @logger.info "Deleting server #{server_id}..."
+            env[:ui].info(I18n.t("vagrant_profitbricks.deleting_server"))
+            
+            server.attached_volumes.each do |vol_info|
+              volume = compute.volumes.get(vol_info['id'])
+              volume.delete if volume
+            end
+            server.delete
+            env[:machine].id = nil
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProfitBricks
+    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-profitbricks/action/list_flavors.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      class ListFlavors
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          compute_service = env[:profitbricks_compute]
+          env[:ui].info ('%-36s %s' % ['Flavor ID', 'Flavor Name'])
+          compute_service.flavors.sort_by(&:id).each do |flavor|
+            env[:ui].info ('%-36s %s' % [flavor.id, flavor.name])
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-profitbricks/action/list_images.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      class ListImages
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          compute_service = env[:profitbricks_compute]
+          env[:ui].info ('%-36s %s' % ['Image ID', 'Image Name'])
+          compute_service.images.sort_by(&:name).each do |image|
+            env[:ui].info ('%-36s %s' % [image.id.to_s, image.name])
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-profitbricks/action/list_keypairs.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      class ListKeyPairs
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          compute_service = env[:profitbricks_compute]
+          env[:ui].info ('%s' % ['KeyPair Name'])
+          compute_service.key_pairs.sort_by(&:name).each do |keypair|
+            env[:ui].info ('%s' % [keypair.name])
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-profitbricks/action/list_networks.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      class ListInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          compute_service = env[:profitbricks_compute]
+          env[:ui].info ('%-36s %-24s %s' % ['Lan Id', 'NIC IPs', 'Internet'])
+          compute_service.interfaces.sort_by(&:server_id).each do |network|
+            env[:ui].info ('%-36s %-24s %s' % [network.lan_id, network.ips, network.internet_access])
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-profitbricks/action/list_servers.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProfitBricks
+    module Action
+      class ListServers
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          compute_service = env[:profitbricks_compute]
+          env[:ui].info ('%-20s %-20s %s' % ['Server Name', 'State', 'IPv4 address'])
+          compute_service.servers.sort_by(&:name).each do |server|
+            ip = server.interfaces[0] ? server.interfaces[0].ips : "-"
+            env[:ui].info ('%-20s %-20s %s' % [server.name, server.state, ip])
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end