vagrant-cosmic 0.1.0

data/functional-tests/networking/networking_spec.rb

@@ -0,0 +1,14 @@
+describe 'Networking features' do
+  it 'creates firewall and portwarding rules for both Virtual Router and VPC' do
+    expect(`vagrant up`).to include(
+                                'VRbox1: Machine is booted and ready for use!',
+                                'VRbox2: Machine is booted and ready for use!',
+                                'VPCbox1: Machine is booted and ready for use!',
+                                'VPCbox2: Machine is booted and ready for use!'
+    )
+    expect($?.exitstatus).to eq(0)
+
+    expect(`vagrant destroy --force`).to include('Terminating the instance...')
+    expect($?.exitstatus).to eq(0)
+  end
+end

data/functional-tests/rsync/Vagrantfile.advanced_networking

@@ -0,0 +1,40 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = '2'
+
+Vagrant.require_version '>= 1.5.0'
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = ENV['LINUX_TEMPLATE_NAME']
+
+  config.vm.synced_folder ".", "/vagrant", type: "rsync",
+  rsync__exclude: [".git/", "vendor"]
+
+  config.vm.provider :cosmic do |cosmic, override|
+    cosmic.display_name = ENV['TEST_NAME']
+
+    cosmic.host       = ENV['COSMIC_HOST']
+    cosmic.path       = '/client/api'
+    cosmic.port       = '443'
+    cosmic.scheme     = 'https'
+    cosmic.api_key    = ENV['COSMIC_API_KEY']
+    cosmic.secret_key = ENV['COSMIC_SECRET_KEY']
+    cosmic.expunge_on_destroy = ENV['EXPUNGE_ON_DESTROY']=="true"
+
+    cosmic.zone_name             = ENV['ZONE_NAME']
+    cosmic.network_name          = ENV['NETWORK_NAME']
+    cosmic.service_offering_name = ENV['SERVICE_OFFERING_NAME']
+
+    cosmic.pf_ip_address         = ENV['PUBLIC_SOURCE_NAT_IP']
+    cosmic.pf_trusted_networks   = ENV['SOURCE_CIDR']
+    cosmic.pf_open_firewall      = false
+
+    unless ENV['SSH_KEY'].nil?
+        cosmic.ssh_key               = ENV['SSH_KEY']
+        cosmic.ssh_user              = ENV['SSH_USER']
+    end
+  end
+
+end

data/functional-tests/rsync/rsync_spec.rb

@@ -0,0 +1,9 @@
+describe 'VM RSync' do
+  it 'does rsync to the VM' do
+    expect(`vagrant up`).to include('Machine is booted and ready for use!')
+    expect($?.exitstatus).to eq(0)
+    expect(`vagrant ssh -c "ls /vagrant; echo;"`).to include('Vagrantfile.advanced_networking')
+    expect(`vagrant destroy --force`).to include('Terminating the instance...')
+    expect($?.exitstatus).to eq(0)
+  end
+end

data/functional-tests/vmlifecycle/Vagrantfile.advanced_networking

