mtncloud-cli 1.0.0

data/lib/mtncloud/api/vdi_apps_interface.rb

@@ -0,0 +1,9 @@
+require 'mtncloud/api/rest_interface'
+
+class MtnCloud::VdiAppsInterface < MtnCloud::RestInterface
+
+  def base_path
+    "/api/vdi-apps"
+  end
+
+end

data/lib/mtncloud/api/vdi_gateways_interface.rb

@@ -0,0 +1,9 @@
+require 'mtncloud/api/rest_interface'
+
+class MtnCloud::VdiGatewaysInterface < MtnCloud::RestInterface
+
+  def base_path
+    "/api/vdi-gateways"
+  end
+
+end

data/lib/mtncloud/api/vdi_interface.rb

@@ -0,0 +1,28 @@
+require 'mtncloud/api/api_client'
+
+# Interface for VDI Persona that provides viewing and allocating virtual desktops (VDI pools)
+class MtnCloud::VdiInterface < MtnCloud::APIClient
+
+  def base_path
+    "/api/vdi"
+  end
+
+  # def dashboard(params={})
+  #   execute(method: :get, url: "#{base_path}/dashboard", params: params)
+  # end
+
+  def list(params={})
+    execute(method: :get, url: "#{base_path}", params: params)
+  end
+
+  def get(id, params={})
+    validate_id!(id)
+    execute(method: :get, url: "#{base_path}/#{id}", params: params)
+  end
+
+  def allocate(id, payload, params={})
+    validate_id!(id)
+    execute(method: :post, url: "#{base_path}/#{id}/allocate", params: params, payload: payload.to_json)
+  end
+
+end

data/lib/mtncloud/api/vdi_pools_interface.rb

@@ -0,0 +1,19 @@
+require 'mtncloud/api/rest_interface'
+
+class MtnCloud::VdiPoolsInterface < MtnCloud::RestInterface
+
+  def base_path
+    "/api/vdi-pools"
+  end
+
+  # NOT json, multipart file upload
+  def update_logo(id, logo_file)
+    url = "#{base_path}/#{id}/update-logo"
+    headers = { :params => {}, :authorization => "Bearer #{@access_token}"}
+    payload = {}
+    payload[:logo] = logo_file
+    payload[:multipart] = true
+    execute(method: :post, url: url, headers: headers, payload: payload)
+  end
+
+end

data/lib/mtncloud/api/virtual_images_interface.rb

