AbstractFrameworkImpl

abstract def scheduling: Scheduling

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def abort(): Future[Status]

Aborts the driver

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def connect(): Future[(FrameworkID, MasterInfo, MesosDriver)]

Opens the connection to Mesos using the FW and master info known by the driver.

val connectTimeout: Duration

If no connection related event arrives for this duration, the connection attempt will be considered unsuccessful.

def currentDriver(msg: String): MesosDriver

def currentDriver(): MesosDriver

The currently connected driver instance (throws exception if not connected).

def decline(offerId: OfferID): Unit

Decline a previously received offer

def disconnect(): Future[Status]

Closes the connection to Mesos (with the possibility of reopening it later)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executor: ExecutionContext

def finalize(): Unit

val fw: MesosFramework

final def getClass(): Class[_]

def handle(offers: Seq[Offer]): Future[Unit]

Handles the offers as they arrive

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def kill(taskId: TaskID): Future[TaskID]

Kills a previously launched task

val killTimeout: Duration

If no task kill related event arrives for this duration, the kill attempt will be considered unsuccessful.

def launch(offerIds: Iterable[OfferID], tasks: Iterable[TaskInfo]): Iterable[Future[TaskInfo]]

Tries to launch the specified tasks by using the selected offerIds

val launchTimeout: Duration

If no task launch related event arrives for this duration, the launch attempt will be considered unsuccessful.

lazy val logger: Logger

val mkDriver: () ⇒ MesosDriver

We depend on a driver, which actually communicates with Mesos

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def submitTask(task: TaskDescriptor, filter: Filter): LaunchedTask

def submitTask(task: TaskDescriptor): LaunchedTask

def submitTasks(tasks: Seq[TaskDescriptor], filter: Option[Filter]): Seq[LaunchedTask]

Submits the specified tasks; the framework will try to automatically allocate incoming offers to launch these tasks.

def submitTasks(tasks: Seq[TaskDescriptor], filter: Filter): Seq[LaunchedTask]

Convenience overload, to submit with a filter

def submitTasks(tasks: Seq[TaskDescriptor]): Seq[LaunchedTask]

Convenience overload, to submit without a filter

final def synchronized[T0](arg0: ⇒ T0): T0

def terminate(): Future[Status]

This method signifies that it is expected that this framework will never reconnect to Mesos.

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit