apcera 0.1.6.2 → 0.1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a10688de5010633265e3d0636240ce3491c842fd
-  data.tar.gz: 272a13cdb43fb0e60e061acb60285fbb4b3f4dbd
+  metadata.gz: e504cd0ce27ad6fb761226d1d57a6b4a6e31c2a5
+  data.tar.gz: 61225f96f94e4a97366f74dd5952f02d4b30ccdd
 SHA512:
-  metadata.gz: 736bd13a82d03755278bd61e056abe71659e0585e2d3d963f8e6dccbe80cc09bb9fb9b76d84bec9bbb40b773e2cfc86806c83604e603dd384dd8c2396f2c0d66
-  data.tar.gz: 23135e53927acd53817ad3c23b3ad8dd5f50bddd33f9f7db9e72b3e03805b87d4f7519d2bc3543d5f63cf004a46b86ee5c85e4b1b747c0361f990ab267c4b315
+  metadata.gz: 52a6cd2d72bf0fcd07c8e18eaf9cf6248724e4076d9f4e8d3ddfab24a25da9ba4d50224cfac7cd540b3bcda4bad742f6885d1ff4214d8a4c8a99bd3e20b2a19b
+  data.tar.gz: a30bb99ab6c4ee76af2d12f631dec2d4ada84d41ef9dbcfb046685fb28fdbd73a2cfe48022443e46f84dc90fbfba001afa082c6223fb99f7c87e5e647116e756

data/lib/apcera/version.rb

@@ -1,3 +1,3 @@
 module Apcera
-  VERSION = "0.1.6.2"
+  VERSION = "0.1.6.3"
 end

data/lib/apcera_api_helper.rb

@@ -0,0 +1,1077 @@
+#!/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)
+
+				ApceraApiHelper.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
+					ApceraApiHelper.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 ApceraApiHelper
+	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)
+		ApceraApiHelper.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)	
+		ApceraApiHelper.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
+		ApceraApiHelper.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?)
+			ApceraApiHelper.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")
+			ApceraApiHelper.notice new_pkg.to_yaml
+		end
+
+		ApceraApiHelper.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
+			#
+			ApceraApiHelper.notice "post failed, validate presense"
+			check_pkg = self.get_package_by_name(new_pkg.fqn)
+			if !check_pkg.nil?
+				ApceraApiHelper.notice "Package State is #{check_pkg.state}"
+				return ### SHOULD I REALLY??
+			end			
+		end
+		
+		
+		ApceraApiHelper.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)
+
+		# ApceraApiHelper.notice self.get_logs("staging.#{created_pkg.uuid}")
+
+		ApceraApiHelper.notice("Waiting for package #{job_name} to stage (might take some time)...")
+		pkg = self.spin_until_package_staged(package_fqn)
+
+		ApceraApiHelper.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}")
+			ApceraApiHelper.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}")
+			ApceraApiHelper.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)
+			ApceraApiHelper.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?
+			ApceraApiHelper.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?
+			ApceraApiHelper.notice job.to_yaml
+		end
+		
+		if job.nil? 
+			ApceraApiHelper.notice "Error, job #{job_name} was not found"
+			return nil
+		elsif (job.state == "started" && job.num_instances == num_instances)
+			ApceraApiHelper.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)
+		
+		ApceraApiHelper.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)	
+		ApceraApiHelper.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?
+			ApceraApiHelper.notice "JOB is\n\n"
+			ApceraApiHelper.notice job.to_yaml
+		end
+
+		if job.nil? || job.state == "stopped"
+			ApceraApiHelper.notice "Error, job #{job_name} is either already stopped or not found"
+			return job
+		end
+		job.state = "stopped"
+		self.update_job(job)		
+		
+		ApceraApiHelper.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?
+			ApceraApiHelper.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?
+			ApceraApiHelper.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)
+				ApceraApiHelper.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()
+		ApceraApiHelper.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apcera
 version: !ruby/object:Gem::Version
-  version: 0.1.6.2
+  version: 0.1.6.3
 platform: ruby
 authors:
 - Jamie Smith
@@ -273,6 +273,7 @@ files:
 - 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:
 - Apache-2.0