secured-cloud-vagrant 1.0.0

data/lib/secured-cloud-vagrant/configs/virtual_machine.rb

@@ -0,0 +1,136 @@
+require "vagrant"
+
+require_relative "ip_mapping"
+
+module VagrantPlugins
+  module SecuredCloud
+    module Configuration
+      class VirtualMachine < Vagrant.plugin(2, :config)
+
+        attr_accessor :name
+        attr_accessor :description
+        attr_accessor :storageGB
+        attr_accessor :memoryMB
+        attr_accessor :vcpus
+        attr_accessor :osTemplateUrl
+        attr_accessor :imageResourceUrl
+        attr_accessor :newOsPassword
+        attr_accessor :nodeResourceUrl
+        attr_accessor :orgResourceUrl
+        attr_accessor :ipMappings
+        
+        
+        def initialize
+
+          @name = UNSET_VALUE
+          @description = UNSET_VALUE
+          @storageGB = UNSET_VALUE
+          @memoryMB = UNSET_VALUE
+          @vcpus = UNSET_VALUE
+          @osTemplateUrl = UNSET_VALUE
+          @imageResourceUrl = UNSET_VALUE
+          @newOsPassword = UNSET_VALUE
+          @nodeResourceUrl = UNSET_VALUE
+          @orgResourceUrl = UNSET_VALUE
+          @ipMappings = UNSET_VALUE
+
+        end
+
+        def validate(machine)
+
+          errors = _detected_errors
+
+          if @name.nil? || @name.empty?
+            errors << "The VM name must be properly defined "
+          end
+
+          if !@ipMappings.nil? && !@ipMappings.respond_to?(:each)
+            errors << "A valid array of IP mappings must be specified "
+          else
+            @ipMappings.each do |ipMapping|
+              ipMapping.validate(machine)
+            end
+          end
+
+          { "Secured Cloud Provider" => errors}
+          
+        end
+        
+
+        def merge(other)
+
+          super.tap do |result|
+
+            result.name = (other.name == UNSET_VALUE) ? @name : other.name
+            result.description = (other.description == UNSET_VALUE) ? @description : other.description
+            result.storageGB = (other.storageGB == UNSET_VALUE) ? @storageGB : other.storageGB
+            result.memoryMB = (other.memoryMB == UNSET_VALUE) ? @memoryMB : other.memoryMB
+            result.vcpus = (other.vcpus == UNSET_VALUE) ? @vcpus : other.vcpus
+            result.osTemplateUrl = (other.osTemplateUrl == UNSET_VALUE) ? @osTemplateUrl : other.osTemplateUrl
+            result.imageResourceUrl = (other.imageResourceUrl == UNSET_VALUE) ? @imageResourceUrl : other.imageResourceUrl
+            result.newOsPassword = (other.newOsPassword == UNSET_VALUE) ? @newOsPassword : other.newOsPassword
+            result.nodeResourceUrl = (other.nodeResourceUrl == UNSET_VALUE) ? @nodeResourceUrl : other.nodeResourceUrl
+            result.orgResourceUrl = (other.orgResourceUrl == UNSET_VALUE) ? @orgResourceUrl : other.orgResourceUrl
+
+            if(other.ipMappings == UNSET_VALUE || other.ipMappings.nil?)
+              result.ipMappings = @ipMappings
+            elsif @ipMappings == UNSET_VALUE || @ipMappings.nil?
+              result.ipMappings = other.ipMappings
+            else
+              result.ipMappings = @ipMappings.concat(other.ipMappings)
+            end
+
+          end
+        end
+
+        def finalize!
+
+          @name = nil if (@name == UNSET_VALUE)
+          @description = nil if (@description == UNSET_VALUE)
+          @storageGB = nil if (@storageGB == UNSET_VALUE)
+          @memoryMB = nil if (@memoryMB == UNSET_VALUE)
+          @vcpus = nil if (@vcpus == UNSET_VALUE)
+          @osTemplateUrl = nil if (@osTemplateUrl == UNSET_VALUE)
+          @imageResourceUrl = nil if( @imageResourceUrl == UNSET_VALUE)
+          @newOsPassword = nil if (@newOsPassword == UNSET_VALUE)
+          @nodeResourceUrl = nil if (@nodeResourceUrl == UNSET_VALUE)
+          @orgResourceUrl = nil if (@orgResourceUrl == UNSET_VALUE)
+
+          if (@ipMappings == UNSET_VALUE || @ipMappings == nil)
+            @ipMappings = Array.new
+          else
+            finalizeIpMappings
+          end
+
+        end
+        
+        
+        def finalizeIpMappings
+
+          if(!@ipMappings.empty?)
+            
+            ipMappingsList = Array.new
+
+            @ipMappings.each do |ipMapping|
+
+              currentIpMapping = IpMapping.new
+              currentIpMapping.privateIp = ipMapping[:privateIp]
+              currentIpMapping.newPublicIpCount = ipMapping[:newPublicIpCount]
+              currentIpMapping.publicIpsFromReserved = ipMapping[:publicIpsFromReserved]
+
+              currentIpMapping.finalize!
+              ipMappingsList << currentIpMapping
+
+            end
+
+            @ipMappings = ipMappingsList
+
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/secured-cloud-vagrant/plugin.rb

@@ -0,0 +1,77 @@
+begin
+	require "vagrant"
+rescue LoadError
+	raise "This plugin must run within Vagrant."
+end
+
+module VagrantPlugins
+	module SecuredCloud
+	
+		class SecuredCloudPlugin < Vagrant.plugin('2')
+		
+			name 'Secured Cloud Vagrant Plugin'
+			
+			description <<-DESC
+			This plugin installs a provider that allows Vagrant to manage virtual machine in Secured Cloud
+			DESC
+			
+			provider('secured_cloud') do
+			
+				# Setup logging
+				setup_logging
+			
+				require_relative "provider"
+				SecuredCloudProvider
+			end
+			
+			config(:secured_cloud, :provider) do
+				require_relative "configs/config"
+				Configuration::Config
+			end
+
+			
+			command('ssh-config') do
+				require_relative "commands/ssh_config"
+				Command::SshConfig
+			end
+			
+			
+			command('list') do
+			  require_relative "commands/list"
+			  Command::List
+			end
+			
+			
+			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 `FATAL`. But
+					# we tell the user.
+					level = Log4r.const_get('FATAL')
+				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::secured_cloud')
+					logger.outputters = Log4r::Outputter.stdout
+					logger.level = level
+					logger = nil
+				end
+						
+			end
+		end
+	end
+end

data/lib/secured-cloud-vagrant/provider.rb

@@ -0,0 +1,73 @@
+require "vagrant"
+
+module VagrantPlugins
+	module SecuredCloud
+		class SecuredCloudProvider < 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.
+				return Action.send(name) if Action.respond_to?(name)
+				nil
+			end
+			
+			# This method is called if the underlying machine ID changes. Providers
+			# can use this method to load in new data for the actual backing
+			# machine or to realize that the machine is now gone (the ID can
+			# become `nil`). No parameters are given, since the underlying machine
+			# is simply the machine instance given to this object. And no
+			# return value is necessary.
+			def machine_id_changed
+			end
+			
+			# This should return a hash of information that explains how to
+			# SSH into the machine. If the machine is not at a point where
+			# SSH is even possible, then `nil` should be returned.
+			#
+			# The general structure of this returned hash should be the
+			# following:
+			#
+			#     {
+			#       :host => "1.2.3.4",
+			#       :port => "22",
+			#       :username => "mitchellh",
+			#       :private_key_path => "/path/to/my/key"
+			#     }
+			#
+			# **Note:** Vagrant only supports private key based authentication,
+			# mainly for the reason that there is no easy way to exec into an
+			# `ssh` prompt with a password, whereas we can pass a private key
+			# via commandline.
+			#
+			# @return [Hash] SSH information. For the structure of this hash
+			#   read the accompanying documentation for this method.
+			def ssh_info
+				env = @machine.action(:read_ssh_info)
+				env[:vm_conn_info]
+			end
+			
+			# This should return the state of the machine within this provider.
+			# The state must be an instance of {MachineState}. Please read the
+			# documentation of that class for more information.
+			def state
+			
+				env = @machine.action("read_machine_state")
+				
+				vm_name = (env[:vm_name].nil? || env[:vm_name].empty?) ? env[:machine].provider_config.vm.name : env[:vm_name]
+			
+				state = (env[:machine_state].nil?) ? :unknown : env[:machine_state]
+				short_desc = I18n.t("secured_cloud_vagrant.states.#{state}.short") 
+				long_desc = I18n.t("secured_cloud_vagrant.states.#{state}.long", :vm_name => vm_name) 
+				
+				Vagrant::MachineState.new(state, short_desc, long_desc)
+			end
+		end
+	end
+end

data/lib/secured-cloud-vagrant/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module SecuredCloud
+      VERSION = "1.0.0"
+  end
+end

data/locales/en.yml

