danarchy_sys 0.2.17 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5dd08ba1e4fcce5f446e2198ca93828f8f9271d9
-  data.tar.gz: 00c68532f44cbec2e9891bf47f820419ef57e287
+  metadata.gz: aeb862f65f50235701c84688ad465846b206ea7d
+  data.tar.gz: c24cd5c66b0281c655a2a504b718d376e6f9ddf2
 SHA512:
-  metadata.gz: 395284512dd1b5b7447cb7e3f9dafac22c5a88283d36c224f5d812389a4863628c46d3ed52f3c88e757d102dec638b59a3530e397ee6f5461ac617663dbaeec5
-  data.tar.gz: 8c8f71e0205ed5af717fc2fe95c9f1e14bc791687cbbbf97d1dfef592ba2b83cdbb60c15cd633c0dcb7c677eca98d28dac30d55e9aba93ee2acae2a3704117ae
+  metadata.gz: 0e4534817fc4c50e88473c6915e91a385cdf4c9b5c084d3d5c2671c8c5c1f703af773c3145250880a727ab3b493fd16b935dc6d58fa5e80eb42cc3e30d8abc03
+  data.tar.gz: 06b2984a4da6b5b5d01f26a0b96824580de98ee48e9beb02c78e64aac85234e57085a01e2d136d2fd9c9ef75b427b8d7dc3625c897b5a1ec9a562bd2bd5eb252

data/lib/danarchy_sys/cli/instance_manager.rb

@@ -58,7 +58,7 @@ class InstanceManager
           puts "\nInvalid action for #{instance.name}'s current status!"
           next
         end
-        
+
         until status != instance.state
           instance = os_compute.instances.get_instance(instance.name)
           sleep(3)
@@ -66,9 +66,30 @@ class InstanceManager
         end
 
         printf("\n%#{instance.name.size}s %0s %0s\n", instance.name, ' => ', instance.state)
+      elsif cmd == 'rebuild'
+        print "Should we rebuild #{instance.name}? (Y/N): "
+        if gets.chomp =~ /^y(es)?$/i
+          image = PromptsCreateInstance.image(os_compute.images)
+          instance.rebuild(image.id, instance.name)
+
+          print "Rebuilding #{instance.name} with #{image.name}"
+          instance = os_compute.instances.get_instance(instance.name)
+          until instance.state == 'ACTIVE'
+            instance = os_compute.instances.get_instance(instance.name)
+            sleep(3)
+            print ' .'
+          end
+
+          addrs = os_compute.instances.get_public_addresses(instance.name)
+          addrs.each { |ip| `ssh-keygen -R #{ip} &>/dev/null` }
+          puts "\nRebuild successful!"
+        else
+          puts "Not rebuilding #{instance.name} at this time."
+        end
       elsif cmd == 'connect'
         if instance.state == 'ACTIVE'
-          os_compute.ssh(instance.name.to_s)
+          connect = os_compute.ssh(instance.name)
+          puts connect if connect != true
         else
           puts "Unable to connect: #{instance.name} is not running!"
         end
@@ -84,12 +105,12 @@ class InstanceManager
   def self.chooser(os_compute)
     comp_inst = os_compute.instances
     instances = comp_inst.all_instances
-    instances_numhash = Helpers.objects_to_numhash(instances)
-    instance_name = 'nil'
-    instance = 'nil'
+    instances_numhash = Helpers.objects_to_numhash(comp_inst.all_instances)
+    instance_name = nil
+    instance = nil
 
     # Create a new instances if none exist
-    if instances_numhash.empty?
+    if instances.empty?
       print 'No existing instances were found. Should we create a new one? (Y/N): '
       abort('Exiting!') unless gets.chomp =~ /^y(es)?$/i
       instance = PromptsCreateInstance.create_instance(os_compute, 'nil')
@@ -97,16 +118,14 @@ class InstanceManager
       return instance
     end
 
-    # Display existing instances in numbered hash
-    fields = PrintFormats.printf_numhash_values(instances_numhash, [:name, :state])
-
     puts 'Available instances:'
-    InstanceStatus.all_instances(os_compute, instances)
-    
+    istatus = InstanceStatus.new(os_compute)
+    istatus.all_instances(instances)
+
     # Loop input until an existing instance is selected
     print 'Enter an instance to manage or enter a name for a new instance: '
 
-    until Helpers.check_nested_hash_value(instances_numhash, :name, instance_name) == true
+    until comp_inst.check_instance(instance_name) == true
       instance_name = gets.chomp
 
       until instance_name.empty? == false
