vagrant-oneandone 1.0.0

data/lib/vagrant-oneandone/command/list_load_balancers.rb

@@ -0,0 +1,43 @@
+require 'vagrant-oneandone/command/utils'
+
+module VagrantPlugins
+  module OneAndOne
+    module Command
+      class ListLoadBalancers < Vagrant.plugin('2', :command)
+        include VagrantPlugins::OneAndOne::Command::Utils
+
+        def execute
+          options = OptionParser.new do |o|
+            o.banner = I18n.t('vagrant_1and1.command.list_load_balancers')
+            o.separator ''
+            o.separator 'Usage: vagrant oneandone loadbalancers [<api_key>]'
+            o.separator ''
+          end
+
+          argv = parse_options(options)
+          return unless argv
+
+          compute = fog_oneandone(argv[0])
+
+          rows = []
+          compute.list_load_balancers.body.each do |lb|
+            rows << [
+              lb['id'],
+              lb['name'],
+              lb['ip'],
+              lb['method'],
+              lb['state'],
+              lb['datacenter']['country_code']
+            ]
+          end
+
+          display_table(
+            @env,
+            ['ID', 'Name', 'IP Address', 'Method', 'State', 'Data Center'],
+            rows
+          )
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/command/list_monitor_policies.rb

@@ -0,0 +1,32 @@
+require 'vagrant-oneandone/command/utils'
+
+module VagrantPlugins
+  module OneAndOne
+    module Command
+      class ListMonitorPolicies < Vagrant.plugin('2', :command)
+        include VagrantPlugins::OneAndOne::Command::Utils
+
+        def execute
+          options = OptionParser.new do |o|
+            o.banner = I18n.t('vagrant_1and1.command.list_monitor_policies')
+            o.separator ''
+            o.separator 'Usage: vagrant oneandone monitors [<api_key>]'
+            o.separator ''
+          end
+
+          argv = parse_options(options)
+          return unless argv
+
+          compute = fog_oneandone(argv[0])
+
+          rows = []
+          compute.monitoring_policies.all.each do |mp|
+            rows << [mp.id, mp.name, mp.email, mp.state, mp.agent ? 'yes' : 'no']
+          end
+
+          display_table(@env, %w(ID Name Email State Agent), rows)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/command/list_servers.rb

@@ -0,0 +1,32 @@
+require 'vagrant-oneandone/command/utils'
+
+module VagrantPlugins
+  module OneAndOne
+    module Command
+      class ListServers < Vagrant.plugin('2', :command)
+        include VagrantPlugins::OneAndOne::Command::Utils
+
+        def execute
+          options = OptionParser.new do |o|
+            o.banner = I18n.t('vagrant_1and1.command.list_servers')
+            o.separator ''
+            o.separator 'Usage: vagrant oneandone servers [<api_key>]'
+            o.separator ''
+          end
+
+          argv = parse_options(options)
+          return unless argv
+
+          compute = fog_oneandone(argv[0])
+
+          rows = []
+          compute.servers.all.each do |s|
+            rows << [s.id, s.name, s.status['state'], s.datacenter['country_code']]
+          end
+
+          display_table(@env, ['ID', 'Name', 'State', 'Data Center'], rows)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/command/list_sizes.rb

@@ -0,0 +1,43 @@
+require 'vagrant-oneandone/command/utils'
+
+module VagrantPlugins
+  module OneAndOne
+    module Command
+      class ListSizes < Vagrant.plugin('2', :command)
+        include VagrantPlugins::OneAndOne::Command::Utils
+
+        def execute
+          options = OptionParser.new do |o|
+            o.banner = I18n.t('vagrant_1and1.command.list_sizes')
+            o.separator ''
+            o.separator 'Usage: vagrant oneandone sizes [<api_key>]'
+            o.separator ''
+          end
+
+          argv = parse_options(options)
+          return unless argv
+
+          compute = fog_oneandone(argv[0])
+
+          rows = []
+          compute.list_fixed_servers.body.each do |s|
+            rows << [
+              s['id'],
+              s['name'],
+              s['hardware']['ram'],
+              s['hardware']['vcore'],
+              s['hardware']['cores_per_processor'],
+              s['hardware']['hdds'][0]['size']
+            ]
+          end
+
+          display_table(
+            @env,
+            ['ID', 'Name', 'RAM (GB)', 'CPU No.', 'Cores per CPU', 'Disk Size (GB)'],
+            rows
+          )
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/command/main.rb

@@ -0,0 +1,85 @@
+require 'vagrant-oneandone/action'
+
+module VagrantPlugins
+  module OneAndOne
+    module Command
+      class Main < Vagrant.plugin('2', :command)
+        def self.synopsis
+          I18n.t('vagrant_1and1.command.synopsis')
+        end
+
+        def initialize(argv, env)
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+
+          @subcommands.register(:appliances) do
+            require File.expand_path('../list_appliances', __FILE__)
+            ListAppliances
+          end
+          @subcommands.register(:datacenters) do
+            require File.expand_path('../list_datacenters', __FILE__)
+            ListDatacenters
+          end
+          @subcommands.register(:firewalls) do
+            require File.expand_path('../list_firewalls', __FILE__)
+            ListFirewalls
+          end
+          @subcommands.register(:ips) do
+            require File.expand_path('../list_ips', __FILE__)
+            ListIPs
+          end
+          @subcommands.register(:loadbalancers) do
+            require File.expand_path('../list_load_balancers', __FILE__)
+            ListLoadBalancers
+          end
+          @subcommands.register(:monitors) do
+            require File.expand_path('../list_monitor_policies', __FILE__)
+            ListMonitorPolicies
+          end
+          @subcommands.register(:servers) do
+            require File.expand_path('../list_servers', __FILE__)
+            ListServers
+          end
+          @subcommands.register(:sizes) do
+            require File.expand_path('../list_sizes', __FILE__)
+            ListSizes
+          end
+
+          super(argv, env)
+        end
+
+        def execute
+          if @main_args.include?('-h') || @main_args.include?('--help')
+            return help
+          end
+
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant oneandone <subcommand> [<api_key>]'
+            o.separator ''
+            o.separator I18n.t('vagrant_1and1.command.available_subcommands')
+
+            keys = []
+            @subcommands.each { |key| keys << key.to_s }
+
+            keys.sort.each { |key| o.separator "     #{key}" }
+
+            o.separator ''
+            o.separator I18n.t('vagrant_1and1.command.help_subcommands') +
+                        ' `vagrant oneandone <subcommand> -h`'
+          end
+
+          @env.ui.info(opts.help)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/command/utils.rb

