Scala KeeperException类代码示例

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

import java.util.{List => JList}

import scala.collection.JavaConverters._

import org.apache.zookeeper.data.Stat
import org.apache.zookeeper.{AsyncCallback, KeeperException}

import com.twitter.util.{Promise, Return, Throw}


  protected def process(rc: Int, path: String)(result: => T) {
    KeeperException.Code.get(rc) match {
      case KeeperException.Code.OK => updateIfEmpty(Return(result))
      case code => updateIfEmpty(Throw(KeeperException.create(code, path)))
    }
  }
}

class StringCallbackPromise extends AsyncCallbackPromise[String] with AsyncCallback.StringCallback {
  def processResult(rc: Int, path: String, ctx: AnyRef, name: String) {
    process(rc, path) { name }
  }
}

class UnitCallbackPromise extends AsyncCallbackPromise[Unit] with AsyncCallback.VoidCallback {
  def processResult(rc: Int, path: String, ctx: AnyRef) {
    process(rc, path) { Unit }
  }
}

class ExistsCallbackPromise(znode: ZNode) extends AsyncCallbackPromise[ZNode.Exists]
    with AsyncCallback.StatCallback {
  def processResult(rc: Int, path: String, ctx: AnyRef, stat: Stat) {
    process(rc, path) {
      znode(stat)
    }
  }
}

class ChildrenCallbackPromise(znode: ZNode) extends AsyncCallbackPromise[ZNode.Children]
    with AsyncCallback.Children2Callback {
  def processResult(rc: Int, path: String, ctx: AnyRef, children: JList[String], stat: Stat) {
    process(rc, path) {
      znode(stat, children.asScala.toSeq)
    }
  }
}

class DataCallbackPromise(znode: ZNode) extends AsyncCallbackPromise[ZNode.Data]
    with AsyncCallback.DataCallback {
  def processResult(rc: Int, path: String, ctx: AnyRef, bytes: Array[Byte], stat: Stat) {
    process(rc, path) {
      znode(stat, bytes)
    }
  }
} 

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

import akka.actor.SupervisorStrategy._
import akka.actor._
import org.apache.zookeeper.KeeperException
import tanukkii.reactivezk._
import tanukkii.reactivezk.ZooKeeperSession.Close
import org.apache.zookeeper.Watcher.Event.KeeperState._
import scala.util.Random

class WorkerSupervisor extends Actor with ActorLogging {
  import WorkerProtocol._

  context.system.eventStream.subscribe(self, classOf[ZooKeeperWatchEvent])

  val settings = ZKSessionSettings(context.system)

  val zookeeperSession = context.actorOf(ZooKeeperSessionActor.props(settings.connectString, settings.sessionTimeout), "zookeeper-session")

  val worker = context.actorOf(Worker.props(Integer.toHexString(new Random().nextInt()), zookeeperSession, self), "worker")

  override def supervisorStrategy: SupervisorStrategy = {
    val keeperDecider: Decider = {
      case e: KeeperException => {
        log.error(e, "ZooKeeper error")
        zookeeperSession ! Close
        Stop
      }
    }
    OneForOneStrategy()(keeperDecider orElse SupervisorStrategy.defaultDecider)
  }

  def receive: Receive = {
    case ZooKeeperWatchEvent(e) if e.getState == SyncConnected => {
      context.system.eventStream.unsubscribe(self, classOf[ZooKeeperWatchEvent])
      worker ! CreateAssignNode
    }
    case WorkerBootstrapFinished => worker ! Register
    case Registered => worker ! GetTasks
  }
}

object WorkerSupervisor {
  def props = Props(new WorkerSupervisor)
}