func TestController(t *testing.T) {
setkeys := []string{
"/deis/registry/protocol",
"deis/registry/host",
"/deis/registry/port",
"/deis/cache/host",
"/deis/cache/port",
}
setdir := []string{
"/deis/controller",
"/deis/cache",
"/deis/database",
"/deis/registry",
"/deis/domains",
}
testID := utils.NewID()
err := dockercli.BuildImage(t, "../", "deis/controller:"+testID)
if err != nil {
t.Fatal(err)
}
etcdPort := utils.GetRandomPort()
dockercli.RunEtcdTest(t, testID, etcdPort)
handler := etcdutils.InitetcdValues(setdir, setkeys, etcdPort)
etcdutils.Publishvalues(t, handler)
dbPort := utils.GetRandomPort()
mock.RunMockDatabase(t, testID, etcdPort, dbPort)
servicePort := utils.GetRandomPort()
fmt.Printf("--- Test deis-controller-%s at port %s\n", testID, servicePort)
runDeisControllerTest(t, testID, etcdPort, servicePort)
dockercli.DeisServiceTest(
t, "deis-controller-"+testID, servicePort, "http")
dockercli.ClearTestSession(t, testID)
}
func TestCache(t *testing.T) {
var err error
tag := utils.BuildTag()
imageName := utils.ImagePrefix() + "cache" + ":" + tag
etcdPort := utils.RandomPort()
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run %s at %s:%s\n", imageName, host, port)
name := "deis-cache-" + tag
defer cli.CmdRm("-f", name)
go func() {
_ = cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":6379",
"-e", "EXTERNAL_PORT="+port,
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
imageName)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "started")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "tcp")
etcdutils.VerifyEtcdValue(t, "/deis/cache/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/cache/port", port, etcdPort)
}
func TestLogger(t *testing.T) {
var err error
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
//start etcd container
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run deis/logger:%s at %s:%s\n", tag, host, port)
name := "deis-logger-" + tag
defer cli.CmdRm("-f", name)
go func() {
_ = cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":514/udp",
"-e", "EXTERNAL_PORT="+port,
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"deis/logger:"+tag)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "deis-logger running")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "udp")
etcdutils.VerifyEtcdValue(t, "/deis/logs/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/logs/port", port, etcdPort)
}
func TestRouter(t *testing.T) {
setkeys := []string{
"deis/controller/host",
"/deis/controller/port",
"/deis/builder/host",
"/deis/builder/port",
}
setdir := []string{
"/deis/controller",
"/deis/router",
"/deis/database",
"/deis/services",
"/deis/builder",
"/deis/domains",
}
testID := utils.NewID()
err := dockercli.BuildImage(t, "../", "deis/router:"+testID)
if err != nil {
t.Fatal(err)
}
etcdPort := utils.GetRandomPort()
dockercli.RunEtcdTest(t, testID, etcdPort)
handler := etcdutils.InitetcdValues(setdir, setkeys, etcdPort)
etcdutils.Publishvalues(t, handler)
servicePort := utils.GetRandomPort()
fmt.Printf("--- Test deis-router-%s at port %s\n", testID, servicePort)
runDeisRouterTest(t, testID, etcdPort, servicePort)
// TODO: nginx needs a few seconds to wake up here--fixme!
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(
t, "deis-router-"+testID, servicePort, "http")
dockercli.ClearTestSession(t, testID)
}
func TestRouter(t *testing.T) {
var err error
setkeys := []string{
"/deis/controller/host",
"/deis/controller/port",
"/deis/builder/host",
"/deis/builder/port",
"/deis/store/gateway/host",
"/deis/store/gateway/port",
}
setdir := []string{
"/deis/controller",
"/deis/router",
"/deis/database",
"/deis/services",
"/deis/builder",
"/deis/domains",
"/deis/store",
}
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
imageName := utils.ImagePrefix() + "router" + ":" + tag
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
handler := etcdutils.InitEtcd(setdir, setkeys, etcdPort)
etcdutils.PublishEtcd(t, handler)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run %s at %s:%s\n", imageName, host, port)
name := "deis-router-" + tag
go func() {
_ = cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":80",
"-p", utils.RandomPort()+":2222",
"-e", "EXTERNAL_PORT="+port,
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"-e", "LOG=debug",
imageName)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "deis-router running")
if err != nil {
t.Fatal(err)
}
// FIXME: nginx needs a couple seconds to wake up here
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "http")
etcdutils.VerifyEtcdValue(t, "/deis/router/gzip", "on", etcdPort)
etcdutils.VerifyEtcdValue(t,
"/deis/router/hosts/"+host,
fmt.Sprintf("%s:%s", host, port),
etcdPort)
_ = cli.CmdRm("-f", name)
}
func TestBuilder(t *testing.T) {
var err error
setkeys := []string{
"/deis/registry/protocol",
"/deis/registry/host",
"/deis/registry/port",
"/deis/cache/host",
"/deis/cache/port",
"/deis/controller/protocol",
"/deis/controller/host",
"/deis/controller/port",
"/deis/controller/builderKey",
}
setdir := []string{
"/deis/controller",
"/deis/cache",
"/deis/database",
"/deis/registry",
"/deis/domains",
"/deis/services",
}
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
handler := etcdutils.InitEtcd(setdir, setkeys, etcdPort)
etcdutils.PublishEtcd(t, handler)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run deis/builder:%s at %s:%s\n", tag, host, port)
name := "deis-builder-" + tag
defer cli.CmdRm("-f", "-v", name)
go func() {
_ = cli.CmdRm("-f", "-v", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":22",
"-e", "PORT=22",
"-e", "STORAGE_DRIVER=aufs",
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"-e", "EXTERNAL_PORT="+port,
"--privileged", "deis/builder:"+tag)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "deis-builder running")
if err != nil {
t.Fatal(err)
}
// FIXME: builder needs a few seconds to wake up here!
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "tcp")
etcdutils.VerifyEtcdValue(t, "/deis/builder/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/builder/port", port, etcdPort)
}
func TestController(t *testing.T) {
var err error
setkeys := []string{
"/deis/registry/protocol",
"/deis/registry/host",
"/deis/registry/port",
"/deis/platform/domain",
"/deis/logs/host",
}
setdir := []string{
"/deis/controller",
"/deis/database",
"/deis/registry",
"/deis/domains",
"/deis/scheduler",
}
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
imageName := utils.ImagePrefix() + "controller" + ":" + tag
//start etcd container
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
handler := etcdutils.InitEtcd(setdir, setkeys, etcdPort)
etcdutils.PublishEtcd(t, handler)
mock.RunMockDatabase(t, tag, etcdPort, utils.RandomPort())
defer cli.CmdRm("-f", "deis-test-database-"+tag)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run %s at %s:%s\n", imageName, host, port)
name := "deis-controller-" + tag
defer cli.CmdRm("-f", name)
go func() {
cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-v", "/var/run/docker.sock:/var/run/docker.sock",
"-v", "/var/run/fleet.sock:/var/run/fleet.sock",
"-p", port+":8000",
"-e", "EXTERNAL_PORT="+port,
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
imageName)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "Booting")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "http")
etcdutils.VerifyEtcdValue(t, "/deis/controller/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/controller/port", port, etcdPort)
}
func TestRegistry(t *testing.T) {
var err error
setkeys := []string{
"/deis/cache/host",
"/deis/cache/port",
"/deis/store/gateway/host",
"/deis/store/gateway/port",
"/deis/store/gateway/accessKey",
"/deis/store/gateway/secretKey",
}
setdir := []string{
"/deis/cache",
"/deis/store",
}
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
handler := etcdutils.InitEtcd(setdir, setkeys, etcdPort)
etcdutils.PublishEtcd(t, handler)
// run mock ceph containers
cephName := "deis-ceph-" + tag
mock.RunMockCeph(t, cephName, cli, etcdPort)
defer cli.CmdRm("-f", "-v", cephName+"-monitor")
defer cli.CmdRm("-f", "-v", cephName+"-daemon")
defer cli.CmdRm("-f", cephName+"-metadata")
defer cli.CmdRm("-f", cephName+"-gateway")
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run deis/registry:%s at %s:%s\n", tag, host, port)
name := "deis-registry-" + tag
defer cli.CmdRm("-f", name)
go func() {
_ = cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":5000",
"-e", "EXTERNAL_PORT="+port,
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"deis/registry:"+tag)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "Booting")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "http")
etcdutils.VerifyEtcdValue(t, "/deis/registry/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/registry/port", port, etcdPort)
}
func TestCache(t *testing.T) {
testID := utils.NewID()
err := dockercli.BuildImage(t, "../", "deis/cache:"+testID)
if err != nil {
t.Fatal(err)
}
etcdPort := utils.GetRandomPort()
dockercli.RunEtcdTest(t, testID, etcdPort)
servicePort := utils.GetRandomPort()
fmt.Printf("--- Test deis-cache-%s at port %s\n", testID, servicePort)
runDeisCacheTest(t, testID, etcdPort, servicePort)
dockercli.DeisServiceTest(
t, "deis-cache-"+testID, servicePort, "tcp")
dockercli.ClearTestSession(t, testID)
}
func TestDatabase(t *testing.T) {
var err error
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
cli, stdout, stdoutPipe := dockercli.NewClient()
// start etcd container
etcdName := "deis-etcd-" + tag
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
// run mock ceph containers
cephName := "deis-ceph-" + tag
mock.RunMockCeph(t, cephName, cli, etcdPort)
defer cli.CmdRm("-f", "-v", cephName+"-monitor")
defer cli.CmdRm("-f", "-v", cephName+"-daemon")
defer cli.CmdRm("-f", cephName+"-metadata")
defer cli.CmdRm("-f", cephName+"-gateway")
// run database container
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run deis/database:%s at %s:%s\n", tag, host, port)
name := "deis-database-" + tag
defer cli.CmdRm("-f", name)
go func() {
_ = cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":5432",
"-e", "EXTERNAL_PORT="+port,
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"deis/database:"+tag)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "database: postgres is running...")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "tcp")
etcdutils.VerifyEtcdValue(t, "/deis/database/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/database/port", port, etcdPort)
}
func TestRegistry(t *testing.T) {
setkeys := []string{
"/deis/cache/host",
"/deis/cache/port",
}
setdir := []string{
"/deis/cache",
}
testID := utils.NewID()
err := dockercli.BuildImage(t, "../", "deis/registry:"+testID)
if err != nil {
t.Fatal(err)
}
etcdPort := utils.GetRandomPort()
dockercli.RunEtcdTest(t, testID, etcdPort)
handler := etcdutils.InitetcdValues(setdir, setkeys, etcdPort)
etcdutils.Publishvalues(t, handler)
servicePort := utils.GetRandomPort()
fmt.Printf("--- Test deis-registry-%s at port %s\n", testID, servicePort)
runDeisRegistryTest(t, testID, etcdPort, servicePort)
dockercli.DeisServiceTest(
t, "deis-registry-"+testID, servicePort, "http")
dockercli.ClearTestSession(t, testID)
}
func TestStore(t *testing.T) {
hostname := utils.Hostname()
var err error
// Set up etcd, which will be used by all containers
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
host := utils.HostAddress()
// prep etcd with the monitor hostname -- this is done in an ExecStartPre in the monitor unit
etcdutils.SetSingle(t, "/deis/store/hosts/"+host, hostname, etcdPort)
// since we're only running one OSD, our default of 128 placement groups is too large
etcdutils.SetSingle(t, "/deis/store/pgNum", "64", etcdPort)
// test deis-store-monitor
fmt.Printf("--- Run deis/store-monitor:%s at %s\n", tag, host)
name := "deis-store-monitor-" + tag
defer cli.CmdRm("-f", name)
go func() {
_ = cli.CmdRm("-f", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"-e", "NUM_STORES=1",
"--net=host",
"deis/store-monitor:"+tag)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "monmap e1: 1 mons at")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, "6789", "tcp")
etcdutils.VerifyEtcdKey(t, "/deis/store/monKeyring", etcdPort)
etcdutils.VerifyEtcdKey(t, "/deis/store/adminKeyring", etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/store/monSetupComplete", "youBetcha", etcdPort)
// test deis-store-daemon
fmt.Printf("--- Run deis/store-daemon:%s at %s\n", tag, host)
name = "deis-store-daemon-" + tag
cli2, stdout2, stdoutPipe2 := dockercli.NewClient()
defer cli2.CmdRm("-f", "-v", name)
go func() {
_ = cli2.CmdRm("-f", "-v", name)
err = dockercli.RunContainer(cli2,
"--name", name,
"--rm",
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"--net=host",
"deis/store-daemon:"+tag)
}()
dockercli.PrintToStdout(t, stdout2, stdoutPipe2, "journal close /var/lib/ceph/osd/ceph-0/journal")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, "6800", "tcp")
etcdutils.VerifyEtcdValue(t, "/deis/store/osds/"+host, "0", etcdPort)
// test deis-store-metadata
fmt.Printf("--- Run deis/store-metadata:%s at %s\n", tag, host)
name = "deis-store-metadata-" + tag
cli3, stdout3, stdoutPipe3 := dockercli.NewClient()
defer cli3.CmdRm("-f", "-v", name)
go func() {
_ = cli3.CmdRm("-f", "-v", name)
err = dockercli.RunContainer(cli3,
"--name", name,
"--rm",
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"--net=host",
"deis/store-metadata:"+tag)
}()
dockercli.PrintToStdout(t, stdout3, stdoutPipe3, "mds.0.1 active_start")
if err != nil {
t.Fatal(err)
}
// test deis-store-gateway
port := utils.RandomPort()
fmt.Printf("--- Run deis/store-gateway:%s at %s:%s\n", tag, host, port)
name = "deis-store-gateway-" + tag
cli4, stdout4, stdoutPipe4 := dockercli.NewClient()
defer cli4.CmdRm("-f", name)
go func() {
_ = cli4.CmdRm("-f", name)
err = dockercli.RunContainer(cli4,
"--name", name,
"--rm",
"-h", "deis-store-gateway",
"-p", port+":8888",
"-e", "HOST="+host,
"-e", "EXTERNAL_PORT="+port,
"-e", "ETCD_PORT="+etcdPort,
"deis/store-gateway:"+tag)
}()
dockercli.PrintToStdout(t, stdout4, stdoutPipe4, "deis-store-gateway running...")
if err != nil {
t.Fatal(err)
}
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "http")
etcdutils.VerifyEtcdValue(t, "/deis/store/gateway/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/store/gateway/port", port, etcdPort)
etcdutils.VerifyEtcdKey(t, "/deis/store/gatewayKeyring", etcdPort)
etcdutils.VerifyEtcdKey(t, "/deis/store/gateway/accessKey", etcdPort)
etcdutils.VerifyEtcdKey(t, "/deis/store/gateway/secretKey", etcdPort)
}
func TestBuilder(t *testing.T) {
var err error
var errfile error
setkeys := []string{
"/deis/registry/protocol",
"/deis/registry/host",
"/deis/registry/port",
"/deis/cache/host",
"/deis/cache/port",
"/deis/controller/protocol",
"/deis/controller/host",
"/deis/controller/port",
"/deis/controller/builderKey",
}
setdir := []string{
"/deis/controller",
"/deis/cache",
"/deis/database",
"/deis/registry",
"/deis/domains",
"/deis/services",
}
setproxy := []byte("HTTP_PROXY=\nhttp_proxy=\n")
tmpfile, errfile := ioutil.TempFile("/tmp", "deis-test-")
if errfile != nil {
t.Fatal(errfile)
}
ioutil.WriteFile(tmpfile.Name(), setproxy, 0644)
defer os.Remove(tmpfile.Name())
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
imageName := utils.ImagePrefix() + "builder" + ":" + tag
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
handler := etcdutils.InitEtcd(setdir, setkeys, etcdPort)
etcdutils.PublishEtcd(t, handler)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run %s at %s:%s\n", imageName, host, port)
name := "deis-builder-" + tag
defer cli.CmdRm("-f", "-v", name)
go func() {
_ = cli.CmdRm("-f", "-v", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":22",
"-e", "PORT=22",
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"-e", "EXTERNAL_PORT="+port,
"--privileged",
"-v", tmpfile.Name()+":/etc/environment_proxy",
imageName)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "deis-builder running")
if err != nil {
t.Fatal(err)
}
// FIXME: builder needs a few seconds to wake up here!
// FIXME: Wait until etcd keys are published
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "tcp")
etcdutils.VerifyEtcdValue(t, "/deis/builder/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/builder/port", port, etcdPort)
}
func TestBuilder(t *testing.T) {
var err error
var errfile error
setkeys := []string{
"/deis/registry/protocol",
"/deis/registry/host",
"/deis/registry/port",
"/deis/cache/host",
"/deis/cache/port",
"/deis/controller/protocol",
"/deis/controller/host",
"/deis/controller/port",
"/deis/controller/builderKey",
}
setdir := []string{
"/deis/controller",
"/deis/cache",
"/deis/database",
"/deis/registry",
"/deis/domains",
"/deis/services",
}
setproxy := []byte("HTTP_PROXY=\nhttp_proxy=\n")
tmpfile, errfile := ioutil.TempFile("/tmp", "deis-test-")
if errfile != nil {
t.Fatal(errfile)
}
ioutil.WriteFile(tmpfile.Name(), setproxy, 0644)
defer os.Remove(tmpfile.Name())
tag, etcdPort := utils.BuildTag(), utils.RandomPort()
imageName := utils.ImagePrefix() + "builder:" + tag
etcdName := "deis-etcd-" + tag
cli, stdout, stdoutPipe := dockercli.NewClient()
dockercli.RunTestEtcd(t, etcdName, etcdPort)
defer cli.CmdRm("-f", etcdName)
handler := etcdutils.InitEtcd(setdir, setkeys, etcdPort)
etcdutils.PublishEtcd(t, handler)
host, port := utils.HostAddress(), utils.RandomPort()
fmt.Printf("--- Run %s at %s:%s\n", imageName, host, port)
// Run a mock registry to test whether the builder can push its initial
// images.
regport := utils.RandomPort()
mockRegistry(host, regport, t)
setupRegistry("http", host, regport, t, handler)
// When we switch to Registry v2, we probably want to uncomment this
// and then remove mockRegistry.
// dockercli.RunTestRegistry(t, "registry", host, regport)
name := "deis-builder-" + tag
defer cli.CmdRm("-f", "-v", name)
go func() {
_ = cli.CmdRm("-f", "-v", name)
err = dockercli.RunContainer(cli,
"--name", name,
"--rm",
"-p", port+":2223",
"-e", "PORT=2223",
"-e", "HOST="+host,
"-e", "ETCD_PORT="+etcdPort,
"-e", "EXTERNAL_PORT="+port,
"--privileged",
"-v", tmpfile.Name()+":/etc/environment_proxy",
imageName)
}()
dockercli.PrintToStdout(t, stdout, stdoutPipe, "Builder is running")
if err != nil {
t.Fatal(err)
}
time.Sleep(5000 * time.Millisecond)
dockercli.DeisServiceTest(t, name, port, "tcp")
etcdutils.VerifyEtcdValue(t, "/deis/builder/host", host, etcdPort)
etcdutils.VerifyEtcdValue(t, "/deis/builder/port", port, etcdPort)
}