vagrant-profitbricks 1.0.0 → 4.0.0

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler/setup'
 require 'rspec/core/rake_task'
@@ -8,7 +10,7 @@ $stdout.sync = true
 $stderr.sync = true
 
 # Change to the directory of this file.
-Dir.chdir(File.expand_path("../", __FILE__))
+Dir.chdir(File.expand_path('../', __FILE__))
 
 # This installs the tasks that help with gem creation and
 # publishing.
@@ -18,4 +20,4 @@ Bundler::GemHelper.install_tasks
 RSpec::Core::RakeTask.new
 
 # Default task is to run the unit tests
-task :default => "spec"
+task default: 'spec'

data/Vagrantfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
@@ -5,26 +7,29 @@
 # configures the configuration version (we support older styles for
 # backwards compatibility). Please don't change it unless you know what
 # you're doing.
-Vagrant.configure("2") do |config|
+Vagrant.configure('2') do |config|
   # The most common configuration options are documented and commented below.
   # For a complete reference, please see the online documentation at
   # https://docs.vagrantup.com.
 
   # Every Vagrant development environment requires a box. You can search for
   # boxes at https://atlas.hashicorp.com/search.
-  config.vm.box = 'profitbricks'
+  config.ssh.private_key_path = '/path/to/.ssh/id_rsa'
+
   config.vm.provider :profitbricks do |profitbricks|
-    profitbricks.username  = 'YOUR_PB_USERNAME'
-    profitbricks.password = 'YOUR_PB_PASSWORD'
-    profitbricks.profitbricks_url = 'https://api.profitbricks.com/cloudapi/v3/'
-    profitbricks.datacenter_id = 'pb vagrant test'
+    profitbricks.username = ENV['PROFITBRICKS_USERNAME']
+    profitbricks.password = ENV['PROFITBRICKS_PASSWORD']
+    profitbricks.profitbricks_url = 'https://api.profitbricks.com/cloudapi/v4/'
+    profitbricks.datacenter_id = '19f5531c-4fb5-4657-9fee-ac6731131074'
     profitbricks.location = 'de/fkb'
-    profitbricks.image = 'openSUSE-13.2-server-2016-11-01'
-    profitbricks.volume_licence_type = 'LINUX'
-    profitbricks.profitbricks_cores = '1'
-    profitbricks.profitbricks_ram = '2048'
-    profitbricks.image_password = 'PASSWORD'
-    # profitbricks.volume_ssh_keys = ['YOUR_PUBLIC_SSH_KEY'] # if you want to enable SSH (Works with ProfitBricks supplied Linux images)
+    profitbricks.image_alias = 'ubuntu:latest'
+    profitbricks.cores = '4'
+    profitbricks.ram = '4096'
+    profitbricks.image_password = 'test1234'
+    profitbricks.public_ssh_keys = [File.read('/path/to/.ssh/id_rsa.pub')]
+  end
+
+  config.vm.provision 'shell' do |s|
+    s.inline = 'apt-get update && apt-get install -y'
   end
-  
 end

data/example_box/Vagrantfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure('2') do |config|
+  config.vm.provider :profitbricks do |pb|
+  end
+end

data/lib/vagrant-profitbricks.rb

@@ -1,23 +1,25 @@
-require "pathname"
-require "vagrant-profitbricks/plugin"
+# frozen_string_literal: true
+
+require 'pathname'
+require 'vagrant-profitbricks/plugin'
 
 module VagrantPlugins
   module ProfitBricks
-    lib_path = Pathname.new(File.expand_path("../vagrant-profitbricks", __FILE__))
-    autoload :Action, lib_path.join("action")
-    autoload :Errors, lib_path.join("errors")
+    lib_path = Pathname.new(File.expand_path('../vagrant-profitbricks', __FILE__))
+    autoload :Action, lib_path.join('action')
+    autoload :Errors, lib_path.join('errors')
 
     # This returns the path to the source of this plugin.
     #
     # @return [Pathname]
     def self.source_root
-      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
     end
 
     # 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.load_path << File.expand_path('locales/en.yml', source_root)
       I18n.reload!
     end
 
@@ -27,7 +29,7 @@ module VagrantPlugins
       # Initialize logging
       level = nil
       begin
-        level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        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
@@ -38,15 +40,14 @@ module VagrantPlugins
       # 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)
+      level = nil unless 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_profitbricks")
+        logger = Log4r::Logger.new('vagrant_profitbricks')
         logger.outputters = Log4r::Outputter.stderr
         logger.level = level
-        logger = nil
       end
     end
   end

data/lib/vagrant-profitbricks/action.rb

@@ -1,6 +1,8 @@
-require "pathname"
+# frozen_string_literal: true
 
-require "vagrant/action/builder"
+require 'pathname'
+
+require 'vagrant/action/builder'
 
 module VagrantPlugins
   module ProfitBricks
@@ -9,28 +11,30 @@ module VagrantPlugins
       include Vagrant::Action::Builtin
 
       # The autoload farm
-      action_root = Pathname.new(File.expand_path("../action", __FILE__))
-      autoload :ConnectProfitBricks, action_root.join("connect_profitbricks")
-      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 :RunInitScript, action_root.join("run_init_script")
-      autoload :CreateImage, action_root.join("create_image")
-      autoload :ListImages, action_root.join("list_images")
-      autoload :ListFlavors, action_root.join("list_flavors")
-      autoload :ListInterfaces, action_root.join("list_networks")
-      autoload :ListServers, action_root.join("list_servers")
+      action_root = Pathname.new(File.expand_path('../action', __FILE__))
+      autoload :ConnectProfitBricks, action_root.join('connect_profitbricks')
+      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 :RunInitScript, action_root.join('run_init_script')
+      autoload :CreateImage, action_root.join('create_image')
+      autoload :Stop, action_root.join('stop_server')
+      autoload :ListFlavors, action_root.join('list_flavors')
+      autoload :Start, action_root.join('start_server')
+      autoload :ListServers, action_root.join('list_servers')
+      autoload :Reboot, action_root.join('reboot_server')
+      autoload :ListImages, action_root.join('list_images')
 
       # 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, b1|
-            if !env[:result]
+            unless env[:result]
               b1.use MessageNotCreated
               next
             end
@@ -41,7 +45,7 @@ module VagrantPlugins
                 b2.use DeleteServer
                 b2.use ProvisionerCleanup if defined?(ProvisionerCleanup)
               else
-                b2.use Message, I18n.t("vagrant_profitbricks.will_not_destroy")
+                b2.use Message, I18n.t('vagrant_profitbricks.will_not_destroy')
                 next
               end
             end
@@ -49,18 +53,35 @@ module VagrantPlugins
         end
       end
 
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectProfitBricks
+          b.use Call, GetState do |env, b1|
+            case env[:machine_state]
+            when :active
+              b1.use Reload
+              b1.use Provision
+            when :off
+              env[:ui].info I18n.t('vagrant_profitbricks.states.long_off')
+            when :not_created
+              env[:ui].info I18n.t('vagrant_profitbricks.not_created')
+            end
+          end
+        end
+      end
+
       # This action is called when `vagrant provision` is called.
       def self.action_provision
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConfigValidate
           b.use Call, IsCreated do |env, b2|
-            if !env[:result]
+            unless env[:result]
               b2.use MessageNotCreated
               next
             end
 
             b2.use Provision
-            b2.use SyncedFolders
           end
         end
       end
@@ -91,7 +112,7 @@ module VagrantPlugins
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConfigValidate
           b.use Call, IsCreated do |env, b2|
-            if !env[:result]
+            unless env[:result]
               b2.use MessageNotCreated
               next
             end
@@ -105,7 +126,7 @@ module VagrantPlugins
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConfigValidate
           b.use Call, IsCreated do |env, b2|
-            if !env[:result]
+            unless env[:result]
               b2.use MessageNotCreated
               next
             end
