vmfloaty 0.8.1 → 0.10.0

data/lib/vmfloaty/abs.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require 'vmfloaty/errors'
+require 'vmfloaty/http'
+require 'faraday'
+require 'json'
+
+class ABS
+  # List active VMs in ABS
+  # This is what a job request looks like:
+  # {
+  #   "state":"filled",
+  #   "last_processed":"2019-10-31 20:59:33 +0000",
+  #   "allocated_resources": [
+  #     {
+  #       "hostname":"h3oyntawjm7xdch.delivery.puppetlabs.net",
+  #       "type":"centos-7.2-tmpfs-x86_64",
+  #       "engine":"vmpooler"}
+  #     ],
+  #   "audit_log":{
+  #     "2019-10-30 20:33:12 +0000":"Allocated h3oyntawjm7xdch.delivery.puppetlabs.net for job 1572467589"
+  #   },
+  #   "request":{
+  #     "resources":{
+  #       "centos-7.2-tmpfs-x86_64":1
+  #     },
+  #   "job": {
+  #     "id":1572467589,
+  #     "tags": {
+  #           "user":"mikker",
+  #           "url_string":"floaty://mikker/1572467589"
+  # },
+  #           "user":"mikker",
+  #           "time-received":1572467589
+  #         }
+  #       }
+  #     }
+  #
+
+  @active_hostnames = {}
+
+  def self.list_active(verbose, url, _token, user)
+    all_jobs = []
+    @active_hostnames = {}
+
+    get_active_requests(verbose, url, user).each do |req_hash|
+      all_jobs.push(req_hash['request']['job']['id'])
+      @active_hostnames[req_hash['request']['job']['id']] = req_hash
+    end
+
+    all_jobs
+  end
+
+  def self.get_active_requests(verbose, url, user)
+    conn = Http.get_conn(verbose, url)
+    res = conn.get 'status/queue'
+    requests = JSON.parse(res.body)
+
+    ret_val = []
+
+    requests.each do |req|
+      next if req == 'null'
+
+      req_hash = JSON.parse(req)
+
+      begin
+        next unless user == req_hash['request']['job']['user']
+
+        ret_val.push(req_hash)
+      rescue NoMethodError
+        puts "Warning: couldn't parse line returned from abs/status/queue: ".yellow
+      end
+    end
+
+    ret_val
+  end
+
+  def self.all_job_resources_accounted_for(allocated_resources, hosts)
+    allocated_host_list = allocated_resources.map { |ar| ar['hostname'] }
+    (allocated_host_list - hosts).empty?
+  end
+
+  def self.delete(verbose, url, hosts, token, user)
+    # In ABS terms, this is a "returned" host.
+    conn = Http.get_conn(verbose, url)
+    conn.headers['X-AUTH-TOKEN'] = token if token
+
+    puts "Trying to delete hosts #{hosts}" if verbose
+    requests = get_active_requests(verbose, url, user)
+
+    jobs_to_delete = []
+
+    ret_status = {}
+    hosts.each do |host|
+      ret_status[host] = {
+        'ok' => false,
+      }
+    end
+
+    requests.each do |req_hash|
+      next unless req_hash['state'] == 'allocated' || req_hash['state'] == 'filled'
+
+      if hosts.include? req_hash['request']['job']['id']
+        jobs_to_delete.push(req_hash)
+        next
+      end
+
+      req_hash['allocated_resources'].each do |vm_name, _i|
+        if hosts.include? vm_name['hostname']
+          if all_job_resources_accounted_for(req_hash['allocated_resources'], hosts)
+            ret_status[vm_name['hostname']] = {
+              'ok' => true,
+            }
+            jobs_to_delete.push(req_hash)
+          else
+            puts "When using ABS you must delete all vms that you requested at the same time: Can't delete #{req_hash['request']['job']['id']}: #{hosts} does not include all of #{req_hash['allocated_resources']}"
+          end
+        end
+      end
+    end
+
+    response_body = {}
+
+    jobs_to_delete.each do |job|
+      req_obj = {
+        'job_id' => job['request']['job']['id'],
+        'hosts'  => job['allocated_resources'],
+      }
+
+      puts "Deleting #{req_obj}" if verbose
+
+      return_result = conn.post 'return', req_obj.to_json
+      req_obj['hosts'].each do |host|
+        response_body[host['hostname']] = { 'ok' => true } if return_result.body == 'OK'
+      end
+    end
+
+    response_body
+  end
+
+  # List available VMs in ABS
+  def self.list(verbose, url, os_filter = nil)
+    conn = Http.get_conn(verbose, url)
+
+    os_list = []
+
+    res = conn.get 'status/platforms/vmpooler'
+
+    res_body = JSON.parse(res.body)
+    os_list << '*** VMPOOLER Pools ***'
+    os_list += JSON.parse(res_body['vmpooler_platforms'])
+
+    res = conn.get 'status/platforms/ondemand_vmpooler'
+    res_body = JSON.parse(res.body)
+    unless res_body['ondemand_vmpooler_platforms'] == '[]'
+      os_list << ''
+      os_list << '*** VMPOOLER ONDEMAND Pools ***'
+      os_list += JSON.parse(res_body['ondemand_vmpooler_platforms'])
+    end
+
+    res = conn.get 'status/platforms/nspooler'
+    res_body = JSON.parse(res.body)
+    os_list << ''
+    os_list << '*** NSPOOLER Pools ***'
+    os_list += JSON.parse(res_body['nspooler_platforms'])
+
+    res = conn.get 'status/platforms/aws'
+    res_body = JSON.parse(res.body)
+    os_list << ''
+    os_list << '*** AWS Pools ***'
+    os_list += JSON.parse(res_body['aws_platforms'])
+
+    os_list.delete 'ok'
+
+    os_filter ? os_list.select { |i| i[/#{os_filter}/] } : os_list
+  end
+
+  # Retrieve an OS from ABS.
+  def self.retrieve(verbose, os_types, token, url, user, options, _ondemand = nil)
+    #
+    # Contents of post must be like:
+    #
+    # {
+    #   "resources": {
+    #     "centos-7-i386": 1,
+    #     "ubuntu-1404-x86_64": 2
+    #   },
+    #   "job": {
+    #     "id": "12345",
+    #     "tags": {
+    #       "user": "username",
+    #     }
+    #   }
+    # }
+
+    conn = Http.get_conn(verbose, url)
+    conn.headers['X-AUTH-TOKEN'] = token if token
+
+    saved_job_id = DateTime.now.strftime('%Q')
+
+    req_obj = {
+      :resources => os_types,
+      :job       => {
+        :id   => saved_job_id,
+        :tags => {
+          :user => user,
+        },
+      },
+    }
+
+    if options['priority']
+      req_obj[:priority] = if options['priority'] == 'high'
+                             1
+                           elsif options['priority'] == 'medium'
+                             2
+                           elsif options['priority'] == 'low'
+                             3
+                           else
+                             options['priority'].to_i
+                           end
+    end
+
+    puts "Posting to ABS #{req_obj.to_json}" if verbose
+
+    # os_string = os_type.map { |os, num| Array(os) * num }.flatten.join('+')
+    # raise MissingParamError, 'No operating systems provided to obtain.' if os_string.empty?
+    puts "Requesting VMs with job_id: #{saved_job_id}.  Will retry for up to an hour."
+    res = conn.post 'request', req_obj.to_json
+
+    retries = 360
+
+    raise AuthError, "HTTP #{res.status}: The token provided could not authenticate to the pooler.\n#{res_body}" if res.status == 401
+
+    (1..retries).each do |i|
+      queue_place, res_body = check_queue(conn, saved_job_id, req_obj)
+      return translated(res_body) if res_body
+
+      sleep_seconds = 10 if i >= 10
+      sleep_seconds = i if i < 10
+      puts "Waiting #{sleep_seconds} seconds to check if ABS request has been filled.  Queue Position: #{queue_place}... (x#{i})"
+
+      sleep(sleep_seconds)
+    end
+    nil
+  end
+
+  #
+  # We should fix the ABS API to be more like the vmpooler or nspooler api, but for now
+  #
+  def self.translated(res_body)
+    vmpooler_formatted_body = {}
+
+    res_body.each do |host|
+      if vmpooler_formatted_body[host['type']] && vmpooler_formatted_body[host['type']]['hostname'].class == Array
+        vmpooler_formatted_body[host['type']]['hostname'] << host['hostname']
+      else
+        vmpooler_formatted_body[host['type']] = { 'hostname' => [host['hostname']] }
+      end
+    end
+    vmpooler_formatted_body['ok'] = true
+
+    vmpooler_formatted_body
+  end
+
+  def self.check_queue(conn, job_id, req_obj)
+    queue_info_res = conn.get "status/queue/info/#{job_id}"
+    queue_info = JSON.parse(queue_info_res.body)
+
+    res = conn.post 'request', req_obj.to_json
+
+    unless res.body.empty?
+      res_body = JSON.parse(res.body)
+      return queue_info['queue_place'], res_body
+    end
+    [queue_info['queue_place'], nil]
+  end
+
+  def self.snapshot(_verbose, _url, _hostname, _token)
+    puts "Can't snapshot with ABS, use '--service vmpooler' (even for vms checked out with ABS)"
+  end
+
+  def self.status(verbose, url)
+    conn = Http.get_conn(verbose, url)
+
+    res = conn.get 'status'
+
+    res.body == 'OK'
+  end
+
+  def self.summary(verbose, url)
+    conn = Http.get_conn(verbose, url)
+
+    res = conn.get 'summary'
+    JSON.parse(res.body)
+  end
+
+  def self.query(verbose, url, hostname)
+    return @active_hostnames if @active_hostnames
+
+    puts "For vmpooler/snapshot information, use '--service vmpooler' (even for vms checked out with ABS)"
+    conn = Http.get_conn(verbose, url)
+
+    res = conn.get "host/#{hostname}"
+    JSON.parse(res.body)
+  end
+
+  def self.modify(_verbose, _url, _hostname, _token, _modify_hash)
+    raise NoMethodError, 'modify is not defined for ABS'
+  end
+
+  def self.disk(_verbose, _url, _hostname, _token, _disk)
+    raise NoMethodError, 'disk is not defined for ABS'
+  end
+
+  def self.revert(_verbose, _url, _hostname, _token, _snapshot_sha)
+    raise NoMethodError, 'revert is not defined for ABS'
+  end
+end

data/lib/vmfloaty/auth.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'json'
 require 'vmfloaty/http'
@@ -7,46 +9,36 @@ class Auth
   def self.get_token(verbose, url, user, password)
     conn = Http.get_conn_with_auth(verbose, url, user, password)
 
-    resp = conn.post "token"
+    resp = conn.post 'token'
 
     res_body = JSON.parse(resp.body)
-    if res_body["ok"]
-      return res_body["token"]
-    else
-      raise TokenError, "HTTP #{resp.status}: There was a problem requesting a token:\n#{res_body}"
-    end
+    return res_body['token'] if res_body['ok']
+
+    raise TokenError, "HTTP #{resp.status}: There was a problem requesting a token:\n#{res_body}"
   end
 
   def self.delete_token(verbose, url, user, password, token)
-    if token.nil?
-      raise TokenError, 'You did not provide a token'
-    end
+    raise TokenError, 'You did not provide a token' if token.nil?
 
     conn = Http.get_conn_with_auth(verbose, url, user, password)
 
     response = conn.delete "token/#{token}"
     res_body = JSON.parse(response.body)
-    if res_body["ok"]
-      return res_body
-    else
-      raise TokenError, "HTTP #{response.status}: There was a problem deleting a token:\n#{res_body}"
-    end
+    return res_body if res_body['ok']
+
+    raise TokenError, "HTTP #{response.status}: There was a problem deleting a token:\n#{res_body}"
   end
 
   def self.token_status(verbose, url, token)
-    if token.nil?
-      raise TokenError, 'You did not provide a token'
-    end
+    raise TokenError, 'You did not provide a token' if token.nil?
 
     conn = Http.get_conn(verbose, url)
 
     response = conn.get "token/#{token}"
     res_body = JSON.parse(response.body)
 
-    if res_body["ok"]
-      return res_body
-    else
-      raise TokenError, "HTTP #{response.status}: There was a problem getting the status of a token:\n#{res_body}"
-    end
+    return res_body if res_body['ok']
+
+    raise TokenError, "HTTP #{response.status}: There was a problem getting the status of a token:\n#{res_body}"
   end
 end

data/lib/vmfloaty/conf.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 class Conf
-
   def self.read_config
     conf = {}
     begin
       conf = YAML.load_file("#{Dir.home}/.vmfloaty.yml")
-    rescue
+    rescue StandardError
       STDERR.puts "WARNING: There was no config file at #{Dir.home}/.vmfloaty.yml"
     end
     conf

data/lib/vmfloaty/errors.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 class AuthError < StandardError
-  def initialize(msg="Could not authenticate to pooler")
+  def initialize(msg = 'Could not authenticate to pooler')
     super
   end
 end
 
 class TokenError < StandardError
-  def initialize(msg="Could not do operation with token provided")
+  def initialize(msg = 'Could not do operation with token provided')
     super
   end
 end
 
 class MissingParamError < StandardError
-  def initialize(msg="Argument provided to function is missing")
+  def initialize(msg = 'Argument provided to function is missing')
     super
   end
 end
 
 class ModifyError < StandardError
-  def initialize(msg="Could not modify VM")
+  def initialize(msg = 'Could not modify VM')
     super
   end
 end

data/lib/vmfloaty/http.rb

@@ -1,60 +1,49 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'uri'
 
 class Http
-  def self.is_url(url)
+  def self.url?(url)
     # This method exists because it seems like Farady
     # has no handling around if a user gives us a URI
     # with no protocol on the beginning of the URL
 
     uri = URI.parse(url)
 
-    if uri.kind_of?(URI::HTTP) or uri.kind_of?(URI::HTTPS)
-      return true
-    end
+    return true if uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
 
-    return false
+    false
   end
 
   def self.get_conn(verbose, url)
-    if url.nil?
-      raise "Did not provide a url to connect to"
-    end
+    raise 'Did not provide a url to connect to' if url.nil?
 
-    unless is_url(url)
-      url = "https://#{url}"
-    end
+    url = "https://#{url}" unless url?(url)
 
-    conn = Faraday.new(:url => url, :ssl => {:verify => false}) do |faraday|
+    conn = Faraday.new(:url => url, :ssl => { :verify => false }) do |faraday|
       faraday.request :url_encoded
       faraday.response :logger if verbose
       faraday.adapter Faraday.default_adapter
     end
 
-    return conn
+    conn
   end
 
   def self.get_conn_with_auth(verbose, url, user, password)
-    if url.nil?
-      raise "Did not provide a url to connect to"
-    end
+    raise 'Did not provide a url to connect to' if url.nil?
 
-    if user.nil?
-      raise "You did not provide a user to authenticate with"
-    end
+    raise 'You did not provide a user to authenticate with' if user.nil?
 
-    unless is_url(url)
-      url = "https://#{url}"
-    end
+    url = "https://#{url}" unless url?(url)
 
-    conn = Faraday.new(:url => url, :ssl => {:verify => false}) do |faraday|
+    conn = Faraday.new(:url => url, :ssl => { :verify => false }) do |faraday|
       faraday.request :url_encoded
       faraday.request :basic_auth, user, password
       faraday.response :logger if verbose
       faraday.adapter Faraday.default_adapter
     end
 
-    return conn
+    conn
   end
-
 end