morpheus-cli 2.10.0 → 2.10.1

data/lib/morpheus/api/custom_instance_types_interface.rb

@@ -1,29 +1,24 @@
-require 'json'
-require 'morpheus/rest_client'
+require 'morpheus/api/api_client'
 
 class Morpheus::CustomInstanceTypesInterface < 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 list(options={})
+  def list(options={})
     url = "#{@base_url}/api/custom-instance-types"
     headers = { params: {}, authorization: "Bearer #{@access_token}" }
     headers[:params].merge!(options)
-    response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 10, headers: headers, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :get, url: url, headers: headers)
   end
 
   def get(id)
     url = "#{@base_url}/api/custom-instance-types/#{id}"
     headers = { params: {}, authorization: "Bearer #{@access_token}" }
-    response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 10, headers: headers, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :get, url: url, headers: headers)
   end
 
   def create(options)
@@ -36,9 +31,7 @@ class Morpheus::CustomInstanceTypesInterface < Morpheus::APIClient
     # if it
     #   it.each { |k,v| payload["instanceType.#{k}"] = v }
     # end
-    response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
   end
 
   def update(id, options)
@@ -51,83 +44,65 @@ class Morpheus::CustomInstanceTypesInterface < Morpheus::APIClient
     # if it
     #   it.each { |k,v| payload["instanceType.#{k}"] = v }
     # end
-    response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 10, headers: headers, payload: payload.to_json, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
   end
 
   # NOT json, multipart file upload
   def update_logo(id, logo_file)
-    url = "#{@base_url}/api/custom-instance-types/#{id}/updateLogo"
+    url = "#{@base_url}/api/custom-instance-types/#{id}/update-logo"
     headers = { :params => {}, :authorization => "Bearer #{@access_token}"}
     payload = {}
     payload[:logo] = logo_file
     payload[:multipart] = true
-    response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 10, headers: headers, payload: payload, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :post, url: url, headers: headers, payload: payload)
   end
 
   def destroy(id)
     url = "#{@base_url}/api/custom-instance-types/#{id}"
     headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-    response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 10, headers: headers, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :delete, url: url, headers: headers)
   end
 
   def create_version(instance_type_id, options)
     url = "#{@base_url}/api/custom-instance-types/#{instance_type_id}/versions"
     headers = { :params => {}, :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, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
   end
 
   def update_version(instance_type_id, id, options)
     url = "#{@base_url}/api/custom-instance-types/#{instance_type_id}/versions/#{id}"
     headers = { :params => {}, :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, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
   end
 
   def destroy_version(instance_type_id, id)
     url = "#{@base_url}/api/custom-instance-types/#{instance_type_id}/versions/#{id}"
     headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json'}
     payload = options
-    response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 10, headers: headers, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :delete, url: url, headers: headers)
   end
 
   def create_upgrade(instance_type_id, options)
     url = "#{@base_url}/api/custom-instance-types/#{instance_type_id}/upgrades"
     headers = { :params => {}, :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, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
   end
 
   def update_upgrade(instance_type_id, id, options)
     url = "#{@base_url}/api/custom-instance-types/#{instance_type_id}/upgrades/#{id}"
     headers = { :params => {}, :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, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
   end
 
   def destroy_upgrade(instance_type_id, id)
     url = "#{@base_url}/api/custom-instance-types/#{instance_type_id}/upgrades/#{id}"
     headers = { :params => {}, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json'}
     payload = options
-    response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 10, headers: headers, verify_ssl:false)
-    JSON.parse(response.to_s)
+    execute(method: :delete, url: url, headers: headers)
   end
 
 end

data/lib/morpheus/api/dashboard_interface.rb

@@ -1,13 +1,12 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::DashboardInterface < 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={})
     dashboard(options)
@@ -17,21 +16,15 @@ class Morpheus::DashboardInterface < Morpheus::APIClient
     url = "#{@base_url}/api/dashboard"
     headers = { params: {}, authorization: "Bearer #{@access_token}" }
     headers[:params].merge!(options)
-    response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers, verify_ssl: false)
-    JSON.parse(response.to_s)
+    execute(method: :get, url: url, headers: headers)
   end
 
-	def recent_activity(account_id=nil, options={})
+  def recent_activity(account_id=nil, options={})
     url = "#{@base_url}/api/dashboard/recentActivity"
     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)
+    execute(method: :get, url: url, headers: headers)
   end
 
-	
-
 end

data/lib/morpheus/api/deploy_interface.rb

@@ -1,88 +1,76 @@
-require 'json'
+require 'morpheus/api/api_client'
 require 'net/http/post/multipart'
 require 'mime/types'
-require 'morpheus/rest_client'
 
 class Morpheus::DeployInterface < 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(instanceId, options=nil)
