Question

我正在Scala中构建一个基于actor的服务，消费者可以在其中查询客户端是否已获得授权，还可以授权客户端。

如果消费者查询客户端的授权状态并且该客户端尚未授权，则该actor应在指定的超时内等待传入的Authorize消息，然后发送回复。 IsAuthorized应该能够在使用者代码中同步执行，以便阻止并等待回复。像

这样的东西

service !? IsAuthorized(client) => {
  case IsAuthorizedResponse(_, authorized) => // do something
}

然而，我的演员中的receiveWithin()永远不会收到消息，并且总是会遇到超时。

这是我的代码

case object WaitingForAuthorization
case class WaitingForAuthorizationResponse(clients: immutable.Set[Client])
case class IsAuthorized(client: Client)
case class IsAuthorizedResponse(client: Client, authorized: Boolean)
case class Authorize(client: Client)

class ClientAuthorizationService {
  private val authorized: mutable.Set[Client] = new mutable.HashSet[Client] with mutable.SynchronizedSet[Client]
  private val waiting: mutable.Set[Client] = new mutable.HashSet[Client] with mutable.SynchronizedSet[Client]

  def actor = Actor.actor {
    loop {
      react {
        case IsAuthorized(client: Client) => reply {
          if (authorized contains client) {
            IsAuthorizedResponse(client, true)
          } else {
            waiting += client
            var matched = false;
            val end = Instant.now.plus(ClientAuthorizationService.AUTH_TIMEOUT)

            while (!matched && Instant.now.isBefore(end)) {
              // ERROR HERE: Never receives Authorize messages
              receiveWithin(ClientAuthorizationService.AUTH_TIMEOUT) {
                case Authorize(authorizedClient: Client) => {
                  authorizeClient(authorizedClient)
                  if (authorizedClient == client) matched = true
                }
                case TIMEOUT => // do nothing since we handle the timeout in the while loop
              }
            }

            IsAuthorizedResponse(client, matched)
          }
        }

        case Authorize(client: Client) => authorizeClient(client)
        case WaitingForAuthorization => reply {
          WaitingForAuthorizationResponse(immutable.Set() ++ waiting)
        }
      }
    }
  }

  private def authorizeClient(client: Client) = synchronized {
    authorized += client
    waiting -= client
  }
}

object ClientAuthorizationService {
  val AUTH_TIMEOUT: Long = 60 * 1000;
}

当我在actor中发送Authorize消息时，当它在receiveWithin块中时，消息被下面的第二个case语句捕获，实际上只有当没有人等待响应时才能捕获这些消息那个时候。

我的代码出了什么问题？

更新

这是相关代码的缩短版本，它实际上代表了一个更简单和不同的逻辑，但可能更好地澄清了问题：

loop {
  react {
    case IsAuthorized(client: Client) => reply {
      var matched = false

      // In the "real" logic we would actually loop here until either the
      // authorized client matches the requested client or the timeout is hit.
      // For the sake of the demo we only take the first Authorize message.

      receiveWithin(60*1000) {
        // Although Authorize is send to actor it's never caught here
        case Authorize(authorizedClient: Client) => matched = authorizedClient == client
        case TIMEOUT => 
      }

      IsAuthorizedResponse(client, matched)
    }

    case Authorize(client: Client) => // this case is hit
  }
}

更新2：

我终于解决了这个问题。我认为问题在于，当试图在对前面的Authorize消息的回复中收到IsAuthorized消息时，该演员正在阻止。

我重写了代码，以便在等待Authorized时启动匿名Actor。这是感兴趣的人的代码。 waiting是Map[Client, Actor]。

loop {
  react {
    case IsAuthorized(client: Client) =>
      if (authorized contains client) {
        sender ! IsAuthorizedResponse(client, true)
      } else {
        val receipient = sender
        // Start an anonymous actor that waits for an Authorize message
        // within a given timeout and sends a reply to the consumer.
        // The actor will be notified by the parent actor below.
        waiting += client -> Actor.actor {
          val cleanup = () => {
            waiting -= client
            exit()
          }

          receiveWithin(ClientAuthorizationService.AUTH_TIMEOUT) {
            case Authorize(c) =>
              receipient ! IsAuthorizedResponse(client, true)
              cleanup()
            case TIMEOUT =>
              receipient ! IsAuthorizedResponse(client, false)
              cleanup()
          }
        }
      }

    case Authorize(client: Client) =>
      authorized += client

      waiting.get(client) match {
        case Some(actor) => actor ! Authorize(client)
        case None =>
      }

    case WaitingForAuthorization => sender ! WaitingForAuthorizationResponse(immutable.Set() ++ waiting.keySet)
  }
}

如果有更好的方法可以解决这个问题，请告诉我！

Answer 1

不回复问题？在

case IsAuthorized(client: Client) => reply { ... }

所有代码都在回复块的参数中，因此在实际发送回复之前执行（包括receiveWithing）。这意味着当您的客户处理您的回复时，您将不再等待它。

在原始代码中，它应该类似于

case IsAuthorized(client: Client) =>
  if(ok) reply(AuthorizedReply(client, true))
  else {
     reply(AuthorizedReply(client, false))
     receiveWithin(...)
  }

Answer 2

我终于解决了这个问题。我认为问题在于，当试图在对前面的Authorize消息的回复中收到IsAuthorized消息时，该演员正在阻止。

我重写了代码，以便在等待Authorized时启动匿名Actor。这是感兴趣的人的代码。 waiting是Map[Client, Actor]。

loop {
  react {
    case IsAuthorized(client: Client) =>
      if (authorized contains client) {
        sender ! IsAuthorizedResponse(client, true)
      } else {
        val receipient = sender
        // Start an anonymous actor that waits for an Authorize message
        // within a given timeout and sends a reply to the consumer.
        // The actor will be notified by the parent actor below.
        waiting += client -> Actor.actor {
          val cleanup = () => {
            waiting -= client
            exit()
          }

          receiveWithin(ClientAuthorizationService.AUTH_TIMEOUT) {
            case Authorize(c) =>
              receipient ! IsAuthorizedResponse(client, true)
              cleanup()
            case TIMEOUT =>
              receipient ! IsAuthorizedResponse(client, false)
              cleanup()
          }
        }
      }

    case Authorize(client: Client) =>
      authorized += client

      waiting.get(client) match {
        case Some(actor) => actor ! Authorize(client)
        case None =>
      }

    case WaitingForAuthorization => sender ! WaitingForAuthorizationResponse(immutable.Set() ++ waiting.keySet)
  }
}

如果有更好的方法可以解决这个问题，请告诉我！

Scala actor：receiveWithin（）不接收消息

2 个答案: