//设置package包名称以及导入依赖的类
package com.example

import akka.actor.SupervisorStrategy.{Decider, Resume}
import akka.actor._
import akka.event.LoggingReceive


class StatsSupervisorActor(maybeAccuracy: Option[Int]) extends Actor with ActorLogging {

  private val decider: Decider = {
    case StatsActor.StatstActorException =>
      log.warning("Received exception on stats, trying to resume it")
      Resume
  }

  override def supervisorStrategy: SupervisorStrategy = {
    OneForOneStrategy() {
      decider.orElse(super.supervisorStrategy.decider)
    }
  }

  private val statsActor = createStatsActor()

  override def receive: Receive = LoggingReceive {
    case message => statsActor.forward(message)
  }

  private[example] def createStatsActor(): ActorRef = {
    val acc = maybeAccuracy.getOrElse(context.system.settings.config.getInt("main.stats-accuracy"))
    context.actorOf(StatsActor.props(acc), "stats-actor")
  }

}

object StatsSupervisorActor {
  def props(maybeAccuracy: Option[Int]): Props = {
    Props(new StatsSupervisorActor(maybeAccuracy))
  }
} 

//设置package包名称以及导入依赖的类
package auctionsystem

import akka.actor.Actor
import akka.actor.ActorRef
import akka.actor.SupervisorStrategy
import akka.actor.OneForOneStrategy
import akka.event.LoggingReceive
import akka.actor.Props
import auctionsystem.Notifier.Notification
import auctionsystem.Notifier.RepeatRequest
import auctionsystem.exceptions.RemoteServerErrorException
import akka.actor.SupervisorStrategy.Resume
import akka.actor.SupervisorStrategy.Stop

class Notifier extends Actor {
  val auctionPublisher = context.actorSelection("akka.tcp://[email protected]:2552/user/auctionPublisher")
  var requestsMap = Map [ActorRef, Notification]()
  var idx = 0;
  override def supervisorStrategy: SupervisorStrategy = OneForOneStrategy(maxNrOfRetries = 3) {
     case _: RemoteServerErrorException =>
       println(s"An error occurred when trying to connect with remote server, node that caused failure: ${sender.path}. Resuming...")
       self ! RepeatRequest(requestsMap(sender), sender)
       Resume
 
     case e =>
       println(s"Something else went wrong: $e")
       Stop
  }
  
  def receive = LoggingReceive {
    case Notification(auction, highestBidder, highestBid) =>
      val notifierRequest = context.actorOf(Props(new NotifierRequest(auctionPublisher)), "notifierRequest" + idx);      
      idx = idx + 1
      val notification = Notification(auction, highestBidder, highestBid)
      requestsMap += (notifierRequest -> notification)
      notifierRequest ! notification
  }
}

object Notifier {
  final case class RepeatRequest(notification: Notification, notifierRequest: ActorRef)
  final case class Notification(auctionName: String, highestBidder: ActorRef, highestBid: Int);
} 

//设置package包名称以及导入依赖的类
import akka.actor.SupervisorStrategy.Resume
import akka.actor.{Actor, OneForOneStrategy, SupervisorStrategy}

import scala.concurrent.duration._

class ClientActor extends Actor {
  override def receive: Receive = {
    case Ordered =>
      println("\033[33m:: Book was ordered\033[0m")
    case Searched(titles, prices) =>
      for (i <- titles.indices)
        println("\033[33m:: " + s"'${titles(i)}' costs ${prices(i)} PLN" + "\033[0m")
    case SearchError(message) =>
      println("\033[33m:: Search failed in database: " + message + "\033[0m")
    case StreamLine(line) =>
      println("\033[37m" + line + "\033[0m")
  }

  override def supervisorStrategy: SupervisorStrategy = OneForOneStrategy(10, Duration(60, "seconds")) {
    case _: Exception => Resume
  }
} 

//设置package包名称以及导入依赖的类
package actors

import akka.actor.SupervisorStrategy.{Resume, Restart, Stop, Escalate}
import akka.actor.{OneForOneStrategy, Actor, ActorLogging, Props}
import com.typesafe.config.Config
import play.api.libs.ws.WSClient
import scala.concurrent.duration._

class BotSupervisor(wsClient: WSClient,config: Config) extends Actor with ActorLogging{

  override val supervisorStrategy =
    OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
      case _: ArithmeticException      => Resume
      case _: NullPointerException     => Restart
      case _: IllegalArgumentException => Stop
      case _: Exception                => Escalate
    }

  val tinderBot =
    context
      .actorOf(Props(new TinderBot(wsClient,config))
        ,"TinderBot")

  override def preStart() = {
    log.info("Starting Tinder Bot Supervisor")
        tinderBot ! TinderBot.Start
  }



  override def receive: Receive = {
    case _ =>
  }
}

object BotSupervisor {
  def props = Props[BotSupervisor]
} 

//设置package包名称以及导入依赖的类
package trove.core.event

import akka.actor.SupervisorStrategy.{Resume, Stop}
import akka.actor.{ActorInitializationException, ActorKilledException, OneForOneStrategy, SupervisorStrategy, SupervisorStrategyConfigurator}
import grizzled.slf4j.Logging

class AkkaSupervision extends SupervisorStrategyConfigurator with Logging {
  override def create(): SupervisorStrategy = {
    logger.debug("Creating custom akka supervisor strategy")
    OneForOneStrategy() {
      case _: ActorInitializationException => Stop
      case _: ActorKilledException         => Stop
      case e: Exception                    =>
        logger.error("Exception in event listener", e)
        Resume
    }    
  }
} 

//设置package包名称以及导入依赖的类
package com.nossin.ndb

