LivyScalaApi

org.apache.livy.scalaapi

*LivyScalaClient
ScalaJobContext
ScalaJobHandle
ScalaWrapper*

---

LivyScalaClient：
创建LivyScalaClient

val scalaClient = new LivyClientBuilder().setURI(new URI(url)).build().asScalaClient

Functions：

def addFile(uri: URI): Future[_] 将文件添加到正在运行的远程上下文。
请注意，Spark驱动程序进程可以访问该URL。 如果以群集模式运行驱动程序，它可能驻留在不同的主机上，这意味着“file：”URL必须存在于该节点上（而不是客户端计算机上）。如果提供的URI没有方案，则认为它与Livy服务器中配置的默认文件系统相关。
URI 文件的位置。
return 可用于监控操作的返回值。

def addJar(uri: URI): Future[_] 将jar文件添加到正在运行的远程上下文中。与addFile相同。

def run[T](fn: (ScalaJobContext) ⇒ T): Future[T] 要求远程上下文立即运行作业。
通常，远程上下文将根据已配置的工作线程数来对作业进行排队并执行它们。 此方法将在处理RPC消息的同一线程中运行提交的作业，因此排队不适用。建议此方法仅用于运行快速完成的代码。 这避免了干扰上下文的正常操作。
FN 要执行的工作。 它是一个函数，它接收ScalaJobContext并返回具有该上下文的作业执行结果。
return 可用于监视作业的句柄。

def stop(shutdownContext: Boolean): Unit
停止远程上下文。任何待处理的作业都将被取消，远程上下文将被拆除。
shutdownContext：是否关闭基础Spark上下文。 如果为false，则上下文将继续运行，如果正在使用的后端支持，则仍然可以向其发送命令。

def submit[T](fn: (ScalaJobContext) ⇒ T): ScalaJobHandle[T]
提交异步执行作业。
fn：要执行的工作。 它是一个函数，它接收ScalaJobContext并返回具有该上下文的作业执行结果。
return：可用于监视作业的句柄。

defuploadFile(file: File): Future[_]
上传要传递给Spark应用程序的文件。
file:要上载的本地文件。
return:可用于监视此操作的返回值

def uploadJar(jar: File): Future[_]
上传要传递给Spark应用程序的Jar。同上。

---

ScalaJobContext
保存有关作业执行对象的运行时信息。

Functions：
def createStreamingContext(batchDuration: Long): Unit
创建Spark Streaming对象。
batchDuration：批量持续时间，将流数据分成批次的时间间隔（以毫秒为单位）。

def getSharedVariable[E](name: String): E 获取共享对象

def hivectx: HiveContext 获取HiveContext实例

def localTmpDir: File 返回特定于上下文的本地tmp目录。

def removeSharedVariable[E](name: String): E 从缓存中删除共享对象

def sc: SparkContext SparkContext实例。

def setSharedVariable[E](name: String, obj: E): Unit 设置共享对象，如果已经存在，它将替换旧的对象

def sparkSession[E]: E

def sqlctx: SQLContext ：SqlContext实例

def stopStreamingContext(): Unit 停止SparkStreaming实例

def streamingctx: StreamingContext 返回已创建的StreamingContext。

---

ScalaJobHandle
提交作业的句柄。 允许监视和控制正在运行的远程作业。

Functions:

def andThen[U](pf: PartialFunction[Try[T], U])(implicit executor: ExecutionContext): Future[T]

def collect[S](pf: PartialFunction[T, S])(implicit executor: ExecutionContext): Future[S]

def failed: Future[Throwable]

def fallbackTo[U >: T](that: Future[U]): Future[U]

def filter(p: (T) ⇒ Boolean)(implicit executor: ExecutionContext): Future[T]

def flatMap[S](f: (T) ⇒ Future[S])(implicit executor: ExecutionContext): Future[S]

def foreach[U](f: (T) ⇒ U)(implicit executor: ExecutionContext): Unit

def isCompleted: Boolean 返回作业是否已使用值或异常完成。
注意：使用此方法会产生不确定的数据流程序。
return:如果作业已经完成，则为true，否则为false。

def map[S](f: (T) ⇒ S)(implicit executor: ExecutionContext): Future[S]

def mapTo[S](implicit tag: ClassTag[S]): Future[S]

def onComplete[U](func: (Try[T]) ⇒ U)(implicit executor: ExecutionContext): Unit
通过异常或值完成作业后，应用提供的功能。
如果作业已经完成，则可以立即应用，也可以异步安排。可以注册多个回调; 无法保证它们将按特定顺序执行。
提供的回调总是在提供的隐式ExecutionContext中运行，但不能保证每次回调都会调用ExecutionContext上的execute（）方法，或者在当前线程中调用execute（）。 也就是说，实现可以在单个execute（）中批量运行多个回调，并且可以立即或异步地运行execute（）。

def onFailure[U](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Unit

def onJobCancelled[U](func: (Boolean) ⇒ Unit)(implicit executor: ExecutionContext): Unit
取消此作业后，应用提供的功能。
可以注册多个回调; 无法保证它们将按特定顺序执行。
提供的回调总是在提供的隐式ExecutionContext中运行，但不能保证每次回调都会调用ExecutionContext上的execute（）方法，或者在当前线程中调用execute（）。 也就是说，实现可以在单个execute（）中批量运行多个回调，并且可以立即或异步地运行execute（）。

def onJobQueued[U](func: ⇒ Unit)(implicit executor: ExecutionContext): Unit
当此作业排队时，应用提供的功能。
可以注册多个回调; 无法保证它们将按特定顺序执行。
提供的回调总是在提供的隐式ExecutionContext中运行，但不能保证每次回调都会调用ExecutionContext上的execute（）方法，或者在当前线程中调用execute（）。 也就是说，实现可以在单个execute（）中批量运行多个回调，并且可以立即或异步地运行execute（）。

def onJobStarted[U](func: ⇒ Unit)(implicit executor: ExecutionContext): Unit
此作业开始后，应用提供的功能。
可以注册多个回调; 无法保证它们将按特定顺序执行。
提供的回调总是在提供的隐式ExecutionContext中运行，但不能保证每次回调都会调用ExecutionContext上的execute（）方法，或者在当前线程中调用execute（）。 也就是说，实现可以在单个execute（）中批量运行多个回调，并且可以立即或异步地运行execute（）。

def onSuccess[U](pf: PartialFunction[T, U])(implicit executor: ExecutionContext): Unit

def ready(atMost: Duration)(implicit permit: CanAwait): ScalaJobHandle.this.type
支持Scala的Await.ready（atmost）等待完成工作。
atMost：最长等待时间，可能是负数（无等待），无限制等待的持续时间.Inf，或有限的正持续时间。
return：ScalaJobHandle

def recover[U >: T](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U]

def recoverWith[U >: T](pf: PartialFunction[Throwable, Future[U]])(implicit executor: ExecutionContext): Future[U]

def result(atMost: Duration)(implicit permit: CanAwait): T
支持Scala的Await.result（atmost）等待作业完成并返回结果（类型为T）。
atMost：最长等待时间，可能是负数（无等待），无限制等待的持续时间.Inf，或有限的正持续时间。
return：如果作业在特定的最长等待时间内完成，则为结果值。

def state: State 返回作业的当前状态

def transform[S](s: (T) ⇒ S, f: (Throwable) ⇒ Throwable)(implicit executor: ExecutionContext): Future[S]

def value: Option[Try[T]]
作业的结果值。
如果作业未完成，则返回的值将为None。 如果作业完成，则值为Some（Success（t））。 如果它包含有效结果，或者某些（失败（错误））如果它包含异常。

final def withFilter(p: (T) ⇒ Boolean)(implicit executor: ExecutionContext): Future[T]

def zip[U](that: Future[U]): Future[(T, U)]

---

ScalaWrapper
Livy的Scala Client，它是Java客户端的包装器。

new
ScalaWrapper(livyJavaClient: LivyClient)
Creates a Scala client.

Value Members
def asScalaClient: LivyScalaClient