danarchy_sys 0.2.10

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

@@ -0,0 +1,50 @@
+
+class InstanceStatus
+  def self.all_instances(os_compute, instances)
+    istats = {}
+
+    id = 1
+    instances.each do |instance|
+      istats[id] = single_instance(os_compute, instance)
+      id += 1
+    end
+
+    fields = %w[name state 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['image'],
+             i['vcpus'],
+             i['ram'],
+             i['disk'],
+             i['keypair'],
+            )
+    end
+  end
+
+  def self.single_instance(os_compute, instance)
+    comp_inst = os_compute.compute_instances
+    comp_imgs = os_compute.compute_images
+    comp_flvs = os_compute.compute_flavors
+
+    image  = comp_imgs.get_image_by_id(instance.image['id'])
+    flavor = comp_flvs.get_flavor_by_id(instance.flavor['id'])
+
+    istats = { 'name'  => instance.name,
+               'state' => instance.state,
+               'image' => image.name,
+               'vcpus' => flavor.vcpus,
+               'ram'   => flavor.ram,
+               'disk'  => flavor.disk,
+               'keypair' => instance.key_name,
+             }
+  end
+
+  def self._header(format)
+    printf("#{format}\n", 'Id', 'Name', 'State', 'Image', 'VCPUS', 'RAM', 'Disk', 'KeyPair')
+  end
+end

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

@@ -0,0 +1,182 @@
+
+# CLI Prompt to create a new instance
+class PromptsCreateInstance
+  def self.create_instance(os_compute, instance_name)
+    comp_inst = os_compute.compute_instances
+    comp_imgs = os_compute.compute_images
+    comp_flvs = os_compute.compute_flavors
+    comp_keys = os_compute.compute_keypairs
+
+    # Prompt for and check that instance_name is unused
+    if instance_name == 'nil'
+      print "\nWhat should we name the instance?: "
+      instance_name = gets.chomp
+    end
+
+    # Make sure instance_name isn't already in use
+    until comp_inst.check_instance(instance_name) == false
+      print "\n#{instance_name} already exists! Try another name: "
+      instance_name = gets.chomp
+    end
+
+    puts "Creating instance: #{instance_name}"
+
+    # Prompt for image
+    puts "\nSelect an image (operating system) for #{instance_name}"
+    image = PromptsCreateInstance.image(comp_imgs)
+
+    # Prompt for flavor
+    puts "\nSelect a flavor (instance size) for #{instance_name}"
+    flavor = PromptsCreateInstance.flavor(comp_flvs)
+
+    # Prompt for keypair
+    puts "\nSelect a keypair (SSH key) for #{instance_name}"
+    keypair = PromptsCreateInstance.keypair(comp_keys)
+
+    # Print summary and prompt to continue
+    puts "\nInstance Name: #{instance_name}"
+    puts "        Linux: #{image.name}"
+    puts "Instance Size: #{flavor.name}"
+    puts "      Keypair: #{keypair.name}"
+
+    print 'Should we continue with creating the instance? (Y/N): '
+    instance = 'nil'
+    continue = gets.chomp
+
+    if continue =~ /^y(es)?$/i
+      puts "Creating instance: #{instance_name}"
+      instance = comp_inst.create_instance(instance_name, image.id, flavor.id, keypair.name)
+    else
+      puts "Abandoning creation of #{instance_name}"
+      return false
+    end
+
+    instance_check = comp_inst.check_instance(instance_name)
+
+    if instance_check == true
+      puts "Instance #{instance.name} is ready!"
+      return instance
+    else
+      raise "Error: Could not create instance: #{instance_name}" if instance_check == false
+    end
+  end
+
+  def self.image(comp_imgs)
+    images_numbered = Helpers.array_to_numhash(comp_imgs.list_images)
+    image_name = 'nil'
+
+    # List available images in a numbered hash.
+    puts "\nAvailable Images:"
+    i_name_length = Helpers.hash_largest_value(images_numbered).length
+    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)
+          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_s]
+      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
+    end
+
+    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'
+
+    puts "\nAvailable Instance Flavors:"
+    puts sprintf("%0s %-15s %-10s %-10s %0s", 'Id', 'Name', 'RAM', 'VCPUs', 'Disk')
+    flavors.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"
+    comp_flvs.get_flavor(flavor_name)
+  end
+
+  def self.keypair(comp_keys)
+    keypairs = Helpers.objects_to_numhash(comp_keys.all_keypairs)
+    keypair_name = 'nil'
+
+    # List available keypairs
+    puts "\nAvailable Keypairs:"
+    print sprintf("%0s %-15s\n", 'Id', 'KeyPair Name')
+    keypairs.each do |id, key|
+      print sprintf("%0s %-15s\n", "#{id}.", key[:name])
+    end
+
+    # Loop input until existing flavor is selected or create a new one
+    print 'Enter a keypair to use for this instance or enter a name for a new keypair : '
+    keypair_check = false
+
+    until keypair_check == true
+      keypair_name = gets.chomp
+
+      # Accept keypair Id as an entry
+      if keypair_name =~ /^[0-9]*$/
+        until keypairs.keys.include?(keypair_name.to_i)
+          print "#{keypair_name} is not a valid Id.
+Enter an Id from above, or \'return\' to restart keypair selection. : "
+          keypair_name = gets.chomp
+          return keypair(settings, compute) if keypair_name == 'return'
+        end
+
+        keypair_name = keypairs[keypair_name.to_i][:name]
+      end
+
+      keypair_check = Helpers.check_nested_hash_value(keypairs, :name, keypair_name)
+
+      if keypair_check == false
+        print "#{keypair_name} is not an existing keypair.
+Should we create a new keypair named #{keypair_name}? (Y/N): "
+
+        if gets.chomp =~ /^y(es)?$/i
+          puts "Creating keypair: #{keypair_name}!"
+          return comp_keys.create_keypair(keypair_name)
+        else
+          print 'Please enter an option from above: '
+        end
+      end
+    end
+
+    comp_keys.get_keypair(keypair_name)
+  end
+end

data/lib/danarchy_sys/cli/menus.rb

@@ -0,0 +1,60 @@
+
+class Menus
+  def self.get_menu(menu)
+    menus = { 'main' => { 'instance'    => 'Instance Manager',
+                          'keypair'     => 'Keypair Manager (Not yet implemented!)',
+                          'help'        => 'Outputs commands for current the menu level',
+                          'exit'        => 'Exit dAnarchy_sys'},
+              'instance' => { 'status'  => 'Current running status of instance',
+                              'connect' => 'Connect to instance through SSH',
+                              'start'   => 'Start a currently stopped instance',
+                              'stop'    => 'Stop a currently running instance',
+                              'pause'   => 'Pause instance (to RAM)',
+                              'unpause' => 'Unpause instance from paused state',
+                              'suspend' => 'Suspend Instance (to disk)',
+                              'resume'  => 'Resume instance from suspended state',
+                              'create'  => 'Create a new instance',
+                              'delete'  => 'Delete this instance'}
+            }
+
+    menus[menu]
+  end
+
+  def self.numbered_menu(menu)
+    numbered_menu = Helpers.hash_to_numhash(get_menu(menu))
+  end
+
+  def self.print_menu(menu)
+    if menu == 'main'
+      puts 'dAnarchy_sys main menu commands:'
+      puts 'Enter \'help\' to view available commands or \'exit\' to leave.'
+      # print_menu(menu)
+    elsif menu == 'instance'
+      puts 'Instance Manager commands: '
+      puts 'Enter \'help\' to view available commands or \'back\' for the main menu.'
+      # print_menu(menu)
+    elsif menu == 'keypair'
+      puts 'Keypair Manager commands: '
+      puts 'Not yet implemented!'
+      return
+      # print_menu(menu)
+    elsif menu == 'storage'
+      puts 'Storage Manager commands: '
+      puts 'Not yet implemented!'
+      return
+      # print_menu(menu)
+    end
+
+    # numbered_menu = Helpers.hash_to_numhash(menu)
+    numbered_menu = numbered_menu(menu)
+    menu = get_menu(menu)
+    
+    fields = PrintFormats.printf_numhash(numbered_menu)
+
+    numbered_menu.each do |id, v|
+      v.each do |name, info|
+        printf("#{fields}\n", "#{id}.", "#{name}:", info)
+      end
+    end
+  end
+end