@@ -0,0 +1,64 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = '2'
+
+Vagrant.require_version '>= 1.5.0'
+
+machines = {
+  'linux-box' => {
+    'template'       => ENV['LINUX_TEMPLATE_NAME'],
+    'communicator'   => 'ssh',
+    'rsync_disabled' => true
+  },
+  'windows-box' => {
+    'template'       => ENV['WINDOWS_TEMPLATE_NAME'],
+    'communicator'   => 'winrm',
+    'rsync_disabled' => true
+  }
+}
+
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |global_config|
+  machines.each_pair do |name, options|
+    global_config.vm.define name do |config|
+      config.vm.box = options['template']
+
+      config.vm.communicator = options['communicator']
+      config.winrm.retry_delay = 30
+      config.vm.synced_folder ".", "/vagrant", type: "rsync",
+        rsync__exclude: [".git/", "vendor"], disabled: options['rsync_disabled']
+      config.vm.provider :cosmic do |cosmic, override|
+
+        cosmic.display_name = ENV['TEST_NAME']
+
+        cosmic.host       = ENV['COSMIC_HOST']
+        cosmic.path       = '/client/api'
+        cosmic.port       = '443'
+        cosmic.scheme     = 'https'
+        cosmic.api_key    = ENV['COSMIC_API_KEY']
+        cosmic.secret_key = ENV['COSMIC_SECRET_KEY']
+        cosmic.expunge_on_destroy = ENV['EXPUNGE_ON_DESTROY']=="true"
+
+        cosmic.zone_name             = ENV['ZONE_NAME']
+        cosmic.network_name          = ENV['NETWORK_NAME']
+        cosmic.service_offering_name = ENV['SERVICE_OFFERING_NAME']
+        cosmic.disk_offering_name    = ENV['DISK_OFFERING_NAME']
+
+        cosmic.pf_ip_address         = ENV['PUBLIC_SOURCE_NAT_IP']
+
+        cosmic.pf_public_port        = options['public_port']
+        cosmic.pf_private_port       = options['private_port']
+        cosmic.pf_trusted_networks   = ENV['SOURCE_CIDR']
+        cosmic.pf_open_firewall      = false
+
+
+        cosmic.ssh_key               = ENV['SSH_KEY'] unless ENV['SSH_KEY'].nil?
+        cosmic.ssh_user              = ENV['SSH_USER'] unless ENV['SSH_USER'].nil?
+        cosmic.vm_user               = ENV['WINDOWS_USER'] unless ENV['WINDOWS_USER'].nil?
+
+      end
+    end
+  end
+end

data/functional-tests/vmlifecycle/vmlifecycle_spec.rb

@@ -0,0 +1,25 @@
+def which(cmd)
+  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+    exts.each { |ext|
+      exe = File.join(path, "#{cmd}#{ext}")
+      return exe if File.executable?(exe) && !File.directory?(exe)
+    }
+  end
+  return nil
+end
+insert_tee_log = '  2>&1 | tee -a vagrant.log ' if which('tee')
+
+describe 'VM Life Cycle' do
+  it 'starts Linux and Windows VM' do
+    expect(`vagrant up  #{insert_tee_log}`).to include(
+      'linux-box: Machine is booted and ready for use!',
+      'windows-box: Machine is booted and ready for use!'
+    )
+    expect($?.exitstatus).to eq(0)
+  end
+  it 'destroys Linux and Windows VM' do
+    expect(`vagrant destroy --force  #{insert_tee_log}`).to include('Done removing resources')
+    expect($?.exitstatus).to eq(0)
+  end
+end

data/lib/vagrant-cosmic/action/connect_cosmic.rb

@@ -0,0 +1,47 @@
+require 'fog/cosmic'
+require 'log4r'
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This action connects to Cosmic, verifies credentials work, and
+      # puts the Cosmic connection object into the
+      # `:cosmic_compute` key in the environment.
+      class ConnectCosmic
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_cosmic::action::connect_cosmic')
+        end
+
+        def call(env)
+          # Get the domain we're going to booting up in
+          domain        = env[:machine].provider_config.domain_id
+
+          # Get the configs
+          domain_config = env[:machine].provider_config.get_domain_config(domain)
+
+          # Build the fog config
+          fog_config    = {
+              :provider => :cosmic
+              #:domain        => domain_config
+          }
+
+          if domain_config.api_key
+            fog_config[:cosmic_api_key]           = domain_config.api_key
+            fog_config[:cosmic_secret_access_key] = domain_config.secret_key
+          end
+
+          fog_config[:cosmic_host]   = domain_config.host if domain_config.host
+          fog_config[:cosmic_path]   = domain_config.path if domain_config.path
+          fog_config[:cosmic_port]   = domain_config.port if domain_config.port
+          fog_config[:cosmic_scheme] = domain_config.scheme if domain_config.scheme
+
+          @logger.info('Connecting to Cosmic...')
+          env[:cosmic_compute] = Fog::Compute.new(fog_config)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      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-cosmic/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is stopped and branch in the middleware.
+      class IsStopped
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :stopped
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_cosmic.already_status", :status => "created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_cosmic.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_cosmic.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/read_rdp_info.rb

@@ -0,0 +1,42 @@
+require_relative 'read_transport_info.rb'
+require 'log4r'
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This action reads the WinRM info for the machine and puts it into the
+      # `:machine_winrm_info` key in the environment.
+      class ReadRdpInfo < ReadTransportInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cosmic::action::read_rdp_info")
+
+          @public_port_fieldname = 'pf_public_rdp_port'
+        end
+
+        def call(env)
+          env[:machine_rdp_info] = read_rdp_info(env[:cosmic_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_rdp_info(cosmic, machine)
+          return nil if (server = find_server(cosmic, machine)).nil?
+
+          # Get the Port forwarding config
+          domain        = machine.provider_config.domain_id
+          domain_config = machine.provider_config.get_domain_config(domain)
+
+          pf_ip_address, pf_public_port = retrieve_public_ip_port(cosmic, domain_config, machine)
+
+          transport_info = {
+                       :host => pf_ip_address || server.nics[0]['ipaddress'],
+                       :port => pf_public_port
+                     }
+
+          transport_info
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/read_ssh_info.rb

@@ -0,0 +1,70 @@
+require_relative 'read_transport_info.rb'
+require 'log4r'
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo < ReadTransportInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cosmic::action::read_ssh_info")
+
+          @public_port_fieldname = 'pf_public_port'
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:cosmic_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(cosmic, machine)
+          return nil if (server = find_server(cosmic, machine)).nil?
+
+          # Get the Port forwarding config
+          domain        = machine.provider_config.domain_id
+          domain_config = machine.provider_config.get_domain_config(domain)
+
+          pf_ip_address, pf_public_port = retrieve_public_ip_port(cosmic, domain_config, machine)
+
+          if domain_config.keypair.nil? && domain_config.ssh_key.nil?
+            sshkeyfile_file = machine.data_dir.join('sshkeyfile')
+            if sshkeyfile_file.file?
+              domain_config.ssh_key = sshkeyfile_file.to_s
+            end
+          end
+
+          nic_ip_address = fetch_nic_ip_address(server.nics, domain_config)
+
+          transport_info = {
+                       :host => pf_ip_address || nic_ip_address,
+                       :port => pf_public_port
+                     }
+          transport_info = transport_info.merge({
+            :private_key_path => domain_config.ssh_key,
+            :password         => nil
+          }) unless domain_config.ssh_key.nil?
+          transport_info = transport_info.merge({ :username => domain_config.ssh_user }) unless domain_config.ssh_user.nil?
+          transport_info
+        end
+
+        def fetch_nic_ip_address(nics, domain_config)
+          ssh_nic =
+            if !domain_config.ssh_network_id.nil?
+              nics.find { |nic| nic["networkid"] == domain_config.ssh_network_id }
+            elsif !domain_config.ssh_network_name.nil?
+              nics.find { |nic| nic["networkname"] == domain_config.ssh_network_name }
+            else
+              # When without neither ssh_network_id and ssh_network_name, use 1st nic
+              nics[0]
+            end
+
+          ssh_nic ||= nics[0]
+          ssh_nic["ipaddress"]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/read_state.rb

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cosmic::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:cosmic_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(cosmic, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = cosmic.servers.get(machine.id)
+          if server.nil? || [:"shutting-down", :terminated].include?(server.state.downcase.to_sym)
+            # The machine can't be found
+            @logger.info("Machine not found or terminated, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          server.state.downcase.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/read_transport_info.rb

@@ -0,0 +1,59 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      class ReadTransportInfo
+        def initialize
+          @public_port_fieldname = 'pf_public_port'
+        end
+
+        def retrieve_public_ip_port(cosmic, domain_config, machine)
+          pf_ip_address_id = domain_config.pf_ip_address_id
+          pf_ip_address = domain_config.pf_ip_address
+          pf_public_port = domain_config.send(@public_port_fieldname)
+
+          if pf_public_port.nil?
+            pf_public_port_file = machine.data_dir.join(@public_port_fieldname)
+            if pf_public_port_file.file?
+              File.read(pf_public_port_file).each_line do |line|
+                pf_public_port = line.strip
+              end
+              domain_config.send("#{@public_port_fieldname}=", pf_public_port)
+            end
+          end
+
+          if not pf_ip_address and pf_ip_address_id and pf_public_port
+            begin
+              response = cosmic.list_public_ip_addresses({:id => pf_ip_address_id})
+            rescue Fog::Cosmic::Compute::Error => e
+              raise Errors::FogError, :message => e.message
+            end
+
+            if (response['listpublicipaddressesresponse']['count']).zero?
+              @logger.info("IP address #{pf_ip_address_id} not exists.")
+              env[:ui].info(I18n.t("IP address #{pf_ip_address_id} not exists."))
+              pf_ip_address = nil
+            else
+              pf_ip_address = response['listpublicipaddressesresponse']['publicipaddress'][0]['ipaddress']
+            end
+          end
+          return pf_ip_address, pf_public_port
+        end
+
+        def find_server(cosmic, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = cosmic.servers.get(machine.id)
+          if server.nil? || [:"shutting-down", :terminated].include?(server.state.downcase.to_sym)
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          server
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/read_winrm_info.rb

@@ -0,0 +1,69 @@
+require_relative 'read_transport_info.rb'
+require 'log4r'
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This action reads the WinRM info for the machine and puts it into the
+      # `:machine_winrm_info` key in the environment.
+      class ReadWinrmInfo < ReadTransportInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cosmic::action::read_winrm_info")
+
+          @public_port_fieldname = 'pf_public_port'
+        end
+
+        def call(env)
+          env[:machine_winrm_info] = read_winrm_info(env[:cosmic_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_winrm_info(cosmic, machine)
+          return nil if (server = find_server(cosmic, machine)).nil?
+
+          # Get the Port forwarding config
+          domain        = machine.provider_config.domain_id
+          domain_config = machine.provider_config.get_domain_config(domain)
+
+          pf_ip_address, pf_public_port = retrieve_public_ip_port(cosmic, domain_config, machine)
+
+
+          transport_info = {
+                       :host => pf_ip_address || server.nics[0]['ipaddress'],
+                       :port => pf_public_port
+                     }
+
+          transport_info = transport_info.merge({
+            :username => domain_config.vm_user
+          }) unless domain_config.vm_user.nil?
+          machine.config.winrm.username = domain_config.vm_user unless domain_config.vm_user.nil?
+          # The WinRM communicator doesnt support passing
+          # the username via winrm_info ... yet ;-)
+
+          # Read password from file into domain_config
+          if domain_config.vm_password.nil?
+            vmcredentials_file = machine.data_dir.join("vmcredentials")
+            if vmcredentials_file.file?
+              vmcredentials_password = nil
+              File.read(vmcredentials_file).each_line do |line|
+                vmcredentials_password = line.strip
+              end
+              domain_config.vm_password = vmcredentials_password
+            end
+          end
+
+          transport_info = transport_info.merge({
+            :password => domain_config.vm_password
+          }) unless domain_config.vm_password.nil?
+          # The WinRM communicator doesnt support passing
+          # the password via winrm_info ... yet ;-)
+          machine.config.winrm.password = domain_config.vm_password unless domain_config.vm_password.nil?
+
+          transport_info
+        end
+      end
+    end
+  end
+end