func pushApp() string {
appName := generator.PrefixedRandomName("LATS-App-")
appPush := cf.Cf("push", appName, "-p", "assets/dora").Wait(60 * time.Second)
Expect(appPush).To(gexec.Exit(0))
return appName
}
func RunTerraform() {
command := exec.Command("terraform", "apply")
session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
Ω(err).ShouldNot(HaveOccurred())
session.Wait(1800 * time.Second)
Eventually(session).Should(gexec.Exit(0))
}
func stopRedisAndDeleteData(redisConn redis.Conn, aofPath string) {
redisSession.Kill().Wait()
Eventually(redisSession).Should(gexec.Exit())
os.Remove(aofPath)
os.Remove(filepath.Join(aofPath, "..", "dump.rdb"))
}
func (runner *Runner) Truncate() {
truncate := exec.Command(
"psql",
"-U", "postgres",
"-p", strconv.Itoa(runner.Port),
"testdb",
"-c", `
SET client_min_messages TO WARNING;
CREATE OR REPLACE FUNCTION truncate_tables() RETURNS void AS $$
DECLARE
statements CURSOR FOR
SELECT tablename FROM pg_tables
WHERE schemaname = 'public' AND tablename != 'migration_version';
BEGIN
FOR stmt IN statements LOOP
EXECUTE 'TRUNCATE TABLE ' || quote_ident(stmt.tablename) || ' RESTART IDENTITY CASCADE;';
END LOOP;
END;
$$ LANGUAGE plpgsql;
SELECT truncate_tables();
`,
)
truncateS, err := gexec.Start(truncate, ginkgo.GinkgoWriter, ginkgo.GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
<-truncateS.Exited
Expect(truncateS).To(gexec.Exit(0))
}
func numPipes(pid int) (num int) {
sess, err := gexec.Start(exec.Command("sh", "-c", fmt.Sprintf("lsof -p %d | grep pipe", pid)), GinkgoWriter, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
Eventually(sess).Should(gexec.Exit(0))
return bytes.Count(sess.Out.Contents(), []byte{'\n'})
}
func runBashScript(baseCmd *exec.Cmd, script string) *gexec.Session {
cmd := bashScript(baseCmd, script)
session, err := gexec.Start(cmd, GinkgoWriter, GinkgoWriter)
Expect(err).ToNot(HaveOccurred())
Eventually(session, ExecutionTimeout).Should(gexec.Exit(0))
return session
}
func cleanupCliqueAgent() {
sess, err := gexec.Start(
exec.Command("pkill", "-9", "clique-agent"),
GinkgoWriter, GinkgoWriter,
)
Expect(err).NotTo(HaveOccurred())
Eventually(sess).Should(gexec.Exit())
}
func guidForAppName(appName string) string {
cfApp := cf.Cf("app", appName, "--guid")
Expect(cfApp.Wait()).To(gexec.Exit(0))
appGuid := strings.TrimSpace(string(cfApp.Out.Contents()))
Expect(appGuid).NotTo(Equal(""))
return appGuid
}
func executeCommand(args []string, exitCode int) *gexec.Session {
cmd := exec.Command(pathToBBL, args...)
session, err := gexec.Start(cmd, GinkgoWriter, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
Eventually(session, 10*time.Second).Should(gexec.Exit(exitCode))
return session
}
func (b BBL) Destroy() {
session := b.execute([]string{
"--state-dir", b.stateDirectory,
"destroy",
"--no-confirm",
}, os.Stdout, os.Stderr)
Eventually(session, 10*time.Minute).Should(gexec.Exit(0))
}
func (a *cfApp) Scale(numInstances int) {
Eventually(cf.Cf("target", "-o", a.orgName, "-s", a.spaceName)).Should(gexec.Exit(0))
Eventually(cf.Cf("scale", a.appName, "-i", strconv.Itoa(numInstances))).Should(gexec.Exit(0))
Eventually(func() int {
found := make(map[string]struct{})
for i := 0; i < numInstances*2; i++ {
id, err := a.Curl("id")
if err != nil {
log.Printf("Failed Curling While Scaling: %s\n", err.Error())
return -1
}
found[id] = struct{}{}
time.Sleep(1 * time.Second)
}
return len(found)
}).Should(Equal(numInstances))
}
func (runner *Runner) Truncate() {
truncate := exec.Command(
"psql",
"-U", "postgres",
"-p", strconv.Itoa(runner.Port),
"testdb",
"-c", `
SET client_min_messages TO WARNING;
CREATE OR REPLACE FUNCTION truncate_tables() RETURNS void AS $$
DECLARE
statements CURSOR FOR
SELECT tablename FROM pg_tables
WHERE schemaname = 'public' AND tablename != 'migration_version';
BEGIN
FOR stmt IN statements LOOP
EXECUTE 'TRUNCATE TABLE ' || quote_ident(stmt.tablename) || ' RESTART IDENTITY CASCADE;';
END LOOP;
END;
$$ LANGUAGE plpgsql;
CREATE OR REPLACE FUNCTION drop_ephemeral_sequences() RETURNS void AS $$
DECLARE
statements CURSOR FOR
SELECT relname FROM pg_class
WHERE relname LIKE 'build_event_id_seq_%';
BEGIN
FOR stmt IN statements LOOP
EXECUTE 'DROP SEQUENCE ' || quote_ident(stmt.relname) || ';';
END LOOP;
END;
$$ LANGUAGE plpgsql;
CREATE OR REPLACE FUNCTION reset_global_sequences() RETURNS void AS $$
DECLARE
statements CURSOR FOR
SELECT relname FROM pg_class
WHERE relname IN ('one_off_name', 'config_version_seq');
BEGIN
FOR stmt IN statements LOOP
EXECUTE 'ALTER SEQUENCE ' || quote_ident(stmt.relname) || ' RESTART WITH 1;';
END LOOP;
END;
$$ LANGUAGE plpgsql;
SELECT truncate_tables();
SELECT drop_ephemeral_sequences();
SELECT reset_global_sequences();
`,
)
truncateS, err := gexec.Start(truncate, ginkgo.GinkgoWriter, ginkgo.GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
<-truncateS.Exited
Expect(truncateS).To(gexec.Exit(0))
}
func defineTheMainTests(runner *integrationTestRunner) {
Describe("exit codes", func() {
It("exits non-zero when an unknown command is invoked", func() {
command := runner.command("unknownCommand")
session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
Expect(err).ToNot(HaveOccurred())
Eventually(session, 3*time.Second).Should(gbytes.Say("not a registered command"))
Eventually(session).Should(gexec.Exit(1))
})
It("exits non-zero when known command is invoked with invalid option", func() {
command := runner.command("status", "--badFlag")
session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
Expect(err).ToNot(HaveOccurred())
Eventually(session, 3*time.Second).Should(gexec.Exit(1))
})
})
}
func (runner *Runner) DropTestDB() {
dropdb := exec.Command("dropdb", "-U", "postgres", "-p", strconv.Itoa(runner.Port), "testdb")
dropS, err := gexec.Start(dropdb, ginkgo.GinkgoWriter, ginkgo.GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
<-dropS.Exited
Expect(dropS).To(gexec.Exit(0))
}
func (b BBL) DeleteLB() {
args := []string{
"--state-dir", b.stateDirectory,
"delete-lbs",
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 10*time.Minute).Should(gexec.Exit(0))
}
func cp(src string, dst string) {
session, err := gexec.Start(
exec.Command("cp", "-a", src, dst),
GinkgoWriter,
GinkgoWriter,
)
Ω(err).ShouldNot(HaveOccurred())
Eventually(session).Should(gexec.Exit(0))
}
func (appCurler *AppCurler) CurlAndWait(cfg CurlConfig, appName string, path string, timeout time.Duration, args ...string) string {
appUri := appCurler.UriCreator.AppUri(appName, path)
curlArgs := append([]string{appUri}, args...)
curlCmd := appCurler.CurlFunc(cfg, curlArgs...).Wait(timeout)
ExpectWithOffset(3, curlCmd).To(gexec.Exit(0))
ExpectWithOffset(3, string(curlCmd.Err.Contents())).To(HaveLen(0))
return string(curlCmd.Out.Contents())
}
func linkUp(netNsName, linkName string) bool {
cmd := exec.Command("ip", "netns", "exec", netNsName, "ip", "link", "list", linkName)
buffer := gbytes.NewBuffer()
sess, err := gexec.Start(cmd, buffer, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
Eventually(sess).Should(gexec.Exit(0))
return !strings.Contains(string(buffer.Contents()), "DOWN")
}
func (b BBL) UpWithInvalidAWSCredentials() {
args := []string{
"--state-dir", b.stateDirectory,
"up",
"--aws-access-key-id", "some-bad-access-key-id",
"--aws-secret-access-key", "some-bad-secret-access-key",
"--aws-region", b.configuration.AWSRegion,
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 10*time.Second).Should(gexec.Exit(1))
}
func (b BBL) Up() {
args := []string{
"--state-dir", b.stateDirectory,
"up",
"--aws-access-key-id", b.configuration.AWSAccessKeyID,
"--aws-secret-access-key", b.configuration.AWSSecretAccessKey,
"--aws-region", b.configuration.AWSRegion,
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 40*time.Minute).Should(gexec.Exit(0))
}
func (b BBL) UpdateLB(certPath, keyPath string) {
args := []string{
"--state-dir", b.stateDirectory,
"update-lbs",
"--cert", certPath,
"--key", keyPath,
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 10*time.Minute).Should(gexec.Exit(0))
}
func (b BBL) LBs() *gexec.Session {
args := []string{
"--state-dir", b.stateDirectory,
"lbs",
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 10*time.Minute).Should(gexec.Exit(0))
return session
}
func (a *cfApp) VerifySsh(instanceIndex int) {
envCmd := cf.Cf("ssh", a.appName, "-i", strconv.Itoa(instanceIndex), "-c", `"/usr/bin/env"`)
Expect(envCmd.Wait()).To(gexec.Exit(0))
output := string(envCmd.Buffer().Contents())
Expect(string(output)).To(MatchRegexp(fmt.Sprintf(`VCAP_APPLICATION=.*"application_name":"%s"`, a.appName)))
Expect(string(output)).To(MatchRegexp(fmt.Sprintf("INSTANCE_INDEX=%d", instanceIndex)))
Eventually(cf.Cf("logs", a.appName, "--recent")).Should(gbytes.Say("Successful remote access"))
Eventually(cf.Cf("events", a.appName)).Should(gbytes.Say("audit.app.ssh-authorized"))
}
func boshCmd(manifest, action, completeMsg string) {
args := []string{"-n"}
if manifest != "" {
args = append(args, "-d", manifest)
}
args = append(args, strings.Split(action, " ")...)
cmd := bosh(args...)
sess, err := gexec.Start(cmd, GinkgoWriter, GinkgoWriter)
Expect(err).NotTo(HaveOccurred())
Eventually(sess, BOSH_DEPLOY_TIMEOUT).Should(gexec.Exit(0))
Expect(sess).To(gbytes.Say(completeMsg))
}
func (b BBL) CreateLB(loadBalancerType string, cert string, key string, chain string) {
args := []string{
"--state-dir", b.stateDirectory,
"create-lbs",
"--type", loadBalancerType,
"--cert", cert,
"--key", key,
"--chain", chain,
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 10*time.Minute).Should(gexec.Exit(0))
}
func runBackup(configPath string) int {
cmd := exec.Command(backupExecutablePath, "-config", configPath)
cmd.Stdout = GinkgoWriter
cmd.Stderr = GinkgoWriter
session, err := gexec.Start(cmd, GinkgoWriter, GinkgoWriter)
Expect(err).ToNot(HaveOccurred())
Eventually(session, 10).Should(gexec.Exit())
fmt.Println(string(session.Err.Contents()))
return session.ExitCode()
}
func execBin(configPath string) *gexec.Session {
var cmd *exec.Cmd
if configPath != "" {
cmd = exec.Command(execPath, "--config", configPath)
} else {
cmd = exec.Command(execPath)
}
session, err := gexec.Start(cmd, GinkgoWriter, GinkgoWriter)
Expect(err).ToNot(HaveOccurred())
Eventually(session).Should(gexec.Exit())
return session
}
func (a *cfApp) Push() {
// create org and space
Eventually(func() int {
return cf.Cf("login", "-a", "api."+config.OverrideDomain, "-u", CFUser, "-p", CFPassword, "--skip-ssl-validation").Wait().ExitCode()
}).Should(Equal(0))
Eventually(cf.Cf("create-org", a.orgName)).Should(gexec.Exit(0))
Eventually(cf.Cf("target", "-o", a.orgName)).Should(gexec.Exit(0))
Eventually(cf.Cf("create-space", a.spaceName)).Should(gexec.Exit(0))
Eventually(cf.Cf("target", "-s", a.spaceName)).Should(gexec.Exit(0))
// push app
Eventually(cf.Cf("push", a.appName, "-p", "dora", "-i", "1", "-b", "ruby_buildpack"), 5*time.Minute).Should(gexec.Exit(0))
Eventually(cf.Cf("logs", a.appName, "--recent")).Should(gbytes.Say("[HEALTH/0]"))
curlAppMain := func() string {
response, err := a.Curl("")
if err != nil {
return ""
}
return response
}
Eventually(curlAppMain).Should(ContainSubstring("Hi, I'm Dora!"))
}
func (b BBL) UpdateLB(certPath, keyPath string) {
args := []string{
"--aws-access-key-id", b.configuration.AWSAccessKeyID,
"--aws-secret-access-key", b.configuration.AWSSecretAccessKey,
"--aws-region", b.configuration.AWSRegion,
"--state-dir", b.stateDirectory,
"unsupported-update-lbs",
"--cert", certPath,
"--key", keyPath,
}
session := b.execute(args, os.Stdout, os.Stderr)
Eventually(session, 10*time.Minute).Should(gexec.Exit(0))
}
func StartVagrant(provider string) (Agent, error) {
if len(provider) == 0 {
provider = "virtualbox"
}
command := exec.Command(fmt.Sprintf("./setup_%s.sh", provider))
session, err := gexec.Start(command, ginkgo.GinkgoWriter, ginkgo.GinkgoWriter)
if err != nil {
return Agent{}, err
}
gomega.Eventually(session, 20*time.Minute).Should(gexec.Exit(0))
return Agent{
ID: agentID,
}, nil
}