apcera 0.1.6.4 → 0.1.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89c6a2b9627777df9b0c64766ea272c08ca92185
-  data.tar.gz: 00b74de099599855980df01b15aae46a1c7dbcee
+  metadata.gz: 654b32622d2de0dc4ad3eb64ccc7fa07e8a0d956
+  data.tar.gz: 6c6326489c4defd48a2e46a93784ed74698a2308
 SHA512:
-  metadata.gz: 8d58942c6d2f452e1dbe215ad1a99a0971562a45f562729a884ac5a8ab3d3705d03bf327a907e3418f7ebf3f6240e6bfa6c9f7511ba41d9980aea36e20fd46a5
-  data.tar.gz: 0807ba66246e513841be733b10d60c7267b6079d3372ee785516b5820e2b79d5e1c3a85a6b3d486077756058e583d35ce9896a3d790c2d7f2cf2925f86e1f33d
+  metadata.gz: 3bc4b78c732b8ab68b0a5e03f5df0656a9585784df3e3c3e1212746f0a47581fd28a967806de218b55f6ab6e18a165d988e8d4a1a50d32c3381f0d65b9009614
+  data.tar.gz: c97e4cd6d67c126f67effba42ea08806ba5f47e32c5b7407dae6aa2e1e08a12e99a2cbd07be6ea1b3f7aabd00ac672f1abf94b41cf7fd9927334f3ca2f43ac1f

data/lib/apcera/version.rb

@@ -1,3 +1,3 @@
 module Apcera
-  VERSION = "0.1.6.4"
+  VERSION = "0.1.6.5"
 end

data/lib/apcera_api_helper.rb

@@ -218,7 +218,7 @@ class ApceraApiHelper
 			config.verify_ssl = false
 		end		  
 		
-		@_bindings_api = Apcera::ServicesAndBindingsApi.new
+		@_bindings_api ||= Apcera::ServicesAndBindingsApi.new
 		@_instances_api ||= Apcera::InstancesApi.new
 		@_jobs_api ||= Apcera::JobsApi.new
 		@_logs_api ||= Apcera::LogsApi.new	

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: apcera
 version: !ruby/object:Gem::Version
-  version: 0.1.6.4
+  version: 0.1.6.5
 platform: ruby
 authors:
 - Jamie Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-29 00:00:00.000000000 Z
+date: 2016-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -272,7 +272,6 @@ files:
 - lib/apcera/models/virtual_network_endpoint.rb
 - lib/apcera/models/virtual_network_endpoint_interface.rb
 - lib/apcera/version.rb
-- lib/apcera_api_gem.rb
 - lib/apcera_api_helper.rb
 homepage: http://apcera.com
 licenses:
@@ -294,7 +293,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Unofficial wrapper for the Apcera REST APIs

data/lib/apcera_api_gem.rb

