class ApceraApiHelper

Attributes

api_host[R]
docker_layer_hash[R]
domain[R]
sandbox[R]
target[R]

Public Class Methods

new(enable_debugging, target = "", bearer = "") click to toggle source

cache_file_path = File.expand_path(“~/.apcera_api”)

# File lib/apcera_api_helper.rb, line 210
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

        @domain = apc_env.domain
        
        Apcera.configure do |config|
                config.scheme = apc_env.scheme
                
                # If we are using APP_TOKEN these won't be set
                #
        if !apc_env.token.nil?
          config.api_key['authorization'] = apc_env.token
        end
      
        if !apc_env.token_prefix.nil?
          config.api_key_prefix['authorization'] = apc_env.token_prefix
        end
                
                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
notice(text) click to toggle source
# File lib/apcera_api_helper.rb, line 1106
def self.notice(text)
        puts text
end

Public Instance Methods

_get_job_preferences_by_name(namespace, job_name) click to toggle source
# File lib/apcera_api_helper.rb, line 1042
def _get_job_preferences_by_name(namespace, job_name)
        @_jobs_api.preferences_job_get("job::#{namespace}::#{job_name}")      
end
add_service_to_job(job_fqn, service_fqn, name) click to toggle source
# File lib/apcera_api_helper.rb, line 870
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
banner(text) click to toggle source
build_docker_job_prototype(namespace, job_name, image_url, start_command) click to toggle source
# File lib/apcera_api_helper.rb, line 973
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
check_task_status(task_uuid) click to toggle source
# File lib/apcera_api_helper.rb, line 736
def check_task_status(task_uuid)
        @_jobs_api.tasks_uuid_get(task_uuid)
end
create_and_stage_git_repo(repo_name, clone_to, repo_subdir, namespace, job_name, change_to = "", pipeline = nil, tags = {}) click to toggle source
# File lib/apcera_api_helper.rb, line 431
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
create_and_stage_package(filename, namespace, job_name, change_to = "", pipeline = nil, tags = {}) click to toggle source

If filename is “*” then it does the whole directory Example:

stage_package("*", "/sandbox/fred.flintstone", "my_new_job")
# File lib/apcera_api_helper.rb, line 452
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
create_binding(binding) click to toggle source

Binding operations

# File lib/apcera_api_helper.rb, line 849
def create_binding(binding)
        @_bindings_api.bindings_post(binding)         
end
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) click to toggle source
# File lib/apcera_api_helper.rb, line 689
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 => "always",
            :maximum_attempts => 3
        })
        
        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
create_job(job) click to toggle source
# File lib/apcera_api_helper.rb, line 740
def create_job(job)
        @_jobs_api.jobs_post(job)
end
create_package(package) click to toggle source
# File lib/apcera_api_helper.rb, line 381
def create_package(package)
        @_packages_api.packages_post(package)
end
debug_mode() click to toggle source
# File lib/apcera_api_helper.rb, line 263
def debug_mode()
        @debug_mode
end
debug_mode=(mode) click to toggle source
# File lib/apcera_api_helper.rb, line 254
def debug_mode=(mode)
        @debug_mode = mode
        Apcera::Configuration.debugging = mode
end
debug_mode?() click to toggle source
# File lib/apcera_api_helper.rb, line 259
def debug_mode?()
        @debug_mode
end
delete_job(job_name) click to toggle source
# File lib/apcera_api_helper.rb, line 806
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
delete_package(package_name) click to toggle source
# File lib/apcera_api_helper.rb, line 393
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
find_packages(opt = {}) click to toggle source

Package operations

# File lib/apcera_api_helper.rb, line 343
def find_packages(opt = {})
        @_packages_api.packages_get(opt)
end
get_base_domain() click to toggle source
# File lib/apcera_api_helper.rb, line 1082
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
get_cluster_metrics(opts = {}) click to toggle source
# File lib/apcera_api_helper.rb, line 329
def get_cluster_metrics(opts = {})
        @_metrics_api.metrics_cluster_get(opts)       
end
get_docker_namespace(job_name) click to toggle source
# File lib/apcera_api_helper.rb, line 1046
def get_docker_namespace(job_name)
        prefs = self._get_job_preferences_by_name(self.sandbox, job_name)
        prefs.docker_cache_namespace
