- Clean up unnecessary code

diff --git a/src/servicemgr/service_agent.go b/src/servicemgr/service_agent.go
deleted file mode 100644 (file)
index d4a9966..0000000
--- a/src/servicemgr/service_agent.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package servicemgr
-
-import (
-       "encoding/json"
-       "fmt"
-       "log"
-       "os/exec"
-       "time"
-)
-
-func makeTime() string {
-       t := time.Now()
-       return t.Format(time.RFC3339)
-}
-
-// Create function
-func Create(serviceParam map[string]interface{}) []byte {
-       instanceCount := int(serviceParam["Count"].(float64))
-
-       ret := ServiceCreationResponse{}
-       ret.Status = ConstServiceFound
-       ret.ServiceList = make([]ServiceCreationResponseItem, instanceCount)
-
-       for index := 0; index < instanceCount; index++ {
-               var cmd *exec.Cmd
-
-               id, _, _ := CreateServiceMap(cmd, serviceParam["ServiceBinPath"].(string)+serviceParam["ServiceName"].(string), serviceParam["AppName"].(string))
-
-               serviceInfo := ServiceCreationResponseItem{id, makeTime()}
-               ret.ServiceList[index] = serviceInfo
-       }
-
-       sibytes, _ := json.Marshal(ret)
-       return sibytes
-}
-
-// Run is for executing service
-func Run(distService map[string]interface{}, serviceID uint64) {
-       serviceName, err := GetServiceName(serviceID)
-       if err != nil {
-               log.Println(err.Error())
-               return
-       }
-
-       userArgs := distService["UserArgs"].([]interface{})
-       args := make([]string, len(userArgs))
-
-       for _, userParam := range userArgs {
-               args = append(args, fmt.Sprint(userParam))
-       }
-
-       args = append(args, "--remote")
-
-       notificationTargetURL := distService["NotificationTargetURL"].(string)
-
-       service := Service{serviceID, serviceName, args, notificationTargetURL}
-       service.execute()
-}
-
-// Delete is for removing service
-func Delete(serviceID uint64) (err error) {
-       cmd, err := GetCmd(serviceID)
-       if err != nil {
-               return
-       }
-
-       if cmd.ProcessState.Exited() == false {
-               err = cmd.Process.Kill()
-               if err != nil {
-                       log.Println(err.Error())
-               }
-       }
-
-       return
-}

