morpheus-cli 2.10.0 → 2.10.1

data/lib/morpheus/api/app_templates_interface.rb

@@ -1,74 +1,58 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::AppTemplatesInterface < 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 get(id)
-		raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
-		url = "#{@base_url}/api/app-templates/#{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 list(options={})
-		url = "#{@base_url}/api/app-templates"
-		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 create(options)
-		url = "#{@base_url}/api/app-templates"
-		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 update(id, options)
-		url = "#{@base_url}/api/app-templates/#{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/app-templates/#{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 list_tiers(options={})
-		url = "#{@base_url}/api/app-templates/tiers"
-		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_types(options={})
-		url = "#{@base_url}/api/app-templates/types"
-		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
-	
-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(id)
+    raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
+    url = "#{@base_url}/api/app-templates/#{id}"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def list(options={})
+    url = "#{@base_url}/api/app-templates"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    headers[:params].merge!(options)
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def create(options)
+    url = "#{@base_url}/api/app-templates"
+    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(id, options)
+    url = "#{@base_url}/api/app-templates/#{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(id)
+    url = "#{@base_url}/api/app-templates/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    execute(method: :delete, url: url, headers: headers)
+  end
+
+  def list_tiers(options={})
+    url = "#{@base_url}/api/app-templates/tiers"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    headers[:params].merge!(options)
+    execute(method: :get, url: url, headers: headers)
+  end
+
+  def list_types(options={})
+    url = "#{@base_url}/api/app-templates/types"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    headers[:params].merge!(options)
+    execute(method: :get, url: url, headers: headers)
+  end
+  end

data/lib/morpheus/api/apps_interface.rb

@@ -1,135 +1,114 @@
-require 'json'
-require 'morpheus/rest_client'
+require 'morpheus/api/api_client'
 
 class Morpheus::AppsInterface < 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 get(options=nil)
-		url = "#{@base_url}/api/apps"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
-
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/apps/#{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
-
-	def create(options)
-		url = "#{@base_url}/api/apps"
-		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 update(app_id, options)
-		url = "#{@base_url}/api/apps/#{app_id}"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		
-		payload = options
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                                                     timeout: 30, headers: headers, payload: payload.to_json)
-		JSON.parse(response.to_s)
-	end
-
-	def add_instance(app_id, options)
-		url = "#{@base_url}/api/apps/#{app_id}/add-instance"
-		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 remove_instance(app_id, options)
-		url = "#{@base_url}/api/apps/#{app_id}/remove-instance"
-		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 destroy(id)
-		url = "#{@base_url}/api/apps/#{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
-
-=begin
-	def stop(id)
-		url = "#{@base_url}/api/apps/#{id}/stop"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                                                     timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
-
-	def start(id)
-		url = "#{@base_url}/api/apps/#{id}/start"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                                                     timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
-
-	def restart(id)
-		url = "#{@base_url}/api/apps/#{id}/restart"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                                                     timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
-=end
-
-	def firewall_disable(id)
-		url = "#{@base_url}/api/apps/#{id}/security-groups/disable"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
-
-	def firewall_enable(id)
-		url = "#{@base_url}/api/apps/#{id}/security-groups/enable"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
-
-	def security_groups(id)
-		url = "#{@base_url}/api/apps/#{id}/security-groups"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers)
-		JSON.parse(response.to_s)
-	end
-
-	def apply_security_groups(id, options)
-		url = "#{@base_url}/api/apps/#{id}/security-groups"
-		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 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/apps"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/apps/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def create(options)
+    url = "#{@base_url}/api/apps"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def update(app_id, options)
+    url = "#{@base_url}/api/apps/#{app_id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def add_instance(app_id, options)
+    url = "#{@base_url}/api/apps/#{app_id}/add-instance"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def remove_instance(app_id, options)
+    url = "#{@base_url}/api/apps/#{app_id}/remove-instance"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
+
+  def destroy(id)
+    url = "#{@base_url}/api/apps/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :delete, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def stop(id)
+    url = "#{@base_url}/api/apps/#{id}/stop"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def start(id)
+    url = "#{@base_url}/api/apps/#{id}/start"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def restart(id)
+    url = "#{@base_url}/api/apps/#{id}/restart"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def firewall_disable(id)
+    url = "#{@base_url}/api/apps/#{id}/security-groups/disable"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def firewall_enable(id)
+    url = "#{@base_url}/api/apps/#{id}/security-groups/enable"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def security_groups(id)
+    url = "#{@base_url}/api/apps/#{id}/security-groups"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :get, url: url, headers: headers}
+    execute(opts)
+  end
+
+  def apply_security_groups(id, options)
+    url = "#{@base_url}/api/apps/#{id}/security-groups"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :post, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
 end

