lib/xdsserver/apiv1-targets.go

   1 /*
   2  * Copyright (C) 2018 "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 xdsserver
  19
  20 import (
  21         "net/http"
  22
  23         common "gerrit.automotivelinux.org/gerrit/src/xds/xds-common.git"
  24         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server.git/lib/xsapiv1"
  25         "github.com/gin-gonic/gin"
  26 )
  27
  28 /***
  29  * Targets
  30  ***/
  31
  32 // getTargets returns all targets configuration
  33 func (s *APIService) getTargets(c *gin.Context) {
  34         c.JSON(http.StatusOK, s.targets.GetConfigArr())
  35 }
  36
  37 // getTarget returns a specific target configuration
  38 func (s *APIService) getTarget(c *gin.Context) {
  39         id, err := s.targets.ResolveID(c.Param("id"))
  40         if err != nil {
  41                 common.APIError(c, err.Error())
  42                 return
  43         }
  44         f := s.targets.Get(id)
  45         if f == nil {
  46                 common.APIError(c, "Invalid id")
  47                 return
  48         }
  49
  50         c.JSON(http.StatusOK, (*f).GetConfig())
  51 }
  52
  53 // addTarget adds a new target to server config
  54 func (s *APIService) addTarget(c *gin.Context) {
  55         var cfgArg xsapiv1.TargetConfig
  56         if c.BindJSON(&cfgArg) != nil {
  57                 common.APIError(c, "Invalid arguments")
  58                 return
  59         }
  60
  61         // Retrieve session info
  62         sess := s.sessions.Get(c)
  63         if sess == nil {
  64                 common.APIError(c, "Unknown sessions")
  65                 return
  66         }
  67
  68         s.Log.Debugln("Add target config: ", cfgArg)
  69
  70         newTgt, err := s.targets.Add(cfgArg, sess)
  71         if err != nil {
  72                 common.APIError(c, err.Error())
  73                 return
  74         }
  75
  76         c.JSON(http.StatusOK, newTgt)
  77 }
  78
  79 // delTarget deletes target from server config
  80 func (s *APIService) delTarget(c *gin.Context) {
  81         id, err := s.targets.ResolveID(c.Param("id"))
  82         if err != nil {
  83                 common.APIError(c, err.Error())
  84                 return
  85         }
  86
  87         // Retrieve session info
  88         sess := s.sessions.Get(c)
  89         if sess == nil {
  90                 common.APIError(c, "Unknown sessions")
  91                 return
  92         }
  93
  94         s.Log.Debugln("Delete target id ", id)
  95
  96         delEntry, err := s.targets.Delete(id, sess)
  97         if err != nil {
  98                 common.APIError(c, err.Error())
  99                 return
 100         }
 101         c.JSON(http.StatusOK, delEntry)
 102 }
 103
 104 /***
 105  * Terminals
 106  ***/
 107 // getTgtTerms Get list of all terminals
 108 func (s *APIService) getTgtTerms(c *gin.Context) {
 109         id, err := s.targets.ResolveID(c.Param("id"))
 110         if err != nil {
 111                 common.APIError(c, err.Error())
 112                 return
 113         }
 114
 115         res, err := s.targets.GetTerminalsArr(id)
 116         if err != nil {
 117                 common.APIError(c, err.Error())
 118                 return
 119         }
 120
 121         c.JSON(http.StatusOK, res)
 122 }
 123
 124 // getTgtTerm Get info a terminal
 125 func (s *APIService) getTgtTerm(c *gin.Context) {
 126         id, tid, err := s._decodeTermArgs(c)
 127         if err != nil {
 128                 common.APIError(c, err.Error())
 129                 return
 130         }
 131
 132         iTerm, err := s.targets.GetTerminal(id, tid)
 133         if err != nil {
 134                 common.APIError(c, err.Error())
 135                 return
 136         }
 137
 138         c.JSON(http.StatusOK, (*iTerm).GetConfig())
 139 }
 140
 141 // createTgtTerm Create a new terminal
 142 func (s *APIService) createTgtTerm(c *gin.Context) {
 143         s.updateTgtTerm(c)
 144 }
 145
 146 // updateTgtTerm Update terminal config
 147 func (s *APIService) updateTgtTerm(c *gin.Context) {
 148         var cfgArg xsapiv1.TerminalConfig
 149
 150         tgtID, termID, err := s._decodeTermArgs(c)
 151         if tgtID == "" && err != nil {
 152                 common.APIError(c, err.Error())
 153                 return
 154         }
 155         if err := c.BindJSON(&cfgArg); err != nil {
 156                 common.APIError(c, "Invalid arguments")
 157                 return
 158         }
 159         if cfgArg.ID == "" {
 160                 cfgArg.ID = termID
 161         }
 162         if termID != "" && cfgArg.ID != termID {
 163                 common.APIError(c, "Invalid arguments, inconsistent terminal id ")
 164                 return
 165         }
 166         s.Log.Debugln("Add or Update terminal config: ", cfgArg)
 167         term, err := s.targets.CreateUpdateTerminal(tgtID, cfgArg, false)
 168         if err != nil {
 169                 common.APIError(c, err.Error())
 170                 return
 171         }
 172         c.JSON(http.StatusOK, term)
 173 }
 174
 175 // delTgtTerm Delete a terminal
 176 func (s *APIService) delTgtTerm(c *gin.Context) {
 177
 178         tgtID, termID, err := s._decodeTermArgs(c)
 179         if err != nil {
 180                 common.APIError(c, err.Error())
 181                 return
 182         }
 183         term, err := s.targets.DeleteTerminal(tgtID, termID)
 184         if err != nil {
 185                 common.APIError(c, err.Error())
 186                 return
 187         }
 188
 189         c.JSON(http.StatusOK, term)
 190 }
 191
 192 // openTgtTerm Open a target terminal/console
 193 func (s *APIService) openTgtTerm(c *gin.Context) {
 194
 195         id, tid, err := s._decodeTermArgs(c)
 196         if err != nil {
 197                 common.APIError(c, err.Error())
 198                 return
 199         }
 200
 201         // Retrieve session info
 202         sess := s.sessions.Get(c)
 203         if sess == nil {
 204                 common.APIError(c, "Unknown sessions")
 205                 return
 206         }
 207
 208         term, err := s.targets.OpenTerminal(id, tid, sess)
 209         if err != nil {
 210                 common.APIError(c, err.Error())
 211                 return
 212         }
 213         c.JSON(http.StatusOK, term)
 214 }
 215
 216 // closeTgtTerm Close a terminal
 217 func (s *APIService) closeTgtTerm(c *gin.Context) {
 218         id, tid, err := s._decodeTermArgs(c)
 219         if err != nil {
 220                 common.APIError(c, err.Error())
 221                 return
 222         }
 223
 224         // Retrieve session info
 225         sess := s.sessions.Get(c)
 226         if sess == nil {
 227                 common.APIError(c, "Unknown sessions")
 228                 return
 229         }
 230
 231         term, err := s.targets.CloseTerminal(id, tid, sess)
 232         if err != nil {
 233                 common.APIError(c, err.Error())
 234                 return
 235         }
 236         c.JSON(http.StatusOK, term)
 237 }
 238
 239 // resizeTgtTerm Resize a terminal
 240 func (s *APIService) resizeTgtTerm(c *gin.Context) {
 241         var sizeArg xsapiv1.TerminalResizeArgs
 242
 243         id, tid, err := s._decodeTermArgs(c)
 244         if err != nil {
 245                 common.APIError(c, err.Error())
 246                 return
 247         }
 248         if err := c.BindJSON(&sizeArg); err != nil {
 249                 common.APIError(c, "Invalid arguments")
 250                 return
 251         }
 252
 253         // Retrieve session info
 254         sess := s.sessions.Get(c)
 255         if sess == nil {
 256                 common.APIError(c, "Unknown sessions")
 257                 return
 258         }
 259
 260         term, err := s.targets.ResizeTerminal(id, tid, sizeArg.Cols, sizeArg.Rows, sess)
 261         if err != nil {
 262                 common.APIError(c, err.Error())
 263                 return
 264         }
 265         c.JSON(http.StatusOK, term)
 266 }
 267
 268 // signalTgtTerm Send a signal to a terminal
 269 func (s *APIService) signalTgtTerm(c *gin.Context) {
 270         var sigArg xsapiv1.TerminalSignalArgs
 271
 272         id, tid, err := s._decodeTermArgs(c)
 273         if err != nil {
 274                 common.APIError(c, err.Error())
 275                 return
 276         }
 277
 278         sigName := c.Param("sig")
 279         if sigName == "" {
 280                 if err := c.BindJSON(&sigArg); err != nil {
 281                         common.APIError(c, "Invalid arguments")
 282                         return
 283                 }
 284                 sigName = sigArg.Signal
 285         }
 286         if sigName == "" {
 287                 common.APIError(c, "Invalid arguments")
 288                 return
 289         }
 290
 291         if err := s.targets.SignalTerminal(id, tid, sigName); err != nil {
 292                 common.APIError(c, err.Error())
 293                 return
 294         }
 295
 296         c.JSON(http.StatusOK, "")
 297 }
 298
 299 // _decodeTermArgs Helper to decode arguments of Terminal routes
 300 func (s *APIService) _decodeTermArgs(c *gin.Context) (string, string, error) {
 301         id, err := s.targets.ResolveID(c.Param("id"))
 302         if err != nil {
 303                 return "", "", err
 304         }
 305
 306         termID, err := s.targets.ResolveTerminalID(c.Param("tid"))
 307         if err != nil {
 308                 return id, "", err
 309         }
 310
 311         return id, termID, nil
 312 }