func (self *manager) AcceptOffer(offerId *mesosproto.OfferID, slaveId *mesosproto.SlaveID, taskRequest *managerInterface.Task) {
glog.Infoln("Working on: ", taskRequest.TaskInfo)
taskRequest.TaskInfo.SlaveId = slaveId
message := &mesosproto.LaunchTasksMessage{
FrameworkId: &mesosproto.FrameworkID{Value: &self.frameworkId},
OfferIds: []*mesosproto.OfferID{offerId},
Tasks: []*mesosproto.TaskInfo{taskRequest.TaskInfo},
Filters: &mesosproto.Filters{},
}
messagePackage := communication.NewMessage(self.masterUPID, message, nil)
if err := communication.SendMessageToMesos(self.selfUPID, messagePackage); err != nil {
glog.Errorf("Failed to send AcceptOffer message: %v\n", err)
} else {
taskRequest.RequestSent = true
}
}
func (self *manager) handleRunDockerImageImpl(task *managerInterface.Task) {
if self.scheduler != nil && self.scheduler.OverwriteTaskAttributes != nil {
self.scheduler.OverwriteTaskAttributes(self, task)
}
id := fmt.Sprintf("%v-%v", strings.Replace(task.ID, " ", "", -1), time.Now().UnixNano())
memory := float64(task.Mem)
portResources := []*mesosproto.Value_Range{}
cpus := float64(0.1)
if task.Cpus > 0 {
cpus = task.Cpus
}
dockerInfo := &mesosproto.ContainerInfo_DockerInfo{
Image: &task.DockerImage,
}
containerInfo := &mesosproto.ContainerInfo{
Type: mesosproto.ContainerInfo_DOCKER.Enum(),
Docker: dockerInfo,
}
for _, volume := range task.Volumes {
mode := mesosproto.Volume_RW
if volume.Mode == "ro" {
mode = mesosproto.Volume_RO
}
containerInfo.Volumes = append(containerInfo.Volumes, &mesosproto.Volume{
ContainerPath: &volume.ContainerPath,
HostPath: &volume.HostPath,
Mode: &mode,
})
}
for _, port := range task.Ports {
dockerInfo.PortMappings = append(dockerInfo.PortMappings, &mesosproto.ContainerInfo_DockerInfo_PortMapping{
ContainerPort: &port.ContainerPort,
HostPort: &port.HostPort,
})
portResources = append(portResources, &mesosproto.Value_Range{
Begin: proto.Uint64(uint64(port.HostPort)),
End: proto.Uint64(uint64(port.HostPort)),
})
}
if len(task.Ports) > 0 {
// port mapping only works in bridge mode
dockerInfo.Network = mesosproto.ContainerInfo_DockerInfo_BRIDGE.Enum()
} else if len(task.NetworkMode) > 0 {
if task.NetworkMode == managerInterface.NETWORK_MODE_BRIDGE {
dockerInfo.Network = mesosproto.ContainerInfo_DockerInfo_BRIDGE.Enum()
} else if task.NetworkMode == managerInterface.NETWORK_MODE_HOST {
dockerInfo.Network = mesosproto.ContainerInfo_DockerInfo_HOST.Enum()
} else if task.NetworkMode == managerInterface.NETWORK_MODE_NONE {
dockerInfo.Network = mesosproto.ContainerInfo_DockerInfo_NONE.Enum()
}
}
commandInfo := &mesosproto.CommandInfo{
Shell: proto.Bool(false),
}
if len(task.Arguments) > 0 {
for _, argument := range task.Arguments {
commandInfo.Arguments = append(commandInfo.Arguments, argument)
}
}
resources := []*mesosproto.Resource{
&mesosproto.Resource{
Name: proto.String("mem"),
Scalar: &mesosproto.Value_Scalar{Value: &memory},
Type: mesosproto.Value_SCALAR.Enum(),
},
&mesosproto.Resource{
Name: proto.String("cpus"),
Scalar: &mesosproto.Value_Scalar{Value: &cpus},
Type: mesosproto.Value_SCALAR.Enum(),
},
}
if len(task.Ports) > 0 {
resources = append(resources,
&mesosproto.Resource{
Name: proto.String("ports"),
Ranges: &mesosproto.Value_Ranges{Range: portResources},
Type: mesosproto.Value_RANGES.Enum(),
},
)
}
taskInfo := &mesosproto.TaskInfo{
Name: &id,
TaskId: &mesosproto.TaskID{Value: &id},
Container: containerInfo,
Command: commandInfo,
Resources: resources,
}
task.InternalID = id
task.CreatedAt = time.Now().Unix()
task.TaskInfo = taskInfo
task.RequestSent = false
glog.Infoln("Task: ", task)
taskRegistry.Register(id, task)
}