-		url = "#{@base_url}/api/instances/#{instanceId}/deploy"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def get(instanceId, options=nil)
+    url = "#{@base_url}/api/instances/#{instanceId}/deploy"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
 
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(String)
-			headers[:params]['name'] = options
-		end
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
 
 
-	def create(instanceId, options=nil)
-		url = "#{@base_url}/api/instances/#{instanceId}/deploy"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		
-		payload = options || {}
-		response = Morpheus::RestClient.execute(method: :post, url: url,
-                            timeout: 30, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def create(instanceId, options=nil)
+    url = "#{@base_url}/api/instances/#{instanceId}/deploy"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options || {}
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  end
 
-	def list_files(id)
-		url = "#{@base_url}/api/deploy/#{id}/files"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		
-		payload = options
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
+  def list_files(id)
+    url = "#{@base_url}/api/deploy/#{id}/files"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :get, url: url, headers: headers)
+  end
 
-	def upload_file(id,path,destination=nil)
-		url_string = "#{@base_url}/api/deploy/#{id}/files"
-		if !destination.empty?
-			url_string += "/#{destination}"
-		end
+  # todo: use execute() to support @dry_run?
+  def upload_file(id,path,destination=nil)
+    url_string = "#{@base_url}/api/deploy/#{id}/files"
+    if !destination.empty?
+      url_string += "/#{destination}"
+    end
 
-		url = URI.parse(url_string)
-		req = Net::HTTP::Post::Multipart.new url.path,
-		  "file" => UploadIO.new(File.new(path,'rb'), "image/jpeg", File.basename(path))
+    url = URI.parse(url_string)
+    req = Net::HTTP::Post::Multipart.new url.path,
+    "file" => UploadIO.new(File.new(path,'rb'), "image/jpeg", File.basename(path))
 
-		  req['Authorization'] = "Bearer #{@access_token}"
-		res = Net::HTTP.start(url.host, url.port) do |http|
-		  http.request(req)
-		end
-		
-		res
-	end
+    req['Authorization'] = "Bearer #{@access_token}"
+    res = Net::HTTP.start(url.host, url.port) do |http|
+      http.request(req)
+    end
+        res
+  end
 
-	def destroy(id)
-		url = "#{@base_url}/api/deploy/#{id}"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :delete, url: url,
-                            timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
+  def destroy(id)
+    url = "#{@base_url}/api/deploy/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, headers: headers)
+  end
 
-	def deploy(id, options)
-		url = "#{@base_url}/api/deploy/#{id}/deploy"
-		payload = options
-		if !options[:appDeploy].nil?
-			if !options[:appDeploy][:config].nil?
-				options[:appDeploy][:config] = options[:appDeploy][:config].to_json
-			end
-		end
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :post, url: url, headers: headers, timeout: nil, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
+  def deploy(id, options)
+    url = "#{@base_url}/api/deploy/#{id}/deploy"
+    payload = options
+    if !options[:appDeploy].nil?
+      if !options[:appDeploy][:config].nil?
+        options[:appDeploy][:config] = options[:appDeploy][:config].to_json
+      end
+    end
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :post, url: url, headers: headers, timeout: nil, payload: payload.to_json)
+  end
 end

data/lib/morpheus/api/deployments_interface.rb

@@ -1,82 +1,64 @@
-require 'json'
-require 'morpheus/rest_client'
+require 'morpheus/api/api_client'
 
 class Morpheus::DeploymentsInterface < 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/deployments"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/deployments/#{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/deployments"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def list_versions(deployment_id,options=nil)
+    url = "#{@base_url}/api/deployments/#{deployment_id}/versions"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
 
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/deployments/#{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/deployments/#{deployment_id}/versions/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    execute(method: :get, url: url, headers: headers)
+  end
 
-	def list_versions(deployment_id,options=nil)
-		url = "#{@base_url}/api/deployments/#{deployment_id}/versions"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def get_version(deployment_id,version_id)
+    url = "#{@base_url}/api/deployments/#{deployment_id}/versions/#{version_id}"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+  end
 
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/deployments/#{deployment_id}/versions/#{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_version(deployment_id,version_id)
-		url = "#{@base_url}/api/deployments/#{deployment_id}/versions/#{version_id}"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def create(options)
+    url = "#{@base_url}/api/deployments"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :post, url: url, headers: headers, payload: payload.to_json)
+  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/deployments/#{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/deployments"
-		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 update(id, options)
-		url = "#{@base_url}/api/deployments/#{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 destroy(id)
-		url = "#{@base_url}/api/deployments/#{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 destroy(id)
+    url = "#{@base_url}/api/deployments/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, headers: headers)
+  end
 end