@@ -119,46 +140,64 @@ module VagrantPlugins
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConfigValidate
           b.use ConnectProfitBricks
-          b.use Call, IsCreated do |env, b2|
+          b.use Call, ReadState do |env, b2|
             if env[:result]
               b2.use MessageAlreadyCreated
               next
             end
-
-            b2.use Provision
-            b2.use CreateServer
+            case env[:machine_state_id]
+            when :not_created
+              b2.use CreateServer
+              b2.use Provision
+            when :off
+              b2.use Start
+              b2.use Provision
+            end
           end
         end
       end
 
-      # Extended actions
-      def self.action_list_images
+      def self.action_halt
         Vagrant::Action::Builder.new.tap do |b|
-          # b.use ConfigValidate # is this per machine?
-          b.use ConnectProfitBricks
-          b.use ListImages
+          b.use Call, IsCreated do |env, b1|
+            unless env[:result]
+              b1.use MessageNotCreated
+              next
+            end
+
+            b1.use ConfigValidate
+            b1.use ConnectProfitBricks
+            b1.use Stop
+          end
         end
       end
 
-      def self.action_list_flavors
+      def self.action_reload
         Vagrant::Action::Builder.new.tap do |b|
-          # b.use ConfigValidate # is this per machine?
-          b.use ConnectProfitBricks
-          b.use ListFlavors
+          b.use Call, IsCreated do |env, b1|
+            unless env[:result]
+              b1.use MessageNotCreated
+              next
+            end
+            b1.use ConfigValidate
+            b1.use ConnectProfitBricks
+            b1.use Reboot
+          end
         end
       end
 
-      def self.action_list_networks
+      def self.action_list_flavors
         Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
           b.use ConnectProfitBricks
-          b.use ListInterfaces
+          b.use ListFlavors
         end
       end
 
-      def self.action_list_servers
+      def self.action_list_images
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConnectProfitBricks
-          b.use ListServers
+          b.use ListImages
         end
       end
     end

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

@@ -1,35 +1,37 @@
-require "fog/profitbricks"
-require "log4r"
+# frozen_string_literal: true
+
+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)
+        def initialize(app, _env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_profitbricks::action::connect_profitbricks")
+          @logger = Log4r::Logger.new('vagrant_profitbricks::action::connect_profitbricks')
         end
 
         def call(env)
           # Get the configs
-          config   = env[:machine].provider_config
-          password  = config.password
+          config = env[:machine].provider_config
+          password = config.password
           username = config.username
-
           params = {
-            :provider => 'ProfitBricks',
-            :profitbricks_password => password,
-            :profitbricks_username => username
+            provider: 'ProfitBricks',
+            profitbricks_password: password,
+            profitbricks_username: username,
+            profitbricks_user_agent: I18n.t('vagrant_profitbricks.version')
           }
 
           if config.profitbricks_url
-            @logger.info("Connecting to ProfitBricks profitbricks_url...")
+            @logger.info('Connecting to ProfitBricks Cloud API...')
             params[:profitbricks_url] = config.profitbricks_url
           end
 
           env[:profitbricks_compute] = Fog::Compute.new params
-          @logger.info("env[:profitbricks_compute]: " + env[:profitbricks_compute].to_s)
+          @logger.info('env[:profitbricks_compute]: ' + env[:profitbricks_compute].to_s)
 
           @app.call(env)
         end

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

@@ -1,5 +1,7 @@
-require "fog/profitbricks"
-require "log4r"
+# frozen_string_literal: true
+
+require 'fog/profitbricks'
+require 'log4r'
 
 require 'vagrant/util/retryable'
 
@@ -13,10 +15,11 @@ module VagrantPlugins
         def initialize(app, env)
           @app     = app
           @compute = env[:profitbricks_compute]
-          @logger  = Log4r::Logger.new("vagrant_profitbricks::action::create_server")
+          @logger  = Log4r::Logger.new('vagrant_profitbricks::action::create_server')
         end
 
         def call(env)
+          uuid_regex = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/
           # Get the ProfitBricks configs
           config           = env[:machine].provider_config
           machine_config   = env[:machine].config
@@ -27,52 +30,53 @@ module VagrantPlugins
           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)
