1. Update ubuntu
   

   sudo apt-get -y update
   

   • Troubleshooting: invliad PPA error
     

     • In my case it is something related with “yarn”.
       
     • So delete that PPA. see: How to Remove or Delete PPA in Ubuntu Linux
       

     ls /etc/apt/sources.list.d
     sudo rm -i /etc/apt/sources.list.d/yarn.list
     sudo rm -i /etc/apt/sources.list.d/yarn.list.save
     

2. Download go install package
   
   • Go to the download page and download the binary release suitable for your system.
     

   • Extract the archive file
     

     sudo tar -C /usr/local -xzf go1.16.6.linux-amd64.tar.gz
     

   • Make sure go/bin is in PATH
     

     export PATH=$PATH:/usr/local/go/bin
     

   • Check installed go version and its env
     

     go version
     go env
     

1. What is Go proxy?
   
   • See https://jfrog.com/blog/why-goproxy-matters-and-which-to-pick/
     

2. Set proxy according to your location
   

   go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct
   # Or other proxy
   go env -w GOPROXY=https://goproxy.io/zh/,direct
   

3. Test proxy setting works
   

   time go get golang.org/x/tour
   

4. To unset proxy
   

   go env -u GOPROXY
   
   # Now it should show default one: 
   go env | grep proxy
   # GOPROXY="https://proxy.golang.org,direct"
   

1. Create folder -tester
   

2. Cd into -tester, then initialize the project as go module
   

   go mod init loadtest
   
   go get -u github.com/aws/aws-sdk-go/...
   

3. Test aws configuration(~/.aws/config) since this work is related with using AWS SDK.
   

   package main
   
   import (
     "fmt"
     "github.com/aws/aws-sdk-go/aws"
     "github.com/aws/aws-sdk-go/aws/session"
   )
   
   func main() {
     sess, err := session.NewSession(&aws.Config{
       Region: aws.String("us-east-1")},
     )
   
     if err != nil {
       fmt.Println("session error:", err)
     }
   
     fmt.Printf("using session: %v\n", sess)
   }
   

4. Then, go run main.go to see if it works.
   

5. We will implement different packages(.go and *_test.go in one folder) under this loadtest module(the whole code repository). In one package, we use other packages like:
   

   package main
   
   import (
     "fmt"
     "loadtest/aws"
     "loadtest/cmd"
     "loadtest/tools"
       ...
   )
   

   Notice: you could not import main package into other package. So, keep main package simple.
   

• Using Go modules
  
• Getting Started with the AWS SDK for Go
  
• AWS SDK for Go Code Examples
  
• AWS SDK for Go API Reference
  
• Mocking Out the AWS SDK for Go for Unit Testing
  

I would say the only downside of using comparing with Javascript is it is not very convenient to process JSON. In Golang, JSON object is represent as a combination of map[string]interfaces{} and []interface{}.

For example, we want to convert a struct into []string such that it could be write into CSV files (encoding/csv need data to be []string)

type LoadtestRecord struct {
  Id               int
  Timestamp        time.Time
  TesterName       string
  Guid             string
  Linetype         string
  OpenPartDuration time.Duration
  CompleteDuration time.Duration
  Text             string
  SinceBegin       time.Duration
}

func (l LoadtestRecord) toStrings() []string {
  v := reflect.ValueOf(l)
  typeOfS := v.Type()

  result := []string{}
  for i := 0; i < v.NumField(); i++ {

    k := typeOfS.Field(i).Name
    v := v.Field(i).Interface()

    if k == "Timestamp" {
      result = append(result, formatTime(v.(time.Time)))
    } else if k == "OpenPartDuration" {
      result = append(result, fmt.Sprintf("%v", int64(v.(time.Duration)/time.Millisecond)))
    } else if k == "CompleteDuration" {
      result = append(result, fmt.Sprintf("%v", int64(v.(time.Duration)/time.Millisecond)))
    } else if k == "Id" || k == "SinceBegin" {
      continue
    } else {
      str := v.(string)
      result = append(result, removeLastStr(strings.TrimSpace(str), "\n"))
    }
  }

  return result
}

• Here, we define a method on the type LoadtestRecord such it we could convert subset of its attributes into []string to save it into CSV file.
  

So easy in Golang

var n, p, t int
var minNumOfEC2, maxNumOfEC2 int
var stackEnv, workerVersion, jsonFile string
// var setUTC bool
flag.IntVar(&n, "n", 1, "number of testers to launch per path")
flag.IntVar(&p, "p", 1, "how many patch")
flag.IntVar(&t, "t", 5, "time interval(seconds) between patch")
flag.StringVar(&stackEnv, "e", "dev", "stack stackEnv, for example: dev, preprod...etc")
flag.StringVar(&workerVersion, "w", "Worker.3100", "the worker version used for tester, by default it will use Worker.3100")
flag.StringVar(&jsonFile, "j", "input_clouddash_dev.json", "the json file contains the APIs used by tester, by default it will use input_clouddash_dev.json")
flag.BoolVar(&setUTC, "utc", false, "time displayed in log will be using UTC by default, -utc=true to set timestamp in UTC")
flag.Parse()

• ref: Structuring Tests in Go
  
• ref: 5 simple tips and tricks for writing unit tests in #golang
  
• ref: Interface in Go
  
• ref: Mocking Out the AWS SDK for Go for Unit Testing
  