diff --git a/src/servicemgr/service_discovery.go b/src/servicemgr/service_discovery.go
deleted file mode 100644 (file)
index 1489c6f..0000000
--- a/src/servicemgr/service_discovery.go
+++ /dev/null
@@ -1,251 +0,0 @@
-package servicemgr
-
-import (
-       "context"
-       "fmt"
-       "strconv"
-       "strings"
-       "time"
-
-       "github.com/grandcat/zeroconf"
-)
-
-const (
-       // pass & fail public enum
-       Fail = 0
-       Pass = 1
-
-       // service type for ochestration.
-       serviceType = "_ochestration._tcp"
-       servicePort = 5737
-)
-
-var exits = make(map[uint64]chan int)
-
-func RegisterService(appName string, serviceID uint64, serviceName string, status string, ret chan error) {
-       if appName == "" {
-               ret <- fmt.Errorf("Missing app name")
-               return
-       }
-
-       if serviceName == "" {
-               ret <- fmt.Errorf("Missing service name")
-               return
-       }
-
-       if exits[serviceID] != nil {
-               ret <- fmt.Errorf("Service id is duplicated")
-               return
-       }
-
-       if status == "" {
-               ret <- fmt.Errorf("Missing service status")
-               return
-       }
-
-       appName = appName + "+" + strconv.FormatUint(serviceID, 10)
-       domain := "local"
-       text := []string{strconv.FormatUint(serviceID, 10), serviceName, status}
-       server, err := zeroconf.Register(appName, serviceType, domain, servicePort, text, nil)
-       if err != nil {
-               ret <- err
-               return
-       }
-       defer server.Shutdown()
-
-       exits[serviceID] = make(chan int)
-       ret <- nil
-
-       select {
-       case <-exits[serviceID]:
-               fmt.Println("Service has been terminated")
-       }
-}
-
-func RemoveService(id uint64) error {
-       done := make(chan int)
-
-       if exits[id] == nil {
-               return fmt.Errorf("Service id is invalid")
-       }
-
-       go func() {
-               exits[id] <- Pass
-               done <- Pass
-       }()
-
-       select {
-       case <-done:
-               delete(exits, id)
-       }
-       return nil
-}
-
-func ServiceList() ([]AppReturnInfo, error) {
-       domain := "local"
-
-       resolver, err := zeroconf.NewResolver(nil)
-       if err != nil {
-               return nil, err
-       }
-
-       var data = make(map[string][]ServiceReturnInfo) //data[appname]
-       entries := make(chan *zeroconf.ServiceEntry)
-       go func(results <-chan *zeroconf.ServiceEntry) {
-               for entry := range results {
-                       appName := strings.Split(entry.Instance, "+")[0]
-                       var services []ServiceReturnInfo
-                       if data[appName] != nil {
-                               services = data[appName]
-                       }
-
-                       strID := entry.Text[0]
-                       if id, err := strconv.ParseUint(strID, 10, 64); err == nil {
-                               services = append(services, ServiceReturnInfo{
-                                       ServiceID:   id,
-                                       ServiceName: entry.Text[1],
-                                       Status:      entry.Text[2],
-                                       DeviceIP:    entry.AddrIPv4[0].String()})
-                       }
-                       data[appName] = services
-               }
-       }(entries)
-
-       ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(1))
-       defer cancel()
-       err = resolver.Browse(ctx, serviceType, domain, entries)
-       if err != nil {
-               return nil, err
-       }
-       <-ctx.Done()
-
-       var ret []AppReturnInfo
-       for key, value := range data {
-               ret = append(ret, AppReturnInfo{
-                       AppName:     key,
-                       ServiceList: value})
-       }
-
-       return ret, nil
-}
-
-func FindServiceByName(name string) (AppReturnInfo, error) {
-       if name == "" {
-               return AppReturnInfo{}, fmt.Errorf("App name is invalid")
-       }
-
-       domain := "local"
-       resolver, err := zeroconf.NewResolver(nil)
-       if err != nil {
-               return AppReturnInfo{}, err
-       }
-
-       app := AppReturnInfo{
-               AppName: name}
-
-       entries := make(chan *zeroconf.ServiceEntry)
-       go func(results <-chan *zeroconf.ServiceEntry) {
-               for entry := range results {
-                       strID := entry.Text[0]
-                       if id, err := strconv.ParseUint(strID, 10, 64); err == nil &&
-                               name == strings.Split(entry.Instance, "+")[0] {
-                               app.ServiceList = append(app.ServiceList, ServiceReturnInfo{
-                                       ServiceID:   id,
-                                       ServiceName: entry.Text[1],
-                                       Status:      entry.Text[2],
-                                       DeviceIP:    entry.AddrIPv4[0].String()})
-                       }
-               }
-       }(entries)
-
-       ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(1))
-       defer cancel()
-       err = resolver.Browse(ctx, serviceType, domain, entries)
-       if err != nil {
-               return AppReturnInfo{}, err
-       }
-
-       <-ctx.Done()
-       return app, nil
-}
-
-func FindServiceByID(serviceID uint64) (ServiceReturnInfo, error) {
-       domain := "local"
-
-       resolver, err := zeroconf.NewResolver(nil)
-       if err != nil {
-               return ServiceReturnInfo{}, err
-       }
-
-       ctx, cancel := context.WithCancel(context.Background())
-       defer cancel()
-
-       var ret ServiceReturnInfo
-       entries := make(chan *zeroconf.ServiceEntry)
-       go func(results <-chan *zeroconf.ServiceEntry) {
-               for entry := range results {
-                       if strconv.FormatUint(serviceID, 10) == entry.Text[0] {
-                               ret.ServiceID = serviceID
-                               ret.ServiceName = entry.Text[1]
-                               ret.Status = entry.Text[2]
-                               ret.DeviceIP = entry.AddrIPv4[0].String()
-                               cancel()
-                               return
-                       }
-               }
-       }(entries)
-
-       err = resolver.Browse(ctx, serviceType, domain, entries)
-       if err != nil {
-               return ServiceReturnInfo{}, err
-       }
-       <-ctx.Done()
-
-       return ret, nil
-}
-
-func ChangeServiceStatus(serviceID uint64, status string) error {
-       domain := "local"
-
-       resolver, err := zeroconf.NewResolver(nil)
-       if err != nil {
-               return err
-       }
-
-       ctx, cancel := context.WithCancel(context.Background())
-       defer cancel()
-
-       var appName string
-       var service ServiceReturnInfo
-       entries := make(chan *zeroconf.ServiceEntry)
-       go func(results <-chan *zeroconf.ServiceEntry) {
-               for entry := range results {
-                       if strconv.FormatUint(serviceID, 10) == entry.Text[0] {
-                               appName = strings.Split(entry.Instance, "+")[0]
-                               service.ServiceID = serviceID
-                               service.ServiceName = entry.Text[1]
-                               service.Status = entry.Text[2]
-                               service.DeviceIP = entry.AddrIPv4[0].String()
-                               cancel()
-                               return
-                       }
-               }
-       }(entries)
-
-       err = resolver.Browse(ctx, serviceType, domain, entries)
-       if err != nil {
-               return err
-       }
-       <-ctx.Done()
-
-       RemoveService(serviceID)
-
-       ret := make(chan error)
-       go RegisterService(appName, serviceID, service.ServiceName, status, ret)
-
-       if err := <-ret; err != nil {
-               return err
-       }
-
-       return nil
-}