vendor/github.com/miekg/dns/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                 HostKeyCallback: InsecureIgnoreHostKey(),
  45         }
  46         serverConf := ServerConfig{
  47                 NoClientAuth: true,
  48         }
  49         serverConf.AddHostKey(testSigners["ecdsa"])
  50         done := make(chan *server, 1)
  51         go func() {
  52                 server, err := newServer(c2, &serverConf)
  53                 if err != nil {
  54                         done <- nil
  55                 }
  56                 done <- server
  57         }()
  58
  59         client, _, reqs, err := NewClientConn(c1, "", &clientConf)
  60         if err != nil {
  61                 return nil, nil, err
  62         }
  63
  64         server := <-done
  65         if server == nil {
  66                 return nil, nil, errors.New("server handshake failed.")
  67         }
  68         go DiscardRequests(reqs)
  69
  70         return client, server, nil
  71 }
  72
  73 func BenchmarkEndToEnd(b *testing.B) {
  74         b.StopTimer()
  75
  76         client, server, err := sshPipe()
  77         if err != nil {
  78                 b.Fatalf("sshPipe: %v", err)
  79         }
  80
  81         defer client.Close()
  82         defer server.Close()
  83
  84         size := (1 << 20)
  85         input := make([]byte, size)
  86         output := make([]byte, size)
  87         b.SetBytes(int64(size))
  88         done := make(chan int, 1)
  89
  90         go func() {
  91                 newCh, err := server.Accept()
  92                 if err != nil {
  93                         b.Fatalf("Client: %v", err)
  94                 }
  95                 ch, incoming, err := newCh.Accept()
  96                 go DiscardRequests(incoming)
  97                 for i := 0; i < b.N; i++ {
  98                         if _, err := io.ReadFull(ch, output); err != nil {
  99                                 b.Fatalf("ReadFull: %v", err)
 100                         }
 101                 }
 102                 ch.Close()
 103                 done <- 1
 104         }()
 105
 106         ch, in, err := client.OpenChannel("speed", nil)
 107         if err != nil {
 108                 b.Fatalf("OpenChannel: %v", err)
 109         }
 110         go DiscardRequests(in)
 111
 112         b.ResetTimer()
 113         b.StartTimer()
 114         for i := 0; i < b.N; i++ {
 115                 if _, err := ch.Write(input); err != nil {
 116                         b.Fatalf("WriteFull: %v", err)
 117                 }
 118         }
 119         ch.Close()
 120         b.StopTimer()
 121
 122         <-done
 123 }