@@ -1,1077 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'apcera'
-require 'rubygems'
-require 'json'
-require 'rest-client'
-require 'securerandom'
-require 'open-uri'
-require 'yaml'
-require 'digest/sha1'
-require 'getoptlong'
-require 'base64'
-
-class String
-	def blank?
-		nil? || empty?
-	end
-
-	def nonblank?
-		!nil? && !empty?
-	end
-end
-
-class ApceraAuth
-	
-	# These are the bare minimum
-	#
-	attr_reader :target
-	attr_reader :bearer
-	
-	# These are calculated from the above
-	#
-	attr_reader :token
-	attr_reader :token_prefix
-	attr_reader :domain
-	attr_reader :scheme
-	attr_reader :api_host
-	attr_reader :auth_host
-	attr_reader :base_api_url
-	attr_reader :base_auth_url
-	
-	# This is situational
-	#
-	attr_reader :cache_file_path
-	
-	def initialize(target = "", bearer = "")
-		# If a target or bearer is passed in, use that, otherwise, try to figure it out		
-		#
-		cache_credentials = false
-		
-		if (target.nonblank? || bearer.nonblank?)
-			@target = target
-			@bearer = bearer
-		else
-			cache_credentials = true
-			
-			@cache_file_path = File.expand_path("~/.apcera_api")
-
-			if !File.writable?(File.expand_path("~/"))
-				puts "Cache File #{@cache_file_path} not writable, falling back to tmp"
-				@cache_file_path = "/tmp/.apcera_api"
-			end
-			
-			cached_fields = {}
-			if (File.exists?(@cache_file_path))
-				cached_fields = JSON.parse(File.read(@cache_file_path))
-			end
-		
-			# First, get the target.  If it isn't in the cache or env, prompt for it
-			#
-			if (!cached_fields.has_key?("target") || cached_fields["target"] == "")
-			
-				default = "http://demo.proveapcera.io"
-			
-				# This can also be set in the environment
-				#
-				if ENV.key?("APC_TARGET")
-					puts "WARNING: Using APC_TARGET from ENV"
-					value = ENV["APC_TARGET"]
-				else
-					value = prompt_for_value("Enter the domain name for the cluster [#{default}] : ").delete!("\n")
-				end
-
-				if value == ""
-					value = default
-				end
-				cached_fields["target"] = value
-			end
-			
-			# Just need to make sure that these are set when done
-			#
-			@target = cached_fields["target"]
-		end
-
-		# Build the paths
-		#
-		parts = @target.split(/[:\/]/)
-	
-		@scheme = parts.first
-		@domain = parts.last
-
-		@api_host = "api.#{@domain}"
-		@auth_host = "auth.#{@domain}"
-		@base_api_url = "#{scheme}://#{@api_host}"
-		@base_auth_url = "#{scheme}://#{@auth_host}"
-		
-		if (target.nonblank? || bearer.nonblank?)
-			@bearer = bearer
-		else
-			# We need to find it.
-			#
-			if (ENV.key?("APC_REFRESH_TOKEN"))
-				puts "WARNING: Using refresh token from environment"
-				cached_fields["refresh_token"] = ENV["APC_REFRESH_TOKEN"]
-			end
-
-			if (!cached_fields.has_key?("refresh_token") || cached_fields["refresh_token"] == "")
-				response = RestClient.get("#{@base_auth_url}/v1/oauth2/device/google/getcode")
-				code = JSON.parse(response)
-
-				ApceraApi.notice "go to \n\n#{code['verification_url']}\n\n and enter code #{code['user_code']}\n\n"
-		
-				# This stuff only works on the mac
-				#
-				system("echo #{code['user_code']} | pbcopy")
-				system("open #{code['verification_url']}")
-
-				value = prompt_for_value "Press Y when completed: "
-
-				if value.delete!("\n").casecmp("Y") != 0
-					ApceraApi.notice "Error, giving up."
-					exit
-				end
-
-				device_code = code['device_code']
-
-				redeemed_url = "#{@base_auth_url}/v1/oauth2/device/google/redeemed"
-
-				obj = {:device_code => device_code}
-
-				refresh_token_wrapper = JSON.parse(RestClient.post(redeemed_url, obj.to_json, {:content_type => :json}))
-				cached_fields["refresh_token"] = refresh_token_wrapper["refresh_token"]
-			end	
-			
-			# If the token isn't there, or is expired, refresh it
-			#
-			if !cached_fields.has_key?("token") || cached_fields["token"] == "" || Time.parse(cached_fields["expires"]) < Time.now
-				refresh_url = "#{@base_auth_url}/v1/oauth2/device/google/refresh"
-
-				refresh_token_wrapper = {:refresh_token => cached_fields["refresh_token"], :token_type => "GOOGLE_REFRESH" }
-				refresh_resp = RestClient.post(refresh_url, refresh_token_wrapper.to_json, {:content_type => :json})
-				refreshed_token = JSON.parse(refresh_resp)
-				
-				cached_fields["token"] = "Bearer #{refreshed_token['access_token']}"
-				cached_fields["expires"] = Time.now + refreshed_token["expires_in"].to_i			
-			end
-			@bearer = cached_fields["token"]			
-		end
-		
-		@token_prefix = @bearer.split.first
-		@token = @bearer.split.last
-	
-		if (cache_credentials)	
-			File.write(cache_file_path, JSON.pretty_generate(cached_fields))
-		end
-
-	end
-	
-	def prompt_for_value(*args)
-	    print(*args)
-	    gets
-	end
-
-	def to_s
-		body  = "target            [#{@target}]\n"
-		body += "bearer            [#{@bearer}]\n"
-		body += "token             [#{@token}]\n"
-		body += "token_prefix      [#{@token_prefix}]\n"
-		body += "domain            [#{@domain}]\n"
-		body += "scheme            [#{@scheme}]\n"
-		body += "api_host          [#{@api_host}]\n"
-		body += "auth_host         [#{@auth_host}]\n"
-		body += "base_api_url      [#{@base_api_url}]\n"
-		body += "base_auth_url     [#{@base_auth_url}]\n"
-		body += "cache_file_path   [#{@cache_file_path}]\n"
-	end
-end
-
-
-class ApceraApiGem
-	attr_reader   :docker_layer_hash
-	attr_reader   :sandbox
-	attr_reader   :target
-	attr_reader   :api_host
-
-	# cache_file_path = File.expand_path("~/.apcera_api")
-	
-	def initialize(enable_debugging, target = "", bearer = "")
-		self.debug_mode = enable_debugging
-
-		apc_env = ApceraAuth.new(target, bearer)
-		if (self.debug_mode)
-			puts apc_env.to_s
-		end
-		
-		Apcera.configure do |config|
-			config.scheme = apc_env.scheme
-			config.api_key['authorization'] = apc_env.token
-			config.api_key_prefix['authorization'] = apc_env.token_prefix
-
-			config.host = apc_env.api_host
-			config.base_path = '/v1'
-
-			config.debugging = enable_debugging
-			config.verify_ssl = false
-		end		  
-		
-		@_bindings_api = Apcera::ServicesAndBindingsApi.new
-		@_instances_api ||= Apcera::InstancesApi.new
-		@_jobs_api ||= Apcera::JobsApi.new
-		@_logs_api ||= Apcera::LogsApi.new	
-		@_metrics_api ||= Apcera::MetricsApi.new	
-		@_packages_api ||= Apcera::PackagesApi.new
-		@_stagingpipeline_api ||= Apcera::StagingPipelinesApi.new
-		@_stagingpipeline_api ||= Apcera::StagingPipelinesApi.new
-		@_utilities_api ||= Apcera::UtilitiesApi.new
-		
-		sb = self.get_sandbox()
-		@sandbox = sb.namespace
-	end
-	
-	def debug_mode=(mode)
-		@debug_mode = mode
-		Apcera::Configuration.debugging = mode
-	end
-
-	def debug_mode?()
-		@debug_mode
-	end
-
-	def debug_mode()
-		@debug_mode
-	end
-	
-	def get_info
-		@_utilities_api.info_get()	
-	end
-	
-	def get_instance_managers()
-		@_instances_api.instance_managers_get()	
-	end
-		
-	# Runtime operations
-	#
-	def runtimes_get()
-		@_utilities_api.runtimes_get()	
-	end
-
-	def get_sandbox()
-		@_utilities_api.namespace_default_get()
-	end
-
-	# Staging Pipeline operations
-	#
-	def stagingpipelines_get(opts = {})
-		@_stagingpipeline_api.stagingpipelines_get({:fqn => staging_pipeline})
-	end
-
-	def get_staging_pipeline_by_name(name)
-		ret = @_stagingpipeline_api.stagingpipelines_get({:fqn => name})
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def get_matching_staging_pipeline(name)
-		ApceraApi.notice "get_matching_staging_pipeline for #{name}"
-		runtimes = self.runtimes_get()
-		staging_pipeline = ""
-		
-		# First find the matching runtime
-		#
-		runtimes.each do | runtime |
-			runtime.patterns.each do | pattern |
-				# If the name is a star, we are doing the whole directory
-				#
-				if ((name == "*") && (!Dir.glob(pattern).empty?) ||
-					(name != "*") && (File.fnmatch(pattern, name)))	
-					staging_pipeline = "stagpipe::/apcera::#{runtime.runtime}"
-					break
-				end
-			end
-		end
-
-		pipeline = self.get_staging_pipeline_by_name(staging_pipeline)
-		return pipeline
-	end
-	
-	# Metrics operations
-	#
-	def get_job_metrics(opts = {})
-		@_metrics_api.metrics_jobs_get(opts)	
-	end
-
-	def get_instance_manager_metrics(opts = {})
-		@_metrics_api.metrics_instance_managers_get(opts)	
-	end
-
-	def get_cluster_metrics(opts = {})
-		@_metrics_api.metrics_cluster_get(opts)	
-	end
-
-	def get_route_metrics(opts = {})
-		@_metrics_api.metrics_route_counters_get(opts)	
-	end
-
-	def get_namespace_metrics(opts = {})
-		@_metrics_api.metrics_namespace_get(opts)	
-	end
-
-	# Package operations
-	#
-	def find_packages(opt = {})
-		@_packages_api.packages_get(opt)
-	end
-
-	def package_exist?(fqn)
-		!get_package_by_name(fqn).nil?
-	end
-
-	def get_package_by_name(fqn)
-		ret = @_packages_api.packages_get({:fqn => fqn})
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def get_package_for_docker_layer(docker_namespace, layer_id)
-		# ret = @_packages_api.find_packages({:fqn => docker_namespace,
-		# 									:matchPartialFQN => true,
-		# 									:tag => "docker_layer_id,#{layer_id}" })
-		ret = @_packages_api.packages_get({:fqn => "package::#{docker_namespace}", :match_partial_fqn => "true", :tag => "docker_layer_id,#{layer_id}" })											
-		
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def get_package_uuid_for_docker_layer(docker_namespace, layer_id)
-		ret = self.get_package_for_docker_layer(docker_namespace, layer_id)
-		uuid = !ret.nil? ? ret.uuid : ""
-		uuid
-	end
-
-	def get_package_by_tag(tag)
-		ret = @_packages_api.find_packages({:tag => tag})
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def get_package_by_uuid(uuid)
-		ret = @_packages_api.packages_uuid_get(uuid)
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def create_package(package)
-		@_packages_api.packages_post(package)
-	end
-
-	def update_package_resources_by_uuid(uuid, payload)
-		@_packages_api.packages_resources_uuid_put(uuid, payload)		
-	end
-
-	def update_package_by_uuid(uuid, package)
-		@_packages_api.packages_uuid_put(uuid, package)		
-	end
-
-	def delete_package(package_name)
-		package = self.get_package_by_name(package_name)	
-		ApceraApi.notice("Trying to delete package uuid #{package.uuid}")
-		@_packages_api.packages_uuid_delete(package.uuid)
-	end
-
-	def wait_until_package_staged(package_name)
-		Apcera::Configuration.debugging = false
-		ApceraApi.notice("Checking for #{package_name}...")
-
-		pkg = get_package_by_name(package_name)
-		
-		if (['staging', 'uploading'].include?(pkg.state))
-			self.spin_until_package_staged(package_name)
-		end
-	end
-	
-	def spin_until_package_staged(package_name)
-		save_debug = Apcera::Configuration.debugging
-		Apcera::Configuration.debugging = false
-
-		pkg = get_package_by_name(package_name)
-
-		show_wait_spinner{
-			while (['staging', 'uploading'].include?(pkg.state))
-				pkg = get_package_by_name(package_name)
-				sleep 5
-			end
-		}		
-		
-		Apcera::Configuration.debugging = save_debug
-		
-		# return the package
-		#
-		pkg		
-	end
-
-
-	def create_and_stage_git_repo(repo_name, clone_to, repo_subdir, namespace, job_name, change_to = "", pipeline = nil, tags = {})
-		save_dir = Dir.pwd
-		puts "save_dir is #{save_dir}"
-		tmp_dir = Dir.mktmpdir("git-")
-		puts "tmp_dir is #{tmp_dir}"
-
-		Dir.chdir(tmp_dir)
-		puts "now in #{Dir.pwd}"
-
-		system("git clone #{repo_name} #{clone_to}")
-		Dir.chdir("#{clone_to}/#{repo_subdir}")
-
-		create_and_stage_package("*", namespace, job_name, change_to, pipeline, tags)
-		
-		Dir.chdir(save_dir)
-		FileUtils.rm_rf(tmp_dir)
-	end
-	
-	# If filename is "*" then it does the whole directory
-	# Example:
-	#    stage_package("*", "/sandbox/fred.flintstone", "my_new_job")
-	def create_and_stage_package(filename, namespace, job_name, change_to = "", pipeline = nil, tags = {})
-		file_list = filename
-		
-		if ((filename != "*") && File.exist?("start.sh"))
-			file_list = "#{filename} start.sh"
-		end
-		
-		if pipeline.nil?
-			pipeline = self.get_matching_staging_pipeline(filename)
-		end
-		
-		if (pipeline.nil?)
-			ApceraApi.notice "Fatal ERROR, could not determine staging pipeline for #{filename}"
-			exit
-		end
-
-		# when we stage, we only need the uuid
-		#
-		sp = Apcera::StagingPipeline.new({ :uuid => pipeline.uuid })
-		
-		self.banner("Tarring up the files")
-		tarball_path = "/tmp/pkg-#{job_name.gsub("/", "-")}.tgz"
-		base_dir_opt = ""
-		if change_to.nonblank?
-			base_dir_opt = "-C #{change_to}"
-		end
-		tar_command = "COPYFILE_DISABLE=1 tar #{base_dir_opt} -czf #{tarball_path} #{file_list}"
-		system(tar_command)
-
-		contents = File.binread(tarball_path)
-		hex_digest = Digest::SHA1.hexdigest(contents.to_s)
-		sha256_digest = Digest::SHA256.hexdigest(contents.to_s)
-		length = File.size(tarball_path)
-		
-		# We are now done with the file
-		# 
-		File.delete(tarball_path)
-
-		# At some point will need to switch to the sha256 digest.  Looks like that is now.
-		#
-		# resource = Apcera::PackageResource.new({:length => length, :digest => sha256_digest})
-		#
-		resource = Apcera::PackageResource.new()
-		package_fqn = "package::#{namespace}::#{job_name}"
-		
-		new_pkg = Apcera::Package.new({
-			:name => job_name,
-			:fqn => package_fqn,
-			:staging_pipeline => sp
-			})
-			
-		new_pkg.resources = [resource]
-		
-		new_pkg.tags = tags
-
-		if self.debug_mode?
-			self.banner("Package Is")
-			ApceraApi.notice new_pkg.to_yaml
-		end
-
-		ApceraApi.notice("Creating a placeholder for the new package #{new_pkg.fqn}")
-		
-		begin
-			created_pkg = self.create_package(new_pkg)
-		rescue
-			# Handle the race condition where the package has been created since this function started
-			#
-			ApceraApi.notice "post failed, validate presense"
-			check_pkg = self.get_package_by_name(new_pkg.fqn)
-			if !check_pkg.nil?
-				ApceraApi.notice "Package State is #{check_pkg.state}"
-				return ### SHOULD I REALLY??
-			end			
-		end
-		
-		
-		ApceraApi.notice("Uploading the new package... #{created_pkg.uuid} resource #{created_pkg.resource.uuid}" )
-		
-		@_packages_api.packages_package_uuid_resources_resource_uuid_put(created_pkg.uuid, created_pkg.resource.uuid, contents, "sha256:#{sha256_digest}")
-		
-		# bar = self.update_package_resources_by_uuid(created_pkg.uuid, contents)
-
-		# ApceraApi.notice self.get_logs("staging.#{created_pkg.uuid}")
-
-		ApceraApi.notice("Waiting for package #{job_name} to stage (might take some time)...")
-		pkg = self.spin_until_package_staged(package_fqn)
-
-		ApceraApi.notice "Package (#{job_name}) staging status: #{pkg.state}"		
-		pkg
-	end
-
-	def package_from_files(filename, namespace, job_name, port = 0)
-		# 1) Make sure that a job with that name isn't running
-		#
-		if self.job_exist?("job::#{namespace}::#{job_name}")
-			ApceraApi.notice "Error, job #{namespace}::#{job_name} already exists"
-			return nil
-		end
-
-		# 2) Make sure that a package with that name isn't running
-		#
-		if self.package_exist?("package::#{namespace}::#{job_name}")
-			ApceraApi.notice "Error, package #{namespace}::#{job_name} already exists"
-			return nil
-		end
-
-		create_and_stage_package(filename, namespace, job_name)
-	end
-	
-	def job_from_package(namespace, job_name, allow_egress, port = 0, environment = {}, start_command = "")
-
-		fqn_base = "#{namespace}::#{job_name}"
-		package_fqn = "package::#{fqn_base}"
-		job_fqn = "job::#{fqn_base}"
-
-		if self.job_exist?(job_fqn)
-			ApceraApi.notice "Job #{job_fqn} already exists, aborting"
-			return nil
-		end
-
-		self.banner("Getting package uuid for package #{package_fqn}")
-		pkg = self.get_package_by_name(package_fqn)
-
-		if pkg.nil?
-			ApceraApi.notice "Error, package #{package_fqn} not found, aborting"
-			exit
-		end
-		
-		# Need to build the route name
-		#
-		route = namespace.split("/").reverse.join(".").chomp(".")
-		
-		port_route = Apcera::Port.new({
-			:optional => false,
-			:number => port,
-			:routes => [{:type => "http", :endpoint => "#{job_name}.#{route}.#{@domain}", :weight => 0}]
-		})
-
-		app = Apcera::ProcessObject.new({
-		    # :start_command_raw => "",
-		    :start_command => start_command,
-		    :start_command_timeout => 30,
-		    # :stop_command_raw => "",
-		    :stop_command => "",
-		    :stop_timeout => 5
-		})
-		
-		app.environment = environment
-
-		resource = Apcera::Resource.new({
-		    :cpu => 0,
-		    :memory => 256 * 1024 * 1024,
-		    :disk => 256 * 1024 * 1024,
-		    :network => 5 * 1024 * 1024,
-		    :netmax => 0	
-		})
-		rollout = Apcera::RolloutConfig.new({
-			:force_stop_old_instances_after => 0,
-			:flapping_minimum_restarts => 0,
-			:flapping_percent => 0,
-			:flapping_window => 0,
-			:errored_state_window => 0
-		})
-		
-		process = Apcera::Process.new({ :app => app})
-
-		restart = Apcera::RestartConfig.new({
-		    :restart_mode => "always",
-		    :maximum_attempts => 0
-		})
-		
-		# Gather up all of the above
-		#
-		job_proto = Apcera::Job.new({
-			:uuid => "",
-			:ports => [port_route],
-			:name => job_name,
-			:fqn => job_fqn,
-			:num_instances => 1,
-			:packages => [{:uuid => pkg.uuid}],
-			:processes => process,
-			:resources => resource,
-			:rollout => rollout,
-			:restart => restart,
-			:state => "unknown"
-		})
-		# Ruby doesn't seem to like setting the tags in-line
-		#
-		job_proto.tags = {"app" => job_name}
-		
-		if self.debug_mode?
-			self.banner("NEW JOB #{job_proto.to_yaml}")
-		end
-
-		new_job = self.create_job(job_proto)
-		self.banner("CREATED JOB #{job_name}")
-
-		tmp_pkg = self.get_package_by_name(package_fqn)
-
-		tmp_pkg.tags = {"linked-job" =>"#{new_job.uuid}"}
-
-		self.update_package_by_uuid(tmp_pkg.uuid, tmp_pkg)
-		
-		# Then post the bindings
-		#
-		if allow_egress
-			self.banner("Posting the Allow-Egress binding for #{job_name}")
-			ename = fqn_base.gsub("/", "_").gsub("::", "_").gsub(".", "_")
-			binding = Apcera::Binding.new({
-				:name => "egress_for#{ename}",
-				:fqn  => "binding::#{namespace}::#{job_name}",
-				:job_fqn => job_fqn,
-				:service_fqn => "service::/apcera::outside"
-			})
-			bound = self.create_binding(binding)
-		end
-		
-		# return the new job
-		#
-		self.get_job_by_name(job_fqn)
-	end
-	
-	# Job operations
-	#	
-	def jobs_get(opt = {})
-		@_jobs_api.jobs_get(opt)
-	end
-
-	def job_exist?(name)
-		!self.get_job_by_name(name).nil?
-	end
-
-	def service_exist?(service)
-		!self.get_service_by_name(service).nil?
-	end
-
-	def create_docker_job_new_api(image_url, job_namespace, job_name, start_command, exposed_port = 0, environment = {}, allow_egress = false, ram_mb = 128, disk_mb = 16)
-		
-		job_fqn = "job::#{job_namespace}::#{job_name}"
-		
-		sc = start_command.split(" ")
-		puts "Trying to do job #{job_fqn}"
-
-		resource = Apcera::Resource.new({
-		    :cpu => 0,
-		    :memory => ram_mb * 1024 * 1024,
-		    :disk => disk_mb * 1024 * 1024,
-		    :network => 1 * 1024 * 1024 * 1024,
-		    :netmax => 0	
-		})
-		
-		restart = Apcera::RestartConfig.new({
-		    :restart_mode => "no",
-		    :maximum_attempts => 0
-		})
-		
-		docker_job = Apcera::CreateDockerJobRequest.new({
-			:'allow_egress' => allow_egress,
-	        :'image_url' => image_url,
-	        :'job_fqn' => job_fqn,
-	        :'start_command' => sc,
-			:'resources' => resource,
-			:'restart' => restart
-		})
-		
-		docker_job.env = environment
-
-		# Set up the port
-		#
-		if (!exposed_port.nil? && exposed_port != 0)
-			docker_job.exposed_ports = [exposed_port]
-			
-			# need to also set the route also
-			#
-			sub_route = job_namespace.split("/").reverse.join(".").chomp(".")
-			route_name = "http://#{job_name}.#{sub_route}.#{self.get_base_domain}"
-			docker_job.routes = {route_name => exposed_port}			
-		end
-
-		task = @_jobs_api.docker_jobs_post(docker_job)
-		task
-	end
-
-	def check_task_status(task_uuid)
-		@_jobs_api.tasks_uuid_get(task_uuid)
-	end
-	
-	def create_job(job)
-		@_jobs_api.jobs_post(job)
-	end
-
-	def scale_job(job_fqn, number_of_instances)
-		job = get_job_by_name(job_fqn)
-		return if job.nil?
-
-		puts "Scaling #{job_fqn} from #{job.num_instances} to #{number_of_instances} "
-		job.num_instances = number_of_instances
-		self.update_job(job)
-	end
-
-	def update_job(job)
-		@_jobs_api.jobs_uuid_put(job.uuid, job)
-	end
-
-	def get_job_by_name(name)
-		ret = @_jobs_api.jobs_get({:fqn => name})
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def get_service_by_name(name)
-		ret = @_bindings_api.services_get({:fqn => name})
-		puts ret.to_yaml
-		ret.length > 0 ? ret[0] : nil
-	end
-
-	def get_job_state_by_name(name)
-		ret = @_jobs_api.jobs_get({:fqn => name})
-		
-		ret.length > 0 ? ret[0].state : "JOB_NOT_FOUND"
-	end
-	
-	def start_job(job_name, num_instances = 1)	
-		job = self.get_job_by_name(job_name)
-		
-		if self.debug_mode?
-			ApceraApi.notice job.to_yaml
-		end
-		
-		if job.nil? 
-			ApceraApi.notice "Error, job #{job_name} was not found"
-			return nil
-		elsif (job.state == "started" && job.num_instances == num_instances)
-			ApceraApi.notice "#{job_name} is already running with requested number of instanes (#{num_instances})"
-			return job
-		end
-		job.state = "started"
-		job.num_instances = num_instances
-		job = self.update_job(job)
-		
-		ApceraApi.notice "#{job_name} state is now #{job.state} with #{job.num_instances}"
-		job
-	end
-
-	def delete_job(job_name)
-		job = self.get_job_by_name(job_name)	
-		ApceraApi.notice("Trying to delete job w/ uuid #{job.uuid}")
-		@_jobs_api.jobs_uuid_delete(job.uuid)
-	end
-
-	def stop_job(job_name)	
-		job = self.get_job_by_name(job_name)
-
-		if self.debug_mode?
-			ApceraApi.notice "JOB is\n\n"
-			ApceraApi.notice job.to_yaml
-		end
-
-		if job.nil? || job.state == "stopped"
-			ApceraApi.notice "Error, job #{job_name} is either already stopped or not found"
-			return job
-		end
-		job.state = "stopped"
-		self.update_job(job)		
-		
-		ApceraApi.notice "Job #{job_name} state is now " + self.get_job_state_by_name(job_name)		
-	end
-
-	def get_job_route(namespace, job_name)
-		job = self.get_job_by_name("job::#{namespace}::#{job_name}")	
-
-		url = ""
-
-		if !job.ports.nil?
-			job.ports.each do | port |
-				if !port.routes.nil?
-					route = port.routes[0]
-					url = "#{route.type}://#{route.endpoint}"
-					break
-				end
-			end
-		end
-		url
-	end
-
-	# Binding operations
-	#
-	def create_binding(binding)
-		@_bindings_api.bindings_post(binding)		
-	end
-	
-	def link_jobs(source_job, target_job, name, port)
-		self.banner("Linking #{source_job} to #{target_job} via #{name} on port #{port}")
-		binding = Apcera::Binding.new({
-			:fqn  => "binding::#{self.sandbox}::#{SecureRandom.uuid}",
-			:job_fqn => source_job,
-			:name => name,
-			:target_job_fqn => target_job,
-			:target_job_port => port			
-		})
-	
-		if self.debug_mode?
-			ApceraApi.notice binding.to_yaml
-		end
-
-		self.create_binding(binding)
-	end
-
-	def add_service_to_job(job_fqn, service_fqn, name)
-		self.banner("Trying to bind service #{service_fqn} to #{job_fqn} as #{name}")
-		
-		# first we need the provider for the service
-		#
-		provider = self.get_service_by_name(service_fqn)
-		puts ">>>>Provider is #{provider.to_yaml}"
-		
-		binding = Apcera::Binding.new({
-			:fqn  => "binding::#{self.sandbox}::#{SecureRandom.uuid}",
-			:job_fqn => job_fqn,
-			:name => name,
-			:provider_fqn => provider.provider_fqn,
-			:service_fqn => service_fqn
-		})
-
-		if self.debug_mode?
-			ApceraApi.notice binding.to_yaml
-		end
-
-		self.create_binding(binding)
-	end
-
-	# get job logs
-	#
-	def get_job_logs(uuid, lines)
-	
-		@_jobs_api.jobs_uuid_logs_get(uuid, opts = {:lines => lines})
-		
-	end
-
-	# Log Operations
-	#
-	def get_logs(key)
-		@_logs_api.logs_channel_get(key).to_yaml
-	end
-	
-	# Docker Operations
-	#
-	def initiate_docker_job(namespace, job_name, image_url, start_command = "" )
-		job_proto = self.build_docker_job_prototype(namespace, job_name, image_url, start_command)
-		@_jobs_api.docker_job_check(job_proto)
-		
-		# return the prototype so we can use it later
-		#
-		job_proto
-	end
-
-	def job_from_docker(job_name, job_namespace, registry, image_name, image_tag, start_command = "", allow_egress = false, port = 0, environment = {}, user_name = "", password = "")
-
-		# Make sure that the job isn't running
-		#
-		base_fqn = "#{job_namespace}::#{job_name}"
-		job_fqn = "job::#{base_fqn}"
-
-		# begin
-			if self.job_exist?(job_fqn)
-				ApceraApi.notice "error, job #{job_fqn} exists already, aborting"
-				exit
-			end
-		# rescue
-		# 	puts "crapped out checking #{job_name}"
-		# 	exit
-		# end
-
-		# This is the stuff from the scratchpad
-		#
-		parts = registry.split(/[:\/]/)
-		scheme = parts.first
-		domain = parts.last
-		
-		userinfo = ""
-		if user_name.nonblank? && password.nonblank?
-			userinfo = URI::encode("#{user_name}:#{password}@")
-		end
-
-		image_suffix = ""
-		if image_tag.nonblank?
-			image_suffix = ":#{image_tag}"
-		end
-		endpoint_scheme = "#{scheme}://#{userinfo}"
-		registry_url = "#{endpoint_scheme}#{domain}"
-		image_url = "#{registry_url}/#{image_name}#{image_suffix}"
-		
-		djt = self.create_docker_job_new_api(image_url, job_namespace, job_name, start_command, port, environment, allow_egress)
-		puts "docker job task location for #{job_name} is #{djt.location}"
-		location = djt.location
-
-		uuid = location.split("/").last
-		task = self.check_task_status(uuid)
-		if task.nil?
-			puts "YES, the task is nil for #{job_name}"
-		end
-		while task.state == "running"
-			# sleep a random time between 5 and 10 seconds
-			sleep rand(5..10)
-			task = self.check_task_status(uuid)
-			puts "Staging process (#{job_name}):  *** #{task.state} ***"
-		end
-			
-		return self.get_job_by_name(job_fqn)								 
-	end
-
-	def build_docker_job_prototype(namespace, job_name, image_url, start_command)
-		
-		docker_origin = Apcera::DockerOrigin.new(
-	        "ImageName" => "",
-	        "ImageTag" => "",
-	        "RegistryURL" => image_url,
-			"Volumes" => nil
-		)
-
-		port = Apcera::Port.new({
-			:optional => true,
-			:number => 222
-		})
-		
-		app = Apcera::ProcessObject.new({
-		    # :start_command_raw =>,
-		    :start_command => start_command,
-		    :start_command_timeout => 30,
-		    :stop_command_raw => [],
-		    :stop_command => "",
-		    :stop_timeout => 5,
-			:user => "root"
-		})
-
-		process = Apcera::Process.new({ :app => app})
-
-		resource = Apcera::Resource.new({
-		    :cpu => 0,
-		    :memory => 768 * 1024 * 1024,
-		    :disk => 256 * 1024 * 1024,
-		    :network => 1 * 1024 * 1024 * 1024,
-		    :netmax => 0	
-		})
-
-		restart = Apcera::RestartConfig.new({
-		    :restart_mode => "no",
-		    :maximum_attempts => 0
-		})
-		
-		rollout = Apcera::RolloutConfig.new({
-			:force_stop_old_instances_after => 0,
-			:flapping_minimum_restarts => 0,
-			:flapping_percent => 0,
-			:flapping_window => 0,
-			:errored_state_window => 0
-		})
-		
-		job_proto = Apcera::Job.new({
-			:docker_origin => docker_origin,
-			:fqn => "job::#{namespace}::#{job_name}",
-			:name => job_name,
-			:num_instances => 1,
-			:packages => nil,
-			:ports => [port],
-			:processes => process,
-			:resources => resource,
-			:restart => restart,
-			:rollout => rollout,
-			:state => "unknown",
-			:uuid => "",
-		    :version_id => 0,
-		    :weight => 0			
-		})
-	
-		job_proto.tags = {"app" => job_name, "docker" => job_name, "ssh" => "true"}
-	
-		job_proto
-	end
-	
-	def _get_job_preferences_by_name(namespace, job_name)
-		@_jobs_api.preferences_job_get("job::#{namespace}::#{job_name}")	
-	end
-	
-	def get_docker_namespace(job_name)
-		prefs = self._get_job_preferences_by_name(self.sandbox, job_name)
-		prefs.docker_cache_namespace
-	end
-
-	# Some route operations
-	#
-	def jobs_routes()
-		@_jobs_api.jobs_routes_get()
-	end
-
-	def jobs_routes_for_endpoint(endpoint_name)
-		# @_jobs_api.jobs_routes_get()
-		ApceraApi.notice Base64.urlsafe_encode64(endpoint_name)
-		@_jobs_api.jobs_routes_endpoint_get(Base64.urlsafe_encode64("zoom.jamie.smith.sandbox.demo.proveapcera.io"))
-	end
-	
-	# Utility Operations
-	#
-	def show_wait_spinner(fps=10)
-	  	chars = %w[| / - \\]
-	  	delay = 1.0/fps
-	  	iter = 0
-	  	spinner = Thread.new do
-	  	    while iter do  # Keep spinning until told otherwise
-	  			print chars[(iter+=1) % chars.length]
-	  			sleep delay
-	  			print "\b"
-	  	    end
-	  	end
-	  	yield.tap{         # After yielding to the block, save the return value
-	  		iter = false   # Tell the thread to exit, cleaning up after itself…
-	  		spinner.join   # …and wait for it to do so.
-	  	}                  # Use the block's return value as the method's
-	end
-
-	def get_base_domain()
-		if @_base_domain.nil?
-			foo = @_utilities_api.info_get()
-			domain = foo.url.split(/[:\/]/).last
-		
-			domain.gsub!("api.", "")
-			@_base_domain = domain
-		end
-
-		return @_base_domain
-	end
-
-	def get_server_info()
-		foo = @_utilities_api.info_get()
-		return foo
-	end
-
-	def banner(text)
-		puts "\n\n"
-	  	puts "################################################################################"	
-	  	puts "# #{text}"
-	  	puts "################################################################################"	
-	end
-
-	def self.notice(text)
-		puts text
-	end
-	
-end