func startInstance(url, clusterName, imageName, repoName string, ports []int32) error {
did := sous.DeployID{
ManifestID: sous.ManifestID{
Source: sous.SourceLocation{
Repo: repoName,
},
},
Cluster: clusterName,
}
log.Printf("%#v", did)
reqID := singularity.MakeRequestID(did)
sing := sing.NewClient(url)
req := loadMap(&dtos.SingularityRequest{}, map[string]interface{}{
"Id": reqID,
"RequestType": dtos.SingularityRequestRequestTypeSERVICE,
"Instances": int32(1),
}).(*dtos.SingularityRequest)
for {
_, err := sing.PostRequest(req)
if err != nil {
if rerr, ok := err.(*swaggering.ReqError); ok && rerr.Status == 409 { //not done deleting the request
continue
}
return err
}
break
}
dockerInfo := loadMap(&dtos.SingularityDockerInfo{}, dtoMap{
"Image": imageName,
}).(*dtos.SingularityDockerInfo)
depReq := loadMap(&dtos.SingularityDeployRequest{}, dtoMap{
"Deploy": loadMap(&dtos.SingularityDeploy{}, dtoMap{
"Id": singularity.MakeDeployID(uuid.NewV4().String()),
"RequestId": reqID,
"Resources": loadMap(&dtos.Resources{}, dtoMap{
"Cpus": 0.1,
"MemoryMb": 100.0,
"NumPorts": int32(1),
}),
"ContainerInfo": loadMap(&dtos.SingularityContainerInfo{}, dtoMap{
"Type": dtos.SingularityContainerInfoSingularityContainerTypeDOCKER,
"Docker": dockerInfo,
}),
}),
}).(*dtos.SingularityDeployRequest)
_, err := sing.Deploy(depReq)
if err != nil {
return err
}
return nil
}
// ResetSingularity clears out the state from the integration singularity service
// Call it (with and extra call deferred) anywhere integration tests use Singularity
func ResetSingularity() {
singClient := sing.NewClient(SingularityURL)
reqList, err := singClient.GetRequests()
if err != nil {
panic(err)
}
for _, r := range reqList {
_, err := singClient.DeleteRequest(r.Request.Id, nil)
if err != nil {
panic(err)
}
}
}
func TestBuildDeployments(t *testing.T) {
t.Skipf("Failing test on master preventing progress on other stories.")
assert := assert.New(t)
sous.Log.Debug.SetOutput(os.Stdout)
ResetSingularity()
defer ResetSingularity()
drc := docker_registry.NewClient()
drc.BecomeFoolishlyTrusting()
db, err := docker.GetDatabase(&docker.DBConfig{
Driver: "sqlite3_sous",
Connection: docker.InMemoryConnection("testresolve"),
})
if err != nil {
panic(err)
}
appLocation := "testhelloreq"
clusterNick := "tcluster"
reqID := appLocation + clusterNick
nc := docker.NewNameCache("", drc, db)
singCl := sing.NewClient(SingularityURL)
//singCl.Debug = true
sr, err := singReqDep(
SingularityURL,
whitespace.CleanWS(`
{
"instances": 1,
"id": "`+reqID+`",
"requestType": "SERVICE",
"owners": ["*****@*****.**", "*****@*****.**"]
}`),
whitespace.CleanWS(`
{
"deploy": {
"id": "`+singularity.MakeDeployID(uuid.NewV4().String())+`",
"requestId": "`+reqID+`",
"resources": {
"cpus": 0.1,
"memoryMb": 32,
"numPorts": 1
},
"containerInfo": {
"type": "DOCKER",
"docker": {
"image": "`+BuildImageName("hello-server-labels", "latest")+`"
},
"volumes": [{"hostPath":"/tmp", "containerPath":"/tmp","mode":"RO"}]
},
"env": {
"TEST": "yes"
}
}
}`),
)
req := singularity.SingReq{
SourceURL: SingularityURL,
Sing: singCl,
ReqParent: sr,
}
if assert.NoError(err) {
clusters := sous.Clusters{clusterNick: {BaseURL: SingularityURL}}
dep, err := singularity.BuildDeployment(nc, clusters, req)
if assert.NoError(err) {
if assert.Len(dep.DeployConfig.Volumes, 1) {
assert.Equal(dep.DeployConfig.Volumes[0].Host, "/tmp")
}
assert.Equal("github.com/docker/dockercloud-hello-world", dep.SourceID.Location.Repo)
}
}
}
