morpheus-cli 2.10.0 → 2.10.1

data/lib/morpheus/api/key_pairs_interface.rb

@@ -1,5 +1,4 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::KeyPairsInterface < Morpheus::APIClient
   def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
@@ -14,9 +13,8 @@ class Morpheus::KeyPairsInterface < Morpheus::APIClient
     url = "#{@base_url}/api/key-pairs/#{id}"
     headers = { params: {}, authorization: "Bearer #{@access_token}" }
     headers[:params]['accountId'] = account_id if account_id
-    response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 10, headers: headers)
-    JSON.parse(response.to_s)
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
   end
 
   def list(account_id, options={})
@@ -24,9 +22,8 @@ class Morpheus::KeyPairsInterface < Morpheus::APIClient
     headers = { params: {}, authorization: "Bearer #{@access_token}" }
     headers[:params].merge!(options)
     headers[:params]['accountId'] = account_id if account_id
-    response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 10, headers: headers)
-    JSON.parse(response.to_s)
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
   end
 
   def create(account_id, options)
@@ -34,9 +31,8 @@ class Morpheus::KeyPairsInterface < Morpheus::APIClient
     headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     headers[:params]['accountId'] = account_id if account_id
     payload = options
-    response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-    JSON.parse(response.to_s)
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
   end
 
   def update(account_id, id, options)
@@ -44,17 +40,15 @@ class Morpheus::KeyPairsInterface < Morpheus::APIClient
     headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     headers[:params]['accountId'] = account_id if account_id
     payload = options
-    response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-    JSON.parse(response.to_s)
+    opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
   end
 
   def destroy(account_id, id)
     url = "#{@base_url}/api/key-pairs/#{id}"
     headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
     headers[:params]['accountId'] = account_id if account_id
-    response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 10, headers: headers)
-    JSON.parse(response.to_s)
+    opts = {method: :delete, url: url, headers: headers}
+    execute(opts)
   end
 end

data/lib/morpheus/api/license_interface.rb

@@ -1,29 +1,24 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::LicenseInterface < Morpheus::APIClient
-	def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
-		@access_token = access_token
-		@refresh_token = refresh_token
-		@base_url = base_url
-		@expires_at = expires_at
-	end
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
 
-	def get()
-		url = "#{@base_url}/api/license"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def get()
+    url = "#{@base_url}/api/license"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+  end
 
-	def apply(key)
-		url = "#{@base_url}/api/license"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = {license: key}
-		response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 30, headers: headers, payload: payload.to_json, verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def apply(key)
+    url = "#{@base_url}/api/license"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = {license: key}
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  end
 
 end

data/lib/morpheus/api/load_balancers_interface.rb

@@ -1,72 +1,57 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::LoadBalancersInterface < Morpheus::APIClient
-	def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
-		@access_token = access_token
-		@refresh_token = refresh_token
-		@base_url = base_url
-		@expires_at = expires_at
-	end
-
-	def load_balancer_types(options={})
-		url = "#{@base_url}/api/load-balancer-types"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/load-balancer-types/#{options}"
-		elsif options.is_a?(String)
-			headers[:params]['name'] = options
-		end
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl:false)
-		JSON.parse(response.to_s)
-	end
-
-	def get(options=nil)
-		url = "#{@base_url}/api/load-balancers"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/load-balancers/#{options}"
-		elsif options.is_a?(String)
-			headers[:params]['name'] = options
-		end
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl:false)
-		JSON.parse(response.to_s)
-	end
-
-	def update(id, options)
-		url = "#{@base_url}/api/load-balancers/#{id}"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
-
-
-	def create(options)
-		url = "#{@base_url}/api/load-balancers"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		
-		payload = options
-		response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 30, headers: headers, verify_ssl:false, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
-
-	def destroy(id)
-		url = "#{@base_url}/api/load-balancers/#{id}"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 30, headers: headers, verify_ssl:false)
-		JSON.parse(response.to_s)
-	end
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
+
+  def load_balancer_types(options={})
+    url = "#{@base_url}/api/load-balancer-types"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/load-balancer-types/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def get(options=nil)
+    url = "#{@base_url}/api/load-balancers"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/load-balancers/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def update(id, options)
+    url = "#{@base_url}/api/load-balancers/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
+
+
+  def create(options)
+    url = "#{@base_url}/api/load-balancers"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  end
+
+  def destroy(id)
+    url = "#{@base_url}/api/load-balancers/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, headers: headers)
+  end
 end

data/lib/morpheus/api/logs_interface.rb

@@ -1,37 +1,33 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::LogsInterface < Morpheus::APIClient
-	def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
-		@access_token = access_token
-		@refresh_token = refresh_token
-		@base_url = base_url
-		@expires_at = expires_at
-	end
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
 
