func (s *BasicSuite) TestBasic(t *c.C) {
name := util.RandomString(30)
t.Assert(s.Flynn("create", name), Outputs, fmt.Sprintf("Created %s\n", name))
push := s.Git("push", "flynn", "master")
t.Assert(push, OutputContains, "Node.js app detected")
t.Assert(push, OutputContains, "Downloading and installing node")
t.Assert(push, OutputContains, "Installing dependencies")
t.Assert(push, OutputContains, "Procfile declares types -> web")
t.Assert(push, OutputContains, "Creating release")
t.Assert(push, OutputContains, "Application deployed")
t.Assert(push, OutputContains, "* [new branch] master -> master")
t.Assert(s.Flynn("scale", "web=3"), Succeeds)
newRoute := s.Flynn("route-add-http", util.RandomString(32)+".dev")
t.Assert(newRoute, Succeeds)
t.Assert(s.Flynn("routes"), OutputContains, strings.TrimSpace(newRoute.Output))
// use Attempts to give the processes time to start
if err := Attempts.Run(func() error {
ps := s.Flynn("ps")
if ps.Err != nil {
return ps.Err
}
psLines := strings.Split(strings.TrimSpace(ps.Output), "\n")
if len(psLines) != 4 {
return fmt.Errorf("Expected 4 ps lines, got %d", len(psLines))
}
for _, l := range psLines[1:] {
idType := regexp.MustCompile(`\s+`).Split(l, 2)
if idType[1] != "web" {
return fmt.Errorf("Expected web type, got %s", idType[1])
}
log := s.Flynn("log", idType[0])
if !strings.Contains(log.Output, "Listening on ") {
return fmt.Errorf("Expected \"%s\" to contain \"Listening on \"", log.Output)
}
}
return nil
}); err != nil {
t.Error(err)
}
// Make HTTP requests
}
func (s *BasicSuite) TestBasic(t *c.C) {
name := random.String(30)
t.Assert(s.Flynn("create", name), Outputs, fmt.Sprintf("Created %s\n", name))
push := s.Git("push", "flynn", "master")
t.Assert(push, OutputContains, "Node.js app detected")
t.Assert(push, OutputContains, "Downloading and installing node")
t.Assert(push, OutputContains, "Installing dependencies")
t.Assert(push, OutputContains, "Procfile declares types -> web")
t.Assert(push, OutputContains, "Creating release")
t.Assert(push, OutputContains, "Application deployed")
t.Assert(push, OutputContains, "* [new branch] master -> master")
t.Assert(s.Flynn("scale", "web=3"), Succeeds)
route := random.String(32) + ".dev"
newRoute := s.Flynn("route", "add", "-t", "http", route)
t.Assert(newRoute, Succeeds)
t.Assert(s.Flynn("route"), OutputContains, strings.TrimSpace(newRoute.Output))
// use Attempts to give the processes time to start
if err := Attempts.Run(func() error {
ps := s.Flynn("ps")
if ps.Err != nil {
return ps.Err
}
psLines := strings.Split(strings.TrimSpace(ps.Output), "\n")
if len(psLines) != 4 {
return fmt.Errorf("Expected 4 ps lines, got %d", len(psLines))
}
for _, l := range psLines[1:] {
idType := regexp.MustCompile(`\s+`).Split(l, 2)
if idType[1] != "web" {
return fmt.Errorf("Expected web type, got %s", idType[1])
}
log := s.Flynn("log", idType[0])
if !strings.Contains(log.Output, "Listening on ") {
return fmt.Errorf("Expected \"%s\" to contain \"Listening on \"", log.Output)
}
}
return nil
}); err != nil {
t.Error(err)
}
// Make HTTP requests
client := &http.Client{}
req, err := http.NewRequest("GET", "http://"+routerIP, nil)
if err != nil {
t.Error(err)
}
req.Host = route
res, err := client.Do(req)
if err != nil {
t.Error(err)
}
defer res.Body.Close()
contents, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Error(err)
}
t.Assert(res.StatusCode, c.Equals, 200)
t.Assert(string(contents), Matches, `Hello to Yahoo from Flynn on port \d+`)
}
func (s *SchedulerSuite) TestTCPApp(t *c.C) {
r, err := s.client.GetAppRelease("gitreceive")
t.Assert(err, c.IsNil)
imageID := r.Processes["app"].Env["SLUGRUNNER_IMAGE_ID"]
app := &ct.App{}
t.Assert(s.client.CreateApp(app), c.IsNil)
artifact := &ct.Artifact{Type: "docker", URI: "https://registry.hub.docker.com/flynn/slugrunner?id=" + imageID}
t.Assert(s.client.CreateArtifact(artifact), c.IsNil)
release := &ct.Release{
ArtifactID: artifact.ID,
Processes: map[string]ct.ProcessType{
"echo": {
Ports: []ct.Port{{Proto: "tcp"}},
Cmd: []string{"sdutil exec -s echo-service:$PORT socat -v tcp-l:$PORT,fork exec:/bin/cat"},
Entrypoint: []string{"sh", "-c"},
},
},
}
t.Assert(s.client.CreateRelease(release), c.IsNil)
t.Assert(s.client.SetAppRelease(app.ID, release.ID), c.IsNil)
stream, err := s.client.StreamJobEvents(app.ID)
defer stream.Close()
if err != nil {
t.Error(err)
}
t.Assert(flynn("/", "-a", app.Name, "scale", "echo=1"), Succeeds)
newRoute := flynn("/", "-a", app.Name, "route", "add", "tcp", "-s", "echo-service")
t.Assert(newRoute, Succeeds)
t.Assert(newRoute.Output, Matches, `.+ on port \d+`)
str := strings.Split(strings.TrimSpace(string(newRoute.Output)), " ")
port := str[len(str)-1]
waitForJobEvents(t, stream.Events, map[string]int{"echo": 1})
// use Attempts to give the processes time to start
if err := Attempts.Run(func() error {
servAddr := routerIP + ":" + port
conn, err := net.Dial("tcp", servAddr)
defer conn.Close()
if err != nil {
return err
}
echo := random.Bytes(16)
_, err = conn.Write(echo)
if err != nil {
return err
}
reply := make([]byte, 16)
_, err = conn.Read(reply)
if err != nil {
return err
}
t.Assert(reply, c.DeepEquals, echo)
return nil
}); err != nil {
t.Error(err)
}
}
