Exemple #1
0
//
// Activate network by sending out all IIPs
//
func (r *Runtime) Activate() {
	if len(r.iips) > 0 {
		// Connect to ports of IIP (so the components can resume execution)
		senders := make([]*zmq.Socket, len(r.iips))
		for i, iip := range r.iips {
			senders[i], _ = zmq.NewSocket(zmq.PUSH)
			senders[i].Connect(iip.Socket)
		}
		defer func() {
			for i := range senders {
				senders[i].Close()
			}
		}()

		// Give some time to the network to deploy
		//TODO: replace this with info from processes (check all entries in processes hash map)
		time.Sleep(2 * time.Second)

		// Send IIPs out!
		log.SystemOutput("Activating processes by sending IIPs...")
		for i, iip := range r.iips {
			log.SystemOutput(fmt.Sprintf("Sending '%s' to socket '%s'", iip.Payload, iip.Socket))
			senders[i].SendMessageDontwait(NewPacket([]byte(iip.Payload)))
		}
	}
}
Exemple #2
0
//
// Start the network based on the current graph
//
func (r *Runtime) Start(dry bool) {
	err := r.prepareProcesses()
	if err != nil {
		log.ErrorOutput("Failed to create a process: " + err.Error())
		r.Done <- true
		return
	}

	if len(r.processes) == 0 {
		log.SystemOutput("No processes to start")
		r.Done <- true
		return
	}

	if dry {
		r.Done <- true
		return
	}

	log.SystemOutput("Starting processes...")
	idx := 0
	for name, ps := range r.processes {
		shutdownMutex.Lock()
		procWaitGroup.Add(1)

		ps.Stdin = nil
		ps.Stdout = log.DefaultFactory.CreateLog(name, idx, false)
		ps.Stderr = log.DefaultFactory.CreateLog(name, idx, true)
		ps.Start()

		go func(name string, ps *Process) {
			ps.Wait()
			procWaitGroup.Done()
			delete(r.processes, name)
			fmt.Fprintln(ps.Stdout, "Stopped")

			// Shutdown when no processes left, otherwise network should collapse
			// in a cascade way...
			//if !ps.cmd.ProcessState.Success() || len(r.processes) == 0 {
			if len(r.processes) == 0 {
				fmt.Fprintln(ps.Stdout, "I was the last running process. Calling runtime to SHUTDOWN")
				r.Shutdown()
			}

		}(name, ps)

		shutdownMutex.Unlock()

		idx++
	}

	r.Activate()

	procWaitGroup.Wait()
}
Exemple #3
0
//
// Shutdown the network
//
func (r *Runtime) Shutdown() {
	shutdownMutex.Lock()
	log.SystemOutput("Shutdown...")

	for name, ps := range r.processes {
		log.SystemOutput(fmt.Sprintf("terminating %s", name))
		ps.cmd.Process.Signal(os.Kill)
	}

	shutdownMutex.Unlock()
	os.Exit(1)
}
Exemple #4
0
//
// Shutdown the network
//
func (r *Runtime) Shutdown() {
	log.SystemOutput("Shutdown...")

	shutdownMutex.Lock()
	for name, ps := range r.processes {
		log.SystemOutput(fmt.Sprintf("sending SIGTERM to %s", name))
		ps.Signal(syscall.SIGTERM)
	}

	if len(r.processes) == 0 {
		r.Done <- true
	}

	go func() {
		time.Sleep(3 * time.Second)
		for name, ps := range r.processes {
			log.SystemOutput(fmt.Sprintf("sending SIGKILL to %s", name))
			ps.Signal(syscall.SIGKILL)
		}
		r.Done <- true
	}()

	shutdownMutex.Unlock()
}