@@ -0,0 +1,210 @@
+require 'mtncloud/api/api_client'
+require 'http'
+require 'zlib'
+
+class MtnCloud::VirtualImagesInterface < MtnCloud::APIClient
+
+  def virtual_image_types(options={})
+    url = "#{@base_url}/api/virtual-image-types"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def get(options=nil)
+    url = "#{@base_url}/api/virtual-images"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/virtual-images/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def list(params={})
+    url = "#{@base_url}/api/virtual-images"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def create(payload)
+    url = "#{@base_url}/api/virtual-images"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  end
+
+  def update(id, payload)
+    url = "#{@base_url}/api/virtual-images/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
+
+  def convert(id, payload)
+    url = "#{@base_url}/api/virtual-images/#{id}/convert"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  end
+
+  def destroy(id, params={})
+    url = "#{@base_url}/api/virtual-images/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, params: params, headers: headers)
+  end
+
+  # multipart file upload
+  # def upload(id, image_file)
+  #   url = "#{@base_url}/api/virtual-images/#{id}/upload"
+  #   headers = { :params => {}, :authorization => "Bearer #{@access_token}"}
+  #   payload = {}
+  #   payload[:file] = image_file
+  #   payload[:multipart] = true
+  #   execute(method: :post, url: url, headers: headers, payload: payload)
+  # end
+
+  # no multipart
+  def upload(id, image_file, filename=nil, do_gzip=false)
+    filename = filename || File.basename(image_file)
+    url = "#{@base_url}/api/virtual-images/#{id}/upload"
+    headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/octet-stream'}
+    headers[:params][:filename] = filename
+    payload = image_file
+    #execute(method: :post, url: url, headers: headers, payload: payload, timeout: 36000)
+    
+    # Using http.rb instead of RestClient
+    # todo: execute() should support :driver
+    
+    
+    http_opts = {}
+    if MtnCloud::RestClient.ssl_verification_enabled? == false
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http_opts[:ssl_context] = ctx
+      # opts[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE
+    end
+    
+    # start_time = Time.now
+    query_params = headers.delete(:params) || {}
+    file_size = image_file.size
+    if File.blockdev?(image_file)
+      file_size = `blockdev --getsz '#{File.absolute_path(image_file)}'`.strip().to_i * 512
+    end
+    if do_gzip
+      # http = http.use(:auto_deflate)
+      headers['Content-Encoding'] = 'gzip'
+      headers['Content-Type'] = 'application/gzip'
+      headers['Content-Length'] = file_size
+      #headers['Transfer-Encoding'] = 'Chunked'
+      query_params['extractedContentLength'] = file_size
+      if @dry_run
+        return {method: :post, url: url, headers: headers, params: query_params, payload: payload}
+      end
+      http = HTTP.headers(headers)
+      http_opts[:params] = query_params
+      
+      rd, wr = IO.pipe
+      Thread.new {
+         gz = Zlib::GzipWriter.new(wr)
+         File.open(payload) do |fp|
+           while chunk = fp.read(10 * 1024 * 1024) do
+             gz.write chunk
+           end
+         end
+         gz.close
+      }
+      http_opts[:body] = MtnCloud::BodyIO.new(rd)
+      if Gem::Version.new(HTTP::VERSION) >= Gem::Version.new("6.0.0")
+        response = http.post(url, **http_opts)
+      else
+        response = http.post(url, http_opts)
+      end
+    else
+      if @dry_run
+        return {method: :post, url: url, headers: headers, params: query_params, payload: payload}
+      end
+      headers['Content-Length'] = file_size
+      http = HTTP.headers(headers)
+      http_opts[:params] = query_params
+      http_opts[:body] = payload
+      if Gem::Version.new(HTTP::VERSION) >= Gem::Version.new("6.0.0")
+        response = http.post(url, **http_opts)
+      else
+        response = http.post(url, http_opts)
+      end
+    end
+    # puts "Took #{Time.now.to_i - start_time.to_i}"
+    # return response
+    return JSON.parse(response.body.to_s)
+  end
+
+  def upload_by_url(id, file_url, filename=nil)
+    url = "#{@base_url}/api/virtual-images/#{id}/upload"
+    headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/octet-stream'}
+    headers[:params][:url] = file_url
+    headers[:params][:filename] = filename if filename
+    execute(method: :post, url: url, headers: headers, timeout: 172800)
+  end
+
+  def destroy_file(id, filename)
+    url = "#{@base_url}/api/virtual-images/#{id}/files"
+    #url = "#{@base_url}/api/virtual-images/#{id}/files/#{filename}"
+    headers = { params: {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    headers[:params][:filename] = filename
+    execute(method: :delete, url: url, headers: headers)
+  end
+
+  def download_chunked(id, outfile, params={})
+    raise "#{self.class}.download_chunked() passed a blank id!" if id.to_s == ''
+    url = "#{@base_url}/api/virtual-images/#{id}/download"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    # execute(opts, {parse_json: false})
+    if Dir.exist?(outfile)
+      raise "outfile is invalid. It is the name of an existing directory: #{outfile}"
+    end
+    # if @verify_ssl == false
+    #   opts[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE
+    # end
+    if @dry_run
+      return opts
+    end
+    http_response = nil
+    File.open(outfile, 'w') {|f|
+      block = proc { |response|
+        response.read_body do |chunk|
+          # writing to #{outfile} ..."
+          f.write chunk
+        end
+      }
+      opts[:block_response] = block
+      http_response = MtnCloud::RestClient.execute(opts)
+    }
+    return http_response
+  end
+
+  def location_base_path(resource_id)
+    "/api/virtual-images/#{resource_id}/locations"
+  end
+
+  def list_locations(resource_id, params={}, headers={})
+    validate_id!(resource_id)
+    execute(method: :get, url: "#{location_base_path(resource_id)}", params: params, headers: headers)
+  end
+
+  def get_location(resource_id, id, params={}, headers={})
+    validate_id!(resource_id)
+    validate_id!(id)
+    execute(method: :get, url: "#{location_base_path(resource_id)}/#{id}", params: params, headers: headers)
+  end
+
+  def destroy_location(resource_id, id, params = {}, headers={})
+    validate_id!(resource_id)
+    validate_id!(id)
+    execute(method: :delete, url: "#{location_base_path(resource_id)}/#{id}", params: params, headers: headers)
+  end
+
+end

data/lib/mtncloud/api/virtual_servers_interface.rb

@@ -0,0 +1,9 @@
+require 'mtncloud/api/rest_interface'
+
+class MtnCloud::VirtualServersInterface < MtnCloud::RestInterface
+
+  def base_path
+    "/api/load-balancer-virtual-servers"
+  end
+
+end

data/lib/mtncloud/api/virtual_switches_interface.rb

@@ -0,0 +1,9 @@
+require 'mtncloud/api/rest_interface'
+
+class MtnCloud::VirtualSwitchesInterface < MtnCloud::RestInterface
+
+  def base_path
+    "/api/virtual-switches"
+  end
+
+end

data/lib/mtncloud/api/whitelabel_settings_interface.rb

@@ -0,0 +1,57 @@
+require 'mtncloud/api/api_client'
+
+class MtnCloud::WhitelabelSettingsInterface < MtnCloud::APIClient
+
+  def base_path
+    "/api/whitelabel-settings"
+  end
+
+  def get(params={})
+    url = base_path
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def update(payload, params={})
+    url = base_path
+    headers = { params: params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
+
+  def update_images(payload, params={})
+    url = "#{base_path}/images"
+    headers = { params: params, :authorization => "Bearer #{@access_token}" }
+    payload[:multipart] = true
+    execute(method: :post, url: url, headers: headers, payload: payload)
+  end
+
+  def reset_image(image_type, params={})
+    url = "#{base_path}/images/#{image_type}"
+    headers = { params: params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, headers: headers)
+  end
+
+  def download_image(image_type, outfile, params={})
+    url = "#{base_path}/images/#{image_type}"
+    headers = { params: params, :authorization => "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers, timeout: 172800}
+
+    if @dry_run
+      return opts
+    end
+
+    http_response = nil
+    File.open(outfile, 'w') {|f|
+      block = proc { |response|
+        response.read_body do |chunk|
+          # writing to #{outfile} ..."
+          f.write chunk
+        end
+      }
+      opts[:block_response] = block
+      http_response = MtnCloud::RestClient.execute(opts)
+    }
+    http_response
+  end
+
+end

data/lib/mtncloud/api/whoami_interface.rb

@@ -0,0 +1,13 @@
+require 'mtncloud/api/api_client'
+
+class MtnCloud::WhoamiInterface < MtnCloud::APIClient
+
+  def default_timeout
+    5
+  end
+
+  def get(params={})
+    execute(method: :get, url: "/api/whoami", params: params)
+  end
+
+end

data/lib/mtncloud/api/wiki_interface.rb

@@ -0,0 +1,48 @@
+require 'mtncloud/api/api_client'
+
+class MtnCloud::WikiInterface < MtnCloud::APIClient
+
+  def get(id, params={})
+    raise "#{self.class}.get() passed a blank name!" if id.to_s == ''
+    url = "#{@base_url}/api/wiki/pages/#{id}"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def list(params={})
+    url = "#{@base_url}/api/wiki/pages"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def create(payload)
+    url = "#{@base_url}/api/wiki/pages"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def update(id, payload)
+    url = "#{@base_url}/api/wiki/pages/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def destroy(id, params={})
+    url = "#{@base_url}/api/wiki/pages/#{id}"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :delete, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def categories(params={})
+    url = "#{@base_url}/api/wiki/categories"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+end

data/lib/mtncloud/api.rb

@@ -0,0 +1,12 @@
+require 'mtncloud/cli/version'
+require 'mtncloud/cli/errors'
+require 'mtncloud/rest_client'
+require 'mtncloud/formatters'
+#require 'mtncloud/logging'
+#require 'term/ansicolor'
+
+# load interfaces
+require 'mtncloud/api/api_client.rb'
+require 'mtncloud/api/rest_interface.rb'
+require 'mtncloud/api/read_interface.rb'
+Dir[File.dirname(__FILE__)  + "/api/**/*.rb"].each {|file| require file }

data/lib/mtncloud/benchmarking.rb

@@ -0,0 +1,259 @@
+require 'securerandom'
+require 'mtncloud/logging'
+require 'mtncloud/cli/cli_registry.rb'
+
+# Provides global Benchmarking functionality
+# This provides a store of benchmarking records which can be looked up by name.
+# There is also a global enabled flag that can be used.
+# There is a mixin HasBenchmarking which provides start_benchmark(), stop_benchmark() and with_benchmark()
+#
+module MtnCloud::Benchmarking
+
+  # a global toggle switch for benchmarking
+  @@enabled = false
+
+  def self.enabled?
+    @@enabled  
+  end
+  
+  def self.enabled
+    @@enabled
+  end
+
+  def self.enabled=(val)
+    @@enabled = !!val
+  end
+
+  # internal Array to store benchmark records for recording
+  # todo: garbage cleanup, roll these off to disk probably.
+  @@benchmark_record_list = []
+  def self.benchmark_record_list
+    @@benchmark_record_list
+  end
+
+  # internal Hash to lookup benchmark records by id
+  @@benchmark_id_store = {}
+  def self.benchmark_id_store
+    @@benchmark_id_store
+  end
+  
+  # internal Hash to lookup benchmark records by name
+  @@benchmark_name_store = {}
+  def self.benchmark_name_store
+    @@benchmark_name_store
+  end
+
+  # start a new BenchmarkRecord
+  # @params opts [String or Hash] String as name like like "my routine" or with a Hash like {name: "my routine"}
+  #         Just a String for name is fine because there are no other settings of interest at the moment.
+  #         Optional, a test can be created without a name. A random :id will be available in the response.
+  # Examples:
+  #   MtnCloud::Benchmarking.start()
+  #   MtnCloud::Benchmarking.start("my routine")
+  # @returns BenchmarkRecord that looks like  {id: ID, name:"my routine",start_time:Time}
+  def self.start(opts={})
+    benchmark_record = BenchmarkRecord.new(opts)
+    benchmark_record_list << benchmark_record
+    # index name and id
+    if benchmark_record.name
+      benchmark_name_store[benchmark_record.name.to_s] = benchmark_record
+    end
+    if benchmark_record.id
+      benchmark_id_store[benchmark_record.id.to_s] = benchmark_record
+    end
+    #benchmark_record.start() # initialize does it 
+    return benchmark_record
+  end
+
+  # stop a BenchmarkRecord identified by name or options
+  # maybe: if opts is nil, the last record is returned
+  # @params opts [String or Hash] String as name like like "my routine" or with a Hash like {name: "my routine"} or {id:ID}
+  # @returns BenchmarkRecord that looks like {id: ID, name:"my routine",start_time:Time}
+  def self.stop(opts, exit_code=0, error=nil)
+    benchmark_record = self.lookup(opts)
+    if benchmark_record
+      benchmark_record.stop(exit_code, error)
+      return benchmark_record
+    else
+      return nil
+    end
+  end
+
+  # lookup a BenchmarkRecord identified by name or options, usually just name.
+  # @params cmd [String or Hash] Name like "my routine" or with a Hash like {id: ID}
+  # @returns BenchmarkRecord that looks like  {id: ID, name:"my routine",start_time:Time}
+  def self.lookup(opts={})
+    benchmark_record = nil
+    if opts.nil? || opts.empty?
+      benchmark_record = nil
+    elsif opts.is_a?(Hash)
+      if opts[:id]
+        benchmark_record = benchmark_name_store[opts[:id].to_s]
+      elsif opts[:name]
+        benchmark_record = benchmark_id_store[opts[:name].to_s]
+      end
+    elsif opts.is_a?(String) || opts.is_a?(Symbol)
+      benchmark_record = benchmark_name_store[opts.to_s] || benchmark_id_store[opts.to_s]
+    else
+      MtnCloud::Logging::DarkPrinter.puts "Benchmarking lookup passed a bad lookup argument: #{opts}" if MtnCloud::Logging.debug?
+    end
+    # could to slow traversal of benchmark_record_list here..
+    return benchmark_record
+  end
+
+  # get last benchmark started. useful if the name, so `benchmark stop` can work
+  # use a unique name or else your record may be overwritten!
+  def self.last()
+    (@@benchmark_record_list || []).last
+  end
+
+  # Mixin for any class that needs benchmarking
+  module HasBenchmarking
+
+    # true when benchmark is currently running
+    # def benchmarking?
+    #   !!@benchmark_record
+    # end
+
+    # def benchmark_record
+    #   @benchmark_record
+    # end
+
+    def with_benchmark(opts, &block)
+      exit_code, err = 0, nil
+      begin
+        start_benchmark(opts)
+        if block_given?
+          result = block.call()
+          exit_code, err = MtnCloud::Cli::CliRegistry.parse_command_result(result)
+        end
+      rescue => ex
+        raise ex
+        exit_code = 1
+        err = ex.msg
+      ensure
+        stop_benchmark(exit_code, err)
+      end
+      #return result
+      return exit_code, err
+    end
+
+    def start_benchmark(opts)
+      @benchmark_record = BenchmarkRecord.new(opts)
+      return @benchmark_record
+    end
+
+    # finish the current benchmark and optionally print the time taken.
+    def stop_benchmark(exit_code=0, err=nil)
+      if defined?(@benchmark_record) && @benchmark_record
+        @benchmark_record.stop(exit_code, err)
+        @last_benchmark_record = @benchmark_record
+        @benchmark_record = nil
+        return @last_benchmark_record
+      else
+        return nil
+      end
+    end
+
+  end
+
+  # An internal class for modeling benchmark info on a single run.
+  # Examples:
+  #   BenchmarkRecord.new()
+  #   BenchmarkRecord.new("my routine")
+  #   BenchmarkRecord.new({name:"my routine"})
+  class BenchmarkRecord
+    
+    attr_reader :id, :name, :command, :start_time, :end_time, :exit_code, :error
+  
+    def initialize(opts={})
+      # no info is fine, anonymous benchmark is cool
+      if opts.nil? || opts.empty?
+        opts = {}
+      end
+      # support String
+      opts = opts.is_a?(Hash) ? opts : {name: opts.to_s}
+      @id = opts[:id] || self.object_id
+      @name = opts[:name]
+      #@command = opts[:command]
+      # store the list of commands would be cool... to record adhoc scripts
+      # @commands = []
+      # @commands << @command if @command
+      start()
+    end
+
+    def start()
+      if !@start_time
+        @start_time = Time.now
+      end
+      return self
+    end
+
+    def stop(exit_code=0, error=nil)
+      if !@end_time
+        @end_time = Time.now
+        @exit_code = exit_code
+        @error = error
+      end
+      return self
+    end
+
+    def duration
+      if @start_time && @end_time
+        return @end_time - @start_time
+      elsif @start_time
+        return Time.now - @start_time
+      else
+        return 0
+      end
+    end
+
+    def msg
+      time_str = ""
+      seconds = self.duration
+      if seconds > 0.002
+        seconds = seconds.round(3)
+      else
+        #seconds = seconds.round(3)
+      end
+      duration_str = duration
+      if @start_time && @end_time
+        time_str = "#{seconds} s"
+      elsif @start_time
+        time_str = "#{seconds} s (running)"
+      else
+        time_str = "(unstarted)"
+      end
+      command_str = "#{@name}" # or "#{@name || @id}"
+      exit_str = "#{@exit_code}"
+      error_str = "#{@error}" # should inspect and format this
+      out = ""
+      
+      # show exit only if non 0
+      # so it looks like:
+      # command  time   [exit: 1]  [error:]
+      # instances list foo         0.049 seconds
+      # foo         0.001 seconds   exit: 1
+      out << "#{command_str.ljust(45, ' ')}"
+      out << "\t"
+      out << "#{time_str.ljust(15, ' ')}" # maybe use the format time: 0.021s
+      out << "\t"
+      if @end_time
+        if @exit_code && @exit_code != 0
+          out << "\texit: #{exit_str.ljust(2, ' ')}"
+        end
+        if @error && @error != ""
+          out << "\terror: #{error_str.ljust(12, ' ')}"
+        end
+      end
+      #out << reset
+      return out
+    end
+
+    def to_s
+      msg
+    end
+
+  end
+
+end