-
+          if config.datacenter_id.match uuid_regex
+            datacenter = find_matching(@compute.datacenters, config.datacenter_id)
+          else
+            raise Errors::NoDatacenterID
           end
-          raise Errors::NoMatchingDatacenter if !datacenter
 
           # Find the flavor
           if config.flavor
-            env[:ui].info(I18n.t("vagrant_profitbricks.finding_flavor"))
+            env[:ui].info(I18n.t('vagrant_profitbricks.finding_flavor'))
             flavor = find_matching(@compute.flavors, config.flavor)
-            raise Errors::NoMatchingFlavor if !flavor
+            raise Errors::NoMatchingFlavor unless 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)
+          if !config.image && !config.image_alias
+            raise Errors::ImageOrLicenceTypeMustBeProvided
+          end
 
-          # Figure out the name for the server
-          server_name = config.server_name || env[:machine].name
+          if config.image
+            images = @compute.images.all
+            image = find_matching_image(images, config.image, datacenter.location)
+          end
 
+          if config.image_alias
+            # Figure out the name for the server
+            server_name = config.server_name || env[:machine].name
+          end
           # 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_name = server_name.to_s + '_volume' if server_name
+
+          vol_size = config.volume_size ? config.volume_size : 5
           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_ssh_keys = config.public_ssh_keys if config.public_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
+            name: vol_name,
+            size: vol_size,
+            type: vol_type,
+            availability_zone: vol_availability_zone
           }
 
-          if vol_image
-            volume[:image] = vol_image
+          if image
+            volume[:image] = image.id
+          elsif config.image_alias
+            volume[:image_alias] = config.image_alias
           elsif vol_licence_type
             volume[:licence_type] = vol_licence_type
           else
@@ -87,32 +91,36 @@ module VagrantPlugins
             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)
+          begin
+            lan = @compute.lans.get(datacenter.id, config.lan_id)
+          rescue Excon::Error::NotFound
+            raise Errors::NoLan
+          end
 
           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_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 = server_name.to_s + '_nic' if server_name
           nic = {
-            :name => nic_name,
-            :lan => lan_id,
-            :dhcp => true,
-            :nat => config.nat
+            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(I18n.t('vagrant_profitbricks.launching_server'))
           env[:ui].info(" -- Data Center ID: #{datacenter.id}")
+          env[:ui].info(" -- Location: #{datacenter.location}")
           env[:ui].info(" -- Name: #{server_name}")
           env[:ui].info(" -- Volume Name: #{vol_name}")
           env[:ui].info(" -- Image: #{image.name}") if image
+          env[:ui].info(" -- Image: #{config.image_alias}") if config.image_alias
 
           server_cores = nil
           server_ram = nil
@@ -121,31 +129,30 @@ module VagrantPlugins
             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
+          elsif config.ram && config.cores
+            env[:ui].info(" -- Server cores: #{config.cores}")
+            env[:ui].info(" -- Server ram: #{config.ram} MB")
+            server_cores = config.cores
+            server_ram = config.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]
-                                           )
+          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"))
+          env[:ui].info(I18n.t('vagrant_profitbricks.ready'))
           @app.call(env)
         end
 
@@ -158,8 +165,8 @@ module VagrantPlugins
         def find_matching(collection, name)
           item = collection.find do |single|
             single.id == name ||
-            single.name == name ||
-            (name.is_a?(Regexp) && name =~ single.name)
+              single.name == name ||
+              (name.is_a?(Regexp) && name =~ single.name)
           end
 
           item
@@ -170,21 +177,21 @@ module VagrantPlugins
         # `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))
+          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}"
+          line = "Progress: #{progress}"
 
           machine.ui.info(line, new_line: false)
         end