@@ -0,0 +1,91 @@
+en:
+  secured_cloud_vagrant:
+    info:
+      not_created: "VM has not been created."
+      already_active: "VM is already active"
+      already_off: "VM is already off"
+      creating: "Creating a new VM ..."
+      destroying: "Destroying the VM ..."
+      powering_off: "Powering OFF the VM ..."
+      powering_on: "Powering ON the VM ..."
+      assigning_public_ips: "Assigning public IPs to VM ..."
+      reloading: "Rebooting the VM ..."
+      task_status: "%{percentage}% : %{task_desc}"
+      success:
+       create_vm: |- 
+         VM %{vm_name} was successfully created with the following resource URL:
+         %{resource_url}
+       delete_vm: "VM '%{vm_name}' was successfully deleted"
+       power_vm: "VM '%{vm_name}' was successfully powered %{power_status}"
+       reboot_vm: "VM '%{vm_name}' was successfully rebooted"
+       assign_public_ip: 
+         global_pool: "VM '%{vm_name}' has been successfully assigned a public IP from the global pool"
+         reserve_pool: "VM '%{vm_name}' has been successfully assigned public IP '%{public_ip}' from the reserve pool"
+    warnings:
+      no_public_ips: "Cannot connect to private VM '%{vm_name}'"
+      network_support: |-
+        Warning! The Secured Cloud provider doesn't support any of the Vagrant 
+        high-level network configurations (`config.vm.network`). They will be 
+        silently ignored.
+      provision_support: |-
+        Warning! The Secured Cloud provider doesn't support any of the Vagrant 
+        high-level provision configurations (`config.vm.provision`). They will be 
+        silently ignored.
+    errors:
+      unspecified_auth: |-
+        The authentication information must be correctly specified in the Vagrantfile
+        in order to be able to get the available %{resource_type}.
+      powering_vm: |-
+        There was an issue powering %{power_status} VM '%{vm_name}'.
+        Please check the following error message for details:
+
+        Error Message: %{error_message}
+      deleting_vm: |-
+        There was an issue with deleting VM '%{vm_name}'.
+        Please check the following error message for details:
+
+        Error Message: %{error_message}
+      creating_vm: |-
+        There was an issue with creating VM '%{vm_name}'.
+        Please check the following error message for details:
+
+        Error Message: %{error_message}
+      rebooting_vm: |-
+        There was an issue with reloading VM '%{vm_name}'.
+        Please check the following error message for details:
+
+        Error Message: %{error_message}
+      assigning_public_ip: |-
+        There was an issue with assigning a public IP to VM '%{vm_name}'.
+        Please check the following error message for details:
+
+        Error Message: %{error_message}
+      internal_server_error: "An internal server error occured. Please try again later."
+      request_timed_out: "The request made to the Secured Cloud API to %{request} timed out"
+      generic_error: "%{error_message}"
+    commands:
+      release_ips_confirmation: "Do you want to release the public IP(s) of the VM? [y/N]"
+      vm-config: |-
+         The following are the VM details required to connect to the Vagrant-managed VM:
+         HostName %{host_name}
+         User %{username}
+         Port %{port}
+         StrictHostKeyChecking no
+         PasswordAuthentication yes
+         Password ********
+    states:
+      not_created:
+       short: "not created"
+       long: "VM '%{vm_name}' is not created. Run 'vagrant up' to create it."
+      active:
+       short: "running"
+       long: |-
+        VM '%{vm_name}' is running. To stop it, you can run 'vagrant halt'.
+        To destroy it, you can run 'vagrant destroy'.
+      stopped:
+       short: "stopped"
+       long: "VM '%{vm_name}' is stopped. Run 'vagrant up' to start it."
+      unknown:
+       short: "unknown"
+       long: "Something is wrong, the state of VM '%{vm_name}' is unknown."
+      

data/secured-cloud-vagrant.gemspec

@@ -0,0 +1,59 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'secured-cloud-vagrant/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "secured-cloud-vagrant"
+  spec.version       = VagrantPlugins::SecuredCloud::VERSION
+  spec.authors       = ["Leanne Borg", "Alan Vella"]
+  spec.email         = ["leanneb@ccbilleu.com", "alanv@ccbilleu.com"]
+  spec.summary       = "Enables Vagrant to manage machines in SecuredCloud."
+  spec.description   = "This is a Vagrant plugin that allows Vagrant users to manage virtual machines in the SecuredCloud."
+  spec.homepage      = "http://phoenixnap.com/secured-cloud/"
+  spec.license       = "MIT"
+
+  #spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.1", ">= 10.1.1"
+  
+  spec.add_dependency "log4r", "~> 1.1", ">= 1.1.10"
+  spec.add_dependency "secured_cloud_api_client", "~> 0.0", ">= 0.0.8"
+  
+   # The following block of code determines the files that should be included
+  # in the gem. It does this by reading all the files in the directory where
+  # this gemspec is, and parsing out the ignored files from the gitignore.
+  # Note that the entire gitignore(5) syntax is not supported, specifically
+  # the "!" syntax, but it should mostly work correctly.
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+  # Ignore any directories, the gemspec only cares about files
+  next true if File.directory?(file)
+
+  # Ignore any paths that match anything in the gitignore. We do
+  # two tests here:
+  #
+  #   - First, test to see if the entire path matches the gitignore.
+  #   - Second, match if the basename does, this makes it so that things
+  #     like '.DS_Store' will match sub-directories too (same behavior
+  #     as git).
+  #
+  gitignore.any? do |ignore|
+    File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+      File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+
+  spec.files         = unignored_files
+end

data/templates/os_templates.erb

@@ -0,0 +1,12 @@
+<% if !os_templates.nil? && !os_templates.empty? -%>
+
+<% os_templates.each_pair do |key, value| -%>
+Resource URL: <%= key %>
+OS Name: <%= value.get_name %>
+OS Version: <%= value.get_version %>
+Minimum Storage: <%= value.get_minimum_storage_space %> GB
+Default Admin Username: <%= value.get_administrator_username %>
+Disk Expandable: <%= (value.get_disk_expandable) ? "Y" : "N" %>
+		
+<% end -%>
+<% end -%>