func NewTunnelTest() (*TunnelTest, error) {
cfg := &tunnel.ServerConfig{
Debug: testing.Verbose(),
}
s, err := tunnel.NewServer(cfg)
if err != nil {
return nil, err
}
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return nil, err
}
if debugNet {
l = dbgListener{l}
}
addrs, err := UsableAddrs()
if err != nil {
return nil, err
}
go (&http.Server{Handler: s}).Serve(l)
return &TunnelTest{
Server: s,
Clients: make(map[string]*tunnel.Client),
Listeners: map[string][2]net.Listener{"": {l, nil}},
Addrs: addrs,
Tunnels: make(map[string]*Tunnel),
DebugNet: debugNet,
}, nil
}
// NewServer gives new tunneling server for the given options.
func NewServer(opts *ServerOptions) (*Server, error) {
optsCopy := *opts
if optsCopy.ServerAddr == "" {
ip, err := publicIP()
if err != nil {
return nil, err
}
optsCopy.ServerAddr = ip
}
if optsCopy.Log == nil {
optsCopy.Log = logging.NewCustom("tunnelserver", optsCopy.Debug)
}
optsCopy.Log.Debug("Initial server options: %# v", &optsCopy)
if optsCopy.BaseVirtualHost == "" {
optsCopy.BaseVirtualHost = optsCopy.HostedZone
}
if optsCopy.BaseVirtualHost == "" {
return nil, errors.New("either BaseVirtualHost or HostedZone parameter is required to be non-empty")
}
optsCopy.BaseVirtualHost = customPort(optsCopy.BaseVirtualHost, opts.Port, 80, 443)
optsCopy.ServerAddr = customPort(optsCopy.ServerAddr, opts.Port)
if optsCopy.TCPRangeFrom == 0 {
optsCopy.TCPRangeFrom = 20000
}
if optsCopy.TCPRangeTo == 0 {
optsCopy.TCPRangeTo = 50000
}
tunnelCfg := &tunnel.ServerConfig{
Debug: optsCopy.Debug,
Log: optsCopy.Log,
}
server, err := tunnel.NewServer(tunnelCfg)
if err != nil {
return nil, err
}
if optsCopy.NoCNAME && (optsCopy.AccessKey == "" || optsCopy.SecretKey == "") {
return nil, errors.New("no valid Route53 configuration found")
}
var dns *dnsclient.Route53
if optsCopy.AccessKey != "" && optsCopy.SecretKey != "" {
dnsOpts := &dnsclient.Options{
Creds: credentials.NewStaticCredentials(optsCopy.AccessKey, optsCopy.SecretKey, ""),
HostedZone: optsCopy.HostedZone,
Log: optsCopy.Log,
Debug: optsCopy.Debug,
}
dns, err = dnsclient.NewRoute53Client(dnsOpts)
if err != nil {
return nil, err
}
}
// Inserts DNS records for the tunnelserver. Host-routing requires an A record pointing
// to the tunnelserver and a wildcard CNAME record pointing to that A record.
// In other words if tunnel.example.com resolves to the tunnelserver, then
// *.tunnel.example.com must also resolve to the very same tunnelserver instance.
//
// If there are not route53 credentials passed, we assume the DNS records are
// taken care externally.
if !optsCopy.NoCNAME && dns != nil {
id, err := instanceID()
if err != nil {
if optsCopy.Test {
username := os.Getenv("USER")
if u, err := user.Current(); err == nil {
username = u.Username
}
id = "koding-" + username
}
}
if id != "" {
optsCopy.BaseVirtualHost = strings.TrimPrefix(id, "i-") + "." + optsCopy.BaseVirtualHost
}
ip := host(optsCopy.ServerAddr)
base := host(optsCopy.BaseVirtualHost)
tunnelRec := &dnsclient.Record{
Name: base,
IP: ip,
Type: "A",
TTL: 300,
}
allRec := &dnsclient.Record{
Name: "\\052." + base,
IP: base,
Type: "CNAME",
TTL: 300,
}
// TODO(rjeczalik): add retries to pkg/dnsclient (TMS-2052)
for i := 0; i < 5; i++ {
if err = dns.UpsertRecords(tunnelRec, allRec); err == nil {
break
}
time.Sleep(time.Duration(i) * time.Second) // linear backoff, overall time: 30s
}
if err != nil {
return nil, err
}
}
optsCopy.Log.Debug("Server options: %# v", &optsCopy)
s := &Server{
Server: server,
DNS: dns,
opts: &optsCopy,
privateIP: "0.0.0.0",
record: dnsclient.ParseRecord("", optsCopy.ServerAddr),
idents: make(map[string]string),
services: make(map[int]net.Listener),
tunnels: newTunnels(),
}
// Do not bind to private address for testing.
if !s.opts.Test {
if ip, err := privateIP(); err == nil {
s.privateIP = ip
}
}
return s, nil
}