@@ -127,13 +146,12 @@ class InstanceManager
         instance_name = instances_numhash[instance_name.to_i][:name].to_s
       end
 
-      unless Helpers.check_nested_hash_value(instances_numhash, :name, instance_name) == true
+      unless comp_inst.check_instance(instance_name) == true
         print "#{instance_name} is not a valid instance.
 Should we create a new instance named #{instance_name}? (Y/N): "
 
         if gets.chomp =~ /^y(es)?$/i
           PromptsCreateInstance.create_instance(os_compute, instance_name)
-          instances_numhash = Helpers.objects_to_numhash(comp_inst.all_instances)
         else
           puts "Not creating new instance: #{instance_name}."
           return false
@@ -142,9 +160,8 @@ Should we create a new instance named #{instance_name}? (Y/N): "
     end
 
     instance = comp_inst.get_instance(instance_name)
-    status = instance.state
     Menus.print_menu('instance')
-    puts "Managing instance: #{instance_name}\tStatus: #{status}"
+    puts "Managing instance: #{instance_name}\tStatus: #{instance.state}"
     instance
   end
 end

data/lib/danarchy_sys/cli/instance_manager/instance_status.rb

@@ -1,22 +1,25 @@
 
 class InstanceStatus
-  def self.all_instances(os_compute, instances)
+  def initialize(os_compute)
+    @images = os_compute.images
+    @flavors = os_compute.flavors
+  end
+
+  def all_instances(instances)
     istats = {}
 
-    id = 1
-    instances.each do |instance|
-      istats[id] = single_instance(os_compute, instance)
-      id += 1
+    instances.map.with_index(1) do |instance, id|
+      istats[id] = single_instance(instance)
     end
 
-    fields = %w[name state image vcpus ram disk keypair]
+    fields = %w[name status image vcpus ram disk keypair]
     format = PrintFormats.printf_numhash_values(istats, fields)
     _header(format)
-    
+
     istats.each do |id, i|
       printf("#{format}\n", "#{id}.",
              i['name'],
-             i['state'],
+             i['status'],
              i['image'],
              i['vcpus'],
              i['ram'],
@@ -24,18 +27,18 @@ class InstanceStatus
              i['keypair'],
             )
     end
+
+    istats
   end
 
-  def self.single_instance(os_compute, instance)
-    comp_inst = os_compute.instances
-    comp_imgs = os_compute.images
-    comp_flvs = os_compute.flavors
+  def single_instance(instance)
+    image  = @images.get_image_by_id(instance.image['id'])
+    flavor = @flavors.get_flavor_by_id(instance.flavor['id'])
 
-    image  = comp_imgs.get_image_by_id(instance.image['id'])
-    flavor = comp_flvs.get_flavor_by_id(instance.flavor['id'])
+    image = NilImage.new if image == nil
 
     istats = { 'name'  => instance.name,
-               'state' => instance.state,
+               'status' => instance.state,
                'image' => image.name,
                'vcpus' => flavor.vcpus,
                'ram'   => flavor.ram,
@@ -44,7 +47,14 @@ class InstanceStatus
              }
   end
 
-  def self._header(format)
-    printf("#{format}\n", 'Id', 'Name', 'State', 'Image', 'VCPUS', 'RAM', 'Disk', 'KeyPair')
+  def _header(format)
+    printf("#{format}\n", 'Id', 'Name', 'Status', 'Image', 'VCPUS', 'RAM', 'Disk', 'KeyPair')
+  end
+
+  class NilImage
+    def name
+      'Not Found'
+    end
   end
 end
+

data/lib/danarchy_sys/cli/instance_manager/prompts_create_instance.rb

@@ -8,7 +8,7 @@ class PromptsCreateInstance
     comp_keys = os_compute.keypairs
 
     # Prompt for and check that instance_name is unused
-    if instance_name == 'nil'
+    if instance_name == nil
       print "\nWhat should we name the instance?: "
       instance_name = gets.chomp
     end
@@ -40,7 +40,7 @@ class PromptsCreateInstance
     puts "      Keypair: #{keypair.name}"
 
     print 'Should we continue with creating the instance? (Y/N): '
-    instance = 'nil'
+    instance = nil
     continue = gets.chomp
 
     if continue =~ /^y(es)?$/i
@@ -62,79 +62,40 @@ class PromptsCreateInstance
   end
 
   def self.image(comp_imgs)
