vagrant-cosmic 0.1.0

data/lib/vagrant-cosmic/config.rb

@@ -0,0 +1,422 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Cosmic
+    class Config < Vagrant.plugin("2", :config)
+      INSTANCE_VAR_DEFAULT_NIL = %w(host name path port domain_id network_id network_name project_id service_offering_id service_offering_name
+           template_id template_name zone_id zone_name keypair pf_ip_address_id pf_ip_address pf_public_port
+           pf_public_rdp_port pf_private_port pf_trusted_networks display_name group user_data ssh_key ssh_user
+           ssh_network_id ssh_network_name vm_user vm_password private_ip_address).freeze
+      INSTANCE_VAR_DEFAULT_EMPTY_ARRAY = %w(static_nat port_forwarding_rules firewall_rules).freeze
+
+      # Cosmic API host.
+      #
+      # @return [String]
+      attr_accessor :host
+
+      # Hostname for the machine instance
+      # This will be passed through to the api.
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # Cosmic API path.
+      #
+      # @return [String]
+      attr_accessor :path
+
+      # Cosmic API port.
+      #
+      # @return [String]
+      attr_accessor :port
+
+      # Cosmic API scheme
+      #
+      # @return [String]
+      attr_accessor :scheme
+
+      # The API key for accessing Cosmic.
+      #
+      # @return [String]
+      attr_accessor :api_key
+
+      # The secret key for accessing Cosmic.
+      #
+      # @return [String]
+      attr_accessor :secret_key
+
+      # The timeout to wait for an instance to become ready.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_ready_timeout
+
+      # Domain id to launch the instance into.
+      #
+      # @return [String]
+      attr_accessor :domain_id
+
+      # Network uuid(s) that the instance should use
+      #
+      # @return [String,Array]
+      attr_accessor :network_id
+
+      # Network name(s) that the instance should use
+      #
+      # @return [String,Array]
+      attr_accessor :network_name
+
+      # Network Type
+      #
+      # @return [String]
+      attr_accessor :network_type
+
+      # Project uuid that the instance should belong to
+      #
+      # @return [String]
+      attr_accessor :project_id
+
+      # Service offering uuid to use for the instance
+      #
+      # @return [String]
+      attr_accessor :service_offering_id
+
+      # Service offering name to use for the instance
+      #
+      # @return [String]
+      attr_accessor :service_offering_name
+
+      # Disk offering uuid to use for the instance
+      #
+      # @return [String]
+      attr_accessor :disk_offering_id
+
+      # Disk offering name to use for the instance
+      #
+      # @return [String]
+      attr_accessor :disk_offering_name
+
+      # Template uuid to use for the instance
+      #
+      # @return [String]
+      attr_accessor :template_id
+
+      # Template name to use for the instance
+      #
+      # @return [String]
+      attr_accessor :template_name
+
+      # Zone uuid to launch the instance into. If nil, it will
+      # launch in default project.
+      #
+      # @return [String]
+      attr_accessor :zone_id
+
+      # Zone name to launch the instance into. If nil, it will
+      # launch in default project.
+      #
+      # @return [String]
+      attr_accessor :zone_name
+
+      # The name of the keypair to use.
+      #
+      # @return [String]
+      attr_accessor :keypair
+
+      # Paramters for Static NAT
+      #
+      # @return [String]
+      attr_accessor :static_nat
+
+      # IP address id to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_ip_address_id
+
+      # IP address to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_ip_address
+
+      # public port to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_public_port
+
+      # public port to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_public_rdp_port
+
+      # private port to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_private_rdp_port
+
+      # public port to use for port forwarding rule
+      #
+      # @return [Range]
+      attr_accessor :pf_public_port_randomrange
+
+      # private port to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_private_port
+
+      # flag to enable/disable automatic open firewall rule
+      #
+      # @return [Boolean]
+      attr_accessor :pf_open_firewall
+
+      # CIDR List string of trusted networks
+      #
+      # @return [String]
+      attr_accessor :pf_trusted_networks
+
+      # comma separated list of port forwarding rules
+      # (hash with rule parameters)
+      #
+      # @return [Array]
+      attr_accessor :port_forwarding_rules
+
+      # comma separated list of firewall rules
+      # (hash with rule parameters)
+      #
+      # @return [Array]
+      attr_accessor :firewall_rules
+
+      # display name for the instance
+      #
+      # @return [String]
+      attr_accessor :display_name
+
+      # group for the instance
+      #
+      # @return [String]
+      attr_accessor :group
+
+      # The user data string
+      #
+      # @return [String]
+      attr_accessor :user_data
+
+      # The key to be used when loging in to the vm via ssh
+      #
+      # @return [String]
+      attr_accessor :ssh_key
+
+      # The username to be used when loging in to the vm via ssh
+      #
+      # @return [String]
+      attr_accessor :ssh_user
+
+      # The network_id to be used when loging in to the vm via ssh
+      #
+      # @return [String]
+      attr_accessor :ssh_network_id
+
+      # The network_name to be used when loging in to the vm via ssh
+      #
+      # @return [String]
+      attr_accessor :ssh_network_name
+
+      # The username to be used when loging in to the vm
+      #
+      # @return [String]
+      attr_accessor :vm_user
+
+      # The username to be used when loging in to the vm
+      #
+      # @return [String]
+      attr_accessor :vm_password
+
+      # Private ip for the instance
+      #
+      # @return [String]
+      attr_accessor :private_ip_address
+
+      # flag to enable/disable expunge vm on destroy
+      #
+      # @return [Boolean]
+      attr_accessor :expunge_on_destroy
+
+      def initialize(domain_specific = false)
+        # Initialize groups in bulk, re-use these groups to set defaults in bulk
+        INSTANCE_VAR_DEFAULT_NIL.each do |instance_variable|
+          instance_variable_set("@#{instance_variable}", UNSET_VALUE)
+        end
+        # Initialize groups in bulk, re-use these groups to set defaults in bulk
+        INSTANCE_VAR_DEFAULT_EMPTY_ARRAY.each do |instance_variable|
+          instance_variable_set("@#{instance_variable}", UNSET_VALUE)
+        end
+
+        @scheme                     = UNSET_VALUE
+        @api_key                    = UNSET_VALUE
+        @secret_key                 = UNSET_VALUE
+        @instance_ready_timeout     = UNSET_VALUE
+        @network_type               = UNSET_VALUE
+        @pf_private_rdp_port        = UNSET_VALUE
+        @pf_public_port_randomrange = UNSET_VALUE
+        @pf_open_firewall           = UNSET_VALUE
+        @expunge_on_destroy         = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__compiled_domain_configs = {}
+        @__finalized               = false
+        @__domain_config           = {}
+        @__domain_specific         = domain_specific
+      end
+
+      # Allows domain-specific overrides of any of the settings on this
+      # configuration object. This allows the user to override things like
+      # template and keypair name for domains. Example:
+      #
+      #     cosmic.domain_config "abcd-ef01-2345-6789" do |domain|
+      #       domain.template_id = "1234-5678-90ab-cdef"
+      #       domain.keypair_name = "company-east"
+      #     end
+      #
+      # @param [String] domain The Domain name to configure.
+      # @param [Hash] attributes Direct attributes to set on the configuration
+      #   as a shortcut instead of specifying a full block.
+      # @yield [config] Yields a new domain configuration.
+      def domain_config(domain, attributes=nil, &block)
+        # Append the block to the list of domain configs for that domain.
+        # We'll evaluate these upon finalization.
+        @__domain_config[domain] ||= []
+
+        # Append a block that sets attributes if we got one
+        if attributes
+          attr_block = lambda do |config|
+            config.set_options(attributes)
+          end
+
+          @__domain_config[domain] << attr_block
+        end
+
+        # Append a block if we got one
+        @__domain_config[domain] << block if block_given?
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def merge(other)
+        super.tap do |result|
+          # Copy over the domain specific flag. "True" is retained if either
+          # has it.
+          new_domain_specific = other.instance_variable_get(:@__domain_specific)
+          result.instance_variable_set(
+              :@__domain_specific, new_domain_specific || @__domain_specific)
+
+          # Go through all the domain configs and prepend ours onto
+          # theirs.
+          new_domain_config = other.instance_variable_get(:@__domain_config)
+          @__domain_config.each do |key, value|
+            new_domain_config[key] ||= []
+            new_domain_config[key] = value + new_domain_config[key]
+          end
+
+          # Set it
+          result.instance_variable_set(:@__domain_config, new_domain_config)
+
+          # Merge in the tags
+          result.tags.merge!(self.tags)
+          result.tags.merge!(other.tags)
+        end
+      end
+
+      def finalize!
+        INSTANCE_VAR_DEFAULT_NIL.each do |instance_variable|
+          # ... must be nil, since we can't default that
+          instance_variable_set("@#{instance_variable}", nil) if
+              instance_variable_get("@#{instance_variable}") == UNSET_VALUE
+        end
+
+        INSTANCE_VAR_DEFAULT_EMPTY_ARRAY.each do |instance_variable|
+          # ... must be empty array
+          instance_variable_set("@#{instance_variable}", []) if
+              instance_variable_get("@#{instance_variable}") == UNSET_VALUE
+        end
+
+        # We default the scheme to whatever the user has specifid in the .fog file
+        # *OR* whatever is default for the provider in the fog library
+        @scheme                 = nil if @scheme == UNSET_VALUE
+
+        # Try to get access keys from environment variables, they will
+        # default to nil if the environment variables are not present
+        @api_key                = ENV['COSMIC_API_KEY'] if @api_key == UNSET_VALUE
+        @secret_key             = ENV['COSMIC_SECRET_KEY'] if @secret_key == UNSET_VALUE
+
+        # Set the default timeout for waiting for an instance to be ready
+        @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE
+
+        # NetworkType is 'Advanced' by default
+        @network_type           = "Advanced" if @network_type == UNSET_VALUE
+
+        # Private rdp port defaults to 3389
+        @pf_private_rdp_port     = 3389 if @pf_private_rdp_port == UNSET_VALUE
+
+        # Public port random-range, default to rfc6335 'Dynamic Ports'; "(never assigned)"
+        @pf_public_port_randomrange = {:start=>49152, :end=>65535} if @pf_public_port_randomrange == UNSET_VALUE
+
+        # Open firewall is true by default (for backwards compatibility)
+        @pf_open_firewall       = true if @pf_open_firewall == UNSET_VALUE
+
+        # expunge on destroy is nil by default
+        @expunge_on_destroy     = false if @expunge_on_destroy == UNSET_VALUE
+
+        # Compile our domain specific configurations only within
+        # NON-DOMAIN-SPECIFIC configurations.
+        unless @__domain_specific
+          @__domain_config.each do |domain, blocks|
+            config = self.class.new(true).merge(self)
+
+            # Execute the configuration for each block
+            blocks.each { |b| b.call(config) }
+
+            # The domain name of the configuration always equals the domain config name:
+            config.domain = domain
+
+            # Finalize the configuration
+            config.finalize!
+
+            # Store it for retrieval
+            @__compiled_domain_configs[domain] = config
+          end
+        end
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = []
+
+        if @domain
+          # Get the configuration for the domain we're using and validate only that domain.
+          config = get_domain_config(@domain)
+
+          unless config.use_fog_profile
+            errors << I18n.t("vagrant_cosmic.config.api_key_required") if \
+               config.access_key_id.nil?
+            errors << I18n.t("vagrant_cosmic.config.secret_key_required") if \
+               config.secret_access_key.nil?
+          end
+        end
+
+        {"Cosmic Provider" => errors}
+      end
+
+      # This gets the configuration for a specific domain. It shouldn't
+      # be called by the general public and is only used internally.
+      def get_domain_config(name)
+        raise 'Configuration must be finalized before calling this method.' unless @__finalized
+
+        # Return the compiled domain config
+        @__compiled_domain_configs[name] || self
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/errors.rb