-	def container_logs(containers=[], options={})
-		url = "#{@base_url}/api/logs"
-		headers = { params: {'containers' => containers}.merge(options), authorization: "Bearer #{@access_token}" }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def container_logs(containers=[], options={})
+    url = "#{@base_url}/api/logs"
+    headers = { params: {'containers' => containers}.merge(options), authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
 
-	def server_logs(servers=[], options={})
-		url = "#{@base_url}/api/logs"
-		headers = { params: {'servers' => servers}.merge(options), authorization: "Bearer #{@access_token}" }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def server_logs(servers=[], options={})
+    url = "#{@base_url}/api/logs"
+    headers = { params: {'servers' => servers}.merge(options), authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
 
-	def stats()
-		url = "#{@base_url}/api/logs/log-stats"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def stats()
+    url = "#{@base_url}/api/logs/log-stats"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
 
 
 end

data/lib/morpheus/api/options_interface.rb

@@ -1,20 +1,16 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::OptionsInterface < Morpheus::APIClient
-	def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
-		@access_token = access_token
-		@refresh_token = refresh_token
-		@base_url = base_url
-		@expires_at = expires_at
-	end
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
 
-	def options_for_source(source,params = {})
-		url = "#{@base_url}/api/options/#{source}"
-		headers = { params: params, authorization: "Bearer #{@access_token}" }
-
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers,verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
-end
+  def options_for_source(source,params = {})
+    url = "#{@base_url}/api/options/#{source}"
+    headers = { params: params, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+  end
+end

data/lib/morpheus/api/provision_types_interface.rb

@@ -1,27 +1,24 @@
-require 'json'
-require 'morpheus/rest_client'
+require 'morpheus/api/api_client'
 
 class Morpheus::ProvisionTypesInterface < Morpheus::APIClient
-	def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
-		@access_token = access_token
-		@refresh_token = refresh_token
-		@base_url = base_url
-		@expires_at = expires_at
-	end
+  def initialize(access_token, refresh_token,expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
 
-	def get(options=nil)
-		url = "#{@base_url}/api/provision-types"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def get(options=nil)
+    url = "#{@base_url}/api/provision-types"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
 
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/provision-types/#{options}"
-		elsif options.is_a?(String)
-			headers[:params]['name'] = options
-		end
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl:false)
-		JSON.parse(response.to_s)
-	end
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/provision-types/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
 end

data/lib/morpheus/api/roles_interface.rb

@@ -1,109 +1,90 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::RolesInterface < Morpheus::APIClient
-	
-	def initialize(access_token, refresh_token, expires_at = nil, base_url=nil) 
-		@access_token = access_token
-		@refresh_token = refresh_token
-		@base_url = base_url
-		@expires_at = expires_at
-	end
+    def initialize(access_token, refresh_token, expires_at = nil, base_url=nil) 
+    @access_token = access_token
+    @refresh_token = refresh_token
+    @base_url = base_url
+    @expires_at = expires_at
+  end
 
-	def get(account_id, id)
-		raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
-		url = build_url(account_id, id)
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 10, headers: headers)
-		JSON.parse(response.to_s)
-	end
+  def get(account_id, id)
+    raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
+    url = build_url(account_id, id)
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+    execute(method: :get, url: url, headers: headers)
+  end
 
-	def list(account_id, options={})
-		url = build_url(account_id)
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-		headers[:params].merge!(options)
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 10, headers: headers)
-		JSON.parse(response.to_s)
-	end
+  def list(account_id, options={})
+    url = build_url(account_id)
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    headers[:params].merge!(options)
+    execute(method: :get, url: url, headers: headers)
+  end
 
-	def create(account_id, options)
-		url = build_url(account_id)
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = options
-		response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def create(account_id, options)
+    url = build_url(account_id)
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	def update(account_id, id, options)
-		url = build_url(account_id, id)
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def update(account_id, id, options)
+    url = build_url(account_id, id)
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	def destroy(account_id, id)
-		url = build_url(account_id, id)
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 10, headers: headers)
-		JSON.parse(response.to_s)
-	end
+  def destroy(account_id, id)
+    url = build_url(account_id, id)
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, headers: headers)
+  end
 
-	def update_permission(account_id, id, options)
-		url = build_url(account_id, id) + "/update-permission"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def update_permission(account_id, id, options)
+    url = build_url(account_id, id) + "/update-permission"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	def update_instance_type(account_id, id, options)
-		url = build_url(account_id, id) + "/update-instance-type"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def update_instance_type(account_id, id, options)
+    url = build_url(account_id, id) + "/update-instance-type"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	def update_group(account_id, id, options)
-		url = build_url(account_id, id) + "/update-group"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def update_group(account_id, id, options)
+    url = build_url(account_id, id) + "/update-group"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	def update_cloud(account_id, id, options)
-		url = build_url(account_id, id) + "/update-cloud"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def update_cloud(account_id, id, options)
+    url = build_url(account_id, id) + "/update-cloud"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	private
+  private
 
-	def build_url(account_id=nil, role_id=nil)
-		url = "#{@base_url}/api"
-		if account_id
-			#url += "/accounts/#{account_id}/roles"
-			url += "/roles"
-		else
-			url += "/roles"
-		end
-		if role_id
-			url += "/#{role_id}"
-		end
-		url
-	end
+  def build_url(account_id=nil, role_id=nil)
+    url = "#{@base_url}/api"
+    if account_id
+      #url += "/accounts/#{account_id}/roles"
+      url += "/roles"
+    else
+      url += "/roles"
+    end
+    if role_id
+      url += "/#{role_id}"
+    end
+    url
+  end
 
 end