test/target_test.go

   1 /*
   2  * Copyright (C) 2017-2018 "IoT.bzh"
   3  * Author Clément Bénier <clement.benier@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 package xdsservertest
  18
  19 import (
  20         "os"
  21         "path"
  22         "strconv"
  23         "strings"
  24         "testing"
  25         "time"
  26
  27         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xsapiv1"
  28         "github.com/stretchr/testify/assert"
  29 )
  30
  31 /*flush channel with timeout*/
  32 func flushChannelTerm(channel chan xsapiv1.TerminalOutMsg, ms time.Duration) {
  33         timeoutB := false
  34         for !timeoutB {
  35                 select {
  36                 case <-channel:
  37                 case <-time.After(ms * time.Millisecond):
  38                         timeoutB = true
  39                 }
  40         }
  41 }
  42
  43 func ConnectTargetEvents(t *testing.T, channel chan xsapiv1.TargetConfig) {
  44         sCli.Conn.On(xsapiv1.EVTTargetAdd, func(e xsapiv1.EventMsg) {
  45                 target, _ := e.DecodeTargetEvent()
  46                 channel <- target
  47         })
  48
  49         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetAdd}
  50         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  51
  52         sCli.Conn.On(xsapiv1.EVTTargetRemove, func(e xsapiv1.EventMsg) {
  53                 target, _ := e.DecodeTargetEvent()
  54                 channel <- target
  55         })
  56
  57         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetRemove}
  58         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  59 }
  60
  61 func DisconnectTargetEvents(t *testing.T) {
  62         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetAdd}
  63         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  64         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetRemove}
  65         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  66 }
  67
  68 func ConnectTermEvents(t *testing.T, channel chan xsapiv1.TerminalConfig) {
  69         sCli.Conn.On(xsapiv1.EVTTargetTerminalAdd, func(e xsapiv1.EventMsg) {
  70                 termEvt, _ := e.DecodeTerminalEvent()
  71                 channel <- termEvt
  72         })
  73
  74         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalAdd}
  75         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  76
  77         sCli.Conn.On(xsapiv1.EVTTargetTerminalStateChange, func(e xsapiv1.EventMsg) {
  78                 termEvt, _ := e.DecodeTerminalEvent()
  79                 channel <- termEvt
  80         })
  81
  82         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalStateChange}
  83         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  84
  85         sCli.Conn.On(xsapiv1.EVTTargetTerminalRemove, func(e xsapiv1.EventMsg) {
  86                 termEvt, _ := e.DecodeTerminalEvent()
  87                 channel <- termEvt
  88         })
  89
  90         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalRemove}
  91         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  92 }
  93
  94 func DisconnectTermEvents(t *testing.T) {
  95         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalAdd}
  96         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  97         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalStateChange}
  98         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  99         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalRemove}
 100         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
 101 }
 102
 103 func AddTargets(t *testing.T, nbTargets int, chTarget chan xsapiv1.TargetConfig) []string {
 104         listID := make([]string, nbTargets)
 105         for i := 0; i < nbTargets; i++ {
 106                 /*target is local*/
 107                 target := xsapiv1.TargetConfig{
 108                         Name: "fakeTarget" + strconv.Itoa(i),
 109                         Type: xsapiv1.TypeTgtStandard,
 110                         IP:   "127.0.0.1",
 111                 }
 112                 /*add target*/
 113                 assert.Nil(t, HTTPCli.Post("/targets", target, &target))
 114                 targetEvt := <-chTarget //waiting for event targetAdd
 115                 assert.Equal(t, target.ID, targetEvt.ID)
 116                 listID[i] = target.ID
 117         }
 118         for i := 0; i < nbTargets; i++ {
 119                 var target xsapiv1.TargetConfig
 120                 assert.Nil(t, HTTPCli.Get("/targets/"+listID[i], &target))
 121                 assert.Equal(t, target.Status, "Enable")
 122         }
 123         return listID
 124 }
 125
 126 func AddTerms(t *testing.T, nbTerms int, listID []string, chTermEvt chan xsapiv1.TerminalConfig) {
 127         for j := 0; j < len(listID); j++ {
 128                 listTermsID := make([]string, nbTerms)
 129                 for i := 0; i < nbTerms; i++ {
 130                         term := xsapiv1.TerminalConfig{
 131                                 Name: "terminal" + strconv.Itoa(i),
 132                                 Type: xsapiv1.TypeTermSSH,
 133                         }
 134                         /*add terminal on target*/
 135                         assert.Nil(t, HTTPCli.Post("/targets/"+listID[j]+"/terminals", term, &term))
 136                         termEvt := <-chTermEvt //waiting for event terminalAdd*/
 137                         assert.Equal(t, term.ID, termEvt.ID)
 138                         listTermsID[i] = term.ID
 139                 }
 140                 assert.Equal(t, len(listTermsID), nbTerms)
 141                 for i := 0; i < nbTerms; i++ {
 142                         var term xsapiv1.TerminalConfig
 143                         assert.Nil(t, HTTPCli.Get("/targets/"+listID[j]+"/terminals/"+listTermsID[i], &term))
 144                         assert.Equal(t, term.Status, "Close")
 145                 }
 146         }
 147 }
 148
 149 func PostTerms(t *testing.T, post string, chTermEvt chan xsapiv1.TerminalConfig) {
 150         var status string
 151         switch post {
 152         case "open":
 153                 status = "Open"
 154         case "close":
 155                 status = "Closing"
 156         }
 157         var targets []xsapiv1.TargetConfig
 158         assert.Nil(t, HTTPCli.Get("/targets", &targets))
 159         for i := 0; i < len(targets); i++ {
 160                 var terms []xsapiv1.TerminalConfig
 161                 assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals", &terms))
 162                 listTermsID := make([]string, len(terms))
 163                 for j := 0; j < len(terms); j++ {
 164                         var term xsapiv1.TerminalConfig
 165                         assert.Nil(t, HTTPCli.Post("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID+"/"+post, terms[j], &term))
 166                         termEvt := <-chTermEvt //waiting for event terminalStateChange
 167                         assert.Equal(t, term.ID, termEvt.ID)
 168                         assert.Equal(t, term.Status, status)
 169                         assert.Equal(t, termEvt.Status, status)
 170                         listTermsID[i] = term.ID
 171                 }
 172                 time.Sleep(10 * time.Millisecond)
 173                 for j := 0; j < len(listTermsID); j++ {
 174                         var term xsapiv1.TerminalConfig
 175                         assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals/"+listTermsID[i], &term))
 176                         assert.True(t, strings.EqualFold(term.Status, post))
 177                 }
 178         }
 179 }
 180
 181 func RemoveTermsTargets(t *testing.T, chTarget chan xsapiv1.TargetConfig, chTermEvt chan xsapiv1.TerminalConfig) {
 182         var targets []xsapiv1.TargetConfig
 183         assert.Nil(t, HTTPCli.Get("/targets", &targets))
 184         for i := 0; i < len(targets); i++ {
 185                 var terms []xsapiv1.TerminalConfig
 186                 assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals", &terms))
 187                 for j := 0; j < len(terms); j++ {
 188                         var term xsapiv1.TerminalConfig
 189                         assert.Nil(t, HTTPCli.Delete("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID, &term))
 190                         termEvt := <-chTermEvt
 191                         assert.Equal(t, term.ID, termEvt.ID)
 192                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID, &term))
 193                 }
 194                 var tgtRes xsapiv1.TargetConfig
 195                 assert.Nil(t, HTTPCli.Delete("/targets/"+targets[i].ID, &tgtRes))
 196                 targetEvt := <-chTarget
 197                 assert.Equal(t, tgtRes.ID, targetEvt.ID)
 198                 assert.Equal(t, targets[i].ID, tgtRes.ID)
 199         }
 200 }
 201 func TestTarget(t *testing.T) {
 202         nbTargets := 3
 203         nbTermsByTarget := 3
 204         /*channel for target events*/
 205         chTarget := make(chan xsapiv1.TargetConfig)
 206         defer close(chTarget)
 207         ConnectTargetEvents(t, chTarget)
 208
 209         /*channel for terminal events*/
 210         chTermEvt := make(chan xsapiv1.TerminalConfig)
 211         defer close(chTermEvt)
 212         ConnectTermEvents(t, chTermEvt)
 213
 214         /*check that targetArray is empty at startup*/
 215         var targetArray []xsapiv1.TargetConfig
 216         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 217         assert.Equal(t, len(targetArray), 0)
 218
 219         listID := AddTargets(t, nbTargets, chTarget)
 220         AddTerms(t, nbTermsByTarget, listID, chTermEvt)
 221
 222         /*channel for TerminalOutMsg*/
 223         chTerm := make(chan xsapiv1.TerminalOutMsg)
 224         defer close(chTerm)
 225
 226         /*connect on terminalOutMsg event*/
 227         sCli.Conn.On(xsapiv1.TerminalOutEvent, func(ev xsapiv1.TerminalOutMsg) {
 228                 chTerm <- ev
 229         })
 230
 231         /*open first term*/
 232         PostTerms(t, "open", chTermEvt)
 233
 234         /*just for the first term*/
 235         termOut := <-chTerm          //waiting for terminalOutMsg
 236         flushChannelTerm(chTerm, 50) //flushing all terminalOutMsg
 237         stdoutMsg := string(termOut.Stdout)
 238         if strings.Contains(stdoutMsg, "Connection refused") {
 239                 t.Fatalf("%vYou may have to launch ssh server", stdoutMsg)
 240         } else if strings.Contains(stdoutMsg, "password") {
 241                 t.Fatalf("%vcopy your pub key in authorized_keys\ncat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys", stdoutMsg)
 242         }
 243         assert.True(t, strings.Contains(stdoutMsg, "Last login")) //first terminal msg should be Last Login
 244
 245         /*create toto file through terminals*/
 246         rootCfgDir := os.Getenv(envRootCfgDir)
 247         totoFile := path.Join(rootCfgDir, "toto")
 248
 249         /*test with 2 terminals*/
 250         for i := 0; i < 2; i++ {
 251                 totoFileCurrent := totoFile + strconv.Itoa(i)
 252                 /*send cmd though term*/
 253                 data := []byte("echo helloWorld" + strconv.Itoa(i) + " >> " + totoFileCurrent + "\n")
 254                 assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 255                 flushChannelTerm(chTerm, 50) //waiting for terminal msg
 256
 257                 /*check that toto file is created*/
 258                 _, err := os.Stat(totoFileCurrent)
 259                 assert.Nil(t, err)
 260
 261                 /*send cmd though term*/
 262                 data = []byte("cat " + totoFileCurrent + "\n")
 263                 assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 264
 265                 <-chTerm                     //cmd sent
 266                 termOut = <-chTerm           //result of cat cmd
 267                 flushChannelTerm(chTerm, 50) //flushing what remains
 268                 /*check that terminal msg is what was written before*/
 269                 assert.Equal(t, string(termOut.Stdout), "helloWorld"+strconv.Itoa(i)+"\r\n")
 270         }
 271
 272         PostTerms(t, "close", chTermEvt)
 273
 274         /*remove targets and terms*/
 275         RemoveTermsTargets(t, chTarget, chTermEvt)
 276         DisconnectTargetEvents(t)
 277         DisconnectTermEvents(t)
 278 }
 279
 280 func TestTargetErrors(t *testing.T) {
 281         target := xsapiv1.TargetConfig{}
 282         var targetRes xsapiv1.TargetConfig
 283         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 284         target.Type = xsapiv1.TypeTgtStandard
 285         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 286         target.IP = "127.0.0.1"
 287         assert.Nil(t, HTTPCli.Post("/targets", target, &targetRes))
 288
 289         term := xsapiv1.TerminalConfig{}
 290         var termRes xsapiv1.TerminalConfig
 291         assert.NotNil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 292         term.Type = xsapiv1.TypeTermSSH
 293         assert.NotNil(t, HTTPCli.Post("/targets/"+"1010"+"/terminals", term, &termRes))
 294         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 295         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 296         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 297         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 298
 299         /*remove targets and terms*/
 300         var targetArray []xsapiv1.TargetConfig
 301         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 302         for i := 0; i < len(targetArray); i++ {
 303                 var termArray []xsapiv1.TerminalConfig
 304                 assert.Nil(t, HTTPCli.Get("/targets/"+targetArray[i].ID+"/terminals", &termArray))
 305                 for j := 0; j < len(termArray); j++ {
 306                         assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 307                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 308                 }
 309                 var tgtRes xsapiv1.TargetConfig
 310                 assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 311                 assert.Equal(t, targetArray[i].ID, tgtRes.ID)
 312                 assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 313         }
 314 }