@@ -0,0 +1,27 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Cosmic
+    module Errors
+      class VagrantCosmicError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_cosmic.errors")
+      end
+
+      class FogError < VagrantCosmicError
+        error_key(:fog_error)
+      end
+
+      class InstanceReadyTimeout < VagrantCosmicError
+        error_key(:instance_ready_timeout)
+      end
+
+      class RsyncError < VagrantCosmicError
+        error_key(:rsync_error)
+      end
+
+      class UserdataError < VagrantCosmicError
+        error_key(:user_data_error)
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/exceptions/exceptions.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module Cosmic
+    module Exceptions
+      class IpNotFoundException < StandardError
+      end
+      class DuplicatePFRule < StandardError
+      end
+      class CosmicResourceNotFound < StandardError
+        def initialize(msg='Resource not found in cosmic')
+          super
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/model/cosmic_resource.rb

@@ -0,0 +1,51 @@
+module VagrantPlugins
+  module Cosmic
+    module Model
+      class CosmicResource
+        attr_accessor :id, :name, :details
+        attr_reader   :kind
+
+        def initialize(id, name, kind)
+          raise 'Resource must have a kind' if kind.nil? || kind.empty?
+          @id             = id
+          @name           = name
+          @kind           = kind
+        end
+
+        def is_undefined?
+          is_id_undefined? and is_name_undefined?
+        end
+
+        def is_id_undefined?
+          id.nil? || id.empty?
+        end
+
+        def is_name_undefined?
+          name.nil? || name.empty?
+        end
+
+        def to_s
+          "#{kind} - #{id || '<unknown id>'}:#{name || '<unknown name>'}"
+        end
+
+        def self.create_list(ids, names, kind)
+          return create_id_list(ids, kind)     unless ids.empty?
+          return create_name_list(names, kind) unless names.empty?
+          []
+        end
+
+        def self.create_id_list(ids, kind)
+          ids.each_with_object([]) do |id, resources|
+            resources << CosmicResource.new(id, nil, kind)
+          end
+        end
+
+        def self.create_name_list(names, kind)
+          names.each_with_object([]) do |name, resources|
+            resources << CosmicResource.new(nil, name, kind)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/plugin.rb

@@ -0,0 +1,82 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Cosmic plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "2.2.0"
+  raise "The Vagrant Cosmic plugin is only compatible with Vagrant 2.2+"
+end
+
+module VagrantPlugins
+  module Cosmic
+    class Plugin < Vagrant.plugin("2")
+      name "Cosmic"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in Cosmic.
+      DESC
+
+      config(:cosmic, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:cosmic, { parallel: true, box_optional:  true}) do # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      provider_capability(:cosmic, :winrm_info) do
+        require_relative 'capabilities/winrm'
+        VagrantPlugins::Cosmic::Cap::WinRM
+      end
+
+      provider_capability(:cosmic, :rdp_info) do
+        require_relative 'capabilities/rdp'
+        VagrantPlugins::Cosmic::Cap::Rdp
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Cosmic.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          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
+          # we tell the user.
+          level = nil
+        end
+
+        # 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)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger            = Log4r::Logger.new("vagrant_cosmic")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level      = level
+          logger            = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/provider.rb

@@ -0,0 +1,58 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module Cosmic
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def winrm_info
+        # Run a custom action called "read_winrm_info" which does what it
+        # says and puts the resulting WinRM info into the `:machine_winrm_info`
+        # key in the environment.
+        env = @machine.action("read_winrm_info")
+        env[:machine_winrm_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short    = I18n.t("vagrant_cosmic.states.short_#{state_id}")
+        long     = I18n.t("vagrant_cosmic.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "Cosmic (#{id})"
+      end
+    end
+  end
+end