danarchy_sys 0.2.10

data/lib/danarchy_sys/openstack.rb

@@ -0,0 +1,9 @@
+
+require 'fog/openstack'
+
+module DanarchySys
+  module OpenStack
+    # Load OpenStack compute requirements
+    require_relative 'openstack/compute'
+  end
+end

data/lib/danarchy_sys/openstack/compute.rb

@@ -0,0 +1,59 @@
+require_relative 'compute/instances'
+require_relative 'compute/keypairs'
+require_relative 'compute/images'
+require_relative 'compute/flavors'
+
+module DanarchySys
+  module OpenStack
+    class Compute
+      def initialize(provider)
+        config = ConfigMgr.new
+        danarchysys_config = config.load
+        connection = danarchysys_config[:connections][provider]
+        @settings = danarchysys_config[:settings]
+        @compute = Fog::Compute::OpenStack.new(connection)
+      end
+
+      def compute_instances
+        ComputeInstances.new(@compute, @settings)
+      end
+
+      def compute_keypairs
+        ComputeKeypairs.new(@compute, @settings)
+      end
+
+      def compute_images
+        ComputeImages.new(@compute)
+      end
+
+      def compute_flavors
+        ComputeFlavors.new(@compute)
+      end
+
+      def compute_ssh(instance_name)
+        (comp_inst, comp_kp, comp_img) = compute_instances, compute_keypairs, compute_images
+        instance = comp_inst.get_instance(instance_name)
+        keypair_name = instance.key_name
+        pemfile = comp_kp.pemfile_path(keypair_name)
+        
+        # Define user by image_id
+        image_info = instance.image
+        image_id = image_info['id']
+        image = comp_img.get_image_by_id(image_id)
+
+        # CoreOS is an exception with user as simply 'core' and not 'coreos'
+        user = ''
+        if image.name =~ /CoreOS/i
+          user = 'core'
+        else
+          user = image.name.downcase.split('-')[0]
+        end
+
+        ipv4 = comp_inst.get_addresses(instance_name)[1]['addr']
+
+        ssh = "ssh #{user}@#{ipv4} -i '#{pemfile}'"
+        system(ssh)
+      end
+    end
+  end
+end

data/lib/danarchy_sys/openstack/compute/flavors.rb

@@ -0,0 +1,47 @@
+
+# OpenStack Flavor Management
+class ComputeFlavors
+  def initialize(compute)
+    @compute = compute
+  end
+
+  def all_flavors
+    @compute.flavors
+  end
+
+  def list_flavors
+    flavors = all_flavors
+    flavor_list = []
+
+    # Get flavor names into array
+    flavors.each do |i|
+      flavor_list.push(i.name.split('.')[1])
+    end
+
+    flavor_list
+  end
+
+  def get_flavor(flavor_name)
+    flavors = all_flavors
+
+    # Get flavor object based on input flavor_name.
+    flavor = 'nil'
+    flavors.each do |f|
+      flavor = f if f.name.end_with?(flavor_name)
+    end
+
+    flavor
+  end
+
+  def get_flavor_by_id(flavor_id)
+    flavors = all_flavors
+
+    # Get flavor based on input flavor_id.
+    flavor = 'nil'
+    flavors.each do |i|
+      flavor = i if i.id == flavor_id
+    end
+
+    flavor
+  end
+end

data/lib/danarchy_sys/openstack/compute/images.rb

@@ -0,0 +1,52 @@
+
+# OpenStack Image Management
+class ComputeImages
+  def initialize(compute)
+    @compute = compute
+  end
+  
+  def all_images
+    @compute.images
+  end
+
+  def list_images
+    images = all_images
+    image_list = []
+
+    # Get image names into array
+    images.each do |i|
+      next unless i.status == 'ACTIVE'
+      image_list.push(i.name)
+    end
+
+    image_list
+  end
+
+  def get_image_by_name(image_name)
+    images = all_images
+
+    # Get image based on input image_name.
+    image = 'nil'
+    images.each do |i|
+      next unless i.name == image_name
+      next unless i.status == 'ACTIVE'
+      image = i
+    end
+
+    image
+  end
+
+  def get_image_by_id(image_id)
+    images = all_images
+
+    # Get image based on input image_id.
+    image = 'nil'
+    images.each do |i|
+      next unless i.id == image_id
+      next unless i.status == 'ACTIVE'
+      image = i
+    end
+
+    image
+  end
+end

