Reference "app" as "process" where it improves clarity

app/controllers/runtime/app_summaries_controller.rb

@@ -15,7 +15,7 @@ def summary(guid)
         'guid'              => app.guid,
         'name'              => app.name,
         'routes'            => app.routes.map(&:as_summary_json),
-        'running_instances' => instances_reporters.number_of_starting_and_running_instances_for_app(app),
+        'running_instances' => instances_reporters.number_of_starting_and_running_instances_for_process(app),
         'services'          => app.service_bindings.map { |service_binding| service_binding.service_instance.as_summary_json },
         'available_domains' => (app.space.organization.private_domains + SharedDomain.all).map(&:as_summary_json)
       }.merge(app.to_hash)

app/controllers/runtime/apps_ssh_controller.rb

@@ -33,7 +33,7 @@ def ssh_access_with_index(guid, index)
 
       record_ssh_authorized_event(app, index)
 
-      response_body = { 'process_guid' => VCAP::CloudController::Diego::ProcessGuid.from_app(app) }
+      response_body = { 'process_guid' => VCAP::CloudController::Diego::ProcessGuid.from_process(app) }
       [HTTP::OK, MultiJson.dump(response_body)]
     rescue => e
       app = App.find(guid: guid)

app/controllers/runtime/space_summaries_controller.rb

@@ -36,7 +36,7 @@ def space_summary(space)
     end
 
     def app_summary(space)
