lib/agent/apiv1.go

   1 /*
   2  * Copyright (C) 2017-2019 "IoT.bzh"
   3  * Author Sebastien Douheret <sebastien@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package agent
  19
  20 import (
  21         "fmt"
  22         "strconv"
  23         "strings"
  24
  25         "gerrit.automotivelinux.org/gerrit/src/xds/xds-agent.git/lib/xaapiv1"
  26         "gerrit.automotivelinux.org/gerrit/src/xds/xds-agent.git/lib/xdsconfig"
  27         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server.git/lib/xsapiv1"
  28         "github.com/gin-gonic/gin"
  29 )
  30
  31 const apiBaseURL = "/api/v1"
  32
  33 // APIService .
  34 type APIService struct {
  35         *Context
  36         apiRouter   *gin.RouterGroup
  37         serverIndex int
  38 }
  39
  40 // NewAPIV1 creates a new instance of API service
  41 func NewAPIV1(ctx *Context) *APIService {
  42         s := &APIService{
  43                 Context:     ctx,
  44                 apiRouter:   ctx.webServer.router.Group(apiBaseURL),
  45                 serverIndex: 0,
  46         }
  47
  48         s.apiRouter.GET("/version", s.getVersion)
  49
  50         s.apiRouter.GET("/config", s.getConfig)
  51         s.apiRouter.POST("/config", s.setConfig)
  52
  53         // s.apiRouter.GET("/browse", s.browseFS)
  54
  55         s.apiRouter.GET("/projects", s.getProjects)
  56         s.apiRouter.GET("/projects/:id", s.getProject)
  57         s.apiRouter.PUT("/projects/:id", s.updateProject)
  58         s.apiRouter.POST("/projects", s.addProject)
  59         s.apiRouter.POST("/projects/sync/:id", s.syncProject)
  60         s.apiRouter.DELETE("/projects/:id", s.delProject)
  61
  62         s.apiRouter.POST("/exec", s.execCmd)
  63         s.apiRouter.POST("/exec/:id", s.execCmd)
  64         s.apiRouter.POST("/signal", s.execSignalCmd)
  65
  66         s.apiRouter.GET("/events", s.eventsList)
  67         s.apiRouter.POST("/events/register", s.eventsRegister)
  68         s.apiRouter.POST("/events/unregister", s.eventsUnRegister)
  69
  70         s.apiRouter.GET("/monitoring/topo", s.getMonitoringTopo)
  71         s.apiRouter.POST("/monitoring/trace/start", s.startMonitoring)
  72         s.apiRouter.POST("/monitoring/trace/stop", s.stopMonitoring)
  73         s.apiRouter.POST("/monitoring/alc/start", s.StartLowCollector)
  74         s.apiRouter.POST("/monitoring/alc/stop", s.StopLowCollector)
  75         s.apiRouter.GET("/monitoring/alc/read", s.ReadLowCollector)
  76         s.apiRouter.POST("/monitoring/alc/reset", s.ResetLowCollector)
  77         return s
  78 }
  79
  80 // Stop Used to stop/close created services
  81 func (s *APIService) Stop() {
  82         for _, svr := range s.xdsServers {
  83                 svr.Close()
  84         }
  85 }
  86
  87 // AddXdsServer Add a new XDS Server to the list of a server
  88 func (s *APIService) AddXdsServer(cfg xdsconfig.XDSServerConf) (*XdsServer, error) {
  89         var svr *XdsServer
  90         var exist, tempoID bool
  91         tempoID = false
  92
  93         // First check if not already exist and update it
  94         if svr, exist = s.xdsServers[cfg.ID]; exist {
  95
  96                 // Update: Found, so just update some settings
  97                 svr.ConnRetry = cfg.ConnRetry
  98
  99                 tempoID = svr.IsTempoID()
 100                 if svr.Connected && !svr.Disabled && svr.BaseURL == cfg.URL && tempoID {
 101                         return svr, nil
 102                 }
 103
 104                 // URL differ or not connected, so need to reconnect
 105                 svr.BaseURL = cfg.URL
 106
 107         } else {
 108
 109                 // Create a new server object
 110                 cfg.URLIndex = strconv.Itoa(s.serverIndex)
 111                 s.serverIndex = s.serverIndex + 1
 112                 if cfg.APIBaseURL == "" {
 113                         cfg.APIBaseURL = apiBaseURL
 114                 }
 115                 if cfg.APIPartialURL == "" {
 116                         cfg.APIPartialURL = "/servers/" + cfg.URLIndex
 117                 }
 118
 119                 // Create a new XDS Server
 120                 svr = NewXdsServer(s.Context, cfg)
 121
 122                 svr.SetLoggerOutput(s.Config.LogVerboseOut)
 123
 124                 // Define API group for this XDS Server
 125                 grp := s.apiRouter.Group(svr.PartialURL)
 126                 svr.SetAPIRouterGroup(grp)
 127
 128                 // Define servers API processed locally
 129                 s.apiRouter.GET("/servers", s.getServersList)       // API /servers
 130                 svr.apiRouter.GET("", s.getServer)                  // API /servers/:id
 131                 svr.apiRouter.POST("/reconnect", s.reconnectServer) // API /servers/:id/reconnect
 132
 133                 // Declare passthrough API/routes
 134                 s.sdksPassthroughInit(svr)
 135                 s.targetsPassthroughInit(svr)
 136
 137                 // Register callback on Connection
 138                 svr.ConnectOn(func(server *XdsServer) error {
 139
 140                         // Add server to list
 141                         s.xdsServers[server.ID] = svr
 142
 143                         // Register events forwarder
 144                         if err := s.sdksEventsForwardInit(server); err != nil {
 145                                 s.Log.Errorf("XDS Server %v - sdk events forwarding error: %v", server.ID, err)
 146                         }
 147                         if err := s.targetsEventsForwardInit(server); err != nil {
 148                                 s.Log.Errorf("XDS Server %v - target events forwarding error: %v", server.ID, err)
 149                         }
 150                         if err := s.terminalsEventsForwardInit(server); err != nil {
 151                                 s.Log.Errorf("XDS Server %v - terminal events forwarding error: %v", server.ID, err)
 152                         }
 153
 154                         // Load projects
 155                         if err := s.projects.Init(server); err != nil {
 156                                 s.Log.Errorf("XDS Server %v - project init error: %v", server.ID, err)
 157                         }
 158
 159                         // Registered to all events
 160                         if err := server.EventRegister(xsapiv1.EVTAll, ""); err != nil {
 161                                 s.Log.Errorf("XDS Server %v - register all events error: %v", server.ID, err)
 162                         }
 163
 164                         return nil
 165                 })
 166         }
 167
 168         // Established connection
 169         err := svr.Connect()
 170
 171         // Delete temporary ID with it has been replaced by right Server ID
 172         if tempoID && !svr.IsTempoID() {
 173                 delete(s.xdsServers, cfg.ID)
 174         }
 175
 176         return svr, err
 177 }
 178
 179 // DelXdsServer Delete an XDS Server from the list of a server
 180 func (s *APIService) DelXdsServer(id string) error {
 181         if _, exist := s.xdsServers[id]; !exist {
 182                 return fmt.Errorf("Unknown Server ID %s", id)
 183         }
 184         // Don't really delete, just disable it
 185         s.xdsServers[id].Close()
 186         return nil
 187 }
 188
 189 // UpdateXdsServer Update XDS Server configuration settings
 190 func (s *APIService) UpdateXdsServer(cfg xaapiv1.ServerCfg) error {
 191         if _, exist := s.xdsServers[cfg.ID]; !exist {
 192                 return fmt.Errorf("Unknown Server ID %s", cfg.ID)
 193         }
 194
 195         svr := s.xdsServers[cfg.ID]
 196
 197         // Update only some configurable fields
 198         svr.ConnRetry = cfg.ConnRetry
 199
 200         return nil
 201 }
 202
 203 // GetXdsServerFromURLIndex Retrieve XdsServer from URLIndex value
 204 func (s *APIService) GetXdsServerFromURLIndex(urlIdx string) *XdsServer {
 205         for _, svr := range s.xdsServers {
 206                 if svr.URLIndex == urlIdx {
 207                         return svr
 208                 }
 209         }
 210         return nil
 211 }
 212
 213 // ParamGetIndex Retrieve numerical parameter in request url
 214 func (s *APIService) ParamGetIndex(c *gin.Context) string {
 215         uri := c.Request.RequestURI
 216         for idx := strings.LastIndex(uri, "/"); idx > 0; {
 217                 id := uri[idx+1:]
 218                 if _, err := strconv.Atoi(id); err == nil {
 219                         return id
 220                 }
 221                 uri = uri[:idx]
 222                 idx = strings.LastIndex(uri, "/")
 223         }
 224         return ""
 225 }