self.calculate_actual_state

in ee/lib/remote_development/workspace_operations/reconcile/input/actual_state_calculator.rb [38:182]

• 54 lines of code
• 30 McCabe index (conditional complexity)

          def self.calculate_actual_state(
            latest_k8s_deployment_info:, termination_progress: nil, latest_error_details: nil)
            
            
            
            return TERMINATED if termination_progress == TerminationProgress::TERMINATED
            return ERROR if latest_error_details
            return TERMINATING if termination_progress == TerminationProgress::TERMINATING

            
            
            
            
            
            
            return UNKNOWN unless latest_k8s_deployment_info

            spec = latest_k8s_deployment_info[:spec]
            status = latest_k8s_deployment_info[:status]
            conditions = status&.[](:conditions)
            return UNKNOWN unless spec && status && conditions

            progressing_condition = conditions.detect do |condition|
              condition[:type] == CONDITION_TYPE_PROGRESSING
            end
            return UNKNOWN if progressing_condition.nil?

            progressing_reason = progressing_condition[:reason]
            spec_replicas = spec[:replicas]
            return UNKNOWN if progressing_reason.nil? || spec_replicas.nil?

            

            
            
            
            
            
            
            
            
            return FAILED if DEPLOYMENT_PROGRESSING_STATUS_FAILED.include?(progressing_reason)

            
            
            
            
            
            
            if DEPLOYMENT_PROGRESSING_STATUS_PROGRESSING.include?(progressing_reason)
              
              
              
              
              return STOPPING if spec_replicas == 0
              return STARTING if spec_replicas == 1
            end

            
            status_available_replicas = status.fetch(:availableReplicas, 0)
            status_unavailable_replicas = status.fetch(:unavailableReplicas, 0)

            available_condition = conditions.detect do |condition|
              condition[:type] == CONDITION_TYPE_AVAILABLE
            end
            return UNKNOWN if available_condition.nil?

            available_reason = available_condition[:reason]
            return UNKNOWN if available_reason.nil?

            
            
            
            
            
            
            if DEPLOYMENT_PROGRESSING_STATUS_COMPLETE.include?(progressing_reason)
              

              
              if available_reason == AVAILABLE_CONDITION_REASON_MINIMUM_REPLICAS_AVAILABLE &&
                spec_replicas == 0 && status_available_replicas == 0
                return STOPPED
              end

              
              
              
              
              if available_reason == AVAILABLE_CONDITION_REASON_MINIMUM_REPLICAS_AVAILABLE &&
                spec_replicas == status_available_replicas &&
                status_unavailable_replicas == 0
                return RUNNING
              end

              
              
              
              
              
              
              
              
              
              if available_reason == AVAILABLE_CONDITION_REASON_MINIMUM_REPLICAS_AVAILABLE &&
                spec_replicas == 0 && status_available_replicas == 1
                return STOPPING
              end

              
              
              
              
              
              if [
                AVAILABLE_CONDITION_REASON_MINIMUM_REPLICAS_AVAILABLE,
                AVAILABLE_CONDITION_REASON_MINIMUM_REPLICAS_UNAVAILABLE
              ].include?(available_reason) &&
                spec_replicas == 1 && status_available_replicas == 0
                return STARTING
              end

              
              
              
              
              
              
              
              
              
              
              
              
              
              
              
              

              
            end

            UNKNOWN
          end