private def activateRules()

in core/controller/src/main/scala/org/apache/openwhisk/core/controller/Triggers.scala [323:384]
57 lines of code
10 McCabe index (conditional complexity)

  private def activateRules(user: Identity,
                            args: JsObject,
                            rulesToActivate: Map[FullyQualifiedEntityName, ReducedRule])(
    implicit transid: TransactionId): Future[Iterable[RuleActivationResult]] = {
    val ruleResults = rulesToActivate.map {
      case (ruleName, rule) if (rule.status != Status.ACTIVE) =>
        Future.successful {
          RuleActivationResult(
            ActivationResponse.ApplicationError,
            ruleName,
            rule.action,
            Left(Messages.triggerWithInactiveRule(ruleName.asString, rule.action.asString)))
        }
      case (ruleName, rule) =>
        // Invoke the action. Retain action results for inclusion in the trigger activation record
        postActivation(user, rule, args)
          .flatMap { response =>
            response.status match {
              case OK | Accepted =>
                Unmarshal(response.entity).to[JsObject].map { activationResponse =>
                  val activationId = activationResponse.fields("activationId").convertTo[ActivationId]
                  logging.debug(this, s"trigger-fired action '${rule.action}' invoked with activation $activationId")
                  RuleActivationResult(ActivationResponse.Success, ruleName, rule.action, Right(activationId))
                }

              case code =>
                Unmarshal(response.entity).to[String].map { error =>
                  val failureType = code match {
                    case _: ServerError => ActivationResponse.WhiskError // all 500s are to be considered whisk errors
                    case _              => ActivationResponse.ApplicationError
                  }
                  val errorMessage: String = Try(error.parseJson.convertTo[ErrorResponse])
                    .map { e =>
                      def logMsg = s"trigger-fired action '${rule.action}' failed to invoke with ${e.error}, ${e.code}"
                      if (failureType == ActivationResponse.ApplicationError) logging.debug(this, logMsg)
                      else logging.error(this, logMsg)

                      e.error
                    }
                    .getOrElse {
                      logging
                        .error(this, s"trigger-fired action '${rule.action}' failed to invoke with status code $code")
                      InternalServerError.defaultMessage
                    }

                  RuleActivationResult(failureType, ruleName, rule.action, Left(errorMessage))
                }
            }
          }
          .recover {
            case t =>
              logging.error(this, s"trigger-fired action '${rule.action}' failed to invoke with $t")
              RuleActivationResult(
                ActivationResponse.WhiskError,
                ruleName,
                rule.action,
                Left(InternalServerError.defaultMessage))
          }
    }

    Future.sequence(ruleResults)
  }