vendor/golang.org/x/crypto/ssh/benchmark_test.go

   1 // Copyright 2013 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package ssh
   6
   7 import (
   8         "errors"
   9         "io"
  10         "net"
  11         "testing"
  12 )
  13
  14 type server struct {
  15         *ServerConn
  16         chans <-chan NewChannel
  17 }
  18
  19 func newServer(c net.Conn, conf *ServerConfig) (*server, error) {
  20         sconn, chans, reqs, err := NewServerConn(c, conf)
  21         if err != nil {
  22                 return nil, err
  23         }
  24         go DiscardRequests(reqs)
  25         return &server{sconn, chans}, nil
  26 }
  27
  28 func (s *server) Accept() (NewChannel, error) {
  29         n, ok := <-s.chans
  30         if !ok {
  31                 return nil, io.EOF
  32         }
  33         return n, nil
  34 }
  35
  36 func sshPipe() (Conn, *server, error) {
  37         c1, c2, err := netPipe()
  38         if err != nil {
  39                 return nil, nil, err
  40         }
  41
  42         clientConf := ClientConfig{
  43                 User: "user",
  44         }
  45         serverConf := ServerConfig{
  46                 NoClientAuth: true,
  47         }
  48         serverConf.AddHostKey(testSigners["ecdsa"])
  49         done := make(chan *server, 1)
  50         go func() {
  51                 server, err := newServer(c2, &serverConf)
  52                 if err != nil {
  53                         done <- nil
  54                 }
  55                 done <- server
  56         }()
  57
  58         client, _, reqs, err := NewClientConn(c1, "", &clientConf)
  59         if err != nil {
  60                 return nil, nil, err
  61         }
  62
  63         server := <-done
  64         if server == nil {
  65                 return nil, nil, errors.New("server handshake failed.")
  66         }
  67         go DiscardRequests(reqs)
  68
  69         return client, server, nil
  70 }
  71
  72 func BenchmarkEndToEnd(b *testing.B) {
  73         b.StopTimer()
  74
  75         client, server, err := sshPipe()
  76         if err != nil {
  77                 b.Fatalf("sshPipe: %v", err)
  78         }
  79
  80         defer client.Close()
  81         defer server.Close()
  82
  83         size := (1 << 20)
  84         input := make([]byte, size)
  85         output := make([]byte, size)
  86         b.SetBytes(int64(size))
  87         done := make(chan int, 1)
  88
  89         go func() {
  90                 newCh, err := server.Accept()
  91                 if err != nil {
  92                         b.Fatalf("Client: %v", err)
  93                 }
  94                 ch, incoming, err := newCh.Accept()
  95                 go DiscardRequests(incoming)
  96                 for i := 0; i < b.N; i++ {
  97                         if _, err := io.ReadFull(ch, output); err != nil {
  98                                 b.Fatalf("ReadFull: %v", err)
  99                         }
 100                 }
 101                 ch.Close()
 102                 done <- 1
 103         }()
 104
 105         ch, in, err := client.OpenChannel("speed", nil)
 106         if err != nil {
 107                 b.Fatalf("OpenChannel: %v", err)
 108         }
 109         go DiscardRequests(in)
 110
 111         b.ResetTimer()
 112         b.StartTimer()
 113         for i := 0; i < b.N; i++ {
 114                 if _, err := ch.Write(input); err != nil {
 115                         b.Fatalf("WriteFull: %v", err)
 116                 }
 117         }
 118         ch.Close()
 119         b.StopTimer()
 120
 121         <-done
 122 }