end
get_info() click to toggle source
# File lib/apcera_api_helper.rb, line 267
def get_info
        @_utilities_api.info_get()    
end
get_instance_manager_metrics(opts = {}) click to toggle source
# File lib/apcera_api_helper.rb, line 325
def get_instance_manager_metrics(opts = {})
        @_metrics_api.metrics_instance_managers_get(opts)     
end
get_instance_managers() click to toggle source
# File lib/apcera_api_helper.rb, line 271
def get_instance_managers()
        @_instances_api.instance_managers_get()       
end
get_job_by_name(name) click to toggle source
# File lib/apcera_api_helper.rb, line 767
def get_job_by_name(name)
        ret = @_jobs_api.jobs_get({:fqn => name})
        ret.length > 0 ? ret[0] : nil
end
get_job_logs(uuid, lines) click to toggle source

get job logs

# File lib/apcera_api_helper.rb, line 895
def get_job_logs(uuid, lines)

        @_jobs_api.jobs_uuid_logs_get(uuid, opts = {:lines => lines})
        
end
get_job_metrics(opts = {}) click to toggle source

Metrics operations

# File lib/apcera_api_helper.rb, line 321
def get_job_metrics(opts = {})
        @_metrics_api.metrics_jobs_get(opts)  
end
get_job_route(namespace, job_name) click to toggle source
# File lib/apcera_api_helper.rb, line 830
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
get_job_state_by_name(name) click to toggle source
# File lib/apcera_api_helper.rb, line 778
def get_job_state_by_name(name)
        ret = @_jobs_api.jobs_get({:fqn => name})
        
        ret.length > 0 ? ret[0].state : "JOB_NOT_FOUND"
end
get_logs(key) click to toggle source

Log Operations

# File lib/apcera_api_helper.rb, line 903
def get_logs(key)
        @_logs_api.logs_channel_get(key).to_yaml
end
get_matching_staging_pipeline(name) click to toggle source
# File lib/apcera_api_helper.rb, line 296
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
get_namespace_metrics(opts = {}) click to toggle source
# File lib/apcera_api_helper.rb, line 337
def get_namespace_metrics(opts = {})
        @_metrics_api.metrics_namespace_get(opts)     
end
get_package_by_name(fqn) click to toggle source
# File lib/apcera_api_helper.rb, line 351
def get_package_by_name(fqn)
        ret = @_packages_api.packages_get({:fqn => fqn})
        ret.length > 0 ? ret[0] : nil
end
get_package_by_tag(tag) click to toggle source
# File lib/apcera_api_helper.rb, line 371
def get_package_by_tag(tag)
        ret = @_packages_api.find_packages({:tag => tag})
        ret.length > 0 ? ret[0] : nil
end
get_package_by_uuid(uuid) click to toggle source
# File lib/apcera_api_helper.rb, line 376
def get_package_by_uuid(uuid)
        ret = @_packages_api.packages_uuid_get(uuid)
        ret.length > 0 ? ret[0] : nil
end
get_package_for_docker_layer(docker_namespace, layer_id) click to toggle source
# File lib/apcera_api_helper.rb, line 356
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
get_package_uuid_for_docker_layer(docker_namespace, layer_id) click to toggle source
# File lib/apcera_api_helper.rb, line 365
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
get_route_metrics(opts = {}) click to toggle source
# File lib/apcera_api_helper.rb, line 333
def get_route_metrics(opts = {})
        @_metrics_api.metrics_route_counters_get(opts)        
end
get_sandbox() click to toggle source
# File lib/apcera_api_helper.rb, line 281
def get_sandbox()
        @_utilities_api.namespace_default_get()
end
get_server_info() click to toggle source
# File lib/apcera_api_helper.rb, line 1094
def get_server_info()
        foo = @_utilities_api.info_get()
        return foo
end
get_service_by_name(name) click to toggle source
# File lib/apcera_api_helper.rb, line 772
def get_service_by_name(name)
        ret = @_bindings_api.services_get({:fqn => name})
        puts ret.to_yaml
        ret.length > 0 ? ret[0] : nil