-      instances = instances_reporters.number_of_starting_and_running_instances_for_apps(space.apps)
+      instances = instances_reporters.number_of_starting_and_running_instances_for_processes(space.apps)
       space.apps.collect do |app|
         {
           guid:              app.guid,

lib/cloud_controller/backends/instances_reporters.rb

@@ -8,8 +8,8 @@ def initialize(diego_client, health_manager_client)
       @health_manager_client = health_manager_client
     end
 
-    def number_of_starting_and_running_instances_for_app(app)
-      reporter_for_app(app).number_of_starting_and_running_instances_for_app(app)
+    def number_of_starting_and_running_instances_for_process(app)
+      reporter_for_app(app).number_of_starting_and_running_instances_for_process(app)
     end
 
     def all_instances_for_app(app)
@@ -24,12 +24,12 @@ def stats_for_app(app)
       reporter_for_app(app).stats_for_app(app)
     end
 
-    def number_of_starting_and_running_instances_for_apps(apps)
+    def number_of_starting_and_running_instances_for_processes(apps)
       diego_apps = apps.select(&:diego?)
       dea_apps = apps - diego_apps
 
-      diego_instances = diego_reporter.number_of_starting_and_running_instances_for_apps(diego_apps)
-      legacy_instances = legacy_reporter.number_of_starting_and_running_instances_for_apps(dea_apps)
+      diego_instances = diego_reporter.number_of_starting_and_running_instances_for_processes(diego_apps)
+      legacy_instances = legacy_reporter.number_of_starting_and_running_instances_for_processes(dea_apps)
       legacy_instances.merge(diego_instances)
     end
 

lib/cloud_controller/backends/runners.rb

@@ -46,7 +46,7 @@ def diego_apps_from_process_guids(process_guids)
         where(diego: true).
         order(:id).
         all.
-        select { |app| process_guids.include?(Diego::ProcessGuid.from_app(app)) }
+        select { |app| process_guids.include?(Diego::ProcessGuid.from_process(app)) }
     end
 
     def diego_apps_cache_data(batch_size, last_id)

lib/cloud_controller/dea/instances_reporter.rb

@@ -11,13 +11,13 @@ def all_instances_for_app(app)
         VCAP::CloudController::Dea::Client.find_all_instances(app)
       end
 
-      def number_of_starting_and_running_instances_for_app(app)
+      def number_of_starting_and_running_instances_for_process(app)
         return 0 unless app.started?
         return 0 if app.staging_failed?
         health_manager_client.healthy_instances(app)
       end
 
-      def number_of_starting_and_running_instances_for_apps(apps)
+      def number_of_starting_and_running_instances_for_processes(apps)
         apps_without_running_instances = apps.select { |app| !app.started? || app.staging_failed? || app.pending? }
         apps_without_running_instances.inject(
           healthy_instances_bulk(apps - apps_without_running_instances)

lib/cloud_controller/dea/start_app_message.rb

@@ -3,54 +3,54 @@
 module VCAP::CloudController
   module Dea
     class StartAppMessage < Hash
-      def initialize(app, index, config, blobstore_url_generator)
+      def initialize(process, index, config, blobstore_url_generator)
         super()
 
         # Grab the v3 droplet if the app is a v3 process
-        if app.app.nil?
-          droplet_download_url = blobstore_url_generator.droplet_download_url(app)
-          droplet_hash = app.droplet_hash
+        if process.is_v2?
+          droplet_download_url = blobstore_url_generator.droplet_download_url(process)
+          droplet_hash = process.droplet_hash
         else
-          droplet = DropletModel.find(guid: app.app.droplet_guid)
+          droplet = DropletModel.find(guid: process.app.droplet_guid)
           droplet_download_url = blobstore_url_generator.v3_droplet_download_url(droplet)
           droplet_hash = droplet.droplet_hash
         end
 
-        self[:droplet]        = app.guid
-        self[:name]           = app.name
-        self[:stack]          = app.stack.name
-        self[:uris]           = app.uris
-        self[:prod]           = app.production
+        self[:droplet]        = process.guid
+        self[:name]           = process.name
+        self[:stack]          = process.stack.name
+        self[:uris]           = process.uris
+        self[:prod]           = process.production
         self[:sha1]           = droplet_hash
         self[:executableFile] = 'deprecated'
         self[:executableUri]  = droplet_download_url
-        self[:version]        = app.version
+        self[:version]        = process.version
 
-        self[:services] = app.service_bindings.map do |sb|
+        self[:services] = process.service_bindings.map do |sb|
           ServiceBindingPresenter.new(sb, include_instance: true).to_hash
         end
 
         self[:limits] = {
-            mem:  app.memory,
-            disk: app.disk_quota,
-            fds:  app.file_descriptors
+            mem:  process.memory,
+            disk: process.disk_quota,
+            fds:  process.file_descriptors
         }
 
         staging_env = EnvironmentVariableGroup.running.environment_json
-        app_env     = app.environment_json || {}
-        env         = staging_env.merge(app_env).merge({ 'CF_PROCESS_TYPE' => app.type }).map { |k, v| "#{k}=#{v}" }
+        app_env     = process.environment_json || {}
+        env         = staging_env.merge(app_env).merge({ 'CF_PROCESS_TYPE' => process.type }).map { |k, v| "#{k}=#{v}" }
         self[:env]  = env
 
         self[:cc_partition]         = config[:cc_partition]
-        self[:console]              = app.console
-        self[:debug]                = app.debug
-        self[:start_command]        = app.command
-        self[:health_check_timeout] = app.health_check_timeout
+        self[:console]              = process.console
+        self[:debug]                = process.debug
+        self[:start_command]        = process.command
+        self[:health_check_timeout] = process.health_check_timeout
 
-        self[:vcap_application]     = VCAP::VarsBuilder.new(app).to_hash
+        self[:vcap_application]     = VCAP::VarsBuilder.new(process).to_hash
 
         self[:index]                = index
-        self[:egress_network_rules] = EgressNetworkRulesPresenter.new(app.space.security_groups).to_array
+        self[:egress_network_rules] = EgressNetworkRulesPresenter.new(process.space.security_groups).to_array
       end
 
       def has_app_package?

lib/cloud_controller/diego/buildpack/buildpack_entry_generator.rb

@@ -6,8 +6,8 @@ def initialize(blobstore_url_generator)
           @blobstore_url_generator = blobstore_url_generator
         end
 
-        def buildpack_entries(app)
-          buildpack = app.buildpack
+        def buildpack_entries(process)
+          buildpack = process.buildpack
 
           case buildpack
           when VCAP::CloudController::CustomBuildpack

lib/cloud_controller/diego/docker/lifecycle_protocol.rb

@@ -5,10 +5,10 @@ module CloudController
     module Diego
       module Docker
         class LifecycleProtocol
-          def lifecycle_data(app)
+          def lifecycle_data(process)
             lifecycle_data = LifecycleData.new
-            lifecycle_data.docker_image = app.docker_image
-            docker_credentials = app.docker_credentials_json
+            lifecycle_data.docker_image = process.docker_image
+            docker_credentials = process.docker_credentials_json
             if docker_credentials
               lifecycle_data.docker_login_server = docker_credentials['docker_login_server']
               lifecycle_data.docker_user = docker_credentials['docker_user']
@@ -18,12 +18,12 @@ def lifecycle_data(app)
             [Lifecycles::DOCKER, lifecycle_data.message]
           end
 
-          def desired_app_message(app)
-            cached_docker_image = app.current_droplet.cached_docker_image if app.current_droplet
+          def desired_app_message(process)
+            cached_docker_image = process.current_droplet.cached_docker_image if process.current_droplet
 
             {
-              'start_command' => app.command,
-              'docker_image'  => cached_docker_image || app.docker_image,
+              'start_command' => process.command,
+              'docker_image'  => cached_docker_image || process.docker_image,
             }
           end
         end

lib/cloud_controller/diego/docker/staging_completion_handler.rb

@@ -26,17 +26,17 @@ def self.success_parser
 
         private
 
-        def save_staging_result(app, payload)
+        def save_staging_result(process, payload)
           result = payload[:result]
 
-          app.class.db.transaction do
-            app.lock!
+          process.class.db.transaction do
+            process.lock!
 
-            app.mark_as_staged
-            app.add_new_droplet(SecureRandom.hex) # placeholder until image ID is obtained during staging
+            process.mark_as_staged
+            process.add_new_droplet(SecureRandom.hex) # placeholder until image ID is obtained during staging
 
             if result.key?(:execution_metadata)
-              droplet = app.current_droplet
+              droplet = process.current_droplet
               droplet.lock!
               droplet.update_execution_metadata(result[:execution_metadata])
               droplet.update_detected_start_command(result[:process_types][:web])
@@ -49,28 +49,28 @@ def save_staging_result(app, payload)
               droplet.update_cached_docker_image(nil)
             end
 
-            app.save_changes(raise_on_save_failure: true)
+            process.save_changes(raise_on_save_failure: true)
           end
         end
 
         def handle_success(staging_guid, payload)
           begin
-            app = get_app(staging_guid)
-            return if app.nil?
+            process = get_process(staging_guid)
+            return if process.nil?
 
             self.class.success_parser.validate(payload)
 
           rescue Membrane::SchemaValidationError => e
             logger.error('diego.staging.success.invalid-message', staging_guid: staging_guid, payload: payload, error: e.to_s)
-            Loggregator.emit_error(app.guid, 'Malformed message from Diego stager')
+            Loggregator.emit_error(process.guid, 'Malformed message from Diego stager')
 
-            app.mark_as_failed_to_stage('StagingError')
+            process.mark_as_failed_to_stage('StagingError')
             raise CloudController::Errors::ApiError.new_from_details('InvalidRequest', payload)
           end
 
           begin
-            save_staging_result(app, payload)
-            @runners.runner_for_app(app).start
+            save_staging_result(process, payload)
+            @runners.runner_for_app(process).start
           rescue => e
             logger.error(@logger_prefix + 'saving-staging-result-failed', staging_guid: staging_guid, response: payload, error: e.message)
           end

lib/cloud_controller/diego/egress_rules.rb

@@ -6,8 +6,8 @@ def staging
         order_rules(staging_security_groups.map(&:rules).flatten)
       end
 
-      def running(app)
-        order_rules(app.space.security_groups.map(&:rules).flatten)
+      def running(process)
+        order_rules(process.space.security_groups.map(&:rules).flatten)
       end
 
       private

lib/cloud_controller/diego/environment.rb

@@ -6,29 +6,29 @@ module Diego
     class Environment
       EXCLUDE = [:users].freeze
 
-      def initialize(app, initial_env={})
-        @app         = app
+      def initialize(process, initial_env={})
+        @process     = process
         @initial_env = initial_env || {}
       end
 
       def as_json(_={})
         diego_env =
           @initial_env.
-          merge(VCAP_APPLICATION: vcap_application, MEMORY_LIMIT: "#{app.memory}m").
-          merge(SystemEnvPresenter.new(app.all_service_bindings).system_env).
-          merge(app.environment_json || {})
+          merge(VCAP_APPLICATION: vcap_application, MEMORY_LIMIT: "#{process.memory}m").
+          merge(SystemEnvPresenter.new(process.all_service_bindings).system_env).
+          merge(process.environment_json || {})
 
-        diego_env = diego_env.merge(DATABASE_URL: app.database_uri) if app.database_uri
+        diego_env = diego_env.merge(DATABASE_URL: process.database_uri) if process.database_uri
 
         NormalEnvHashToDiegoEnvArrayPhilosopher.muse(diego_env)
       end
 
       private
 
-      attr_reader :app
+      attr_reader :process
 
       def vcap_application
-        VCAP::VarsBuilder.new(app).to_hash.reject do |k, _v|
+        VCAP::VarsBuilder.new(process).to_hash.reject do |k, _v|
           EXCLUDE.include? k
         end
       end