"encoding/json"
"net/http"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/status"
)
type HealthcheckSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&HealthcheckSuite{})
func (s *HealthcheckSuite) createAppWithService(t *c.C, process string, service *host.Service) (*ct.App, *ct.Release) {
app, release := s.createApp(t)
release.ID = ""
proctype := release.Processes[process]
proctype.Ports = []ct.Port{{
Proto: "tcp",
Service: service,
}}
release.Processes[process] = proctype
t.Assert(s.controllerClient(t).CreateRelease(release), c.IsNil)
t.Assert(s.controllerClient(t).SetAppRelease(app.ID, release.ID), c.IsNil)
return app, release
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/Godeps/_workspace/src/golang.org/x/crypto/ssh"
"github.com/flynn/flynn/cli/config"
cc "github.com/flynn/flynn/controller/client"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/resource"
"github.com/flynn/flynn/pkg/attempt"
"github.com/flynn/flynn/pkg/random"
)
type CLISuite struct {
Helper
}
var _ = c.ConcurrentSuite(&CLISuite{})
func (s *CLISuite) flynn(t *c.C, args ...string) *CmdResult {
return flynn(t, "/", args...)
}
func (s *CLISuite) newCliTestApp(t *c.C) *cliTestApp {
app, release := s.createApp(t)
watcher, err := s.controllerClient(t).WatchJobEvents(app.Name, release.ID)
t.Assert(err, c.IsNil)
return &cliTestApp{
name: app.Name,
disc: s.discoverdClient(t),
t: t,
watcher: watcher,
}
import (
"database/sql"
"fmt"
"path/filepath"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
_ "github.com/flynn/flynn/Godeps/_workspace/src/github.com/go-sql-driver/mysql"
"github.com/flynn/flynn/appliance/mariadb"
ct "github.com/flynn/flynn/controller/types"
)
type MariaDBSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&MariaDBSuite{})
// Sirenia integration tests
var sireniaMariaDB = sireniaDatabase{
appName: "mariadb",
serviceKey: "FLYNN_MYSQL",
hostKey: "MYSQL_HOST",
initDb: func(t *c.C, r *ct.Release, d *sireniaDeploy) {
dsn := &mariadb.DSN{
Host: fmt.Sprintf("leader.%s.discoverd", d.name) + ":3306",
User: "******",
Password: r.Env["MYSQL_PWD"],
Database: "mysql",
}
db, err := sql.Open("mysql", dsn.String())
t.Assert(err, c.IsNil)
package main
import (
"path/filepath"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
)
type RedisSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&RedisSuite{})
func (s *RedisSuite) TestDumpRestore(t *c.C) {
a := s.newCliTestApp(t)
t.Assert(a.flynn("resource", "add", "redis"), Succeeds)
release, err := s.controllerClient(t).GetAppRelease(a.id)
t.Assert(err, c.IsNil)
t.Assert(release.Env["FLYNN_REDIS"], c.Not(c.Equals), "")
a.waitForService(release.Env["FLYNN_REDIS"])
t.Assert(a.flynn("redis", "redis-cli", "set", "foo", "bar"), Succeeds)
file := filepath.Join(t.MkDir(), "dump.rdb")
t.Assert(a.flynn("redis", "dump", "-f", file), Succeeds)
t.Assert(a.flynn("redis", "redis-cli", "del", "foo"), Succeeds)
a.flynn("redis", "restore", "-f", file)
"net/http"
"os"
"path/filepath"
"regexp"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/attempt"
)
type GitDeploySuite struct {
Helper
}
var _ = c.ConcurrentSuite(&GitDeploySuite{})
var Attempts = attempt.Strategy{
Total: 60 * time.Second,
Delay: 500 * time.Millisecond,
}
func (s *GitDeploySuite) TestEnvDir(t *c.C) {
r := s.newGitRepo(t, "env-dir")
t.Assert(r.flynn("create"), Succeeds)
t.Assert(r.flynn("env", "set", "FOO=bar", "BUILDPACK_URL=https://github.com/kr/heroku-buildpack-inline"), Succeeds)
push := r.git("push", "flynn", "master")
t.Assert(push, SuccessfulOutputContains, "bar")
}
package main
import (
"bytes"
"fmt"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/cluster"
)
type TaffyDeploySuite struct {
Helper
}
var _ = c.ConcurrentSuite(&TaffyDeploySuite{})
func (s *TaffyDeploySuite) deployWithTaffy(t *c.C, app *ct.App, env, meta, github map[string]string) {
client := s.controllerClient(t)
taffyRelease, err := client.GetAppRelease("taffy")
t.Assert(err, c.IsNil)
args := []string{
app.Name,
github["clone_url"],
github["branch"],
github["rev"],
}
for name, m := range map[string]map[string]string{"--env": env, "--meta": meta} {
"io"
"net/url"
"strings"
"text/template"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/controller/client"
tc "github.com/flynn/flynn/test/cluster"
"github.com/flynn/flynn/updater/types"
)
type ReleaseSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&ReleaseSuite{})
func (s *ReleaseSuite) addReleaseHosts(t *c.C) *tc.BootResult {
res, err := testCluster.AddReleaseHosts()
t.Assert(err, c.IsNil)
t.Assert(res.Instances, c.HasLen, 4)
return res
}
var releaseScript = bytes.NewReader([]byte(`
export TUF_TARGETS_PASSPHRASE="flynn-test"
export TUF_SNAPSHOT_PASSPHRASE="flynn-test"
export TUF_TIMESTAMP_PASSPHRASE="flynn-test"
export GOPATH=~/go
src="${GOPATH}/src/github.com/flynn/flynn"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/cluster"
"github.com/flynn/flynn/pkg/exec"
"github.com/flynn/flynn/pkg/random"
"github.com/flynn/flynn/pkg/schedutil"
)
type HostSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&HostSuite{})
func (s *HostSuite) TestAttachNonExistentJob(t *c.C) {
cluster := s.clusterClient(t)
hosts, err := cluster.Hosts()
t.Assert(err, c.IsNil)
// Attaching to a non-existent job should error
_, err = hosts[0].Attach(&host.AttachReq{JobID: "none", Flags: host.AttachFlagLogs}, false)
t.Assert(err, c.NotNil)
}
func (s *HostSuite) TestAttachFinishedInteractiveJob(t *c.C) {
cluster := s.clusterClient(t)
// run a quick interactive job
package main
import (
"path/filepath"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
)
type PostgresSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&PostgresSuite{})
// Check postgres config to avoid regressing on https://github.com/flynn/flynn/issues/101
func (s *PostgresSuite) TestSSLRenegotiationLimit(t *c.C) {
query := flynn(t, "/", "-a", "controller", "pg", "psql", "--", "-c", "SHOW ssl_renegotiation_limit")
t.Assert(query, Succeeds)
t.Assert(query, OutputContains, "ssl_renegotiation_limit \n-------------------------\n 0\n(1 row)")
}
func (s *PostgresSuite) TestDumpRestore(t *c.C) {
r := s.newGitRepo(t, "empty")
t.Assert(r.flynn("create"), Succeeds)
t.Assert(r.flynn("resource", "add", "postgres"), Succeeds)
t.Assert(r.flynn("pg", "psql", "--", "-c",
"CREATE table foos (data text); INSERT INTO foos (data) VALUES ('foobar')"), Succeeds)
file := filepath.Join(t.MkDir(), "db.dump")
package main
import (
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
)
type DeployerSuite struct {
Helper
}
var _ = c.ConcurrentSuite(&DeployerSuite{})
func (s *DeployerSuite) createRelease(t *c.C, process, strategy string) (*ct.App, *ct.Release) {
app, release := s.createApp(t)
app.Strategy = strategy
s.controllerClient(t).UpdateApp(app)
watcher, err := s.controllerClient(t).WatchJobEvents(app.Name, release.ID)
t.Assert(err, c.IsNil)
defer watcher.Close()
t.Assert(s.controllerClient(t).PutFormation(&ct.Formation{
AppID: app.ID,
ReleaseID: release.ID,
Processes: map[string]int{process: 2},
}), c.IsNil)