opensource/teleport
3
0
Fork 0
mirror of https://github.com/gravitational/teleport.git synced 2026-10-13 00:34:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fixed tsh tests, changed tests ports

Browse Source
This commit is contained in:
Alex Lyulkov
2016-02-25 20:30:44 +03:00
parent cf431fe05e
commit 07c0ca47f9
11 changed files with 207 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Makefile
+2
View File
@@ -47,6 +47,8 @@ production: clean
#
test:
go test -v github.com/gravitational/teleport/lib/... -cover
go test -v github.com/gravitational/teleport/tool/tsh -cover
test-with-etcd: install
${ETCD_FLAGS} go test -v -test.parallel=0 $(shell go list ./... | grep -v /vendor/) -cover
lib/client/client_test.go
+51 -20
View File
@@ -73,6 +73,7 @@ type ClientSuite struct {
otp *hotp.HOTP
user string
pass []byte
freePorts []string
}
var _ = Suite(&ClientSuite{})
@@ -84,6 +85,10 @@ func (s *ClientSuite) SetUpSuite(c *C) {
s.dir2 = c.MkDir()
allowAllLimiter, err := limiter.NewLimiter(limiter.LimiterConfig{})
c.Assert(err, IsNil)
s.freePorts, err = utils.GetFreeTCPPorts(10)
c.Assert(err, IsNil)
baseBk, err := boltbk.New(filepath.Join(s.dir, "db"))
c.Assert(err, IsNil)
@@ -123,7 +128,8 @@ func (s *ClientSuite) SetUpSuite(c *C) {
nil)
// Starting node1
s.srvAddress = "127.0.0.1:30187"
s.srvAddress = "127.0.0.1:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.srv, err = srv.New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.srvAddress},
"alice",
@@ -145,7 +151,8 @@ func (s *ClientSuite) SetUpSuite(c *C) {
c.Assert(s.srv.Start(), IsNil)
// Starting node2
s.srv2Address = "127.0.0.1:30189"
s.srv2Address = "127.0.0.1:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.srv2, err = srv.New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.srv2Address},
"bob",
@@ -172,7 +179,10 @@ func (s *ClientSuite) SetUpSuite(c *C) {
c.Assert(s.srv2.Start(), IsNil)
// Starting proxy
reverseTunnelAddress := utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:33057"}
reverseTunnelPort := s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
c.Assert(err, IsNil)
reverseTunnelAddress := utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:" + reverseTunnelPort}
reverseTunnelServer, err := reversetunnel.NewServer(
reverseTunnelAddress,
[]ssh.Signer{s.signer},
@@ -180,8 +190,8 @@ func (s *ClientSuite) SetUpSuite(c *C) {
c.Assert(err, IsNil)
c.Assert(reverseTunnelServer.Start(), IsNil)
s.proxyAddress = "localhost:34783"
s.proxyAddress = "localhost:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.proxy, err = srv.New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.proxyAddress},
"localhost",
@@ -201,7 +211,7 @@ func (s *ClientSuite) SetUpSuite(c *C) {
go apiSrv.Serve()
tsrv, err := auth.NewTunServer(
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:31498"},
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:0"},
[]ssh.Signer{s.signer},
apiSrv, s.a, allowAllLimiter)
c.Assert(err, IsNil)
@@ -479,7 +489,7 @@ func (s *ClientSuite) TestGetServer(c *C) {
c.Assert(err, IsNil)
server1Info := services.Server{
ID: "alice",
ID: s.srvAddress,
Addr: s.srvAddress,
Hostname: "alice",
Labels: map[string]string{
@@ -496,7 +506,7 @@ func (s *ClientSuite) TestGetServer(c *C) {
}
server2Info := services.Server{
ID: "bob",
ID: s.srv2Address,
Addr: s.srv2Address,
Hostname: "bob",
Labels: map[string]string{
@@ -518,24 +528,45 @@ func (s *ClientSuite) TestGetServer(c *C) {
servers, err := proxyClient.GetServers()
c.Assert(err, IsNil)
c.Assert(servers, DeepEquals, []services.Server{
server1Info,
server2Info,
})
if servers[0].Addr == server1Info.Addr {
c.Assert(servers, DeepEquals, []services.Server{
server1Info,
server2Info,
})
} else {
c.Assert(servers, DeepEquals, []services.Server{
server2Info,
server1Info,
})
}
servers, err = proxyClient.FindServers("label1", "value1")
c.Assert(err, IsNil)
c.Assert(servers, DeepEquals, []services.Server{
server1Info,
server2Info,
})
if servers[0].Addr == server1Info.Addr {
c.Assert(servers, DeepEquals, []services.Server{
server1Info,
server2Info,
})
} else {
c.Assert(servers, DeepEquals, []services.Server{
server2Info,
server1Info,
})
}
servers, err = proxyClient.FindServers("label1", "val.*")
c.Assert(err, IsNil)
c.Assert(servers, DeepEquals, []services.Server{
server1Info,
server2Info,
})
if servers[0].Addr == server1Info.Addr {
c.Assert(servers, DeepEquals, []services.Server{
server1Info,
server2Info,
})
} else {
c.Assert(servers, DeepEquals, []services.Server{
server2Info,
server1Info,
})
}
servers, err = proxyClient.FindServers("label2", ".*ue2")
c.Assert(err, IsNil)
lib/hangout/hangout_test.go
+42 -35
View File
@@ -265,52 +265,59 @@ func (s *HangoutsSuite) TestHangout(c *C) {
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 11 + 22\r\n33\r\n$")
// Initializing tsh join
proxy, err := client.ConnectToProxy(s.proxyAddress,
[]ssh.AuthMethod{s.teleagent.AuthMethod()}, client.CheckHostSignerFromCache, "anyuser")
c.Assert(err, IsNil)
for i := 0; i < 3; i++ {
authConn, err := proxy.ConnectToHangout(hangoutServer.HangoutID+":"+utils.HangoutAuthPortAlias, []ssh.AuthMethod{s.teleagent.AuthMethod()})
c.Assert(err, IsNil)
// Initializing tsh join
proxy, err := client.ConnectToProxy(s.proxyAddress,
[]ssh.AuthMethod{s.teleagent.AuthMethod()}, client.CheckHostSignerFromCache, "anyuser")
c.Assert(err, IsNil)
authClient, err := auth.NewClientFromSSHClient(authConn.Client)
c.Assert(err, IsNil)
authConn, err := proxy.ConnectToHangout(hangoutServer.HangoutID+":"+utils.HangoutAuthPortAlias, []ssh.AuthMethod{s.teleagent.AuthMethod()})
c.Assert(err, IsNil)
nodeAuthMethod, err := Authorize(authClient)
c.Assert(err, IsNil)
authClient, err := auth.NewClientFromSSHClient(authConn.Client)
c.Assert(err, IsNil)
nodeConn, err := proxy.ConnectToHangout(hangoutServer.HangoutID+":"+utils.HangoutNodePortAlias, []ssh.AuthMethod{nodeAuthMethod})
c.Assert(err, IsNil)
nodeAuthMethod, err := Authorize(authClient)
c.Assert(err, IsNil)
shell2, err := nodeConn.Shell(100, 100, "hangoutSession")
c.Assert(err, IsNil)
shell2Reader := bufio.NewReader(shell2)
// tsh join initialized
c.Assert(authConn.Close(), IsNil)
// run second command
_, err = shell1.Write([]byte("expr 2 + 3\n"))
c.Assert(err, IsNil)
nodeConn, err := proxy.ConnectToHangout(hangoutServer.HangoutID+":"+utils.HangoutNodePortAlias, []ssh.AuthMethod{nodeAuthMethod})
c.Assert(err, IsNil)
out, err = shell1Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 2 + 3\r\n5\r\n$")
shell2, err := nodeConn.Shell(100, 100, "hangoutSession")
c.Assert(err, IsNil)
shell2Reader := bufio.NewReader(shell2)
// tsh join initialized
out, err = shell2Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, "expr 2 + 3\r\n5\r\n$")
// run second command
_, err = shell1.Write([]byte("expr 2 + 3\n"))
c.Assert(err, IsNil)
// run third command
_, err = shell2.Write([]byte("expr 6 + 2\n"))
c.Assert(err, IsNil)
out, err = shell1Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 2 + 3\r\n5\r\n$")
out, err = shell1Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 6 + 2\r\n8\r\n$")
out, err = shell2Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, "expr 2 + 3\r\n5\r\n$")
out, err = shell2Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 6 + 2\r\n8\r\n$")
// run third command
_, err = shell2.Write([]byte("expr 6 + 2\n"))
c.Assert(err, IsNil)
out, err = shell1Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 6 + 2\r\n8\r\n$")
out, err = shell2Reader.ReadString('$')
c.Assert(err, IsNil)
c.Assert(out, Equals, " expr 6 + 2\r\n8\r\n$")
c.Assert(shell2.Close(), IsNil)
c.Assert(nodeConn.Close(), IsNil)
c.Assert(proxy.Close(), IsNil)
}
c.Assert(shell1.Close(), IsNil)
c.Assert(shell2.Close(), IsNil)
}
lib/reversetunnel/srv.go
+1
View File
@@ -587,6 +587,7 @@ func newRemoteSite(srv *server, domainName string) (*tunnelSite, error) {
"http://stub:0",
roundtrip.HTTPClient(&http.Client{
Transport: remoteSite.transport,
Timeout: 5 * time.Second,
}))
if err != nil {
return nil, trace.Wrap(err)
lib/srv/proxy.go
+2
View File
@@ -58,10 +58,12 @@ func (t *proxySubsys) execute(sconn *ssh.ServerConn, ch ssh.Channel, req *ssh.Re
serverAddr := fmt.Sprintf("%v:%v", t.host, t.port)
var server *services.Server
for i := range servers {
ip, port, err := net.SplitHostPort(servers[i].Addr)
if err != nil {
return trace.Wrap(err)
}
// match either by hostname of ip, based on the match
if (t.host == ip || t.host == servers[i].Hostname) && port == t.port {
server = &servers[i]
lib/srv/srv.go
+1 -1
View File
@@ -181,7 +181,7 @@ func (s *Server) Addr() string {
}
func (s *Server) ID() string {
return s.hostname
return s.addr.Addr
}
func (s *Server) heartbeatPresence() {
lib/srv/srv_test.go
+30 -16
View File
@@ -55,6 +55,7 @@ func TestSrv(t *testing.T) { TestingT(t) }
type SrvSuite struct {
srv *Server
srvAddress string
srvPort string
srvHostPort string
clt *ssh.Client
bk *encryptedbk.ReplicatedBackend
@@ -65,6 +66,7 @@ type SrvSuite struct {
dir string
user string
domainName string
freePorts []string
}
var _ = Suite(&SrvSuite{})
@@ -80,6 +82,9 @@ func (s *SrvSuite) SetUpTest(c *C) {
c.Assert(err, IsNil)
s.user = u.Username
s.freePorts, err = utils.GetFreeTCPPorts(10)
c.Assert(err, IsNil)
baseBk, err := boltbk.New(filepath.Join(s.dir, "db"))
c.Assert(err, IsNil)
s.bk, err = encryptedbk.NewReplicatedBackend(baseBk,
@@ -132,8 +137,11 @@ func (s *SrvSuite) SetUpTest(c *C) {
)
c.Assert(err, IsNil)
s.srvAddress = "127.0.0.1:30185"
s.srvHostPort = fmt.Sprintf("%v:30185", s.domainName)
s.srvPort = s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.srvAddress = "127.0.0.1:" + s.srvPort
s.srvHostPort = fmt.Sprintf("%v:%v", s.domainName, s.srvPort)
srv, err := New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.srvAddress},
s.domainName,
@@ -351,7 +359,9 @@ func (s *SrvSuite) TestProxy(c *C) {
limiter, err := limiter.NewLimiter(limiter.LimiterConfig{})
c.Assert(err, IsNil)
reverseTunnelAddress := utils.NetAddr{AddrNetwork: "tcp", Addr: fmt.Sprintf("%v:33056", s.domainName)}
reverseTunnelPort := s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
reverseTunnelAddress := utils.NetAddr{AddrNetwork: "tcp", Addr: fmt.Sprintf("%v:%v", s.domainName, reverseTunnelPort)}
reverseTunnelServer, err := reversetunnel.NewServer(
reverseTunnelAddress,
[]ssh.Signer{s.signer},
@@ -388,7 +398,7 @@ func (s *SrvSuite) TestProxy(c *C) {
go apiSrv.Serve()
tsrv, err := auth.NewTunServer(
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:31497"},
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:0"},
[]ssh.Signer{s.signer},
apiSrv, s.a, limiter)
c.Assert(err, IsNil)
@@ -440,7 +450,7 @@ func (s *SrvSuite) TestProxy(c *C) {
c.Assert(err, IsNil)
// Request opening TCP connection to the remote host
unregisteredAddress := "0.0.0.0:30185"
unregisteredAddress := "0.0.0.0:" + s.srvPort
c.Assert(se0.RequestSubsystem(fmt.Sprintf("proxy:%v", unregisteredAddress)), IsNil)
local, err := utils.ParseAddr("tcp://" + proxy.Addr())
@@ -465,7 +475,8 @@ func (s *SrvSuite) TestProxy(c *C) {
s.testClient(c, proxy.Addr(), s.srvHostPort, s.srv.Addr(), sshConfig)
// adding new node
bobAddr := "127.0.0.1:31185"
bobAddr := "127.0.0.1:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
srv2, err := New(
utils.NetAddr{AddrNetwork: "tcp", Addr: bobAddr},
"bob",
@@ -519,8 +530,8 @@ func (s *SrvSuite) TestProxy(c *C) {
for _, node := range nodes {
nmap[node.ID] = node
}
c.Assert(nmap["bob"], DeepEquals, services.Server{
ID: "bob",
c.Assert(nmap[bobAddr], DeepEquals, services.Server{
ID: bobAddr,
Addr: bobAddr,
Hostname: "bob",
Labels: map[string]string{"label1": "value1"},
@@ -536,9 +547,9 @@ func (s *SrvSuite) TestProxy(c *C) {
Result: "5",
}}})
c.Assert(nmap["localhost"], DeepEquals, services.Server{
ID: "localhost",
Addr: "127.0.0.1:30185",
c.Assert(nmap[s.srvAddress], DeepEquals, services.Server{
ID: s.srvAddress,
Addr: s.srvAddress,
Hostname: "localhost"})
}
@@ -550,9 +561,11 @@ func (s *SrvSuite) TestProxyRoundRobin(c *C) {
})
c.Assert(err, IsNil)
reverseTunnelPort := s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
reverseTunnelAddress := utils.NetAddr{
AddrNetwork: "tcp",
Addr: fmt.Sprintf("%v:33066", s.domainName),
Addr: fmt.Sprintf("%v:%v", s.domainName, reverseTunnelPort),
}
reverseTunnelServer, err := reversetunnel.NewServer(
reverseTunnelAddress,
@@ -592,7 +605,7 @@ func (s *SrvSuite) TestProxyRoundRobin(c *C) {
go apiSrv.Serve()
tsrv, err := auth.NewTunServer(
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:31438"},
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:0"},
[]ssh.Signer{s.signer},
apiSrv, s.a, limiter)
c.Assert(err, IsNil)
@@ -665,7 +678,7 @@ func (s *SrvSuite) TestProxyDirectAccess(c *C) {
reverseTunnelAddress := utils.NetAddr{
AddrNetwork: "tcp",
Addr: fmt.Sprintf("%v:33066", s.domainName),
Addr: fmt.Sprintf("%v:0", s.domainName),
}
reverseTunnelServer, err := reversetunnel.NewServer(
reverseTunnelAddress,
@@ -705,7 +718,7 @@ func (s *SrvSuite) TestProxyDirectAccess(c *C) {
go apiSrv.Serve()
tsrv, err := auth.NewTunServer(
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:31538"},
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:0"},
[]ssh.Signer{s.signer},
apiSrv, s.a, limiter)
c.Assert(err, IsNil)
@@ -809,7 +822,8 @@ func (s *SrvSuite) TestLimiter(c *C) {
)
c.Assert(err, IsNil)
srvAddress := "127.0.0.1:30285"
srvAddress := "127.0.0.1:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
srv, err := New(
utils.NetAddr{AddrNetwork: "tcp", Addr: srvAddress},
s.domainName,
lib/sshutils/scp/scp_test.go
+1 -1
View File
@@ -81,7 +81,7 @@ func (s *SCPSuite) TestSendFile(c *C) {
}()
select {
case <-time.After(time.Second):
case <-time.After(2 * time.Second):
c.Fatalf("timeout")
case err := <-errC:
c.Assert(err, IsNil)
lib/utils/utils.go
+17 -14
View File
@@ -112,23 +112,26 @@ func IsHandshakeFailedError(err error) bool {
return strings.Contains(err.Error(), "handshake failed")
}
func GetFreeTCPPort() (port string, e error) {
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return "", trace.Wrap(err)
}
func GetFreeTCPPorts(n int) (ports []string, e error) {
for i := 0; i < n; i++ {
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return nil, trace.Wrap(err)
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return "", trace.Wrap(err)
}
defer listener.Close()
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return nil, trace.Wrap(err)
}
defer listener.Close()
tcpAddr, ok := listener.Addr().(*net.TCPAddr)
if !ok {
return "", trace.Errorf("Can't get tcp address")
tcpAddr, ok := listener.Addr().(*net.TCPAddr)
if !ok {
return nil, trace.Errorf("Can't get tcp address")
}
ports = append(ports, strconv.Itoa(tcpAddr.Port))
}
return strconv.Itoa(tcpAddr.Port), nil
return ports, nil
}
const (
tool/tsh/tsh.go
+3 -10
View File
@@ -279,17 +279,10 @@ func SCP(proxyAddress, source, dest string, isDir bool, port string, authMethods
func Share(proxyAddress, hangoutProxyAddress string, readOnly bool, authMethods []ssh.AuthMethod,
hostKeyCallback utils.HostKeyCallback) error {
nodePort, err := utils.GetFreeTCPPort()
if err != nil {
return trace.Wrap(err)
}
authPort, err := utils.GetFreeTCPPort()
if err != nil {
return trace.Wrap(err)
}
ports, err := utils.GetFreeTCPPorts(2)
nodeListeningAddress := "localhost:" + nodePort
authListeningAddress := "localhost:" + authPort
nodeListeningAddress := "localhost:" + ports[0]
authListeningAddress := "localhost:" + ports[1]
hangoutServer, err := hangout.New(hangoutProxyAddress, nodeListeningAddress,
authListeningAddress, readOnly, authMethods, hostKeyCallback)
tool/tsh/tsh_test.go
+57 -67
View File
@@ -27,6 +27,7 @@ import (
"testing"
"time"
"github.com/gravitational/teleport"
"github.com/gravitational/teleport/lib/auth"
authority "github.com/gravitational/teleport/lib/auth/testauthority"
"github.com/gravitational/teleport/lib/backend"
@@ -48,6 +49,7 @@ import (
"github.com/gokyle/hotp"
"golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/agent"
. "gopkg.in/check.v1"
log "github.com/Sirupsen/logrus"
@@ -58,23 +60,18 @@ func TestTsh(t *testing.T) { TestingT(t) }
type TshSuite struct {
srv *srv.Server
srv2 *srv.Server
srv3 *exec.Cmd
srv4 *exec.Cmd
proxy *srv.Server
srvAddress string
srvHost string
srvPort string
srv2Address string
srv3Address string
srv3Dir string
srv4Address string
srv4Dir string
proxyAddress string
webAddress string
agentAddr string
clt *ssh.Client
bk *encryptedbk.ReplicatedBackend
a *auth.AuthServer
roleAuth *auth.AuthWithRoles
signer ssh.Signer
teleagent *teleagent.TeleAgent
dir string
@@ -84,18 +81,22 @@ type TshSuite struct {
pass []byte
envVars []string
userDir string
freePorts []string
}
var _ = Suite(&TshSuite{})
func (s *TshSuite) SetUpSuite(c *C) {
utils.InitLoggerCLI()
client.KeysDir = c.MkDir()
//client.KeysDir = c.MkDir()
s.dir = c.MkDir()
s.dir2 = c.MkDir()
allowAllLimiter, err := limiter.NewLimiter(limiter.LimiterConfig{})
c.Assert(err, IsNil)
s.freePorts, err = utils.GetFreeTCPPorts(10)
c.Assert(err, IsNil)
baseBk, err := boltbk.New(filepath.Join(s.dir, "db"))
c.Assert(err, IsNil)
@@ -106,13 +107,23 @@ func (s *TshSuite) SetUpSuite(c *C) {
s.a = auth.NewAuthServer(s.bk, authority.New(), "localhost")
eventsLog, err := boltlog.New(filepath.Join(s.dir, "boltlog"))
c.Assert(err, IsNil)
s.roleAuth = auth.NewAuthWithRoles(s.a,
auth.NewStandardPermissions(),
eventsLog,
sess.New(baseBk),
teleport.RoleAdmin,
nil)
// set up host private key and certificate
c.Assert(s.a.UpsertCertAuthority(
*services.NewTestCA(services.HostCA, "localhost"), backend.Forever), IsNil)
hpriv, hpub, err := s.a.GenerateKeyPair("")
c.Assert(err, IsNil)
hcert, err := s.a.GenerateHostCert(hpub, "localhost", "localhost", auth.RoleAdmin, 0)
hcert, err := s.a.GenerateHostCert(hpub, "localhost", "localhost", teleport.RoleAdmin, 0)
c.Assert(err, IsNil)
// set up user CA and set up a user that has access to the server
@@ -123,15 +134,16 @@ func (s *TshSuite) SetUpSuite(c *C) {
c.Assert(err, IsNil)
// Starting node1
s.srvAddress = "127.0.0.1:30136"
s.srvPort = s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.srvHost = "127.0.0.1"
s.srvPort = "30136"
s.srvAddress = s.srvHost + ":" + s.srvPort
s.srv, err = srv.New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.srvAddress},
"localhost",
[]ssh.Signer{s.signer},
s.a,
s.roleAuth,
allowAllLimiter,
s.dir,
srv.SetShell("/bin/sh"),
@@ -140,6 +152,8 @@ func (s *TshSuite) SetUpSuite(c *C) {
"label1": "value1",
"label2": "value2",
"label3": "value3",
"label4": "value4",
"label5": "value5",
},
services.CommandLabels{
"cmdLabel1": services.CommandLabel{
@@ -152,17 +166,18 @@ func (s *TshSuite) SetUpSuite(c *C) {
c.Assert(s.srv.Start(), IsNil)
// Starting node2
s.srv2Address = "127.0.0.1:30983"
s.srv2Address = "127.0.0.1:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.srv2, err = srv.New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.srv2Address},
"localhost",
[]ssh.Signer{s.signer},
s.a,
s.roleAuth,
allowAllLimiter,
s.dir2,
srv.SetShell("/bin/sh"),
srv.SetLabels(
map[string]string{"label1": "value1", "label3": "value4"},
map[string]string{"label1": "value1", "label3": "value4", "label4": "value4", "label5": "value6"},
services.CommandLabels{
"cmdLabel1": services.CommandLabel{
Period: time.Second,
@@ -179,21 +194,24 @@ func (s *TshSuite) SetUpSuite(c *C) {
c.Assert(s.srv2.Start(), IsNil)
// Starting proxy
reverseTunnelAddress := utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:33736"}
reverseTunnelPort := s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
reverseTunnelAddress := utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:" + reverseTunnelPort}
reverseTunnelServer, err := reversetunnel.NewServer(
reverseTunnelAddress,
[]ssh.Signer{s.signer},
s.a, allowAllLimiter)
s.roleAuth, allowAllLimiter)
c.Assert(err, IsNil)
c.Assert(reverseTunnelServer.Start(), IsNil)
s.proxyAddress = "localhost:34284"
s.proxyAddress = "localhost:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
s.proxy, err = srv.New(
utils.NetAddr{AddrNetwork: "tcp", Addr: s.proxyAddress},
"localhost",
[]ssh.Signer{s.signer},
s.a,
s.roleAuth,
allowAllLimiter,
s.dir,
srv.SetProxyMode(reverseTunnelServer),
@@ -213,8 +231,10 @@ func (s *TshSuite) SetUpSuite(c *C) {
)
go apiSrv.Serve()
tunServerAddress := "localhost:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
tsrv, err := auth.NewTunServer(
utils.NetAddr{AddrNetwork: "tcp", Addr: "localhost:31948"},
utils.NetAddr{AddrNetwork: "tcp", Addr: tunServerAddress},
[]ssh.Signer{s.signer},
apiSrv, s.a, allowAllLimiter)
c.Assert(err, IsNil)
@@ -259,7 +279,8 @@ func (s *TshSuite) SetUpSuite(c *C) {
)
c.Assert(err, IsNil)
s.webAddress = "localhost:31236"
s.webAddress = "localhost:" + s.freePorts[len(s.freePorts)-1]
s.freePorts = s.freePorts[:len(s.freePorts)-1]
go func() {
err := http.ListenAndServe(s.webAddress, webHandler)
@@ -270,43 +291,6 @@ func (s *TshSuite) SetUpSuite(c *C) {
currentDir, err := os.Getwd()
c.Assert(err, IsNil)
token1, err := s.a.GenerateToken("localhost", "Node", time.Minute)
c.Assert(err, IsNil)
s.srv3Dir = c.MkDir()
s.srv3Address = "127.0.0.1:30984"
s.srv3 = exec.Command("teleport", "--env")
s.srv3.Dir = s.srv3Dir
s.srv3.Env = append(
[]string{
"TELEPORT_HOSTNAME=localhost",
"TELEPORT_SSH_TOKEN=" + token1,
"TELEPORT_SSH_ENABLED=true",
"TELEPORT_SSH_ADDR=tcp://" + s.srv3Address,
`TELEPORT_AUTH_SERVERS=["tcp://` + tsrv.Addr() + `"]`,
"TELEPORT_DATA_DIR=" + s.srv3Dir,
`TELEPORT_SSH_LABELS={"label4":"value4", "label5":"value5"}`,
"PWD=" + s.srv3Dir}, os.Environ()...,
)
s.srv3.Start()
token2, err := s.a.GenerateToken("localhost", "Node", time.Minute)
c.Assert(err, IsNil)
s.srv4Dir = c.MkDir()
os.Chdir(s.srv4Dir)
s.srv4Address = "127.0.0.1:30985"
s.srv4 = exec.Command("teleport", "--env")
s.srv4.Env = append(
[]string{
"TELEPORT_HOSTNAME=localhost",
"TELEPORT_SSH_TOKEN=" + token2,
"TELEPORT_SSH_ENABLED=true",
"TELEPORT_SSH_ADDR=tcp://" + s.srv4Address,
`TELEPORT_AUTH_SERVERS=["tcp://` + tsrv.Addr() + `"]`,
"TELEPORT_DATA_DIR=" + s.srv4Dir,
`TELEPORT_SSH_LABELS={"label4":"value4", "label5":"value6"}`,
"PWD=" + s.srv4Dir}, os.Environ()...,
)
s.srv4.Start()
os.Chdir(currentDir)
@@ -316,14 +300,17 @@ func (s *TshSuite) SetUpSuite(c *C) {
err = s.teleagent.Login("http://"+s.webAddress, s.user, string(s.pass), s.otp.OTP(), time.Minute)
c.Assert(err, IsNil)
passwordCallback := func() (password, hotpToken string, e error) {
return string(s.pass), s.otp.OTP(), nil
}
err = client.Login(agent.NewKeyring(), s.webAddress, s.user, 5*time.Minute, passwordCallback)
c.Assert(err, IsNil)
s.envVars = append([]string{"SSH_AUTH_SOCK=" + s.agentAddr}, os.Environ()...)
// "Command labels will be calculated only on the second heartbeat"
time.Sleep(time.Millisecond * 3100)
}
func (s *TshSuite) TearDownSuite(c *C) {
s.srv3.Process.Kill()
s.srv4.Process.Kill()
}
func (s *TshSuite) TestRunCommand(c *C) {
@@ -378,11 +365,11 @@ func (s *TshSuite) TestRunCommandOn2Servers(c *C) {
c.Assert(true, Equals, strings.Contains(string(out), fmt.Sprintf(
"Running command on %v\n-----------------------------\n%v\n-----------------------------\n\n",
s.srv3Address, s.userDir)))
s.srvAddress, s.userDir)))
c.Assert(true, Equals, strings.Contains(string(out), fmt.Sprintf(
"Running command on %v\n-----------------------------\n%v\n-----------------------------\n\n",
s.srv4Address, s.userDir)))
s.srv2Address, s.userDir)))
}
func (s *TshSuite) TestRunCommandWithProxy(c *C) {
@@ -393,6 +380,9 @@ func (s *TshSuite) TestRunCommandWithProxy(c *C) {
`""expr 3 + 50""`)
cmd.Env = s.envVars
out, err := cmd.Output()
if err != nil {
c.Assert(string(out), Equals, "")
}
c.Assert(err, IsNil)
c.Assert(string(out), Equals, fmt.Sprintf("Running command on %v\n-----------------------------\n53\n-----------------------------\n\n", s.srvAddress))
@@ -548,8 +538,8 @@ func (s *TshSuite) TestDownloadFileFrom2Servers(c *C) {
c.Assert(err, IsNil)
}
outFile1 := filepath.Join(destDir, "file3", s.srv3Address)
outFile2 := filepath.Join(destDir, "file3", s.srv4Address)
outFile1 := filepath.Join(destDir, "file3", s.srvAddress)
outFile2 := filepath.Join(destDir, "file3", s.srv2Address)
bytes1, err := ioutil.ReadFile(outFile1)
c.Assert(err, IsNil)
@@ -592,10 +582,10 @@ func (s *TshSuite) TestDownloadDirFrom2Servers(c *C) {
c.Assert(err, IsNil)
}
outFile11 := filepath.Join(destDir, "copydir", s.srv3Address, "file11")
outFile12 := filepath.Join(destDir, "copydir", s.srv3Address, "file12")
outFile21 := filepath.Join(destDir, "copydir", s.srv4Address, "file11")
outFile22 := filepath.Join(destDir, "copydir", s.srv4Address, "file12")
outFile11 := filepath.Join(destDir, "copydir", s.srvAddress, "file11")
outFile12 := filepath.Join(destDir, "copydir", s.srvAddress, "file12")
outFile21 := filepath.Join(destDir, "copydir", s.srv2Address, "file11")
outFile22 := filepath.Join(destDir, "copydir", s.srv2Address, "file12")
bytes11, err := ioutil.ReadFile(outFile11)
c.Assert(err, IsNil)