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 targets []xsapiv1.TargetConfig
 151         assert.Nil(t, HTTPCli.Get("/targets", &targets))
 152         for i := 0; i < len(targets); i++ {
 153                 var terms []xsapiv1.TerminalConfig
 154                 assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals", &terms))
 155                 listTermsID := make([]string, len(terms))
 156                 for j := 0; j < len(terms); j++ {
 157                         var term xsapiv1.TerminalConfig
 158                         assert.Nil(t, HTTPCli.Post("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID+"/"+post, term, &term))
 159                         termEvt := <-chTermEvt //waiting for event terminalStateChange
 160                         assert.Equal(t, term.ID, termEvt.ID)
 161                         assert.True(t, strings.EqualFold(termEvt.Status, post))
 162                         listTermsID[i] = term.ID
 163                 }
 164                 for j := 0; j < len(listTermsID); j++ {
 165                         var term xsapiv1.TerminalConfig
 166                         assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals/"+listTermsID[i], &term))
 167                         assert.True(t, strings.EqualFold(term.Status, post))
 168                 }
 169         }
 170 }
 171
 172 func RemoveTermsTargets(t *testing.T, chTarget chan xsapiv1.TargetConfig, chTermEvt chan xsapiv1.TerminalConfig) {
 173         var targets []xsapiv1.TargetConfig
 174         assert.Nil(t, HTTPCli.Get("/targets", &targets))
 175         for i := 0; i < len(targets); i++ {
 176                 var terms []xsapiv1.TerminalConfig
 177                 assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals", &terms))
 178                 for j := 0; j < len(terms); j++ {
 179                         var term xsapiv1.TerminalConfig
 180                         assert.Nil(t, HTTPCli.Delete("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID, &term))
 181                         termEvt := <-chTermEvt
 182                         assert.Equal(t, term.ID, termEvt.ID)
 183                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID, &term))
 184                 }
 185                 var tgtRes xsapiv1.TargetConfig
 186                 assert.Nil(t, HTTPCli.Delete("/targets/"+targets[i].ID, &tgtRes))
 187                 targetEvt := <-chTarget
 188                 assert.Equal(t, tgtRes.ID, targetEvt.ID)
 189                 assert.Equal(t, targets[i].ID, tgtRes.ID)
 190         }
 191 }
 192 func TestTarget(t *testing.T) {
 193         nbTargets := 3
 194         nbTermsByTarget := 3
 195         /*channel for target events*/
 196         chTarget := make(chan xsapiv1.TargetConfig)
 197         defer close(chTarget)
 198         ConnectTargetEvents(t, chTarget)
 199
 200         /*channel for terminal events*/
 201         chTermEvt := make(chan xsapiv1.TerminalConfig)
 202         defer close(chTermEvt)
 203         ConnectTermEvents(t, chTermEvt)
 204
 205         /*check that targetArray is empty at startup*/
 206         var targetArray []xsapiv1.TargetConfig
 207         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 208         assert.Equal(t, len(targetArray), 0)
 209
 210         listID := AddTargets(t, nbTargets, chTarget)
 211         AddTerms(t, nbTermsByTarget, listID, chTermEvt)
 212
 213         /*channel for TerminalOutMsg*/
 214         chTerm := make(chan xsapiv1.TerminalOutMsg)
 215         defer close(chTerm)
 216
 217         /*connect on terminalOutMsg event*/
 218         sCli.Conn.On(xsapiv1.TerminalOutEvent, func(ev xsapiv1.TerminalOutMsg) {
 219                 chTerm <- ev
 220         })
 221
 222         /*open first term*/
 223         PostTerms(t, "open", chTermEvt)
 224
 225         /*just for the first term*/
 226         termOut := <-chTerm          //waiting for terminalOutMsg
 227         flushChannelTerm(chTerm, 50) //flushing all terminalOutMsg
 228         stdoutMsg := string(termOut.Stdout)
 229         if strings.Contains(stdoutMsg, "Connection refused") {
 230                 t.Fatalf("%vYou may have to launch ssh server", stdoutMsg)
 231         } else if strings.Contains(stdoutMsg, "password") {
 232                 t.Fatalf("%vcopy your pub key in authorized_keys\ncat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys", stdoutMsg)
 233         }
 234         assert.True(t, strings.Contains(stdoutMsg, "Last login")) //first terminal msg should be Last Login
 235
 236         /*create toto file through terminals*/
 237         rootCfgDir := os.Getenv(envRootCfgDir)
 238         totoFile := path.Join(rootCfgDir, "toto")
 239
 240         /*test with 2 terminals*/
 241         for i := 0; i < 2; i++ {
 242                 totoFileCurrent := totoFile + strconv.Itoa(i)
 243                 /*send cmd though term*/
 244                 data := []byte("echo helloWorld" + strconv.Itoa(i) + " >> " + totoFileCurrent + "\n")
 245                 assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 246                 flushChannelTerm(chTerm, 50) //waiting for terminal msg
 247
 248                 /*check that toto file is created*/
 249                 _, err := os.Stat(totoFileCurrent)
 250                 assert.Nil(t, err)
 251
 252                 /*send cmd though term*/
 253                 data = []byte("cat " + totoFileCurrent + "\n")
 254                 assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 255
 256                 <-chTerm                     //cmd sent
 257                 termOut = <-chTerm           //result of cat cmd
 258                 flushChannelTerm(chTerm, 50) //flushing what remains
 259                 /*check that terminal msg is what was written before*/
 260                 assert.Equal(t, string(termOut.Stdout), "helloWorld"+strconv.Itoa(i)+"\r\n")
 261         }
 262
 263         PostTerms(t, "close", chTermEvt)
 264
 265         /*remove targets and terms*/
 266         RemoveTermsTargets(t, chTarget, chTermEvt)
 267         DisconnectTargetEvents(t)
 268         DisconnectTermEvents(t)
 269 }
 270
 271 func TestTargetErrors(t *testing.T) {
 272         target := xsapiv1.TargetConfig{}
 273         var targetRes xsapiv1.TargetConfig
 274         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 275         target.Type = xsapiv1.TypeTgtStandard
 276         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 277         target.IP = "127.0.0.1"
 278         assert.Nil(t, HTTPCli.Post("/targets", target, &targetRes))
 279
 280         term := xsapiv1.TerminalConfig{}
 281         var termRes xsapiv1.TerminalConfig
 282         assert.NotNil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 283         term.Type = xsapiv1.TypeTermSSH
 284         assert.NotNil(t, HTTPCli.Post("/targets/"+"1010"+"/terminals", term, &termRes))
 285         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 286         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 287         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 288         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 289
 290         /*remove targets and terms*/
 291         var targetArray []xsapiv1.TargetConfig
 292         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 293         for i := 0; i < len(targetArray); i++ {
 294                 var termArray []xsapiv1.TerminalConfig
 295                 assert.Nil(t, HTTPCli.Get("/targets/"+targetArray[i].ID+"/terminals", &termArray))
 296                 for j := 0; j < len(termArray); j++ {
 297                         assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 298                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 299                 }
 300                 var tgtRes xsapiv1.TargetConfig
 301                 assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 302                 assert.Equal(t, targetArray[i].ID, tgtRes.ID)
 303                 assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 304         }
 305 }