Merge pull request jaliss#511 from danielkza/fix-hardcoded-execution-context

Fix hardcoded execution context

Author: jaliss

module-code/app/securesocial/controllers/LoginApi.scala

@@ -49,7 +49,6 @@ trait BaseLoginApi[U] extends SecureSocial[U] {
   val logger = play.api.Logger("securesocial.controllers.BaseLoginApi")
 
   def authenticate(providerId: String, builderId: String) = Action.async { implicit request =>
-    import ExecutionContext.Implicits.global
     val result = for (
       builder <- env.authenticatorService.find(builderId);
       provider <- env.providers.get(providerId) if provider.isInstanceOf[ApiSupport]
@@ -85,7 +84,7 @@ trait BaseLoginApi[U] extends SecureSocial[U] {
 
   def logout = Action.async { implicit request =>
     import securesocial.core.utils._
-    import ExecutionContext.Implicits.global
+
     env.authenticatorService.fromRequest(request).flatMap {
       case Some(authenticator) => Ok("").discardingAuthenticator(authenticator)
       case None => Future.successful(Ok(""))

module-code/app/securesocial/controllers/LoginPage.scala

@@ -76,7 +76,6 @@ trait BaseLoginPage[U] extends SecureSocial[U] {
         user <- request.user
         authenticator <- request.authenticator
       } yield {
-        import ExecutionContext.Implicits.global
         redirectTo.discardingAuthenticator(authenticator).map {
           _.withSession(Events.fire(new LogoutEvent(user)).getOrElse(request.session))
         }

module-code/app/securesocial/controllers/MailTokenBasedOperations.scala

@@ -74,7 +74,6 @@ abstract class MailTokenBasedOperations[U] extends SecureSocial[U] {
   protected def executeForToken(token: String, isSignUp: Boolean,
     f: MailToken => Future[Result])(implicit request: RequestHeader): Future[Result] =
     {
-      import scala.concurrent.ExecutionContext.Implicits.global
       env.userService.findToken(token).flatMap {
         case Some(t) if !t.isExpired && t.isSignUp == isSignUp => f(t)
         case _ =>

module-code/app/securesocial/controllers/PasswordChange.scala

@@ -66,7 +66,6 @@ trait BasePasswordChange[U] extends SecureSocial[U] {
    * @return a future boolean
    */
   def checkCurrentPassword[A](suppliedPassword: String)(implicit request: SecuredRequest[A]): Future[Boolean] = {
-    import ExecutionContext.Implicits.global
     env.userService.passwordInfoFor(request.user).map {
       case Some(info) =>
         env.passwordHashers.get(info.hasher).exists {
@@ -77,7 +76,6 @@ trait BasePasswordChange[U] extends SecureSocial[U] {
   }
 
   private def execute[A](f: Form[ChangeInfo] => Future[Result])(implicit request: SecuredRequest[A]): Future[Result] = {
-    import ExecutionContext.Implicits.global
     val form = Form[ChangeInfo](
       mapping(
         CurrentPassword ->
@@ -129,7 +127,6 @@ trait BasePasswordChange[U] extends SecureSocial[U] {
           errors => Future.successful(BadRequest(env.viewTemplates.getPasswordChangePage(errors))),
           info => {
             val newPasswordInfo = env.currentHasher.hash(info.newPassword)
-            import ExecutionContext.Implicits.global
             implicit val userLang = request2lang(request)
             env.userService.updatePasswordInfo(request.user, newPasswordInfo).map {
               case Some(u) =>
@@ -152,4 +149,4 @@ trait BasePasswordChange[U] extends SecureSocial[U] {
  * @param currentPassword the user's current password
  * @param newPassword the new password
  */
-case class ChangeInfo(currentPassword: String, newPassword: String)
+case class ChangeInfo(currentPassword: String, newPassword: String)

module-code/app/securesocial/controllers/PasswordReset.scala

@@ -70,7 +70,6 @@ trait BasePasswordReset[U] extends MailTokenBasedOperations[U] {
   def handleStartResetPassword = CSRFCheck {
     Action.async {
       implicit request =>
-        import scala.concurrent.ExecutionContext.Implicits.global
         startForm.bindFromRequest.fold(
           errors => Future.successful(BadRequest(env.viewTemplates.getStartResetPasswordPage(errors))),
           email => env.userService.findByEmailAndProvider(email, UsernamePasswordProvider.UsernamePassword).map {

module-code/app/securesocial/controllers/ProviderController.scala

@@ -87,7 +87,6 @@ trait BaseProviderController[U] extends SecureSocial[U] {
    * @param redirectTo the url the user needs to be redirected to after being authenticated
    */
   private def handleAuth(provider: String, redirectTo: Option[String]) = UserAwareAction.async { implicit request =>
-    import scala.concurrent.ExecutionContext.Implicits.global
     val authenticationFlow = request.user.isEmpty
     val modifiedSession = overrideOriginalUrl(request.session, redirectTo)
 
@@ -112,7 +111,6 @@ trait BaseProviderController[U] extends SecureSocial[U] {
                 logger.debug(s"[securesocial] user completed authentication: provider = ${profile.providerId}, userId: ${profile.userId}, mode = $mode")
                 val evt = if (mode == SaveMode.LoggedIn) new LoginEvent(userForAction) else new SignUpEvent(userForAction)
                 val sessionAfterEvents = Events.fire(evt).getOrElse(request.session)
-                import scala.concurrent.ExecutionContext.Implicits.global
                 builder().fromUser(userForAction).flatMap { authenticator =>
                   Redirect(toUrl(sessionAfterEvents)).withSession(sessionAfterEvents -
                     SecureSocial.OriginalUrlKey -

module-code/app/securesocial/controllers/Registration.scala

@@ -112,15 +112,13 @@ trait BaseRegistration[U] extends MailTokenBasedOperations[U] {
           e => {
             val email = e.toLowerCase
             // check if there is already an account for this email address
-            import scala.concurrent.ExecutionContext.Implicits.global
             env.userService.findByEmailAndProvider(email, UsernamePasswordProvider.UsernamePassword).map {
               maybeUser =>
                 maybeUser match {
                   case Some(user) =>
                     // user signed up already, send an email offering to login/recover password
                     env.mailer.sendAlreadyRegisteredEmail(user)
                   case None =>
-                    import scala.concurrent.ExecutionContext.Implicits.global
                     createToken(email, isSignUp = true).flatMap { token =>
                       env.mailer.sendSignUpEmail(email, token.uuid)
                       env.userService.saveToken(token)
@@ -154,7 +152,6 @@ trait BaseRegistration[U] extends MailTokenBasedOperations[U] {
   def handleSignUp(token: String) = CSRFCheck {
     Action.async {
       implicit request =>
-        import scala.concurrent.ExecutionContext.Implicits.global
         executeForToken(token, true, {
           t =>
             form.bindFromRequest.fold(

module-code/app/securesocial/core/OAuth1Provider.scala

@@ -34,40 +34,42 @@ import play.api.libs.json.JsValue
  */
 trait OAuth1Client {
 
-  def retrieveRequestToken(callbackURL: String)(implicit ec: ExecutionContext): Future[RequestToken]
+  def retrieveRequestToken(callbackURL: String): Future[RequestToken]
 
-  def retrieveOAuth1Info(token: RequestToken, verifier: String)(implicit ec: ExecutionContext): Future[OAuth1Info]
+  def retrieveOAuth1Info(token: RequestToken, verifier: String): Future[OAuth1Info]
 
   def redirectUrl(token: String): String
 
-  def retrieveProfile(url: String, info: OAuth1Info)(implicit ec: ExecutionContext): Future[JsValue]
+  def retrieveProfile(url: String, info: OAuth1Info): Future[JsValue]
+
+  implicit def executionContext: ExecutionContext
 }
 
 object OAuth1Client {
   /**
    * A default implementation based on the Play client
    * @param serviceInfo
    */
-  class Default(val serviceInfo: ServiceInfo, val httpService: HttpService) extends OAuth1Client {
+  class Default(val serviceInfo: ServiceInfo, val httpService: HttpService)(implicit val executionContext: ExecutionContext) extends OAuth1Client {
     private[core] val client = OAuth(serviceInfo, use10a = true)
     override def redirectUrl(token: String): String = client.redirectUrl(token)
 
-    private def withFuture(call: => Either[OAuthException, RequestToken])(implicit ec: ExecutionContext): Future[RequestToken] = Future {
+    private def withFuture(call: => Either[OAuthException, RequestToken]): Future[RequestToken] = Future {
       call match {
         case Left(error) => throw error
         case Right(token) => token
       }
     }
 
-    override def retrieveOAuth1Info(token: RequestToken, verifier: String)(implicit ec: ExecutionContext) = withFuture {
+    override def retrieveOAuth1Info(token: RequestToken, verifier: String) = withFuture {
       client.retrieveAccessToken(token, verifier)
     }.map(accessToken => OAuth1Info(accessToken.token, accessToken.secret))
 
-    override def retrieveRequestToken(callbackURL: String)(implicit ec: ExecutionContext) = withFuture {
+    override def retrieveRequestToken(callbackURL: String) = withFuture {
       client.retrieveRequestToken(callbackURL)
     }
 
-    override def retrieveProfile(url: String, info: OAuth1Info)(implicit ec: ExecutionContext): Future[JsValue] =
+    override def retrieveProfile(url: String, info: OAuth1Info): Future[JsValue] =
       httpService.url(url).sign(OAuthCalculator(serviceInfo.key, RequestToken(info.token, info.secret))).get().map(_.json)
   }
 }
@@ -102,14 +104,18 @@ object ServiceInfoHelper {
 /**
  * Base class for all OAuth1 providers
  */
-abstract class OAuth1Provider(routesService: RoutesService,
-    cacheService: CacheService, val client: OAuth1Client) extends IdentityProvider {
+abstract class OAuth1Provider(
+  routesService: RoutesService,
+  cacheService: CacheService,
+  val client: OAuth1Client)
+    extends IdentityProvider {
+
+  protected implicit val executionContext = client.executionContext
   protected val logger = play.api.Logger(this.getClass.getName)
 
   def authMethod = AuthenticationMethod.OAuth1
 
   def authenticate()(implicit request: Request[AnyContent]): Future[AuthenticationResult] = {
-    import ExecutionContext.Implicits.global
     if (request.queryString.get("denied").isDefined) {
       // the user did not grant access to the account
       Future.successful(AuthenticationResult.AccessDenied())

module-code/app/securesocial/core/OAuth2Provider.scala

@@ -32,18 +32,21 @@ trait OAuth2Client {
   val settings: OAuth2Settings
   val httpService: HttpService
 
-  def exchangeCodeForToken(code: String, callBackUrl: String, builder: OAuth2InfoBuilder)(implicit ec: ExecutionContext): Future[OAuth2Info]
+  def exchangeCodeForToken(code: String, callBackUrl: String, builder: OAuth2InfoBuilder): Future[OAuth2Info]
 
-  def retrieveProfile(profileUrl: String)(implicit ec: ExecutionContext): Future[JsValue]
+  def retrieveProfile(profileUrl: String): Future[JsValue]
 
   type OAuth2InfoBuilder = WSResponse => OAuth2Info
+
+  implicit def executionContext: ExecutionContext
 }
 
 object OAuth2Client {
 
-  class Default(val httpService: HttpService, val settings: OAuth2Settings) extends OAuth2Client {
+  class Default(val httpService: HttpService, val settings: OAuth2Settings)(implicit val executionContext: ExecutionContext)
+      extends OAuth2Client {
 
-    override def exchangeCodeForToken(code: String, callBackUrl: String, builder: OAuth2InfoBuilder)(implicit ec: ExecutionContext): Future[OAuth2Info] = {
+    override def exchangeCodeForToken(code: String, callBackUrl: String, builder: OAuth2InfoBuilder): Future[OAuth2Info] = {
       val params = Map(
         OAuth2Constants.ClientId -> Seq(settings.clientId),
         OAuth2Constants.ClientSecret -> Seq(settings.clientSecret),
@@ -54,22 +57,26 @@ object OAuth2Client {
       httpService.url(settings.accessTokenUrl).post(params).map(builder)
     }
 
-    override def retrieveProfile(profileUrl: String)(implicit ec: ExecutionContext): Future[JsValue] =
+    override def retrieveProfile(profileUrl: String): Future[JsValue] =
       httpService.url(profileUrl).get().map(_.json)
   }
 }
 /**
  * Base class for all OAuth2 providers
  */
-abstract class OAuth2Provider(routesService: RoutesService,
-    client: OAuth2Client,
-    cacheService: CacheService) extends IdentityProvider with ApiSupport {
+abstract class OAuth2Provider(
+  routesService: RoutesService,
+  client: OAuth2Client,
+  cacheService: CacheService)
+    extends IdentityProvider with ApiSupport {
+
+  protected implicit val executionContext: ExecutionContext = client.executionContext
   protected val logger = play.api.Logger(this.getClass.getName)
 
   val settings = client.settings
   def authMethod = AuthenticationMethod.OAuth2
 
-  protected def getAccessToken[A](code: String)(implicit request: Request[A], ec: ExecutionContext): Future[OAuth2Info] = {
+  protected def getAccessToken[A](code: String)(implicit request: Request[A]): Future[OAuth2Info] = {
     val callbackUrl = routesService.authenticationUrl(id)
     client.exchangeCodeForToken(code, callbackUrl, buildInfo)
       .recover {
@@ -91,7 +98,6 @@ abstract class OAuth2Provider(routesService: RoutesService,
   }
 
   def authenticate()(implicit request: Request[AnyContent]): Future[AuthenticationResult] = {
-    import scala.concurrent.ExecutionContext.Implicits.global
     val maybeError = request.queryString.get(OAuth2Constants.Error).flatMap(_.headOption).map {
       case OAuth2Constants.AccessDenied => Future.successful(AuthenticationResult.AccessDenied())
       case error =>
@@ -181,7 +187,6 @@ abstract class OAuth2Provider(routesService: RoutesService,
   val malformedJson = Json.obj("error" -> "Malformed json").toString()
 
   def authenticateForApi(implicit request: Request[AnyContent]): Future[AuthenticationResult] = {
-    import scala.concurrent.ExecutionContext.Implicits.global
     val maybeCredentials = request.body.asJson flatMap {
       _.validate[LoginJson] match {
         case ok: JsSuccess[LoginJson] =>

module-code/app/securesocial/core/RuntimeEnvironment.scala

@@ -6,8 +6,10 @@ import securesocial.core.providers._
 import securesocial.core.providers.utils.{ Mailer, PasswordHasher, PasswordValidator }
 import securesocial.core.services._
 
+import scala.concurrent.ExecutionContext
 import scala.collection.immutable.ListMap
 
+import play.api.libs.concurrent.{ Execution => PlayExecution }
 /**
  * A runtime environment where the services needed are available
  */
@@ -35,6 +37,8 @@ trait RuntimeEnvironment[U] {
   val eventListeners: List[EventListener[U]]
 
   val userService: UserService[U]
+
+  implicit def executionContext: ExecutionContext
 }
 
 object RuntimeEnvironment {
@@ -54,8 +58,8 @@ object RuntimeEnvironment {
     override lazy val passwordHashers: Map[String, PasswordHasher] = Map(currentHasher.id -> currentHasher)
     override lazy val passwordValidator: PasswordValidator = new PasswordValidator.Default()
 
-    override lazy val httpService: HttpService = new HttpService.Default()
-    override lazy val cacheService: CacheService = new CacheService.Default()
+    override lazy val httpService: HttpService = new HttpService.Default
+    override lazy val cacheService: CacheService = new CacheService.Default
     override lazy val avatarService: Option[AvatarService] = Some(new AvatarService.Default(httpService))
     override lazy val idGenerator: IdGenerator = new IdGenerator.Default()
 
@@ -65,6 +69,8 @@ object RuntimeEnvironment {
     )
 
     override lazy val eventListeners: List[EventListener[U]] = List()
+    override implicit def executionContext: ExecutionContext =
+      PlayExecution.defaultContext
 
     protected def include(p: IdentityProvider) = p.id -> p
     protected def oauth1ClientFor(provider: String) = new OAuth1Client.Default(ServiceInfoHelper.forProvider(provider), httpService)

module-code/app/securesocial/core/SecureSocial.scala

@@ -34,6 +34,7 @@ import play.api.mvc.Result
  */
 trait SecureSocial[U] extends Controller {
   implicit val env: RuntimeEnvironment[U]
+  implicit def executionContext: ExecutionContext = env.executionContext
 
   /**
    * A Forbidden response for ajax clients
@@ -101,12 +102,14 @@ trait SecureSocial[U] extends Controller {
    */
   class SecuredActionBuilder(authorize: Option[Authorization[U]] = None)
       extends ActionBuilder[({ type R[A] = SecuredRequest[A] })#R] {
+
+    override protected implicit def executionContext: ExecutionContext = env.executionContext
+
     private val logger = play.api.Logger("securesocial.core.SecuredActionBuilder")
 
     def invokeSecuredBlock[A](authorize: Option[Authorization[U]], request: Request[A],
       block: SecuredRequest[A] => Future[Result]): Future[Result] =
       {
-        import ExecutionContext.Implicits.global
         env.authenticatorService.fromRequest(request).flatMap {
           case Some(authenticator) if authenticator.isValid =>
             authenticator.touch.flatMap { updatedAuthenticator =>
@@ -121,7 +124,6 @@ trait SecureSocial[U] extends Controller {
             }
           case Some(authenticator) if !authenticator.isValid =>
             logger.debug("[securesocial] user tried to access with invalid authenticator : '%s'".format(request.uri))
-            import ExecutionContext.Implicits.global
             notAuthenticatedResult(request).flatMap { _.discardingAuthenticator(authenticator) }
           case None =>
             logger.debug("[securesocial] anonymous user trying to access : '%s'".format(request.uri))
@@ -147,10 +149,11 @@ trait SecureSocial[U] extends Controller {
    * The UserAwareAction builder
    */
   class UserAwareActionBuilder extends ActionBuilder[({ type R[A] = RequestWithUser[A] })#R] {
+    override protected implicit def executionContext: ExecutionContext = env.executionContext
+
     override def invokeBlock[A](request: Request[A],
       block: (RequestWithUser[A]) => Future[Result]): Future[Result] =
       {
-        import ExecutionContext.Implicits.global
         env.authenticatorService.fromRequest(request).flatMap {
           case Some(authenticator) if authenticator.isValid =>
             authenticator.touch.flatMap {
@@ -219,7 +222,7 @@ object SecureSocial {
    * @tparam U the user type
    * @return a future with an option user
    */
-  def currentUser[U](implicit request: RequestHeader, env: RuntimeEnvironment[U], ec: ExecutionContext): Future[Option[U]] = {
+  def currentUser[U](implicit request: RequestHeader, env: RuntimeEnvironment[U], executionContext: ExecutionContext): Future[Option[U]] = {
     env.authenticatorService.fromRequest.map {
       case Some(authenticator) if authenticator.isValid => Some(authenticator.user)
       case _ => None

module-code/app/securesocial/core/authenticator/AuthenticatorStore.scala

@@ -25,7 +25,7 @@ import scala.reflect.ClassTag
  *
  * @tparam A the Authenticator type the store manages
  */
-trait AuthenticatorStore[A <: Authenticator[_]] {
+abstract class AuthenticatorStore[A <: Authenticator[_]](implicit val executionContext: ExecutionContext) {
   /**
    * Retrieves an Authenticator from the backing store
    *
@@ -60,7 +60,9 @@ object AuthenticatorStore {
    * @param cacheService the cache service to use
    * @tparam A the Authenticator type
    */
-  class Default[A <: Authenticator[_]](cacheService: CacheService) extends AuthenticatorStore[A] {
+  class Default[A <: Authenticator[_]](cacheService: CacheService)(implicit executionContext: ExecutionContext)
+      extends AuthenticatorStore[A] {
+      
     /**
      * Retrieves an Authenticator from the cache
      *
@@ -80,7 +82,6 @@ object AuthenticatorStore {
      * @return the saved authenticator
      */
     override def save(authenticator: A, timeoutInSeconds: Int): Future[A] = {
-      import ExecutionContext.Implicits.global
       cacheService.set(authenticator.id, authenticator, timeoutInSeconds).map { _ => authenticator }
     }
 
@@ -94,4 +95,4 @@ object AuthenticatorStore {
       cacheService.remove(id)
     }
   }
-}
+}