import akka.actor.{Actor, AllForOneStrategy, Props}
import akka.actor.SupervisorStrategy.{Escalate, Restart, Resume, Stop}
import com.nossin.ndb.messages.Calculator.{Div, Sub}
//import com.nossin.ndb.messages.Calculator.{Add, Div, Sub}
import scala.concurrent.duration._


class SupervisorAllActor extends Actor{
    override val supervisorStrategy =
      AllForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 seconds)
      {
        case _: ArithmeticException => Restart
        case _: NullPointerException => Resume
        case _: IllegalArgumentException => Stop
        case _: Exception => Escalate

      }
    val printer = context.actorOf(Props[ResultPrinterActor])
    val calculator =  context.actorOf(Props(classOf[CalculatorActor], printer)) //The all supervisor strategy will also restart printer!
    def receive = {
      case "Start" => calculator ! com.nossin.ndb.messages.Calculator.Add(10, 12)
        calculator ! Sub(12, 10)
        calculator ! Div(5, 2)
        calculator ! Div(5, 0)
    }
} 

//设置package包名称以及导入依赖的类
package com.github.uryyyyyyy.akka.helloworld.faultTolerance

import java.io.IOException

import akka.actor.SupervisorStrategy.{Escalate, Resume}
import akka.actor.{Actor, OneForOneStrategy, Props}

import scala.concurrent.duration.DurationInt

class ParentActor extends Actor {

	override val supervisorStrategy =OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = new DurationInt(1).second ) {
		case _: IOException => Resume
		case _: Exception => Escalate
	}

	def receive = {
		case x => {
			val actor1 = context.actorOf(Props[ChildActor1])
			val actor2 = context.actorOf(Props[ChildActor2])
//			val actor3 = context.actorSelection("akka.tcp://notExist")
			val f1 = actor1 ! "hello"
			val f2 = actor2 ! "hello"
			val f3 = actor2 ! "hello"
//			val f3 = actor3 ! "hello"
		}
	}
} 

//设置package包名称以及导入依赖的类
package chapter4

import akka.actor.SupervisorStrategy.Resume
import akka.actor.{OneForOneStrategy, SupervisorStrategy, Actor, Props}


class LogProcSupervisor(dbSupervisorProps:Props) extends Actor{

      //if file corrupted,keep deal the next msg
  override def supervisorStrategy: SupervisorStrategy = OneForOneStrategy(){
    case _:CorruptedFileException=>Resume
  }
    //by dbSupervisorProps, create db supervisor
  val dbSupervisor=context.actorOf(dbSupervisorProps)
  //this supervisor monitoer the logProcessor
  val logProcProps=Props(new LogProcessor(dbSupervisor))
  val logProcessor=context.actorOf(logProcProps)

  def receive={
    case m=> logProcessor forward(m)
  }

} 

//设置package包名称以及导入依赖的类
package teleporter.integration.component.jdbc

import akka.actor.SupervisorStrategy.Resume
import akka.actor._

import scala.concurrent.duration._


object SupervisorTest extends App {
  implicit val system = ActorSystem()

  import system.dispatcher

  class A extends Actor with ActorLogging {
    override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 2) {
      case _ => println("An actor has been killed"); Resume
    }
    val b = context.actorOf(Props[B], "b")
    context.system.scheduler.schedule(10 seconds, 1 seconds, b, true)


    def receive = {
      case true ? println("is resume"); throw new IllegalArgumentException()
      case _ =>
    }
  }

  class B extends Actor with ActorLogging {
    def receive = {
      case true => throw new IllegalArgumentException("exception")
    }
  }

  system.actorOf(Props[A])
} 

//设置package包名称以及导入依赖的类
package com.akkastarting.chapter4

import scala.concurrent.duration._
import akka.actor.SupervisorStrategy.{Escalate, Stop, Restart, Resume}
import akka.actor.{Actor, ActorLogging, Props, OneForOneStrategy}
import akka.pattern.{BackoffOptions, Backoff, BackoffSupervisor}

class Ch4Ping1Actor extends Actor with ActorLogging {
  log.info("Ping1Actor Created, ...")

  val child2Supervisor = BackoffSupervisor.props(createStrategy(Props[Ch4Ping2Actor], "Ping2Actor"))
  val child3Supervisor = BackoffSupervisor.props(createStrategy(Props[Ch4Ping3Actor], "Ping3Actor"))
  val child2 = context.system.actorOf(child2Supervisor, "Ping2ActorWithSupervisor")
  val child3 = context.system.actorOf(child3Supervisor, "Ping3ActorWithSupervisor")

  def receive = {
    case message: Bad =>
      (child2 ! message)(sender)
      (child3 ! message)(sender)
    case message: Good =>
      (child2 ! message)(sender)
      (child3 ! message)(sender)
  }

  def createStrategy(props: Props, name: String): BackoffOptions = {
    
    Backoff.onStop(props,
      childName = name,
      minBackoff = 3.seconds,
      maxBackoff = 30.seconds,
      randomFactor = 0.2)
      .withManualReset
      .withSupervisorStrategy(OneForOneStrategy() {
        case ex: ArithmeticException =>
          Resume
        case ex: NullPointerException =>
          Restart
        case ex: IllegalArgumentException =>
          Stop
        case _ =>
          Escalate
      })
  }
} 

//设置package包名称以及导入依赖的类
package core.cluster

import akka.actor.SupervisorStrategy.{Resume, Stop}
import akka.actor._

trait SupervisionStrategy extends ActorLogging { self: Actor =>
  override val supervisorStrategy =
    AllForOneStrategy() {
      case e: ActorInitializationException =>
        log.error(e, "Escalating to parent")
        Stop
      case e: ActorKilledException =>
        Stop
      case e: Exception => {
        log.error(e, s"Resume actor")
        Resume
      }
    }
}