data/lib/danarchy_sys/cli/providers.rb

@@ -0,0 +1,33 @@
+
+class Providers
+  def self.chooser
+    config = ConfigMgr.new
+    danarchysys_config = config.load
+    providers = Helpers.array_to_numhash(danarchysys_config[:connections].keys)
+    provider = 'nil'
+
+    if providers.count == 1
+      provider = providers['1']
+      return provider
+    end      
+
+    fields = PrintFormats.printf_hash(providers)
+    printf("#{fields}\n", 'Id', 'Provider')
+    providers.each do |id, provider|
+      printf("#{fields}\n", "#{id}.", provider)
+    end
+
+    until providers.values.include?(provider)
+      print 'Which provider should we use? (enter \'exit\' to leave): '
+      provider = gets.chomp
+
+      abort('Exiting') if provider == 'exit'
+
+      if provider =~ /^[0-9]*$/ # select by Id
+        provider = providers[provider.to_s]
+      end
+    end
+
+    provider
+  end
+end

data/lib/danarchy_sys/config.rb

@@ -0,0 +1,66 @@
+
+require 'yaml'
+
+# dAnarchy_sys config management
+class ConfigMgr
+  def initialize
+    @danarchysys_path = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    @config_file = File.join(@danarchysys_path, 'config', 'danarchysys.yml')
+  end
+
+  def config_template
+    config_template = {
+      :connections => {},
+      :settings => {}
+    }
+  end
+
+  def load
+    if File.exists?(@config_file)
+      return YAML.load_file(@config_file)
+    else
+      return config_template
+    end
+  end
+
+  def save(param_hash)
+    File.write(@config_file, param_hash.to_yaml)
+  end
+
+  def connection_add(provider, openstack_auth_url, openstack_username, openstack_api_key, openstack_tenant)
+    danarchysys_config = load
+
+    danarchysys_config[:connections][provider.to_sym] = {
+      openstack_auth_url: openstack_auth_url,
+      openstack_username: openstack_username,
+      openstack_api_key: openstack_api_key,
+      openstack_tenant: openstack_tenant
+    }
+
+    danarchysys_config
+  end
+
+  def connection_delete(provider)
+    danarchysys_config = load
+
+    danarchysys_config[:connections].delete(provider.to_sym)
+
+    danarchysys_config
+  end
+
+  def setting_add(name, value)
+    danarchysys_config = load
+
+    danarchysys_config[:settings][name.to_sym] = value
+
+    danarchysys_config
+  end
+
+  def setting_delete(name)
+    danarchysys_config = load
+
+    danarchysys_config[:settings].delete(name.to_sym)
+
+    danarchysys_config
+  end
+end

data/lib/danarchy_sys/helpers.rb

@@ -0,0 +1,61 @@
+
+# Routine methods for DanarchySys
+class Helpers
+  def self.array_to_numhash(array)
+    numbered_hash = {}
+    
+    count = 1
+    array.sort.each do |item|
+      numbered_hash[count.to_s] = item
+      count += 1
+    end
+
+    numbered_hash
+  end
+
+  def self.hash_to_numhash(hash)
+    numbered_hash = {}
+
+    hash.map.with_index(1) do | (k, v), index |
+      numbered_hash[index] = {k => v}
+    end
+
+    numbered_hash
+  end
+
+  def self.objects_to_numhash(objects)
+    numbered_object_hash = {}
+
+    objects.map.with_index(1) do | obj, index |
+      numbered_object_hash[index] = obj.all_attributes
+    end
+
+    numbered_object_hash
+  end
+
+  def self.hash_largest_key(hash)
+    hash.keys.map(&:to_s).max_by(&:size)
+  end
+
+  def self.hash_largest_value(hash)
+    hash.values.map(&:to_s).max_by(&:size)
+  end
+
+  def self.hash_largest_nested_key(hash)
+    hash.each_value.flat_map(&:keys).max_by(&:size)
+  end
+
+  def self.hash_largest_nested_value(hash)
+    hash.each_value.flat_map(&:values).max_by(&:size)
+  end
+
+  def self.check_nested_hash_value(hash, key, value)
+    check = false
+
+    hash.each_value do |val|
+      check = true if val[key].end_with?(value)
+    end
+
+    check
+  end
+end