"syscall"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"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"
)
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)
defer s.removeHost(t, instance)
httpClient := &http.Client{Transport: &http.Transport{Dial: dialer.Retry.Dial}}
client := cluster.NewHost(instance.ID, fmt.Sprintf("http://%s:1113", instance.IP), httpClient)
// start partial logger job
cmd := exec.JobUsingHost(
client,
exec.DockerImage(imageURIs["test-apps"]),
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"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"
)
type ControllerSuite struct {
schemaPaths []string
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 {
package main
import (
"bytes"
"io"
"net/http"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/discoverd/client"
)
type BlobstoreSuite struct{}
var _ = c.Suite(&BlobstoreSuite{})
// Transfer >512MB data to avoid regressing on https://github.com/flynn/flynn/issues/101
func (b *BlobstoreSuite) TestLargeAmountOfData(t *c.C) {
disc, err := discoverd.NewClientWithAddr(routerIP + ":1111")
t.Assert(err, c.IsNil)
defer disc.Close()
services, err := disc.Services("blobstore", 5*time.Second)
t.Assert(err, c.IsNil)
path := "http://" + services[0].Addr + "/data"
data := make([]byte, 16*1024*1024)
for i := 0; i < 17; i++ {
req, err := http.NewRequest("PUT", path, bytes.NewReader(data))
t.Assert(err, c.IsNil)
import (
"encoding/json"
"fmt"
"net/http"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/controller/client"
ct "github.com/flynn/flynn/controller/types"
)
type DomainMigrationSuite struct {
Helper
}
var _ = c.Suite(&DomainMigrationSuite{})
func (s *DomainMigrationSuite) migrateDomain(t *c.C, dm *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(controller.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)
package main
import (
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/host/types"
"github.com/flynn/flynn/pkg/cluster"
)
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)
"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/cluster"
)
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 jobEventsEqual(expected, actual ct.JobEvents) bool {
for typ, events := range expected {
diff, ok := actual[typ]
if !ok {
return false
}
for state, count := range events {
if diff[state] != count {
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"
tc "github.com/flynn/flynn/test/cluster"
)
// 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 (
"bytes"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
)
type GitreceiveSuite struct {
Helper
}
var _ = c.Suite(&GitreceiveSuite{})
func (s *GitreceiveSuite) SetUpSuite(t *c.C) {
// Unencrypted SSH private key for the flynn-test GitHub account.
// Omits header/footer to avoid any GitHub auto-revoke key crawlers
sshKey := `MIIEpAIBAAKCAQEA2UnQ/17TfzQRt4HInuP1SYz/tSNaCGO3NDIPLydVu8mmxuKT
zlJtH3pz3uWpMEKdZtSjV+QngJL8OFzanQVZtRBJjF2m+cywHJoZA5KsplMon+R+
QmVqu92WlcRdkcft1F1CLoTXTmHHfvuhOkG6GgJONNLP9Z14EsQ7MbBh5guafWOX
kdGFajyd+T2aj27yIkK44WjWqiLjxRIAtgOJrmd/3H0w3E+O1cgNrA2gkFEUhvR1
OHz8SmugYva0VZWKvxZ6muZvn26L1tajYsCntCRR3/a74cAnVFAXjqSatL6YTbSH
sdtE91kEC73/U4SL3OFdDiCrAvXpJ480C2/GQQIDAQABAoIBAHNQNVYRIPS00WIt
wiZwm8/4wAuFQ1aIdMWCe4Ruv5T1I0kRHZe1Lqwx9CQqhWtTLu1Pk5AlSMF3P9s5
i9sg58arahzP5rlS43OKZBP9Vxq9ryWLwWXDJK2mny/EElQ3YgP9qg29+fVi9thw
+dNM5lK/PnnSFwMmGn77HN712D6Yl3CCJJjsAunTfPzR9hyEqX5YvUB5eq/TNhXe
sqrKcGORIoNfv7WohlFSkTAXIvoMxmFWXg8piZ9/b1W4NwvO4wup3ZSErIk0AQ97
HtyXJIXgtj6pLkPqvPXPGvS3quYAddNxvGIdvge7w5LHnrxOzdqbeDAVmJLVwVlv
import (
"encoding/json"
"net"
"reflect"
"time"
c "github.com/flynn/flynn/Godeps/_workspace/src/github.com/flynn/go-check"
"github.com/flynn/flynn/discoverd/client"
"github.com/flynn/flynn/logaggregator/client"
)
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)