示例#1
0
// Daemon will run and maintain skynet services.
//
// Daemon will run the "SkynetDeployment" service, which can be used
// to remotely spawn new services on the host.
func main() {
	si := skynet.NewServiceInfo("SkynetDaemon", "2.0.0")
	deployment := NewSkynetDaemon()

	s := service.CreateService(deployment, si)

	deployment.Service = s

	// handle panic so that we remove ourselves from the pool in case of catastrophic failure
	defer func() {
		s.Shutdown()
		deployment.closeStateFile()

		if err := recover(); err != nil {
			e := err.(error)
			log.Fatal("Unrecovered error occured: " + e.Error())
		}
	}()

	// Collect Host metrics
	statTicker := time.Tick((5 * time.Second))
	go func() {
		for _ = range statTicker {
			deployment.updateHostStats(si.ServiceAddr.IPAddress)
		}
	}()

	// If we pass false here service will not be Registered
	// we could do other work/tasks by implementing the Started method and calling Register() when we're ready
	s.Start().Wait()
}
示例#2
0
func main() {
	tutorial := &TutorialService{}
	config, _ := skynet.GetServiceConfig()

	config.Name = "TutorialService"
	config.Version = "1"
	config.Region = "Development"

	service := service.CreateService(tutorial, config)

	defer func() {
		service.Shutdown()
	}()

	waiter := service.Start(true)
	waiter.Wait()
}
示例#3
0
func main() {
	testService := NewTestService()

	config, _ := skynet.GetServiceConfig()

	if config.Name == "" {
		config.Name = "TestService"
	}

	if config.Version == "" {
		config.Version = "1"
	}

	if config.Region == "unknown" {
		config.Region = "Clearwater"
	}

	var err error
	mlogger, err := skynet.NewMongoSemanticLogger("localhost", "skynet",
		"log", config.UUID)
	clogger := skynet.NewConsoleSemanticLogger("TestService", os.Stdout)
	testService.Log = skynet.NewMultiSemanticLogger(mlogger, clogger)
	config.Log = testService.Log
	if err != nil {
		config.Log.Trace("Could not connect to mongo db for logging")
	}
	service := service.CreateService(testService, config)

	// handle panic so that we remove ourselves from the pool in case
	// of catastrophic failure
	defer func() {
		service.Shutdown()
		if err := recover(); err != nil {
			log.Println("Unrecovered error occured: ", err)
		}
	}()

	// If we pass false here service will not be Registered we could
	// do other work/tasks by implementing the Started method and
	// calling Register() when we're ready
	waiter := service.Start(true)

	// waiting on the sync.WaitGroup returned by service.Start() will
	// wait for the service to finish running.
	waiter.Wait()
}
示例#4
0
// Daemon will run and maintain skynet services.
//
// Daemon will initially deploy those specified in the file given in
// the "-config" option
//
// Daemon will run the "SkynetDeployment" service, which can be used
// to remotely spawn new services on the host.
func main() {
	config, args := skynet.GetServiceConfig()

	config.Name = "SkynetDaemon"
	config.Version = "1"

	// skydaemon does not listen to admin RPC requests
	config.AdminAddr = nil

	var err error
	mlogger, err := skynet.NewMongoSemanticLogger(config.MongoConfig.MongoHosts, "skynet",
		"log", config.UUID)
	clogger := skynet.NewConsoleSemanticLogger("skydaemon", os.Stdout)
	config.Log = skynet.NewMultiSemanticLogger(mlogger, clogger)
	if err != nil {
		config.Log.Trace("Could not connect to mongo db for logging")
	}

	deployment := &SkynetDaemon{
		Log:      config.Log,
		Services: map[string]*SubService{},
	}

	s := service.CreateService(deployment, config)

	deployment.Service = s

	// handle panic so that we remove ourselves from the pool in case of catastrophic failure
	/*defer func() {
		s.Shutdown()
		if err := recover(); err != nil {
			log.Println("Unrecovered error occured: ", err)
		}
	}()*/

	if len(args) == 1 {
		err := deployConfig(deployment, args[0])
		if err != nil {
			config.Log.Error(err.Error())
		}
	}

	// If we pass false here service will not be Registered
	// we could do other work/tasks by implementing the Started method and calling Register() when we're ready
	s.Start(true).Wait()
}
示例#5
0
func main() {
	testService := NewTestService()

	serviceInfo := skynet.NewServiceInfo("TestService", "1.0.0")

	service := service.CreateService(testService, serviceInfo)

	// handle panic so that we remove ourselves from the pool in case
	// of catastrophic failure
	defer func() {
		service.Shutdown()
		if err := recover(); err != nil {
			log.Panic("Unrecovered error occured: ", err)
		}
	}()

	waiter := service.Start()

	// waiting on the sync.WaitGroup returned by service.Start() will
	// wait for the service to finish running.
	waiter.Wait()
}