• Summary
  
  1. How to structure go test
     
     1. Put test code in the same package as target code.
        
     2. Naming convention: if target code is main.go, then test code is main_test.go
        
  2. How to use interface to mock dependencies during test.
     
     1. Ensure dependencies are passed as parameters of function(dependency injection makes function testable).
        
     2. Identify the methods of dependency.
        
     3. Create interface in which those dependent methods are defined.
        
     4. Re-define function parameter as interface instead of concrate type.
        
     5. In test code
        
        • Define Mocking type
          
        • Make Mocking type implement the interface (those dependent methods).
          
        • The caller declares the Mocking type and pass it into target testing function.
          
  3. What is the pattern when mock AWS SDK in go (in a function it calls methods from a Go SDK’s Client)
     

     1. Make testing function injectable: two approaches
        

        • One is pass Client directly as parameter of the function.
          
        • Another is define a struct which contains that Client. Then, define function as method of such struct.
          

        In anyway, we don’t use concrate Client type, we use AWS’s interface type.
        

     2. Here, the steps of identify and create our own interface to hold those methods are ignored. Because AWS already defines those interfaces, we just need to import them and use.
        
     3. In test code
        
        • Define Mocking type
          
        • Make Mocking type implement the interface (those dependent methods).
          
        • Define testing cases as slice in which it contains different cases for input and expecting output
          
        • Use for ... range to loop those cases, in each of them:
          
          • Initialize Mocking type with different input
            
          • Pass initialized Mocking type as parameter of testing function or as attribute of struct.
            
          • During the testing, the testing function is got executed which calls those dependent methods
            
          • That is OK, because Mocking type implements those method from interface.
            

In Golang standard library, a lot of components are interfaces. For example

type Example struct {

}
func (e *Example) Write(p byte[]) (n int, err error) {

}
func (e *Example) Read(p byte[]) (n int, err error) {

}

• A interface will group none, or multiple functions.
  
• A type implements those functions as methods satisfies that interface. Example implements Read/Write interface.
  
• If we use type conversion, Example could be type of Reader && Writer.
  

For a type of function as a reader, it must implement method Read(p []byte) from interface io.Reader.

type Reader interface {
    Read(p []byte) (n int, err error)
}

• Read() will read up to len(p) into p, when possible.
  
• After a Read() call, n may be less then len(p).
  
• Upon error, Read() may still return n bytes in buffer p. For instance, when reading from a TCP socket that is abruptly closed. You may choose to keep the bytes in p or retry.
  

Sometimes a function’s parameters only accept Writer, but we want a Reader. The solution is io.Pipe().

type alphaReader struct {
  src string
  cur int
}

func newAlphaReader(src string) *alphaReader {
  return &alphaReader{src: src}
}

func alpha(r byte) byte {
  if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') {
    return r
  }
  return 0
}

func (a *alphaReader) Read(p []byte) (int, error) {
  if a.cur >= len(a.src) {
    return 0, io.EOF
  }

  x := len(a.src) - a.cur
  n, bound := 0, 0
  if x >= len(p) {
    bound = len(p)
  } else if x <= len(p) {
    bound = x
  }

  buf := make([]byte, bound)
  for n < bound {
    if char := alpha(a.src[a.cur]); char != 0 {
      buf[n] = char
    }
    n++
    a.cur++
  }
  copy(p, buf)
  return n, nil
}

func main() {
  reader := newAlphaReader("Hello! It's 9am, where is the sun?")
  p := make([]byte, 4)
  for {
    n, err := reader.Read(p)
    if err == io.EOF {
      break
    }
    fmt.Print(string(p[:n]))
  }
  fmt.Println()
}

• Notice the display of []byte as string in different terminal shows different result:
  

  fmt.Println(string([]byte{111, 73})) // on terminal, it is displayed as oI
  fmt.Println(string([]byte{111, 0, 0, 0, 0, 73})) // on terminal it is displayed as oI, but for some other terminal, it is displayed as oI
  

• Demystifying Golang’s io.Reader and io.Writer Interfaces (about using pipe to switch writer for reader)
  
• Streaming IO in Go ()
  
• The Beauty of io.Writer
  
• Talk about the confusion about Golang IO reading and writing
  

func observingEC2Instances(done <-chan interface{}, stackEnv string, minNumOfEC2, maxNumOfEC2 *int) {
  // observing the changes of EC2
  observeEC2Ticker := time.NewTicker(10 * time.Second)
  fname := filepath.Join(logFolder, fmt.Sprintf("number-of-EC2-instance.txt"))
  f, _ := os.Create(fname)

  defer observeEC2Ticker.Stop()
  defer f.Close()
  fmt.Println("Observing number of EC2 instances")

  num := aws.GetNumOfEC2(fmt.Sprintf("ecs-%v", stackEnv))
  f.Write([]byte(fmt.Sprintf("NumEC2s\tTime\n")))

  tStr := formatTime(time.Now())
  f.Write([]byte(fmt.Sprintf("%v\t%v\n", num, tStr)))

  *minNumOfEC2 = num
  *maxNumOfEC2 = num
  for {
    select {
    case <-done:
      return
    case <-observeEC2Ticker.C:
      num = aws.GetNumOfEC2(fmt.Sprintf("ecs-%v", stackEnv))
      tStr = formatTime(time.Now())
      f.Write([]byte(fmt.Sprintf("%v\t%v\n", num, tStr)))
      if num > *maxNumOfEC2 {
	*maxNumOfEC2 = num
      }
      if num < *minNumOfEC2 {
	*minNumOfEC2 = num
      }
    }
  }
}

• We usually pass done := make(chan interface{}) into each worker’s goroutine.
  
• Then in it, use for...select pattern to do cleanup operation once we receive messages from done.
  
• Here, we could observe the number of EC2 instance with time interval and cancel it if we want in a goroutine.