end
get_staging_pipeline_by_name(name) click to toggle source
# File lib/apcera_api_helper.rb, line 291
def get_staging_pipeline_by_name(name)
        ret = @_stagingpipeline_api.stagingpipelines_get({:fqn => name})
        ret.length > 0 ? ret[0] : nil
end
initiate_docker_job(namespace, job_name, image_url, start_command = "" ) click to toggle source

Docker Operations

# File lib/apcera_api_helper.rb, line 909
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
job_exist?(name) click to toggle source
# File lib/apcera_api_helper.rb, line 681
def job_exist?(name)
        !self.get_job_by_name(name).nil?
end
job_from_docker(job_name, job_namespace, registry, image_name, image_tag, start_command = "", allow_egress = false, port = 0, environment = {}, user_name = "", password = "") click to toggle source
# File lib/apcera_api_helper.rb, line 918
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
job_from_package(namespace, job_name, allow_egress, port = 0, environment = {}, start_command = "") click to toggle source
# File lib/apcera_api_helper.rb, line 561
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})

        # If restart mode is always, max needs to be set - if it is set to
        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
jobs_get(opt = {}) click to toggle source

Job operations

# File lib/apcera_api_helper.rb, line 677
def jobs_get(opt = {})
        @_jobs_api.jobs_get(opt)
end
jobs_routes() click to toggle source

Some route operations

# File lib/apcera_api_helper.rb, line 1053
def jobs_routes()
        @_jobs_api.jobs_routes_get()
end
jobs_routes_for_endpoint(endpoint_name) click to toggle source
# File lib/apcera_api_helper.rb, line 1057
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
package_exist?(fqn) click to toggle source
# File lib/apcera_api_helper.rb, line 347
def package_exist?(fqn)
        !get_package_by_name(fqn).nil?
end
package_from_files(filename, namespace, job_name, port = 0) click to toggle source
# File lib/apcera_api_helper.rb, line 543
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
runtimes_get() click to toggle source

Runtime operations

# File lib/apcera_api_helper.rb, line 277
def runtimes_get()
        @_utilities_api.runtimes_get()        
end
scale_job(job_fqn, number_of_instances) click to toggle source
# File lib/apcera_api_helper.rb, line 744
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
        puts "Payload is #{job.to_json}"
        begin 
                Timeout.timeout(10) do      
                        self.update_job(job)
                end
        rescue Timeout::Error
                puts '========== REQUEST TO API TIMED OUT =============='
        end
        STDOUT.flush          

        puts "DONE Scaling #{job_fqn} from #{job.num_instances} to #{number_of_instances}"
end
service_exist?(service) click to toggle source
# File lib/apcera_api_helper.rb, line 685
def service_exist?(service)
        !self.get_service_by_name(service).nil?
end
show_wait_spinner(fps=10) { || ... } click to toggle source

Utility Operations

# File lib/apcera_api_helper.rb, line 1065
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
spin_until_package_staged(package_name) click to toggle source
# File lib/apcera_api_helper.rb, line 410
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
stagingpipelines_get(opts = {}) click to toggle source

Staging Pipeline operations

# File lib/apcera_api_helper.rb, line 287
def stagingpipelines_get(opts = {})
        @_stagingpipeline_api.stagingpipelines_get({:fqn => staging_pipeline})
end
start_job(job_name, num_instances = 1) click to toggle source
# File lib/apcera_api_helper.rb, line 784
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
stop_job(job_name) click to toggle source
# File lib/apcera_api_helper.rb, line 812
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
update_job(job) click to toggle source
# File lib/apcera_api_helper.rb, line 763
def update_job(job)
        @_jobs_api.jobs_uuid_put(job.uuid, job)
end
update_package_by_uuid(uuid, package) click to toggle source
# File lib/apcera_api_helper.rb, line 389
def update_package_by_uuid(uuid, package)
        @_packages_api.packages_uuid_put(uuid, package)               
end
update_package_resources_by_uuid(uuid, payload) click to toggle source
# File lib/apcera_api_helper.rb, line 385
def update_package_resources_by_uuid(uuid, payload)
        @_packages_api.packages_resources_uuid_put(uuid, payload)             
end
wait_until_package_staged(package_name) click to toggle source
# File lib/apcera_api_helper.rb, line 399
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