-    images_numbered = Helpers.array_to_numhash(comp_imgs.list_images)
-    image_name = 'nil'
+    images_numbered = Helpers.objects_to_numhash(comp_imgs.all_images({'status' => 'ACTIVE'}))
 
     # List available images in a numbered hash.
     puts "\nAvailable Images:"
-    i_name_length = Helpers.hash_largest_value(images_numbered).length
+    i_name_length = images_numbered.values.collect{|i| i[:name]}.max.size
     printf("%0s %-#{i_name_length}s\n", 'Id', 'Image')
-    images_numbered.each do |id, i_name|
-      printf("%0s %-#{i_name_length}s\n", "#{id}.", i_name)
-    end
-
-    # Loop input until existing image is selected
-    print 'Which image should we use for this instance?: '
-    until images_numbered.values.include?(image_name)
-      image_name = gets.chomp
-
-      if image_name =~ /^[0-9]*$/
-        until images_numbered.keys.include?(image_name.to_i)
-          print "#{image_name} is not a valid Id. Enter an Id from above: "
-          image_name = gets.chomp
-        end
-
-        image_name = images_numbered[image_name.to_i]
-      end
-
-      image_check = images_numbered.values.include?(image_name)
-      print "#{image_name} is not a valid image. Please enter an option from above: " if image_check == false
+    images_numbered.each do |id, image|
+      printf("%0s %-#{i_name_length}s\n", "#{id}.", image[:name])
     end
 
+    image_name = item_chooser(images_numbered, 'image')
     print "Image Name: #{image_name}\n"
     comp_imgs.get_image_by_name(image_name)
   end
 
   def self.flavor(comp_flvs)
-    flavors = Helpers.objects_to_numhash(comp_flvs.all_flavors.sort_by(&:ram))
-    flavor_name = 'nil'
+    flavors_numbered = Helpers.objects_to_numhash(comp_flvs.all_flavors.sort_by(&:ram))
+    flavor_name = nil
 
     puts "\nAvailable Instance Flavors:"
     puts sprintf("%0s %-15s %-10s %-10s %0s", 'Id', 'Name', 'RAM', 'VCPUs', 'Disk')
-    flavors.each do |id, flavor|
+    flavors_numbered.each do |id, flavor|
       print sprintf("%0s %-15s %-10s %-10s %0s\n",
                     "#{id}.", flavor[:name].split('.')[1], flavor[:ram], flavor[:vcpus], flavor[:disk])
     end
 
-    print 'Which flavor should we use for this instance?: '
-    flavor_check = false
-
-    until flavor_check == true
-      flavor_name = gets.chomp
-
-      if flavor_name =~ /^[0-9]*$/
-        until flavors.keys.include?(flavor_name.to_i)
-          print "#{flavor_name} is not a valid Id. Enter an Id from above: "
-          flavor_name = gets.chomp
-        end
-
-        flavor_name = flavors[flavor_name.to_i][:name].split('.')[1]
-      end
-      
-      flavors.each_value do |flavor|
-        flavor_check = true if flavor[:name].end_with?(flavor_name)
-      end
-
-      print "#{flavor_name} is not a valid flavor. Please enter an option from above: " if flavor_check == false
-    end
-
-    print "Flavor Name: #{flavor_name}\n"
+    flavor_name = item_chooser(flavors_numbered, 'flavor')
+    print "Flavor Name: #{flavor_name.split('.')[1]}\n"
     comp_flvs.get_flavor(flavor_name)
   end
 
   def self.keypair(comp_keys)
     keypairs = Helpers.objects_to_numhash(comp_keys.all_keypairs)
-    keypair_name = 'nil'
+    keypair_name = nil
 
     # List available keypairs
     puts "\nAvailable Keypairs:"
@@ -179,4 +140,28 @@ Should we create a new keypair named #{keypair_name}? (Y/N): "
 
     comp_keys.get_keypair(keypair_name)
   end
+
+  private
+  def self.item_chooser(items_numbered, item)
+    # Loop input until existing object is selected
+    item_name = nil
+    print "Which #{item} should we use for this instance?: "
+
+    until items_numbered.values.collect{|i| i[:name]}.include?(item_name)
+      item_name = gets.chomp
+
+      if item_name =~ /^[0-9]*$/
+        until items_numbered.keys.include?(item_name.to_i)
+          print "#{item_name} is not a valid Id. Enter an Id from above: "
+          item_name = gets.chomp
+        end
+
+        item_name = items_numbered[item_name.to_i][:name]
+      end
+
+      item_check = items_numbered.values.collect{|i| i[:name]}.include?(item_name)
+      print "#{item_name} is not a valid item. Please enter an option from above: " if item_check == false
+    end
+    item_name
+  end
 end

data/lib/danarchy_sys/cli/menus.rb

@@ -14,6 +14,7 @@ class Menus
                               'unpause' => 'Unpause instance from paused state',
                               'suspend' => 'Suspend Instance (to disk)',
                               'resume'  => 'Resume instance from suspended state',
+                              'rebuild' => 'Rebuilds instance with a chosen image',
                               'create'  => 'Create a new instance',
                               'delete'  => 'Delete this instance'
                             },

data/lib/danarchy_sys/openstack/compute.rb

@@ -2,6 +2,7 @@ require_relative 'compute/instances'
 require_relative 'compute/keypairs'
 require_relative 'compute/images'
 require_relative 'compute/flavors'
+require_relative 'compute/secgroups'
 
 module DanarchySys
   module OpenStack
@@ -29,29 +30,64 @@ module DanarchySys
         ComputeFlavors.new(@compute)
       end
 
+      def secgroups
+        ComputeSecgroups.new(@compute)
+      end
+
       def ssh(instance_name)
         (comp_inst, comp_kp, comp_img) = instances, keypairs, images
         instance = comp_inst.get_instance(instance_name)
         keypair_name = instance.key_name
         pemfile = comp_kp.pemfile_path(keypair_name)
         
+        addrs = comp_inst.get_public_addresses(instance_name)
+        ipv4 = addrs.grep(/\./).first
+        ipv6 = addrs.grep(/:/).first
+
         # Define user by image_id
-        image_info = instance.image
-        image_id = image_info['id']
+        image_id = instance.image['id']
         image = comp_img.get_image_by_id(image_id)
 
+        if image == nil
+          puts "Image not found for #{instance.name}! This instance needs to be rebuild with a current image."
+          return fallback_ssh(ipv4, pemfile)          
+        end
+
         # 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]
+        user = 'ubuntu' if image.name =~ /ubuntu/i
+        user = 'debian' if image.name =~ /debian/i
+        user = 'centos' if image.name =~ /centos/i
+        user = 'fedora' if image.name =~ /fedora/i
+        user = 'core'   if image.name =~ /coreos/i
+
+        puts "Connecting as user: #{user} => #{ipv4}"
+        connect = "ssh #{user}@#{ipv4} -i '#{pemfile}'"
+        ssh = system(connect)
+
+        attempts = 1
+        until ssh == true || attempts > 3
+          puts "Connection failed. Attempting again after 5 seconds..."
+          sleep(5)
+          fallback_ssh(ipv4, pemfile)
+          attempts += 1
         end
+      end
 
-        ipv4, ipv6 = comp_inst.get_addresses(instance_name)
+      def fallback_ssh(ipv4, pemfile)
+        users = ['ubuntu','debian','centos','fedora','core']
+        ssh = false
 
-        ssh = "ssh #{user}@#{ipv4} -i '#{pemfile}'"
-        system(ssh)
+        users.each do |user|
+          puts "Attempting connection as user: #{user} => #{ipv4}"
+          connect = "ssh #{user}@#{ipv4} -i '#{pemfile}'"
+          ssh = system(connect)
+          return true if ssh == true
+        end
+
+        if ssh == false
+          puts 'Unable to connect after 3 tries!'
+          return false
+        end
       end
     end
   end

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

@@ -4,47 +4,34 @@ class ComputeImages
   def initialize(compute)
     @compute = compute
   end
-  
-  def all_images
-    @compute.images
-  end
 
-  def list_images
-    images = all_images
-    image_list = []
+  def all_images(*filter)
+    filter = filter.shift || {}
+    @compute.images(filters: filter)
+  end
 
-    # Get image names into array
-    images.each do |i|
-      next unless i.status == 'ACTIVE'
-      image_list.push(i.name)
-    end
+  def list_all_images
+    all_images.collect { |i| i.name }
+  end
 
-    image_list
+  def list_active_images
+    all_images({'status' => 'ACTIVE'})
   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
+    all_images({
+                 'status' => 'ACTIVE',
+                 'name'   => image_name
+               }).first
+    # .first may become a problem here
+    # if names are duplicates
   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
+    image = nil
+    
+    all_images.each do |i|
+      image = i if i.id == image_id
     end
 
     image

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

@@ -6,100 +6,115 @@ class ComputeInstances
     @settings = settings
   end
   