data/lib/danarchy_sys/openstack/compute/instances.rb

@@ -0,0 +1,120 @@
+
+# OpenStack Instance Management
+class ComputeInstances
+  def initialize(compute, settings)
+    @compute = compute
+    @settings = settings
+  end
+  
+  def all_instances
+    @compute.servers
+  end
+
+  def list_all_instances
+    instances = all_instances
+    instances.map(&:name)
+  end
+
+  def list_active_instances
+    instances = all_instances
+    instance_list = []
+
+    instances.each do |i|
+      instance_list.push(i.name) if i.state == 'ACTIVE'
+    end
+
+    instance_list
+  end
+
+  def check_instance(instance_name)
+    instances = list_all_instances
+
+    return true if instances.include?(instance_name)
+    false
+  end
+
+  def get_instance(instance_name)
+    servers = all_instances
+
+    # Get servers ID based on input instance_name
+    instance = 'nil'
+    servers.each do |i|
+      instance = i if i.name.end_with?(instance_name)
+    end
+
+    return false unless instance
+    instance
+  end
+
+  def get_addresses(instance_name)
+    instance = get_instance(instance_name)
+
+    addresses = instance.addresses['public']
+    ipv6, ipv4 = addresses[0], addresses[1]
+  end
+
+  def pause(instance_name)
+    instance = get_instance(instance_name)
+    return false unless instance.state == 'ACTIVE'
+    @compute.pause_server(instance.id)
+  end
+
+  def unpause(instance_name)
+    instance = get_instance(instance_name)
+    return false unless instance.state == 'PAUSED'
+    @compute.unpause_server(instance.id)
+  end
+
+  def suspend(instance_name)
+    instance = get_instance(instance_name)
+    return false unless instance.state == 'ACTIVE'
+    @compute.suspend_server(instance.id)
+  end
+
+  def resume(instance_name)
+    instance = get_instance(instance_name)
+    return false unless instance.state == 'SUSPENDED'
+    @compute.resume_server(instance.id)
+  end
+
+  def start(instance_name)
+    instance = get_instance(instance_name)
+    return false unless instance.state == 'SHUTOFF'
+    @compute.start_server(instance.id)
+  end
+
+  def stop(instance_name)
+    instance = get_instance(instance_name)
+    return false unless instance.state == 'ACTIVE'
+    @compute.stop_server(instance.id)
+  end
+
+  def create_instance(instance_name, image_id, flavor_id, keypair_name)
+    instance = @compute.servers.create(name: instance_name,
+                                      image_ref: image_id,
+                                      flavor_ref: flavor_id,
+                                      key_name: keypair_name)
+    # add security_group
+
+    # Put error handling from instance_prompts here
+    
+    instance.wait_for { ready? }
+    instance
+  end
+
+  def delete_instance(instance_name)
+    # check for and delete instance
+    instance = get_instance(instance_name)
+    return 1 if instance == false
+    @compute.delete_server(instance.id)
+
+    attempt = 1
+    until check_instance(instance_name) == false
+      return false if attempt == 5
+      sleep(5)
+      attempt += 1
+    end
+
+    return true
+  end
+end

data/lib/danarchy_sys/openstack/compute/keypairs.rb

