import (
"time"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/pkg/attempt"
tc "github.com/flynn/flynn/test/cluster"
c "github.com/flynn/go-check"
)
// Prefix the suite with "Z" so that it runs after all other tests
type ZDiscoverdSuite struct {
Helper
}
var _ = c.Suite(&ZDiscoverdSuite{})
func (s *ZDiscoverdSuite) TestDeploy(t *c.C) {
// ensure we have enough hosts in the cluster
hosts, err := s.clusterClient(t).Hosts()
t.Assert(err, c.IsNil)
if len(hosts) <= 1 {
t.Skip("cannot deploy discoverd in a single node cluster")
}
client := s.controllerClient(t)
app, err := client.GetApp("discoverd")
t.Assert(err, c.IsNil)
release, err := client.GetAppRelease(app.ID)
t.Assert(err, c.IsNil)
release.ID = ""
import (
"encoding/json"
"fmt"
"net/url"
"os/exec"
"time"
ct "github.com/flynn/flynn/controller/types"
c "github.com/flynn/go-check"
)
type DockerReceiveSuite struct {
Helper
}
var _ = c.Suite(&DockerReceiveSuite{})
func (s *DockerReceiveSuite) TestPushImage(t *c.C) {
// build a Docker image
repo := "docker-receive-test-push"
s.buildDockerImage(t, repo, "RUN echo foo > /foo.txt")
// subscribe to artifact events
client := s.controllerClient(t)
events := make(chan *ct.Event)
stream, err := client.StreamEvents(ct.StreamEventsOptions{
ObjectTypes: []ct.EventType{ct.EventTypeArtifact},
}, events)
t.Assert(err, c.IsNil)
defer stream.Close()
"syscall"
"time"
"github.com/flynn/flynn/host/types"
logaggc "github.com/flynn/flynn/logaggregator/client"
"github.com/flynn/flynn/pkg/cluster"
"github.com/flynn/flynn/pkg/dialer"
"github.com/flynn/flynn/pkg/exec"
c "github.com/flynn/go-check"
)
type HostUpdateSuite struct {
Helper
}
var _ = c.Suite(&HostUpdateSuite{})
func (s *HostUpdateSuite) TestUpdateLogs(t *c.C) {
if testCluster == nil {
t.Skip("cannot boot new hosts")
}
instance := s.addHost(t, "router-api")
defer s.removeHost(t, instance, "router-api")
httpClient := &http.Client{Transport: &http.Transport{Dial: dialer.Retry.Dial}}
client := cluster.NewHost(instance.ID, fmt.Sprintf("http://%s:1113", instance.IP), httpClient, nil)
// start partial logger job
cmd := exec.JobUsingHost(
client,
exec.DockerImage(imageURIs["test-apps"]),
package main
import (
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/cluster"
c "github.com/flynn/go-check"
)
type VolumeSuite struct {
Helper
}
var _ = c.Suite(&VolumeSuite{})
func (s *VolumeSuite) TestVolumeTransmitAPI(t *c.C) {
hosts, err := s.clusterClient(t).Hosts()
t.Assert(err, c.IsNil)
s.doVolumeTransmitAPI(hosts[0], hosts[0], t)
}
func (s *VolumeSuite) TestInterhostVolumeTransmitAPI(t *c.C) {
hosts, err := s.clusterClient(t).Hosts()
t.Assert(err, c.IsNil)
if len(hosts) < 2 {
t.Skip("need multiple hosts for this test")
}
s.doVolumeTransmitAPI(hosts[0], hosts[1], t)
}
func (s *VolumeSuite) doVolumeTransmitAPI(h0, h1 *cluster.Host, t *c.C) {
clus := s.clusterClient(t)
"github.com/cupcake/jsonschema"
"github.com/flynn/flynn/cli/config"
"github.com/flynn/flynn/controller/client"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/cluster"
"github.com/flynn/flynn/pkg/exec"
"github.com/flynn/flynn/pkg/random"
c "github.com/flynn/go-check"
)
type ControllerSuite struct {
schemaCache map[string]*jsonschema.Schema
Helper
}
var _ = c.Suite(&ControllerSuite{})
func (s *ControllerSuite) SetUpSuite(t *c.C) {
var schemaPaths []string
walkFn := func(path string, info os.FileInfo, err error) error {
if !info.IsDir() && filepath.Ext(path) == ".json" {
schemaPaths = append(schemaPaths, path)
}
return nil
}
schemaRoot, err := filepath.Abs(filepath.Join("..", "schema"))
t.Assert(err, c.IsNil)
t.Assert(filepath.Walk(schemaRoot, walkFn), c.IsNil)
s.schemaCache = make(map[string]*jsonschema.Schema, len(schemaPaths))
for _, path := range schemaPaths {
"strings"
"time"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/pkg/dialer"
"github.com/flynn/flynn/router/types"
c "github.com/flynn/go-check"
)
// Prefix the suite with "Z" so that it runs after all other tests because
// if it fails, all other tests after it will be affected
type ZDomainMigrationSuite struct {
Helper
}
var _ = c.Suite(&ZDomainMigrationSuite{})
func (s *ZDomainMigrationSuite) migrateDomain(t *c.C, dm *ct.DomainMigration) *ct.DomainMigration {
debugf(t, "migrating domain from %s to %s", dm.OldDomain, dm.Domain)
client := s.controllerClient(t)
events := make(chan *ct.Event)
stream, err := client.StreamEvents(ct.StreamEventsOptions{
ObjectTypes: []ct.EventType{ct.EventTypeDomainMigration},
}, events)
t.Assert(err, c.IsNil)
defer stream.Close()
prevRouterRelease, err := client.GetAppRelease("router")
t.Assert(err, c.IsNil)
"fmt"
"net/http"
"net/url"
"os"
"os/exec"
"strings"
ct "github.com/flynn/flynn/controller/types"
c "github.com/flynn/go-check"
)
type BlobstoreSuite struct {
Helper
}
var _ = c.Suite(&BlobstoreSuite{})
func (s *BlobstoreSuite) TestBlobstoreBackendS3(t *c.C) {
s3Config := os.Getenv("BLOBSTORE_S3_CONFIG")
if s3Config == "" {
// BLOBSTORE_S3_CONFIG should be set to a valid configuration like:
// backend=s3 access_key_id=xxx secret_access_key=xxx bucket=blobstore-ci region=us-east-1
t.Skip("missing BLOBSTORE_S3_CONFIG env var")
}
s.testBlobstoreBackend(t, "s3", ".+s3.amazonaws.com.+", `"BACKEND_S3=$BLOBSTORE_S3_CONFIG"`)
}
func (s *BlobstoreSuite) TestBlobstoreBackendGCS(t *c.C) {
gcsConfig := os.Getenv("BLOBSTORE_GCS_CONFIG")
if gcsConfig == "" {
"time"
"github.com/flynn/flynn/cli/config"
"github.com/flynn/flynn/controller/client"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/pkg/attempt"
c "github.com/flynn/go-check"
)
// Prefix the suite with "ZZ" so that it runs after all other tests as it is
// pretty disruptive
type ZZBackupSuite struct {
Helper
}
var _ = c.Suite(&ZZBackupSuite{})
func (s *ZZBackupSuite) TestClusterBackups(t *c.C) {
if args.BootConfig.BackupsDir == "" {
t.Skip("--backups-dir not set")
}
backups, err := ioutil.ReadDir(args.BootConfig.BackupsDir)
t.Assert(err, c.IsNil)
if len(backups) == 0 {
t.Fatal("backups dir is empty")
}
for i, backup := range backups {
s.testClusterBackup(t, i, filepath.Join(args.BootConfig.BackupsDir, backup.Name()))
}
"reflect"
"strings"
"time"
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/logaggregator/client"
logagg "github.com/flynn/flynn/logaggregator/types"
c "github.com/flynn/go-check"
)
type LogAggregatorSuite struct {
Helper
}
var _ = c.Suite(&LogAggregatorSuite{})
func (s *LogAggregatorSuite) TestReplication(t *c.C) {
app := s.newCliTestApp(t)
app.flynn("scale", "ish=1")
defer app.flynn("scale", "ish=0")
defer app.cleanup()
aggHost := "logaggregator.discoverd"
waitForAggregator := func(wantUp bool) func() {
ch := make(chan *discoverd.Event)
stream, err := app.disc.Service("logaggregator").Watch(ch)
t.Assert(err, c.IsNil)
up := make(chan struct{})
go func() {
timeout := time.After(60 * time.Second)
ct "github.com/flynn/flynn/controller/types"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/host/types"
logaggc "github.com/flynn/flynn/logaggregator/client"
"github.com/flynn/flynn/pkg/cluster"
"github.com/flynn/flynn/pkg/typeconv"
c "github.com/flynn/go-check"
)
type SchedulerSuite struct {
Helper
}
const scaleTimeout = 60 * time.Second
var _ = c.Suite(&SchedulerSuite{})
func (s *SchedulerSuite) checkJobState(t *c.C, appID, jobID string, state ct.JobState) {
job, err := s.controllerClient(t).GetJob(appID, jobID)
t.Assert(err, c.IsNil)
t.Assert(job.State, c.Equals, state)
}
func (s *SchedulerSuite) TestScale(t *c.C) {
app, release := s.createApp(t)
formation := &ct.Formation{
AppID: app.ID,
ReleaseID: release.ID,
Processes: make(map[string]int),
}
package main
import (
"time"
c "github.com/flynn/go-check"
)
type GitreceiveSuite struct {
Helper
}
var _ = c.Suite(&GitreceiveSuite{})
func (s *GitreceiveSuite) TestRepoCaching(t *c.C) {
r := s.newGitRepo(t, "empty")
t.Assert(r.flynn("create"), Succeeds)
r.git("commit", "-m", "bump", "--allow-empty")
r.git("commit", "-m", "bump", "--allow-empty")
push := r.git("push", "flynn", "master")
t.Assert(push, Succeeds)
t.Assert(push, c.Not(OutputContains), "cached")
// cycle the receiver to clear any cache
t.Assert(flynn(t, "/", "-a", "gitreceive", "scale", "app=0"), Succeeds)
t.Assert(flynn(t, "/", "-a", "gitreceive", "scale", "app=1"), Succeeds)
_, err := s.discoverdClient(t).Instances("gitreceive", 10*time.Second)
t.Assert(err, c.IsNil)
r.git("commit", "-m", "bump", "--allow-empty")