data/lib/morpheus/api/auth_interface.rb

@@ -0,0 +1,30 @@
+require 'morpheus/api/api_client'
+
+class Morpheus::AuthInterface < Morpheus::APIClient
+
+  attr_reader :access_token
+
+  def initialize(base_url, access_token=nil)
+    @base_url = base_url
+    @access_token = access_token
+  end
+
+  def login(username, password)
+    @access_token = nil
+    url = "#{@base_url}/oauth/token"
+    params = {grant_type: 'password', scope:'write', client_id: 'morph-cli', username: username}
+    payload = {password: password}
+    opts = {method: :post, url: url, headers:{ params: params}, payload: payload, timeout: 10}
+    response = execute(opts)
+    return response if @dry_run
+    @access_token = response['access_token']
+    return response
+  end
+
+  def logout()
+    if @access_token
+      # todo: expire the token
+    end
+    raise "#{self}.logout() is not yet implemented"
+  end
+end

data/lib/morpheus/api/clouds_interface.rb

@@ -1,89 +1,84 @@
-require 'json'
-require 'rest-client'
+require 'morpheus/api/api_client'
 
 class Morpheus::CloudsInterface < 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 cloud_types()
-		url = "#{@base_url}/api/zone-types"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def cloud_types()
+    url = "#{@base_url}/api/zone-types"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
+    opts = {method: :get, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  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/zones"
+    headers = { params: {}, authorization: "Bearer #{@access_token}" }
 
+    if options.is_a?(Hash)
+      headers[:params].merge!(options)
+    elsif options.is_a?(Numeric)
+      url = "#{@base_url}/api/zones/#{options}"
+    elsif options.is_a?(String)
+      headers[:params]['name'] = options
+    end
+    opts = {method: :get, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  end
 
-	def get(options=nil)
-		url = "#{@base_url}/api/zones"
-		headers = { params: {}, authorization: "Bearer #{@access_token}" }
+  def create(options)
+    url = "#{@base_url}/api/zones"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :post, url: url, timeout: 30, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
 
-		if options.is_a?(Hash)
-			headers[:params].merge!(options)
-		elsif options.is_a?(Numeric)
-			url = "#{@base_url}/api/zones/#{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/zones/#{id}"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :put, url: url, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
 
+  def destroy(id, params={})
+    url = "#{@base_url}/api/zones/#{id}"
+    headers = { :params => params, :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :delete, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  end
 
-	def create(options)
-		url = "#{@base_url}/api/zones"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		
-		payload = {zone: options}
-		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 firewall_disable(id)
+    url = "#{@base_url}/api/zones/#{id}/security-groups/disable"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  end
 
-	def destroy(id)
-		url = "#{@base_url}/api/zones/#{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 firewall_enable(id)
+    url = "#{@base_url}/api/zones/#{id}/security-groups/enable"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :put, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  end
 
-	def firewall_disable(id)
-		url = "#{@base_url}/api/zones/#{id}/security-groups/disable"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 30, headers: headers,verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def security_groups(id)
+    url = "#{@base_url}/api/zones/#{id}/security-groups"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    opts = {method: :get, url: url, timeout: 30, headers: headers}
+    execute(opts)
+  end
 
-	def firewall_enable(id)
-		url = "#{@base_url}/api/zones/#{id}/security-groups/enable"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :put, url: url,
-                            timeout: 30, headers: headers,verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
-
-	def security_groups(id)
-		url = "#{@base_url}/api/zones/#{id}/security-groups"
-		headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-		response = Morpheus::RestClient.execute(method: :get, url: url,
-                            timeout: 30, headers: headers,verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
-
-	def apply_security_groups(id, options)
-		url = "#{@base_url}/api/zones/#{id}/security-groups"
-		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,verify_ssl: false)
-		JSON.parse(response.to_s)
-	end
+  def apply_security_groups(id, options)
+    url = "#{@base_url}/api/zones/#{id}/security-groups"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    opts = {method: :post, url: url, timeout: 30, headers: headers, payload: payload.to_json}
+    execute(opts)
+  end
 end