def _create_task(tid, offer, command, ns):
"""
`tid` (str) task id
`offer` a mesos Offer instance
`ns.mesos_task_resources` the stuff a task would consume:
{
"cpus": 10,
"mem": 1,
"disk": 12,
"ports": [(20, 34), (35, 35)],
"disks": ["sda1"]
}
`ns.docker_image` (str|None)
a docker image you wish to execute the command in
`ns.volumes` a list of volumes that get mounted into the container:
[
("host_path", "container_path", "mode"),
("/my/directory", "/path/on/container", "ro")
]
"""
task = dict(
task_id=mesos_pb2.TaskID(value=tid),
slave_id=offer.slave_id,
command=mesos_pb2.CommandInfo(
value=command,
uris=[mesos_pb2.CommandInfo.URI(value=uri) for uri in ns.uris],
environment=mesos_pb2.Environment(variables=[
mesos_pb2.Environment.Variable(name=k, value=v)
for k, v in ns.mesos_environment
])))
if ns.mesos_framework_name:
task.update(name="relay.mesos task: %s: %s" %
(ns.mesos_framework_name, tid))
else:
task.update(name="relay.mesos task: %s" % tid)
# ability to inject os.environ values into the command
if ns.docker_image:
volumes = [
mesos_pb2.Volume(host_path=host_path,
container_path=container_path,
mode=mesos_pb2.Volume.Mode.Value(mode.upper()))
for host_path, container_path, mode in ns.volumes
]
task.update(container=mesos_pb2.ContainerInfo(
type=mesos_pb2.ContainerInfo.DOCKER,
volumes=volumes,
docker=mesos_pb2.ContainerInfo.DockerInfo(
image=ns.docker_image,
force_pull_image=ns.force_pull_image,
network=mesos_pb2.ContainerInfo.DockerInfo.Network.Value(
ns.docker_network),
parameters=[
mesos_pb2.Parameter(key=k, value=v)
for k, v in ns.docker_parameters.items()
],
)))
task = mesos_pb2.TaskInfo(**task)
_create_task_add_task_resources(task, ns)
return task
def resourceOffers(self, driver, offers):
for offer in offers:
tasks = []
offerCpus = 0
offerMem = 0
for resource in offer.resources:
if resource.name == "cpus":
offerCpus += resource.scalar.value
elif resource.name == "mem":
offerMem += resource.scalar.value
self.log.info("Received offer %s with cpus: %s and mem: %s",
offer.id.value, offerCpus, offerMem)
remainingCpus = offerCpus
remainingMem = offerMem
while (not self.task_queue.empty()) and \
remainingCpus >= self.task_cpu and \
remainingMem >= self.task_mem:
key, cmd = self.task_queue.get()
tid = self.task_counter
self.task_counter += 1
self.task_key_map[str(tid)] = key
self.log.info("Launching task %d using offer %s", tid,
offer.id.value)
task = mesos_pb2.TaskInfo()
task.task_id.value = str(tid)
task.slave_id.value = offer.slave_id.value
task.name = "AirflowTask %d" % tid
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = self.task_cpu
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = self.task_mem
command = mesos_pb2.CommandInfo()
command.shell = True
command.value = cmd
task.command.MergeFrom(command)
tasks.append(task)
remainingCpus -= self.task_cpu
remainingMem -= self.task_mem
driver.launchTasks(offer.id, tasks)
def build_cmd(self, job, port):
cmd = mesos_pb2.CommandInfo()
cmd.value = "bash wrapper.bash"
env = cmd.environment.variables.add()
env.name = "PORT"
env.value = str(port)
# XXX - This is definitely the wrong place to do this.
job.port = port
for uri in job.uris():
cmd.uris.add().value = uri
return cmd
def setUp(self):
self.framework_id = mesos_pb2.FrameworkID(value=self.FRAMEWORK_ID)
self.framework_info = mesos_pb2.FrameworkInfo(
user='******',
name='fake_framework_name',
)
self.command_info = mesos_pb2.CommandInfo(value='fake-command')
self.executor_id = mesos_pb2.ExecutorID(value='fake-executor-id')
self.executor_info = mesos_pb2.ExecutorInfo(
executor_id=self.executor_id,
framework_id=self.framework_id,
command=self.command_info,
)
self.slave_id = mesos_pb2.SlaveID(value='fake-slave-id')
self.offer_id = mesos_pb2.OfferID(value='1')
def tryOffer(self, offer):
offerCPUs = 0
offerMEMs = 0
offerPortBegin = 0
offerPortEnd = 0
for resource in offer.resources:
if resource.name == "cpus":
offerCPUs += resource.scalar.value
elif resource.name == "mem":
offerMEMs += resource.scalar.value
elif resource.name == "ports":
offerPortBegin = resource.ranges.range[0].begin
offerPortEnd = resource.ranges.range[0].end
if offerCPUs >= self.required_cpu and offerMEMs >= self.required_mem:
#and offerPortBegin >= offerPortEnd and offerPortBegin > 0:
print "Launching task using offer %s" % offer.id.value
task = mesos_pb2.TaskInfo()
container = mesos_pb2.ContainerInfo()
container.type = mesos_pb2.ContainerInfo.DOCKER
print "using port %s to %s" % (offerPortBegin, offerPortEnd)
volume = container.volumes.add()
volume.container_path = "/workspace"
volume.host_path = "/var/opt/docker_singa_wokerspace/"+self.taskID
volume.mode = mesos_pb2.Volume.RW
command = mesos_pb2.CommandInfo()
command.value = "/bin/bash /usr/src/incubator-singa/examples/cifar10_mesos/entry.sh "
+ self.url + " "
+ self.mode
# command.value = "/usr/bin/python -m SimpleHTTPServer 80"
task.command.MergeFrom(command)
task.task_id.value = self.taskID
task.slave_id.value = offer.slave_id.value
task.name = "Singa task in docker"
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = self.required_cpu
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = self.required_mem
docker = mesos_pb2.ContainerInfo.DockerInfo()
docker.image = "singa:latest"
docker.network = mesos_pb2.ContainerInfo.DockerInfo.BRIDGE
ports = task.resources.add()
ports.name = "ports"
ports.type = mesos_pb2.Value.RANGES
ports_range = ports.ranges.range.add()
#ports_range.begin = 31001
#ports_range.end = 31001
ports_range.begin = offerPortBegin
ports_range.end = offerPortBegin
docker_port = docker.port_mappings.add()
docker_port.host_port = offerPortBegin
docker_port.container_port = self.required_port
container.docker.MergeFrom(docker)
task.container.MergeFrom(container)
tasks = []
tasks.append(task)
operation = mesos_pb2.Offer.Operation()
operation.type = mesos_pb2.Offer.Operation.LAUNCH
operation.launch.task_infos.extend(tasks)
driver.acceptOffers([offer.id], [operation])
return True
def new_docker_task(self, offer, id, appconfig):
'''
Creates a task for mesos
:param offer: mesos offer
:type offer: Offer
:param id: Id of the task (unique)
:type id: str
:param appconfig: config of application to be launched
:type appconfig: Appconfig
'''
task = mesos_pb2.TaskInfo()
# We want of container of type Docker
container = mesos_pb2.ContainerInfo()
container.type = 1 # mesos_pb2.ContainerInfo.Type.DOCKER
# Let's create a volume
# container.volumes, in mesos.proto, is a repeated element
# For repeated elements, we use the method "add()" that returns an object that can be updated
if (appconfig.needStorage()):
volume = container.volumes.add()
volume.container_path = appconfig.getStorage() # Path in container
#TODO: we need to generate paths on host based on hash
volume.host_path = "/tmp/mesosexample" # Path on host
volume.mode = 1 # mesos_pb2.Volume.Mode.RW
#volume.mode = 2 # mesos_pb2.Volume.Mode.RO
# Define the command line to execute in the Docker container
command = mesos_pb2.CommandInfo()
command.value = appconfig.getCmd()
task.command.MergeFrom(command) # The MergeFrom allows to create an object then to use this object in an other one. Here we use the new CommandInfo object and specify to use this instance for the parameter task.command.
task.task_id.value = id
task.slave_id.value = offer.slave_id.value
task.name = appconfig.getName()
# CPUs are repeated elements too
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = appconfig.getCpus()
# Memory are repeated elements too
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = appconfig.getRam()
# Let's focus on the Docker object now
docker = mesos_pb2.ContainerInfo.DockerInfo()
docker.image = appconfig.getImage()
docker.network = 2 # mesos_pb2.ContainerInfo.DockerInfo.Network.BRIDGE
docker.force_pull_image = True
#create parameter object to pass the weave information
param = docker.parameters.add()
param.key = "net"
param.value = "weave"
# Set docker info in container.docker
container.docker.MergeFrom(docker)
# Set docker container in task.container
task.container.MergeFrom(container)
# Return the object
return task
def resourceOffers(self, driver, offers):
for offer in offers:
tasks = []
offerCpus = 0
offerMem = 0
for resource in offer.resources:
if resource.name == "cpus":
offerCpus += resource.scalar.value
elif resource.name == "mem":
offerMem += resource.scalar.value
self.log.info("Received offer %s with cpus: %s and mem: %s",
offer.id.value, offerCpus, offerMem)
remainingCpus = offerCpus
remainingMem = offerMem
unmatched_tasks = []
# Matches tasks to offer or adds them to unmatched list to be requeued
while True:
try:
key, cmd, mesos_executor_config = self.task_queue.get(block=False)
except Empty:
for task in unmatched_tasks:
self.task_queue.put(task)
break
task_cpu = mesos_executor_config.request_cpu
task_mem = mesos_executor_config.request_memory
docker_image = mesos_executor_config.image
if remainingCpus <= task_cpu or remainingMem <= task_mem:
unmatched_tasks.append((key, cmd, mesos_executor_config))
continue
tid = self.task_counter
self.task_counter += 1
self.task_key_map[str(tid)] = key
self.log.info("Launching task %d using offer %s", tid, offer.id.value)
task = mesos_pb2.TaskInfo()
task.task_id.value = str(tid)
task.slave_id.value = offer.slave_id.value
task.name = "AirflowTask %d" % tid
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = task_cpu
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = task_mem
command = mesos_pb2.CommandInfo()
command.shell = True
command.value = " ".join(cmd)
task.command.MergeFrom(command)
# If docker image for airflow is specified in config then pull that
# image before running the above airflow command
if docker_image:
network = mesos_pb2.ContainerInfo.DockerInfo.Network.Value('BRIDGE')
docker = mesos_pb2.ContainerInfo.DockerInfo(
image=docker_image,
force_pull_image=False,
network=network
)
container = mesos_pb2.ContainerInfo(
type=mesos_pb2.ContainerInfo.DOCKER,
docker=docker
)
task.container.MergeFrom(container)
tasks.append(task)
remainingCpus -= task_cpu
remainingMem -= task_mem
driver.launchTasks(offer.id, tasks)
def task_format(self, offer, conf):
"""Format arguments into Docker task."""
# Create the container object
container = mesos_pb2.ContainerInfo()
container.type = 1 # mesos_pb2.ContainerInfo.Type.DOCKER
# Create container volumes
output_volume = container.volumes.add()
output_volume.host_path = conf.outdir
output_volume.container_path = conf.outdir
output_volume.mode = 1 # mesos_pb2.Volume.Mode.RW
input_volume = container.volumes.add()
input_volume.host_path = conf.indir
input_volume.container_path = conf.indir
input_volume.mode = 2 # mesos_pb2.Volume.Mode.RO
localtime_volume = container.volumes.add()
localtime_volume.host_path = '/etc/localtime'
localtime_volume.container_path = '/etc/localtime'
localtime_volume.mode = 2 # mesos_pb2.Volume.Mode.RO
aux_volume = container.volumes.add()
aux_volume.host_path = conf.auxdir
aux_volume.container_path = conf.auxdir
aux_volume.mode = 2 # mesos_pb2.Volume.Mode.RO
configuration_volume = container.volumes.add()
configuration_volume.host_path = conf.confloc
configuration_volume.container_path = '/ARD_Clip.conf'
configuration_volume.mode = 2 # mesos_pb2.Volume.Mode.RO
# Specify container Docker image
docker = mesos_pb2.ContainerInfo.DockerInfo()
docker.image = conf.container_name
docker.network = 2 # mesos_pb2.ContainerInfo.DockerInfo.Network.BRIDGE
docker.force_pull_image = False
user_param = docker.parameters.add()
user_param.key = 'user'
user_param.value = '{0}:{1}'.format(conf.container_user,
conf.container_group)
workdir_param = docker.parameters.add()
workdir_param.key = 'workdir'
workdir_param.value = '/mnt/mesos/sandbox'
container.docker.MergeFrom(docker)
# Create the task object
task = mesos_pb2.TaskInfo()
task.task_id.value = self.job_id
task.slave_id.value = offer.slave_id.value
task.name = 'ARD Clip ' + self.job_id.replace('-', ' ')
# Add the container
task.container.MergeFrom(container)
# Define the command line to execute in the Docker container
command = mesos_pb2.CommandInfo()
command.value = self.command
# Set the user to run the task as.
command.user = conf.framework_user
# Add the docker uri for logging into the remote repository
if conf.docker_pkg:
command.uris.add().value = conf.docker_pkg
# The MergeFrom allows to create an object then to use this object
# in an other one. Here we use the new CommandInfo object and specify
# to use this instance for the parameter task.command.
task.command.MergeFrom(command)
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = self.cpus
disk = task.resources.add()
disk.name = "disk"
disk.type = mesos_pb2.Value.SCALAR
disk.scalar.value = self.disk
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = self.mem
# Return the object
return task
def resourceOffers(self, driver, offers):
for offer in offers:
tasks = []
offerCpus = 0
offerMem = 0
for resource in offer.resources:
if resource.name == "cpus":
offerCpus += resource.scalar.value
elif resource.name == "mem":
offerMem += resource.scalar.value
self.log.info("Received offer %s with cpus: %s and mem: %s",
offer.id.value, offerCpus, offerMem)
remainingCpus = offerCpus
remainingMem = offerMem
while (not self.task_queue.empty()) and \
remainingCpus >= self.task_cpu and \
remainingMem >= self.task_mem:
key, cmd = self.task_queue.get()
tid = self.task_counter
self.task_counter += 1
self.task_key_map[str(tid)] = key
self.log.info("Launching task %d using offer %s", tid, offer.id.value)
task = mesos_pb2.TaskInfo()
task.task_id.value = str(tid)
task.slave_id.value = offer.slave_id.value
task.name = "AirflowTask %d" % tid
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = self.task_cpu
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = self.task_mem
command = mesos_pb2.CommandInfo()
command.shell = True
command.value = " ".join(cmd)
task.command.MergeFrom(command)
# If docker image for airflow is specified in config then pull that
# image before running the above airflow command
if self.mesos_slave_docker_image:
network = mesos_pb2.ContainerInfo.DockerInfo.Network.Value('BRIDGE')
docker = mesos_pb2.ContainerInfo.DockerInfo(
image=self.mesos_slave_docker_image,
force_pull_image=False,
network=network
)
container = mesos_pb2.ContainerInfo(
type=mesos_pb2.ContainerInfo.DOCKER,
docker=docker
)
task.container.MergeFrom(container)
tasks.append(task)
remainingCpus -= self.task_cpu
remainingMem -= self.task_mem
driver.launchTasks(offer.id, tasks)
def make_task(self, offer):
"""Create a Mesos task from the job information
"""
# Create the container object
container = MesosPb2.ContainerInfo()
container.type = 1 # MesosPb2.ContainerInfo.Type.DOCKER
# Create container volumes
#volume = container.volumes.add()
#volume.host_path = 'host/path'
#volume.container_path = 'container/path'
#volume.mode = 1 # MesosPb2.Volume.Mode.RW
#volume.mode = 2 # MesosPb2.Volume.Mode.RO
# Specify container Docker Image
docker_cfg = self.info.body['docker']
docker = MesosPb2.ContainerInfo.DockerInfo()
docker.image = ':'.join([docker_cfg['image'], docker_cfg['tag']])
##docker.network = 2 # MesosPb2.ContainerInfo.DockerInfo.BRIDGE
docker.network = 1 # MesosPb2.ContainerInfo.DockerInfo.HOST
docker.force_pull_image = False
# Specify who to run as within the Docker Container
user_param = docker.parameters.add()
user_param.key = 'user'
user_param.value = '{}:{}'.format(self.cfg.docker.user_id,
self.cfg.docker.group_id)
# Specify the working directory
# Typically you will want this to be /mnt/mesos/sandbox
workdir_param = docker.parameters.add()
workdir_param.key = 'workdir'
workdir_param.value = self.cfg.docker.workdir
# Add the Docker information to the container
container.docker.MergeFrom(docker)
# Create the task object
task = MesosPb2.TaskInfo()
task.task_id.value = self.get_task_id()
task.slave_id.value = offer.slave_id.value
task.name = self.get_task_name()
# Add the container
task.container.MergeFrom(container)
# Specify the command line to execute within the Docker container
command = MesosPb2.CommandInfo()
command.value = self.build_command_line()
command.user = self.cfg.mesos.user
# Add the docker uri for logging into the remote repository
#command.uris.add().value = self.cfg.docker.cfg
# Add any required environment variables
variable = command.environment.variables.add()
variable.name = 'DEMO_WORKER_STANDARD_RANGE'
variable.value = self.cfg.worker.std_range
variable = command.environment.variables.add()
variable.name = 'DEMO_WORKER_VARIATION_RANGE'
variable.value = self.cfg.worker.var_range
variable = command.environment.variables.add()
variable.name = 'DEMO_WORKER_VARIATION_PERCENTAGE'
variable.value = self.cfg.worker.var_percent
'''
The MergeFrom allows to create an object then to use this object
in another one. Here we use the new CommandInfo object and specify
to use this instance for the parameter task.command.
'''
task.command.MergeFrom(command)
# Setup the resources we are claiming
cpus = task.resources.add()
cpus.name = 'cpus'
cpus.type = MesosPb2.Value.SCALAR
cpus.scalar.value = self.info.body['cpus']
mem = task.resources.add()
mem.name = 'mem'
mem.type = MesosPb2.Value.SCALAR
mem.scalar.value = self.info.body['mem']
disk = task.resources.add()
disk.name = 'disk'
disk.type = MesosPb2.Value.SCALAR
disk.scalar.value = self.info.body['disk']
return task
def new_docker_task(self, offer, instance_object):
instance = instance_object.instance_info
image_meta = instance_object.image_meta
network_info = instance_object.network_info
volume_info_list = instance_object.volume_info_list
task = self.makeTaskPrototype(offer, instance_object)
# We want of container of type Docker
container = mesos_pb2.ContainerInfo()
container.type = 1 # mesos_pb2.ContainerInfo.Type.DOCKER
# Let's create a volume
# container.volumes, in mesos.proto, is a repeated element
# For repeated elements, we use the method "add()" that returns an object that can be updated
if volume_info_list:
for volume_info in volume_info_list:
if volume_info.type == "rbd":
volume = container.volumes.add()
#TODO(gokrokve) fix volume mountpoints. Here we hardcode
# a volume path to /mnt/volume
# originally it was /mnt/<volume name>
volume.container_path = "/mnt/volume" #+ volume_info.target['name'] # Path in container
volume.host_path = volume_info.target[
'name'] # Path on host
volume.mode = 1 # mesos_pb2.Volume.Mode.RW
# volume.mode = 2 # mesos_pb2.Volume.Mode.RO
# Define the command line to execute in the Docker container
# Command value is empry to run container's default
# Shell is disabled as well
#executorInfo = mesos_pb2.ExecutorInfo()
#executorInfo.executor_id.value = task.task_id.value
command = mesos_pb2.CommandInfo()
command.shell = False
task.command.MergeFrom(command)
task.name = "nova-mesos-01"
# Let's use Docker containers
docker = mesos_pb2.ContainerInfo.DockerInfo()
docker.image = instance_object.image_name
docker.force_pull_image = False
#TODO(gokrokve) Fix networking type to support new network model in docker
docker.network = 2 # mesos_pb2.ContainerInfo.DockerInfo.Network.BRIDGE
docker.volume_driver = "rbd"
# Set docker info in container.docker
container.docker.MergeFrom(docker)
network = container.network_infos.add()
#TODO(gokrokve) collect ip addresses from network_info[][subnets]
network.ip_address = instance_object.ip
network.protocol = 1
labels = mesos_pb2.Labels()
label = labels.labels.add()
label.key = "network_id"
#TODO(gokrokve) add proper network id
label.value = instance_object.network_id
#label.value = "none"
network.labels.MergeFrom(labels)
# Set docker container in task.container
task.container.MergeFrom(container)
#task.executor.container.MergeFrom(container)
# Return the object
return task
def resourceOffers(self, driver, offers):
for offer in offers:
tasks = []
offerCpus = 0
offerMem = 0
offerGpus = 0
for resource in offer.resources:
if resource.name == "cpus":
offerCpus += resource.scalar.value
elif resource.name == "mem":
offerMem += resource.scalar.value
elif resource.name == "gpus":
offerGpus += resource.scalar.value
logging.info("Received offer %s with cpus: %s, mem: %s and gpus: %s", offer.id.value, offerCpus, offerMem, offerGpus)
remainingCpus = offerCpus
remainingMem = offerMem
remainingGpus = offerGpus
rejectedQueue = Queue()
while (not self.task_queue.empty()):
key, cmd, cpus, ram, disk, gpus = self.task_queue.get()
if remainingCpus >= cpus and \
remainingGpus >= gpus and \
remainingMem >= ram:
tid = self.task_counter
self.task_counter += 1
self.task_key_map[str(tid)] = key
logging.info("Launching task %d using %f cpus and %d memory from offer %s", tid, cpus, ram, offer.id.value)
task = mesos_pb2.TaskInfo()
task.task_id.value = str(tid)
task.slave_id.value = offer.slave_id.value
#task.name = "AirflowTask %d" % tid
task.name = "Airflow DAG:%s TASK:%s FOR:%s" % key
task_cpus = task.resources.add()
task_cpus.name = "cpus"
task_cpus.type = mesos_pb2.Value.SCALAR
task_cpus.scalar.value = cpus
task_mem = task.resources.add()
task_mem.name = "mem"
task_mem.type = mesos_pb2.Value.SCALAR
task_mem.scalar.value = ram
task_gpus = task.resources.add()
task_gpus.name = "gpus"
task_gpus.type = mesos_pb2.Value.SCALAR
task_gpus.scalar.value = gpus
command = mesos_pb2.CommandInfo()
command.shell = True
command.value = cmd
task.command.MergeFrom(command)
tasks.append(task)
remainingCpus -= cpus
remainingMem -= ram
remainingGpus -= gpus
logging.info("Remaining resources for offer %s: cpus: %s, mem: %s and gpus: %s", offer.id.value, remainingCpus, remainingMem, remainingGpus)
else:
# We were not able to schedule this task, save it in a separate queue
rejectedQueue.put((key, cmd, cpus, ram, disk, gpus))
# Place any entries from the rejectedQueue back in the task queue
while (not rejectedQueue.empty()):
key, cmd, cpus, ram, disk, gpus= rejectedQueue.get()
self.task_queue.put((key, cmd, cpus, ram, disk, gpus))
self.task_queue.task_done()
driver.launchTasks(offer.id, tasks)
def new_docker_task(self, offer, id):
'''
Creates a task for mesos
:param offer: mesos offer
:type offer: Offer
:param id: Id of the task (unique)
:type id: str
'''
task = mesos_pb2.TaskInfo()
# We want of container of type Docker
container = mesos_pb2.ContainerInfo()
container.type = 1 # mesos_pb2.ContainerInfo.Type.DOCKER
# Let's create a volume
# container.volumes, in mesos.proto, is a repeated element
# For repeated elements, we use the method "add()" that returns an object that can be updated
volume = container.volumes.add()
volume.container_path = "/mnt/mesosexample" # Path in container
volume.host_path = "/tmp/mesosexample" # Path on host
volume.mode = 1 # mesos_pb2.Volume.Mode.RW
#volume.mode = 2 # mesos_pb2.Volume.Mode.RO
# Define the command line to execute in the Docker container
command = mesos_pb2.CommandInfo()
command.value = "sleep 30"
task.command.MergeFrom(command) # The MergeFrom allows to create an object then to use this object in an other one. Here we use the new CommandInfo object and specify to use this instance for the parameter task.command.
task.task_id.value = id
task.slave_id.value = offer.slave_id.value
task.name = "my sample task"
# CPUs are repeated elements too
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = 1
# Memory are repeated elements too
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = 128
# Let's focus on the Docker object now
docker = mesos_pb2.ContainerInfo.DockerInfo()
docker.image = "centos"
docker.network = 2 # mesos_pb2.ContainerInfo.DockerInfo.Network.BRIDGE
docker.force_pull_image = True
# We could (optinally of course) use some ports too available in offer
## First we need to tell mesos we take some ports from the offer, like any other resource
#mesos_ports = task.resources.add()
#mesos_ports.name = "ports"
#mesos_ports.type = mesos_pb2.Value.RANGES
#port_range = mesos_ports.ranges.range.add()
#available_port = get_some_available_port_in_port_offer_resources()
#port_range.begin = available_port
#port_range.end = available_port
## We also need to tell docker to do mapping with this port
#docker_port = docker.port_mappings.add()
#docker_port.host_port = available_port
#docker_port.container_port = available_port
# Set docker info in container.docker
container.docker.MergeFrom(docker)
# Set docker container in task.container
task.container.MergeFrom(container)
# Return the object
return task
def resourceOffers(self, driver, offers):
tasks = []
for offer in offers:
print "Considering resource offer %s from %s" % (offer.id.value,
offer.hostname)
offerCpus = 0
offerMems = 0
port_begin = 0
port_end = 0
for resouce in offer.resources:
if resouce.name == "cpus":
offerCpus += resouce.scalar.value
elif resouce.name == "mem":
offerMems += resouce.scalar.value
elif resouce.name == "ports":
port_begin = resouce.ranges.range[0].begin
port_end = resouce.ranges.range[0].end
print "Received offer %s of %s with cpus: %s and mem: %s" % (
offer.id.value, offer.hostname, offerCpus, offerMems)
leftCPUs = offerCpus
leftMems = offerMems
if self.grpc_started is False and offer.hostname == "node1" and offerCpus > 0.5 and offerMems > 128:
self.pendingInstances.append("master_p")
print(self.pendingInstances)
task = mesos_pb2.TaskInfo()
task.task_id.value = "master_p"
task.slave_id.value = offer.slave_id.value
task.name = "master_p"
dockerinfo = mesos_pb2.ContainerInfo.DockerInfo()
dockerinfo.image = self.imageName
dockerinfo.network = 4
dockerinfo.force_pull_image = False
docker_parameters = dockerinfo.parameters.add()
docker_parameters.key = "interactive"
docker_parameters.value = "true"
port_mapping = dockerinfo.port_mappings.add()
port_mapping.host_port = port_begin
port_mapping.container_port = 50051
containerinfo = mesos_pb2.ContainerInfo()
containerinfo.type = 1
# containerinfo.hostname = "node%d" % tid
networkinfo = containerinfo.network_infos.add()
networkinfo.name = "my-overlay1"
# ip_address = networkinfo.ip_addresses.add()
# ip_address.ip_address = "10.0.1.02%d" % tid
volume = containerinfo.volumes.add()
volume.container_path = "/test_data"
volume.host_path = "/root/docker_study/test_data"
volume.mode = 1
volume_trading = containerinfo.volumes.add()
volume_trading.container_path = "/trading_data"
volume_trading.host_path = "/root/trading_data"
volume_trading.mode = 1
# ttyinfo = mesos_pb2.TTYInfo()
# ttyinfo.window_size.rows = 200
# ttyinfo.window_size.columns = 200
command = mesos_pb2.CommandInfo()
command.value = '/usr/sbin/service ssh restart && sleep 600'
command.shell = True
task.command.MergeFrom(command)
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = 0.5
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = 128
port_r = task.resources.add()
port_r.name = "ports"
port_r.type = mesos_pb2.Value.RANGES
range_s = mesos_pb2.Value.Range()
range_s.begin = port_begin
range_s.end = port_begin
self.grpc_port = port_begin
port_r.ranges.range.append(range_s)
# containerinfo.tty_info.MergeFrom(ttyinfo)
containerinfo.docker.MergeFrom(dockerinfo)
task.container.MergeFrom(containerinfo)
tasks.append(task)
self.taskLaunched += 1
elif self.grpc_started is True and len(self.pendingInstances)+len(self.runningInstances)<=TOTAL_TASKS+1 and\
offer.hostname=="node2":
while leftCPUs >= TASK_CPUS and leftMems >= TASK_MEMS:
tid = self.taskLaunched
task = mesos_pb2.TaskInfo()
task.task_id.value = str(tid)
task.slave_id.value = offer.slave_id.value
task.name = "task_%d" % self.taskLaunched
self.pendingInstances.append(str(tid))
dockerinfo = mesos_pb2.ContainerInfo.DockerInfo()
dockerinfo.image = self.imageName
dockerinfo.network = 4
dockerinfo.force_pull_image = False
docker_parameters = dockerinfo.parameters.add()
docker_parameters.key = "interactive"
docker_parameters.value = "true"
containerinfo = mesos_pb2.ContainerInfo()
containerinfo.type = 1
# containerinfo.hostname = "node%d" % tid
networkinfo = containerinfo.network_infos.add()
networkinfo.name = "my-overlay1"
# ip_address = networkinfo.ip_addresses.add()
# ip_address.ip_address = "10.0.1.02%d" % tid
volume = containerinfo.volumes.add()
volume.container_path = "/test_data"
volume.host_path = "/root/docker_study/test_data"
volume.mode = 1
volume_trading = containerinfo.volumes.add()
volume_trading.container_path = "/trading_data"
volume_trading.host_path = "/root/trading_data"
volume_trading.mode = 1
# ttyinfo = mesos_pb2.TTYInfo()
# ttyinfo.window_size.rows = 200
# ttyinfo.window_size.columns = 200
command = mesos_pb2.CommandInfo()
command.value = '/usr/sbin/service ssh restart && sleep 600'
command.shell = True
task.command.MergeFrom(command)
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = TASK_CPUS
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = TASK_MEMS
# containerinfo.tty_info.MergeFrom(ttyinfo)
containerinfo.docker.MergeFrom(dockerinfo)
task.container.MergeFrom(containerinfo)
tasks.append(task)
self.taskLaunched += 1
leftCPUs -= TASK_CPUS
leftMems -= TASK_MEMS
operation = mesos_pb2.Offer.Operation()
operation.type = mesos_pb2.Offer.Operation.LAUNCH
operation.launch.task_infos.extend(tasks)
driver.acceptOffers([offer.id], [operation])
driver.reviveOffers()
