// Wait for existing requests to complete and shutdown service
func (s *Service) shutdown() {
if s.shuttingDown {
return
}
s.shuttingDown = true
s.doneGroup.Add(1)
s.rpcListener.Close()
s.doneChan <- true
s.activeRequests.Wait()
err := skynet.GetServiceManager().Remove(*s.ServiceInfo)
if err != nil {
log.Println(log.ERROR, "Failed to remove service: "+err.Error())
}
skynet.GetServiceManager().Shutdown()
s.Delegate.Stopped(s) // Call user defined callback
s.doneGroup.Done()
}
func StopDaemon(criteria *skynet.Criteria) {
hosts, err := skynet.GetServiceManager().ListHosts(criteria)
if err != nil {
log.Fatal(err)
}
var wait sync.WaitGroup
for _, host := range hosts {
wait.Add(1)
go func(host string) {
d := daemon.GetDaemonForHost(host)
in := daemon.StopRequest{}
out, err := d.Stop(in)
if err != nil {
fmt.Println("Returned Error: " + err.Error())
wait.Done()
return
}
if out.Ok {
fmt.Printf("Daemon stopped on host: %v\n", host)
} else {
fmt.Printf("Failed to stop daemon on host: %v\n", host)
}
wait.Done()
}(host)
}
wait.Wait()
}
func Stop(criteria *skynet.Criteria) {
instances, err := skynet.GetServiceManager().ListInstances(criteria)
if err != nil {
log.Fatal(err)
}
var wait sync.WaitGroup
for _, instance := range filterDaemon(instances) {
wait.Add(1)
go func(instance skynet.ServiceInfo) {
fmt.Println("Stopping: " + instance.UUID)
d := daemon.GetDaemonForService(&instance)
in := daemon.StopSubServiceRequest{
UUID: instance.UUID,
}
out, err := d.StopSubService(in)
if err != nil {
fmt.Println("Returned Error: " + err.Error())
wait.Done()
return
}
stopTemplate.Execute(os.Stdout, out)
wait.Done()
}(instance)
}
wait.Wait()
}
func SetLogLevel(criteria *skynet.Criteria, level string) {
instances, err := skynet.GetServiceManager().ListInstances(criteria)
if err != nil {
log.Fatal(err)
}
var wait sync.WaitGroup
for _, instance := range filterDaemon(instances) {
wait.Add(1)
go func(instance skynet.ServiceInfo) {
fmt.Println("Setting LogLevel to " + level + " for: " + instance.UUID)
d := daemon.GetDaemonForService(&instance)
in := daemon.SubServiceLogLevelRequest{
UUID: instance.UUID,
Level: level,
}
out, err := d.SubServiceLogLevel(in)
if err != nil {
fmt.Println("Returned Error: " + err.Error())
wait.Done()
return
}
logLevelTemplate.Execute(os.Stdout, out)
wait.Done()
}(instance)
}
wait.Wait()
}
func getInstances(c *skynet.Criteria) []skynet.ServiceInfo {
instances, err := skynet.GetServiceManager().ListInstances(c)
if err != nil {
log.Fatal(err)
}
return instances
}
func getHosts(c *skynet.Criteria) []string {
hosts, err := skynet.GetServiceManager().ListHosts(c)
if err != nil {
log.Fatal(err)
}
return hosts
}
func getServices(c *skynet.Criteria) []string {
services, err := skynet.GetServiceManager().ListServices(c)
if err != nil {
log.Fatal(err)
}
return services
}
func getVersions(c *skynet.Criteria) []string {
versions, err := skynet.GetServiceManager().ListVersions(c)
if err != nil {
log.Fatal(err)
}
return versions
}
func addServiceClient(sc ServiceClientProvider) {
serviceClients = append(serviceClients, sc)
instances := skynet.GetServiceManager().Watch(sc, instanceWatcher)
for _, i := range instances {
pool.AddInstance(i)
sc.Notify(skynet.InstanceNotification{Type: skynet.InstanceAdded, Service: i})
}
}
func (s *Service) unregister() {
// this version must be run from the mux() goroutine
if !s.Registered {
return
}
err := skynet.GetServiceManager().Unregister(s.UUID)
if err != nil {
log.Println(log.ERROR, "Failed to unregister service: "+err.Error())
}
s.Registered = false
log.Printf(log.INFO, "%+v\n", ServiceUnregistered{s.ServiceInfo})
s.Delegate.Unregistered(s) // Call user defined callback
}
// Starts your skynet service, including binding to ports. Optionally register for requests at the same time. Returns a sync.WaitGroup that will block until all requests have finished
func (s *Service) Start() (done *sync.WaitGroup) {
bindWait := &sync.WaitGroup{}
bindWait.Add(1)
go s.listen(s.ServiceAddr, bindWait)
// Watch signals for shutdown
c := make(chan os.Signal, 1)
go watchSignals(c, s)
s.doneChan = make(chan bool, 1)
// We must block here, we don't want to register, until we've actually bound to an ip:port
bindWait.Wait()
s.doneGroup = &sync.WaitGroup{}
s.doneGroup.Add(1)
go func() {
s.mux()
s.doneGroup.Done()
}()
done = s.doneGroup
if r, err := config.Bool(s.Name, s.Version, "service.register"); err == nil {
s.Registered = r
}
err := skynet.GetServiceManager().Add(*s.ServiceInfo)
if err != nil {
log.Println(log.ERROR, "Failed to add service: "+err.Error())
}
if s.Registered {
s.Register()
}
go s.Delegate.Started(s) // Call user defined callback
if s.ServiceInfo.Registered {
go s.Delegate.Registered(s) // Call user defined callback
}
return
}
func Start(criteria *skynet.Criteria, args []string) {
if len(args) < 1 {
fmt.Println("Please provide a service name 'sky start binaryName'")
return
}
hosts, err := skynet.GetServiceManager().ListHosts(criteria)
if err != nil {
log.Fatal(err)
}
var wait sync.WaitGroup
for _, host := range hosts {
wait.Add(1)
go func(host string) {
fmt.Println("Starting on host: " + host)
d := daemon.GetDaemonForHost(host)
in := daemon.StartSubServiceRequest{
BinaryName: args[0],
Args: shellquote.Join(args[1:]...),
// TODO: maybe an optional flag to change this?
Registered: true,
}
out, err := d.StartSubService(in)
if err != nil {
fmt.Println("Returned Error: " + err.Error())
wait.Done()
return
}
startTemplate.Execute(os.Stdout, out)
wait.Done()
}(host)
}
wait.Wait()
}
func (s *SkynetDaemon) cleanupHost(daemonUUID string) (err error) {
sm := skynet.GetServiceManager()
c := skynet.Criteria{}
c.AddHost(s.Service.ServiceInfo.ServiceAddr.IPAddress)
var instances []skynet.ServiceInfo
instances, err = sm.ListInstances(&c)
if err != nil {
return
}
for _, i := range instances {
if i.UUID != daemonUUID {
sm.Remove(i)
}
}
return
}
func SetDaemonLogLevel(criteria *skynet.Criteria, level string) {
hosts, err := skynet.GetServiceManager().ListHosts(criteria)
if err != nil {
log.Fatal(err)
}
var wait sync.WaitGroup
for _, host := range hosts {
wait.Add(1)
go func(host string) {
d := daemon.GetDaemonForHost(host)
in := daemon.LogLevelRequest{
Level: level,
}
out, err := d.LogLevel(in)
if err != nil {
fmt.Println("Returned Error: " + err.Error())
wait.Done()
return
}
if out.Ok {
fmt.Printf("Set daemon log level to %v on host: %v\n", level, host)
} else {
fmt.Printf("Failed to set daemon log level to %v on host: %v\n", level, host)
}
wait.Done()
}(host)
}
wait.Wait()
}