@@ -0,0 +1,84 @@
+
+# OpenStack Keypair Management
+class ComputeKeypairs
+  def initialize(compute, settings)
+    @compute = compute
+    @settings = settings
+  end
+
+  def pemfile_path(keypair_name)
+    "#{@settings[:ssh_key_path]}/fog_#{keypair_name}.pem"
+  end
+
+  def pemfile_check(pemfile)
+    return true if File.exist?(pemfile)
+    false
+  end
+
+  def all_keypairs
+    @compute.key_pairs
+  end
+
+  def list_keypairs
+    keypair_list = []
+    keypairs = all_keypairs
+
+    keypairs.each do |kp|
+      keypair_list.push(kp.name)
+    end
+
+    keypair_list
+  end
+
+  def check_keypair(keypair_name)
+    keypairs = list_keypairs
+
+    return true if keypairs.include?(keypair_name)
+    false
+  end
+
+  def get_keypair(keypair_name)
+    keypairs = all_keypairs
+    keypair = 'nil'
+
+    keypairs.each do |kp|
+      keypair = kp if kp.name == keypair_name
+    end
+
+    keypair
+  end
+
+  def create_keypair(keypair_name)
+    keypair = @compute.create_key_pair(keypair_name)
+    pemfile = pemfile_path(keypair_name)
+
+    # create pemfile at pemfile_path
+    keyhash = keypair.body['keypair']
+    private_key = keyhash['private_key']
+    File.open(pemfile, 'w') do |f|
+      f.puts(private_key)
+      f.chmod(0600)
+    end
+
+    # Verify and return keypair & pemfile
+    keypair_check = check_keypair(keypair_name)
+    pemfile_check = pemfile_check(pemfile)
+    if keypair_check == true && pemfile_check == true
+      puts "Created keypair and pemfile for #{keypair_name}!"
+      return get_keypair(keypair_name)
+    else
+      abort("Error: Could not create keypair: #{keypair}") if keypair_check == false
+      abort("Error: Could not create pemfile: #{pemfile}") if pemfile_check == false
+    end
+  end
+
+  def delete_keypair(keypair_name)
+    # check for and delete key and .pem file
+    pemfile = pemfile_path(keypair_name)
+    pem_check = pemfile_check(pemfile)
+    kp_check = check_keypair(keypair_name)
+
+    @compute.delete_key_pair(keypair_name) if kp_check  == true
+    File.delete(pemfile) if pem_check == true
+  end
+end

data/lib/danarchy_sys/openstack/compute/tests/answer_yes.rb

@@ -0,0 +1,7 @@
+answer = gets.chomp
+
+if answer =~ /^y(es)?$/i
+  puts 'yes'
+else
+  puts 'no'
+end

data/lib/danarchy_sys/openstack/compute/tests/flavors_test.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require 'fog/openstack'
+require '../../../../../config/danarchysys.config'
+require '../../../helpers'
+require '../prompts'
+
+os_connection_params = Connection.os_dreamcompute
+compute = Fog::Compute::OpenStack.new(os_connection_params)
+
+p ComputePrompts.flavor(compute)

data/lib/danarchy_sys/openstack/compute/tests/images_test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'fog/openstack'
+require '../../connection'
+require_relative '../images'
+
+@os_connection_params = Connection.os_dreamcompute
+@compute = Fog::Compute::OpenStack.new(@os_connection_params)
+
+p ComputeImages.image_list(@compute)
+
+print "Which image should we test? : "
+image_name = gets.chomp
+
+p ComputeImages.image_get(@compute, image_name)

data/lib/danarchy_sys/openstack/compute/tests/instance_create_test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'fog/openstack'
+require '../../connection'
+require '../instance_prompts'
+require '../instance_params'
+require '../instance_manage'
+
+@os_connection_params = Connection.os_danarchy
+@compute = Fog::Compute::OpenStack.new(@os_connection_params)
+
+prompts = InstancePrompts.new
+instance = prompts.create_instance(@compute)
+
+p instance

data/lib/danarchy_sys/openstack/compute/tests/instance_manage_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'fog/openstack'
+require '../../../../danarchy_sys'
+require '../instances'
+
+os_connection_params = Connection.os_dreamcompute
+compute = Fog::Compute::OpenStack.new os_connection_params
+
+p ComputeInstances.all_instances compute
+
+puts 'Existing Instances:', ComputeInstances.list_all_instances(compute)
+print 'Which instance should we check?: '
+instance_name = gets.chomp
+
+puts "Checking: #{instance_name}", ComputeInstances.check_instance(compute, instance_name)
+
+puts "Getting: #{instance_name}"
+instance = ComputeInstances.get_instance(compute, instance_name)
+
+addresses = instance.addresses['public']
+ipv6, ipv4 = addresses[0], addresses[1]
+#ipv4 = addresses[1]
+print 'ipv6: ', ipv6['addr'], "\n"
+print 'ipv4: ', ipv4['addr'], "\n"