Beispiel #1
0
func (riakNode *RiakNode) setCoordinatedData(child *metamgr.ZkNode, config templateData) {
	coordinatedData := common.CoordinatedData{
		NodeName:      riakNode.taskData.FullyQualifiedNodeName,
		DisterlPort:   int(config.DisterlPort),
		PBPort:        int(config.PBPort),
		HTTPPort:      int(config.HTTPPort),
		Hostname:      riakNode.taskData.Host,
		ClusterName:   riakNode.taskData.ClusterName,
		FrameworkName: riakNode.taskData.FrameworkName,
	}
	cdBytes, err := coordinatedData.Serialize()
	if err != nil {
		log.Panic("Could not serialize coordinated data	", err)
	}
	child.SetData(cdBytes)
}
Beispiel #2
0
func (riakNode *RiakNode) runLoop(child *metamgr.ZkNode) {

	runStatus := &mesos.TaskStatus{
		TaskId: riakNode.taskInfo.GetTaskId(),
		State:  mesos.TaskState_TASK_RUNNING.Enum(),
	}
	_, err := riakNode.executor.Driver.SendStatusUpdate(runStatus)
	if err != nil {
		log.Panic("Got error", err)
	}

	waitChan := riakNode.pm.Listen()
	select {
	case <-waitChan:
		{
			log.Info("Riak Died, failing")
			// Just in case, cleanup
			// This means the node died :(
			runStatus = &mesos.TaskStatus{
				TaskId: riakNode.taskInfo.GetTaskId(),
				State:  mesos.TaskState_TASK_FAILED.Enum(),
			}
			_, err = riakNode.executor.Driver.SendStatusUpdate(runStatus)
			if err != nil {
				log.Panic("Got error", err)
			}
		}
	case <-riakNode.finishChan:
		{
			log.Info("Finish channel says to shut down Riak")
			riakNode.pm.TearDown()
			runStatus = &mesos.TaskStatus{
				TaskId: riakNode.taskInfo.GetTaskId(),
				State:  mesos.TaskState_TASK_FINISHED.Enum(),
			}
			_, err = riakNode.executor.Driver.SendStatusUpdate(runStatus)
			if err != nil {
				log.Panic("Got error", err)
			}
		}
	}
	child.Delete()
	time.Sleep(15 * time.Second)
	log.Info("Shutting down")
	riakNode.executor.Driver.Stop()

}
Beispiel #3
0
func (riakNode *RiakNode) runLoop(child *metamgr.ZkNode) {

	var runStatus *mesos.TaskStatus
	var err error

	// runStatus := &mesos.TaskStatus{
	// 	TaskId: riakNode.taskInfo.GetTaskId(),
	// 	State:  mesos.TaskState_TASK_RUNNING.Enum(),
	// }
	// _, err := riakNode.executor.Driver.SendStatusUpdate(runStatus)
	// if err != nil {
	// 	log.Panic("Got error", err)
	// }

	waitChan := riakNode.pm.Listen()
	select {
	case <-waitChan:
		{
			log.Infof("Riak Died, finishing with status: %+v", riakNode.killStatus)
			_, err = riakNode.executor.Driver.SendStatusUpdate(riakNode.killStatus)
			if err != nil {
				log.Panic("Got error", err)
			}
		}
	case <-riakNode.finishChan:
		{
			log.Info("Finish channel says to shut down Riak")
			riakNode.pm.TearDown()
			runStatus = &mesos.TaskStatus{
				TaskId: riakNode.taskInfo.GetTaskId(),
				State:  mesos.TaskState_TASK_FINISHED.Enum(),
			}
			riakNode.killStatus = runStatus
			_, err = riakNode.executor.Driver.SendStatusUpdate(riakNode.killStatus)
			if err != nil {
				log.Panic("Got error", err)
			}
		}
	}
	child.Delete()
	time.Sleep(15 * time.Second)
	log.Info("Shutting down")
	riakNode.executor.Driver.Stop()

}
Beispiel #4
0
func GetSchedulerState(mm *metadata_manager.MetadataManager) *SchedulerState {
	var zkNode *metadata_manager.ZkNode
	var err error
	zkNode, err = mm.GetRootNode().GetChild("SchedulerState")
	if err == zk.ErrNoNode {
		ess := emptySchedulerState()
		zkNode, err = mm.GetRootNode().MakeChildWithData("SchedulerState", ess.serialize(), false)
		if err != nil {
			log.Panic(err)
		}
		ess.zkNode = zkNode
		return ess
	} else {
		ss, err := DeserializeSchedulerState(zkNode.GetData())
		if err != nil {
			log.Panic(err)
		}
		ss.zkNode = zkNode
		return ss
	}
}