-  def all_instances
-    @compute.servers
+  def all_instances(*filter)
+    filter = filter.shift || {}
+    @compute.servers(filters: filter)
   end
 
   def list_all_instances
-    instances = all_instances
-    instances.map(&:name)
+    all_instances.collect { |i| i.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
+    all_instances({ 'status' => ['ACTIVE'] }).collect { |i| i.name }
   end
 
   def check_instance(instance_name)
-    instances = list_all_instances
-
-    return true if instances.include?(instance_name)
+    return false if instance_name == nil || instance_name.empty? == true
+    return true if get_instance(instance_name)
     false
   end
 
   def get_instance(instance_name)
-    servers = all_instances
+    instance = all_instances({ 'name' => [instance_name] })
+    return false if !instance.first
+    return false if !instance.collect{ |i| i.name }.include?(instance_name)
+    instance.first
+  end
 
-    # Get servers ID based on input instance_name
-    instance = 'nil'
-    servers.each do |i|
-      instance = i if i.name.end_with?(instance_name)
+  def get_public_addresses(instance)
+    if instance.class == String
+      instance = get_instance(instance)
     end
 
-    return false unless instance
-    instance
+    addrs = instance.addresses
+    return false if !addrs['public']
+    addrs['public'].map{|a| a['addr']}
   end
 
-  def get_addresses(instance_name)
-    instance = get_instance(instance_name)
-   (ipv6, ipv4) = nil, nil
-   addresses = instance.addresses['public']
-
-    addresses.each do |i|
-      ipv4 = i['addr'] if i['addr'].include?('.')
-      ipv6 = i['addr'] if i['addr'].include?(':')
+  def get_private_addresses(instance)
+    if instance.class == String
+      instance = get_instance(instance)
     end
 
-    return ipv4, ipv6
+    addrs = instance.addresses
+    return false if !addrs['private']
+    addrs['public'].map{|a| a['addr']}
   end
 
-  def pause(instance_name)
-    instance = get_instance(instance_name)
+  def pause(instance)
+    if instance.class == String
+      instance = get_instance(instance)
+    end
+
     return false unless instance.state == 'ACTIVE'
-    @compute.pause_server(instance.id)
+    instance.pause
   end
 
-  def unpause(instance_name)
-    instance = get_instance(instance_name)
+  def unpause(instance)
+    if instance.class == String
+      instance = get_instance(instance)
+    end
+
     return false unless instance.state == 'PAUSED'
-    @compute.unpause_server(instance.id)
+    instance.start
   end
 
-  def suspend(instance_name)
-    instance = get_instance(instance_name)
+  def suspend(instance)
+    if instance.class == String
+      instance = get_instance(instance)
+    end
+
     return false unless instance.state == 'ACTIVE'
-    @compute.suspend_server(instance.id)
+    instance.suspend
   end
 
-  def resume(instance_name)
-    instance = get_instance(instance_name)
+  def resume(instance)
+    if instance.class == String
+      instance = get_instance(instance)
+    end
+
     return false unless instance.state == 'SUSPENDED'
-    @compute.resume_server(instance.id)
+    instance.start
   end
 
-  def start(instance_name)
-    instance = get_instance(instance_name)
+  def start(instance)
+    if instance.class == String
+      instance = get_instance(instance)
+    end
+
     return false unless instance.state == 'SHUTOFF'
-    @compute.start_server(instance.id)
+    instance.start
   end
 
-  def stop(instance_name)
-    instance = get_instance(instance_name)
+  def stop(instance)
+    if instance.class == String
+      instance = get_instance(instance)
+    end
+
     return false unless instance.state == 'ACTIVE'
-    @compute.stop_server(instance.id)
+    instance.stop
   end
 
-  def create_instance(instance_name, image_id, flavor_id, keypair_name)
+  def create_instance(instance_name, image_id, flavor_id, keypair_name, *user_data)
+    user_data = nil if user_data.empty?
+
     instance = @compute.servers.create(name: instance_name,
                                       image_ref: image_id,
                                       flavor_ref: flavor_id,
-                                      key_name: keypair_name)
+                                      key_name: keypair_name,
+                                      user_data: user_data)
+    
     # add security_group
 
     # Put error handling from instance_prompts here

data/lib/danarchy_sys/version.rb

@@ -1,3 +1,3 @@
 module DanarchySys
-  VERSION = "0.2.17"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danarchy_sys
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.3.1
 platform: ruby
 authors:
 - Dan James
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-30 00:00:00.000000000 Z
+date: 2017-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog-openstack
@@ -144,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Facilitates the deployment and management of OpenStack.