@@ -0,0 +1,31 @@
+require 'fog-oneandone'
+require 'terminal-table'
+
+module VagrantPlugins
+  module OneAndOne
+    module Command
+      module Utils
+        def fog_oneandone(token)
+          api_key = token ? token : ENV['ONEANDONE_API_KEY']
+
+          raise Errors::NoApiKeyError unless api_key
+
+          params = {
+            oneandone_api_key: api_key
+          }
+
+          Fog::Compute::OneAndOne.new params
+        end
+
+        def display_table(env, headers, rows)
+          table = Terminal::Table.new headings: headers, rows: rows
+          if env.respond_to?('ui')
+            env.ui.info(table.to_s)
+          else
+            env[:ui].info(table.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/config.rb

@@ -0,0 +1,65 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module OneAndOne
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :api_key
+      attr_accessor :name
+      attr_accessor :description
+      attr_accessor :fixed_size
+      attr_accessor :datacenter
+      attr_accessor :appliance
+      attr_accessor :password
+      attr_accessor :firewall_id
+      attr_accessor :ip
+      attr_accessor :load_balancer_id
+      attr_accessor :monitoring_policy_id
+      attr_accessor :timeout
+
+      def initialize
+        @api_key              = UNSET_VALUE
+        @name                 = UNSET_VALUE
+        @description          = UNSET_VALUE
+        @fixed_size           = UNSET_VALUE
+        @datacenter           = UNSET_VALUE
+        @appliance            = UNSET_VALUE
+        @password             = UNSET_VALUE
+        @firewall_id          = UNSET_VALUE
+        @ip                   = UNSET_VALUE
+        @load_balancer_id     = UNSET_VALUE
+        @monitoring_policy_id = UNSET_VALUE
+        @timeout              = UNSET_VALUE
+      end
+
+      def finalize!
+        @api_key              = ENV['ONEANDONE_API_KEY'] if @api_key == UNSET_VALUE
+        @name                 = nil if @name == UNSET_VALUE
+        @password             = nil if @password == UNSET_VALUE
+        @appliance            = 'ubuntu1404-64std' if @appliance == UNSET_VALUE
+        @datacenter           = 'US' if @datacenter == UNSET_VALUE
+        @fixed_size           = 'M' if @fixed_size == UNSET_VALUE
+        @timeout              = nil if @timeout == UNSET_VALUE
+        @ip                   = nil if @ip == UNSET_VALUE
+        @firewall_id          = nil if @firewall_id == UNSET_VALUE
+        @load_balancer_id     = nil if @load_balancer_id == UNSET_VALUE
+        @monitoring_policy_id = nil if @monitoring_policy_id == UNSET_VALUE
+        @description          = nil if @description == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_1and1.config.api_key_required') unless @api_key
+
+        key = machine.config.ssh.private_key_path
+        key = key[0] if key.is_a?(Array)
+        if !key
+          errors << I18n.t('vagrant_1and1.config.private_key')
+        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
+          errors << I18n.t('vagrant_1and1.config.public_key', key: "#{key}.pub")
+        end
+
+        { 'OneAndOne Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/config_resolver.rb

@@ -0,0 +1,97 @@
+module VagrantPlugins
+  module OneAndOne
+    class ConfigResolver
+      def initialize(env)
+        @logger  = Log4r::Logger.new('vagrant_1and1::action::config_resolver')
+        @compute = env[:oneandone_compute]
+        @provider_config = env[:machine].provider_config
+      end
+
+      def resolve_fixed_instance_size(env)
+        @logger.info 'Obtaining fixed-instance list'
+
+        env[:ui].info(I18n.t('vagrant_1and1.finding_fixed_instance_size'))
+
+        sizes = @compute.list_fixed_servers
+
+        @logger.info "Finding size matching '#{@provider_config.fixed_size}'"
+
+        size = find_matching(sizes.body, %w(id name), @provider_config.fixed_size)
+
+        raise Errors::NoMatchingFixedSizeError unless size
+        size['id']
+      end
+
+      def resolve_appliance(env)
+        @logger.info 'Obtaining server appliances'
+
+        env[:ui].info(I18n.t('vagrant_1and1.finding_appliance'))
+
+        appliances = @compute.list_server_appliances(q: @provider_config.appliance)
+
+        @logger.info "Finding server appliance matching '#{@provider_config.appliance}'"
+
+        app = find_matching(appliances.body, %w(id name), @provider_config.appliance)
+
+        raise Errors::NoMatchingApplianceError unless app
+        raise Errors::UnsupportedApplianceError if 'linux'.casecmp(app['os_family']) != 0
+        app['id']
+      end
+
+      def resolve_datacenter(env)
+        @logger.info 'Obtaining data centers'
+
+        env[:ui].info(I18n.t('vagrant_1and1.finding_datacenter'))
+
+        datacenters = @compute.list_datacenters
+
+        @logger.info "Finding data center matching '#{@provider_config.datacenter}'"
+
+        dc = find_matching(datacenters.body, %w(id country_code), @provider_config.datacenter)
+
+        raise Errors::NoMatchingDataCenterError unless dc
+        dc['id']
+      end
+
+      def resolve_public_ip(env)
+        # do nothing unless IP is set
+        if @provider_config.ip
+          @logger.info 'Obtaining public IPs'
+
+          env[:ui].info(I18n.t('vagrant_1and1.finding_public_ip'))
+
+          public_ips = @compute.list_public_ips
+
+          @logger.info "Finding public IP matching '#{@provider_config.ip}'"
+
+          ip = find_matching(public_ips.body, %w(id ip), @provider_config.ip)
+
+          raise Errors::NoMatchingPublicIPAddressError unless ip
+
+          raise Errors::IPAddressInUseError if ip['assigned_to']
+
+          ip['id']
+        end
+      end
+
+      def resolve_ssh_key(env)
+        private_key = env[:machine].config.ssh.private_key_path
+        private_key = private_key[0] if private_key.is_a?(Array)
+        private_key = File.expand_path(private_key, env[:machine].env.root_path)
+        OneAndOne.public_key(private_key)
+      end
+
+      private
+
+      def find_matching(collection, keys, value)
+        collection.each do |item|
+          keys.each do |key|
+            return item if value.casecmp(item[key]) == 0
+          end
+        end
+        @logger.error "No item key '#{value}' found in collection #{collection}"
+        nil
+      end
+    end
+  end
+end

data/lib/vagrant-oneandone/errors.rb

@@ -0,0 +1,45 @@
+module VagrantPlugins
+  module OneAndOne
+    module Errors
+      class OneAndOneError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_1and1.errors')
+      end
+
+      class IPAddressInUseError < OneAndOneError
+        error_key(:ip_address_already_in_use)
+      end
+
+      class NoApiKeyError < OneAndOneError
+        error_key(:missing_api_key)
+      end
+
+      class NoMatchingFixedSizeError < OneAndOneError
+        error_key(:no_matching_fixed_size)
+      end
+
+      class NoMatchingApplianceError < OneAndOneError
+        error_key(:no_matching_appliance)
+      end
+
+      class NoMatchingDataCenterError < OneAndOneError
+        error_key(:no_matching_datacenter)
+      end
+
+      class NoMatchingPublicIPAddressError < OneAndOneError
+        error_key(:no_matching_public_ip)
+      end
+
+      class PublicKeyError < OneAndOneError
+        error_key(:ssh_key_not_found)
+      end
+
+      class RsyncError < OneAndOneError
+        error_key(:rsync)
+      end
+
+      class UnsupportedApplianceError < OneAndOneError
+        error_key(:unsupported_appliance)
+      end
+    end
+  end
+end