[ARVADOS] updated: 1.1.2-132-gbad6499
Git user
git at public.curoverse.com
Fri Jan 26 14:39:37 EST 2018
Summary of changes:
.../crunch-dispatch-slurm/crunch-dispatch-slurm.go | 198 +++++++++++----------
.../crunch-dispatch-slurm_test.go | 81 +++++----
2 files changed, 148 insertions(+), 131 deletions(-)
via bad6499910388c17c4a54b3128f361aa36a670e1 (commit)
from 10f08c358c12468119dc2621c48b68d6d33417da (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
commit bad6499910388c17c4a54b3128f361aa36a670e1
Author: Tom Clegg <tclegg at veritasgenetics.com>
Date: Fri Jan 26 14:33:48 2018 -0500
12199: Refactor for more test-friendly initialization.
Arvados-DCO-1.1-Signed-off-by: Tom Clegg <tclegg at veritasgenetics.com>
diff --git a/services/crunch-dispatch-slurm/crunch-dispatch-slurm.go b/services/crunch-dispatch-slurm/crunch-dispatch-slurm.go
index 879cb78..44123f8 100644
--- a/services/crunch-dispatch-slurm/crunch-dispatch-slurm.go
+++ b/services/crunch-dispatch-slurm/crunch-dispatch-slurm.go
@@ -25,13 +25,16 @@ import (
"github.com/coreos/go-systemd/daemon"
)
-var version = "dev"
+var (
+ version = "dev"
+ defaultConfigPath = "/etc/arvados/crunch-dispatch-slurm/crunch-dispatch-slurm.yml"
+)
-type command struct {
- dispatcher *dispatch.Dispatcher
- cluster *arvados.Cluster
- sqCheck *SqueueChecker
- slurm Slurm
+type Dispatcher struct {
+ *dispatch.Dispatcher
+ cluster *arvados.Cluster
+ sqCheck *SqueueChecker
+ slurm Slurm
Client arvados.Client
@@ -49,15 +52,23 @@ type command struct {
}
func main() {
- err := (&command{}).Run(os.Args[0], os.Args[1:])
+ disp := &Dispatcher{}
+ err := disp.Run(os.Args[0], os.Args[1:])
if err != nil {
log.Fatal(err)
}
}
-const defaultConfigPath = "/etc/arvados/crunch-dispatch-slurm/crunch-dispatch-slurm.yml"
+func (disp *Dispatcher) Run(prog string, args []string) error {
+ if err := disp.configure(prog, args); err != nil {
+ return err
+ }
+ disp.setup()
+ return disp.run()
+}
-func (cmd *command) Run(prog string, args []string) error {
+// configure() loads config files. Tests skip this.
+func (disp *Dispatcher) configure(prog string, args []string) error {
flags := flag.NewFlagSet(prog, flag.ExitOnError)
flags.Usage = func() { usage(flags) }
@@ -84,81 +95,84 @@ func (cmd *command) Run(prog string, args []string) error {
log.Printf("crunch-dispatch-slurm %s started", version)
- err := cmd.readConfig(*configPath)
+ err := disp.readConfig(*configPath)
if err != nil {
return err
}
- if cmd.CrunchRunCommand == nil {
- cmd.CrunchRunCommand = []string{"crunch-run"}
+ if disp.CrunchRunCommand == nil {
+ disp.CrunchRunCommand = []string{"crunch-run"}
}
- if cmd.PollPeriod == 0 {
- cmd.PollPeriod = arvados.Duration(10 * time.Second)
+ if disp.PollPeriod == 0 {
+ disp.PollPeriod = arvados.Duration(10 * time.Second)
}
- if cmd.Client.APIHost != "" || cmd.Client.AuthToken != "" {
+ if disp.Client.APIHost != "" || disp.Client.AuthToken != "" {
// Copy real configs into env vars so [a]
// MakeArvadosClient() uses them, and [b] they get
// propagated to crunch-run via SLURM.
- os.Setenv("ARVADOS_API_HOST", cmd.Client.APIHost)
- os.Setenv("ARVADOS_API_TOKEN", cmd.Client.AuthToken)
+ os.Setenv("ARVADOS_API_HOST", disp.Client.APIHost)
+ os.Setenv("ARVADOS_API_TOKEN", disp.Client.AuthToken)
os.Setenv("ARVADOS_API_HOST_INSECURE", "")
- if cmd.Client.Insecure {
+ if disp.Client.Insecure {
os.Setenv("ARVADOS_API_HOST_INSECURE", "1")
}
- os.Setenv("ARVADOS_KEEP_SERVICES", strings.Join(cmd.Client.KeepServiceURIs, " "))
+ os.Setenv("ARVADOS_KEEP_SERVICES", strings.Join(disp.Client.KeepServiceURIs, " "))
os.Setenv("ARVADOS_EXTERNAL_CLIENT", "")
} else {
log.Printf("warning: Client credentials missing from config, so falling back on environment variables (deprecated).")
}
if *dumpConfig {
- log.Fatal(config.DumpAndExit(cmd))
+ return config.DumpAndExit(disp)
}
- arv, err := arvadosclient.MakeArvadosClient()
- if err != nil {
- log.Printf("Error making Arvados client: %v", err)
- return err
- }
- arv.Retries = 25
-
siteConfig, err := arvados.GetConfig(arvados.DefaultConfigFile)
if os.IsNotExist(err) {
- log.Printf("warning: no cluster config file %q (%s), proceeding with no node types defined", arvados.DefaultConfigFile, err)
+ log.Printf("warning: no cluster config (%s), proceeding with no node types defined", err)
} else if err != nil {
- log.Fatalf("error loading config: %s", err)
- } else if cmd.cluster, err = siteConfig.GetCluster(""); err != nil {
- log.Fatalf("config error: %s", err)
- } else if len(cmd.cluster.InstanceTypes) > 0 {
- go dispatchcloud.SlurmNodeTypeFeatureKludge(cmd.cluster)
+ return fmt.Errorf("error loading config: %s", err)
+ } else if disp.cluster, err = siteConfig.GetCluster(""); err != nil {
+ return fmt.Errorf("config error: %s", err)
}
- if cmd.slurm == nil {
- cmd.slurm = &slurmCLI{}
- }
+ return nil
+}
- cmd.sqCheck = &SqueueChecker{
- Period: time.Duration(cmd.PollPeriod),
- Slurm: cmd.slurm,
+// setup() initializes private fields after configure().
+func (disp *Dispatcher) setup() {
+ arv, err := arvadosclient.MakeArvadosClient()
+ if err != nil {
+ log.Fatalf("Error making Arvados client: %v", err)
}
- defer cmd.sqCheck.Stop()
+ arv.Retries = 25
- cmd.dispatcher = &dispatch.Dispatcher{
+ disp.slurm = &slurmCLI{}
+ disp.sqCheck = &SqueueChecker{
+ Period: time.Duration(disp.PollPeriod),
+ Slurm: disp.slurm,
+ }
+ disp.Dispatcher = &dispatch.Dispatcher{
Arv: arv,
- RunContainer: cmd.run,
- PollPeriod: time.Duration(cmd.PollPeriod),
- MinRetryPeriod: time.Duration(cmd.MinRetryPeriod),
+ RunContainer: disp.runContainer,
+ PollPeriod: time.Duration(disp.PollPeriod),
+ MinRetryPeriod: time.Duration(disp.MinRetryPeriod),
+ }
+}
+
+func (disp *Dispatcher) run() error {
+ defer disp.sqCheck.Stop()
+
+ if disp.cluster != nil && len(disp.cluster.InstanceTypes) > 0 {
+ go dispatchcloud.SlurmNodeTypeFeatureKludge(disp.cluster)
}
if _, err := daemon.SdNotify(false, "READY=1"); err != nil {
log.Printf("Error notifying init daemon: %v", err)
}
-
- go cmd.checkSqueueForOrphans()
-
- return cmd.dispatcher.Run(context.Background())
+ go disp.checkSqueueForOrphans()
+ return disp.Dispatcher.Run(context.Background())
}
var containerUuidPattern = regexp.MustCompile(`^[a-z0-9]{5}-dz642-[a-z0-9]{15}$`)
@@ -168,19 +182,19 @@ var containerUuidPattern = regexp.MustCompile(`^[a-z0-9]{5}-dz642-[a-z0-9]{15}$`
// jobs started by a previous dispatch process that never released
// their slurm allocations even though their container states are
// Cancelled or Complete. See https://dev.arvados.org/issues/10979
-func (cmd *command) checkSqueueForOrphans() {
- for _, uuid := range cmd.sqCheck.All() {
+func (disp *Dispatcher) checkSqueueForOrphans() {
+ for _, uuid := range disp.sqCheck.All() {
if !containerUuidPattern.MatchString(uuid) {
continue
}
- err := cmd.dispatcher.TrackContainer(uuid)
+ err := disp.TrackContainer(uuid)
if err != nil {
log.Printf("checkSqueueForOrphans: TrackContainer(%s): %s", uuid, err)
}
}
}
-func (cmd *command) niceness(priority int) int {
+func (disp *Dispatcher) niceness(priority int) int {
if priority > 1000 {
priority = 1000
}
@@ -191,7 +205,7 @@ func (cmd *command) niceness(priority int) int {
return (1000 - priority) * 10
}
-func (cmd *command) sbatchArgs(container arvados.Container) ([]string, error) {
+func (disp *Dispatcher) sbatchArgs(container arvados.Container) ([]string, error) {
mem := int64(math.Ceil(float64(container.RuntimeConstraints.RAM+container.RuntimeConstraints.KeepCacheRAM) / float64(1048576)))
var disk int64
@@ -203,19 +217,19 @@ func (cmd *command) sbatchArgs(container arvados.Container) ([]string, error) {
disk = int64(math.Ceil(float64(disk) / float64(1048576)))
var sbatchArgs []string
- sbatchArgs = append(sbatchArgs, cmd.SbatchArguments...)
+ sbatchArgs = append(sbatchArgs, disp.SbatchArguments...)
sbatchArgs = append(sbatchArgs, fmt.Sprintf("--job-name=%s", container.UUID))
sbatchArgs = append(sbatchArgs, fmt.Sprintf("--mem=%d", mem))
sbatchArgs = append(sbatchArgs, fmt.Sprintf("--cpus-per-task=%d", container.RuntimeConstraints.VCPUs))
sbatchArgs = append(sbatchArgs, fmt.Sprintf("--tmp=%d", disk))
- sbatchArgs = append(sbatchArgs, fmt.Sprintf("--nice=%d", cmd.niceness(container.Priority)))
+ sbatchArgs = append(sbatchArgs, fmt.Sprintf("--nice=%d", disp.niceness(container.Priority)))
if len(container.SchedulingParameters.Partitions) > 0 {
sbatchArgs = append(sbatchArgs, fmt.Sprintf("--partition=%s", strings.Join(container.SchedulingParameters.Partitions, ",")))
}
- if cmd.cluster == nil {
+ if disp.cluster == nil {
// no instance types configured
- } else if it, err := dispatchcloud.ChooseInstanceType(cmd.cluster, &container); err == dispatchcloud.ErrInstanceTypesNotConfigured {
+ } else if it, err := dispatchcloud.ChooseInstanceType(disp.cluster, &container); err == dispatchcloud.ErrInstanceTypesNotConfigured {
// ditto
} else if err != nil {
return nil, err
@@ -226,39 +240,39 @@ func (cmd *command) sbatchArgs(container arvados.Container) ([]string, error) {
return sbatchArgs, nil
}
-func (cmd *command) submit(container arvados.Container, crunchRunCommand []string) error {
+func (disp *Dispatcher) submit(container arvados.Container, crunchRunCommand []string) error {
// append() here avoids modifying crunchRunCommand's
// underlying array, which is shared with other goroutines.
crArgs := append([]string(nil), crunchRunCommand...)
crArgs = append(crArgs, container.UUID)
crScript := strings.NewReader(execScript(crArgs))
- cmd.sqCheck.L.Lock()
- defer cmd.sqCheck.L.Unlock()
+ disp.sqCheck.L.Lock()
+ defer disp.sqCheck.L.Unlock()
- sbArgs, err := cmd.sbatchArgs(container)
+ sbArgs, err := disp.sbatchArgs(container)
if err != nil {
return err
}
log.Printf("running sbatch %+q", sbArgs)
- return cmd.slurm.Batch(crScript, sbArgs)
+ return disp.slurm.Batch(crScript, sbArgs)
}
// Submit a container to the slurm queue (or resume monitoring if it's
// already in the queue). Cancel the slurm job if the container's
// priority changes to zero or its state indicates it's no longer
// running.
-func (cmd *command) run(_ *dispatch.Dispatcher, ctr arvados.Container, status <-chan arvados.Container) {
+func (disp *Dispatcher) runContainer(_ *dispatch.Dispatcher, ctr arvados.Container, status <-chan arvados.Container) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
- if ctr.State == dispatch.Locked && !cmd.sqCheck.HasUUID(ctr.UUID) {
+ if ctr.State == dispatch.Locked && !disp.sqCheck.HasUUID(ctr.UUID) {
log.Printf("Submitting container %s to slurm", ctr.UUID)
- if err := cmd.submit(ctr, cmd.CrunchRunCommand); err != nil {
+ if err := disp.submit(ctr, disp.CrunchRunCommand); err != nil {
var text string
if err == dispatchcloud.ErrConstraintsNotSatisfiable {
text = fmt.Sprintf("cannot run container %s: %s", ctr.UUID, err)
- cmd.dispatcher.UpdateState(ctr.UUID, dispatch.Cancelled)
+ disp.UpdateState(ctr.UUID, dispatch.Cancelled)
} else {
text = fmt.Sprintf("Error submitting container %s to slurm: %s", ctr.UUID, err)
}
@@ -268,9 +282,9 @@ func (cmd *command) run(_ *dispatch.Dispatcher, ctr arvados.Container, status <-
"object_uuid": ctr.UUID,
"event_type": "dispatch",
"properties": map[string]string{"text": text}}}
- cmd.dispatcher.Arv.Create("logs", lr, nil)
+ disp.Arv.Create("logs", lr, nil)
- cmd.dispatcher.Unlock(ctr.UUID)
+ disp.Unlock(ctr.UUID)
return
}
}
@@ -282,7 +296,7 @@ func (cmd *command) run(_ *dispatch.Dispatcher, ctr arvados.Container, status <-
// no point in waiting for further dispatch updates: just
// clean up and return.
go func(uuid string) {
- for ctx.Err() == nil && cmd.sqCheck.HasUUID(uuid) {
+ for ctx.Err() == nil && disp.sqCheck.HasUUID(uuid) {
}
cancel()
}(ctr.UUID)
@@ -291,68 +305,68 @@ func (cmd *command) run(_ *dispatch.Dispatcher, ctr arvados.Container, status <-
select {
case <-ctx.Done():
// Disappeared from squeue
- if err := cmd.dispatcher.Arv.Get("containers", ctr.UUID, nil, &ctr); err != nil {
+ if err := disp.Arv.Get("containers", ctr.UUID, nil, &ctr); err != nil {
log.Printf("Error getting final container state for %s: %s", ctr.UUID, err)
}
switch ctr.State {
case dispatch.Running:
- cmd.dispatcher.UpdateState(ctr.UUID, dispatch.Cancelled)
+ disp.UpdateState(ctr.UUID, dispatch.Cancelled)
case dispatch.Locked:
- cmd.dispatcher.Unlock(ctr.UUID)
+ disp.Unlock(ctr.UUID)
}
return
case updated, ok := <-status:
if !ok {
- log.Printf("Dispatcher says container %s is done: cancel slurm job", ctr.UUID)
- cmd.scancel(ctr)
+ log.Printf("container %s is done: cancel slurm job", ctr.UUID)
+ disp.scancel(ctr)
} else if updated.Priority == 0 {
- log.Printf("Container %s has state %q, priority %d: cancel slurm job", ctr.UUID, updated.State, updated.Priority)
- cmd.scancel(ctr)
+ log.Printf("container %s has state %q, priority %d: cancel slurm job", ctr.UUID, updated.State, updated.Priority)
+ disp.scancel(ctr)
} else {
- cmd.renice(updated)
+ disp.renice(updated)
}
}
}
}
-func (cmd *command) scancel(ctr arvados.Container) {
- cmd.sqCheck.L.Lock()
- err := cmd.slurm.Cancel(ctr.UUID)
- cmd.sqCheck.L.Unlock()
+func (disp *Dispatcher) scancel(ctr arvados.Container) {
+ disp.sqCheck.L.Lock()
+ err := disp.slurm.Cancel(ctr.UUID)
+ disp.sqCheck.L.Unlock()
if err != nil {
log.Printf("scancel: %s", err)
time.Sleep(time.Second)
- } else if cmd.sqCheck.HasUUID(ctr.UUID) {
+ } else if disp.sqCheck.HasUUID(ctr.UUID) {
log.Printf("container %s is still in squeue after scancel", ctr.UUID)
time.Sleep(time.Second)
}
}
-func (cmd *command) renice(ctr arvados.Container) {
- nice := cmd.niceness(ctr.Priority)
- oldnice := cmd.sqCheck.GetNiceness(ctr.UUID)
+func (disp *Dispatcher) renice(ctr arvados.Container) {
+ nice := disp.niceness(ctr.Priority)
+ oldnice := disp.sqCheck.GetNiceness(ctr.UUID)
if nice == oldnice || oldnice == -1 {
return
}
log.Printf("updating slurm nice value to %d (was %d)", nice, oldnice)
- cmd.sqCheck.L.Lock()
- err := cmd.slurm.Renice(ctr.UUID, nice)
- cmd.sqCheck.L.Unlock()
+ disp.sqCheck.L.Lock()
+ err := disp.slurm.Renice(ctr.UUID, nice)
+ disp.sqCheck.L.Unlock()
if err != nil {
log.Printf("renice: %s", err)
time.Sleep(time.Second)
return
}
- if cmd.sqCheck.HasUUID(ctr.UUID) {
+ if disp.sqCheck.HasUUID(ctr.UUID) {
log.Printf("container %s has arvados priority %d, slurm nice %d",
- ctr.UUID, ctr.Priority, cmd.sqCheck.GetNiceness(ctr.UUID))
+ ctr.UUID, ctr.Priority, disp.sqCheck.GetNiceness(ctr.UUID))
}
}
-func (cmd *command) readConfig(path string) error {
- err := config.LoadFile(cmd, path)
+func (disp *Dispatcher) readConfig(path string) error {
+ err := config.LoadFile(disp, path)
if err != nil && os.IsNotExist(err) && path == defaultConfigPath {
log.Printf("Config not specified. Continue with default configuration.")
err = nil
diff --git a/services/crunch-dispatch-slurm/crunch-dispatch-slurm_test.go b/services/crunch-dispatch-slurm/crunch-dispatch-slurm_test.go
index 459b7c6..b822232 100644
--- a/services/crunch-dispatch-slurm/crunch-dispatch-slurm_test.go
+++ b/services/crunch-dispatch-slurm/crunch-dispatch-slurm_test.go
@@ -37,12 +37,16 @@ var _ = Suite(&IntegrationSuite{})
var _ = Suite(&StubbedSuite{})
type IntegrationSuite struct {
- cmd command
+ disp Dispatcher
+ slurm slurmFake
}
func (s *IntegrationSuite) SetUpTest(c *C) {
arvadostest.StartAPI()
os.Setenv("ARVADOS_API_TOKEN", arvadostest.Dispatch1Token)
+ s.disp = Dispatcher{}
+ s.disp.setup()
+ s.slurm = slurmFake{}
}
func (s *IntegrationSuite) TearDownTest(c *C) {
@@ -87,7 +91,7 @@ func (sf *slurmFake) Cancel(name string) error {
return nil
}
-func (s *IntegrationSuite) integrationTest(c *C, slurm *slurmFake,
+func (s *IntegrationSuite) integrationTest(c *C,
expectBatch [][]string,
runContainer func(*dispatch.Dispatcher, arvados.Container)) arvados.Container {
arvadostest.ResetEnv()
@@ -95,8 +99,6 @@ func (s *IntegrationSuite) integrationTest(c *C, slurm *slurmFake,
arv, err := arvadosclient.MakeArvadosClient()
c.Assert(err, IsNil)
- s.cmd.slurm = slurm
-
// There should be one queued container
params := arvadosclient.Dict{
"filters": [][]string{{"state", "=", "Queued"}},
@@ -106,34 +108,35 @@ func (s *IntegrationSuite) integrationTest(c *C, slurm *slurmFake,
c.Check(err, IsNil)
c.Check(len(containers.Items), Equals, 1)
- s.cmd.CrunchRunCommand = []string{"echo"}
+ s.disp.CrunchRunCommand = []string{"echo"}
ctx, cancel := context.WithCancel(context.Background())
doneRun := make(chan struct{})
- s.cmd.dispatcher = &dispatch.Dispatcher{
+ s.disp.Dispatcher = &dispatch.Dispatcher{
Arv: arv,
PollPeriod: time.Duration(1) * time.Second,
RunContainer: func(disp *dispatch.Dispatcher, ctr arvados.Container, status <-chan arvados.Container) {
go func() {
runContainer(disp, ctr)
- slurm.queue = ""
+ s.slurm.queue = ""
doneRun <- struct{}{}
}()
- s.cmd.run(disp, ctr, status)
+ s.disp.runContainer(disp, ctr, status)
cancel()
},
}
- s.cmd.sqCheck = &SqueueChecker{Period: 500 * time.Millisecond, Slurm: slurm}
+ s.disp.slurm = &s.slurm
+ s.disp.sqCheck = &SqueueChecker{Period: 500 * time.Millisecond, Slurm: s.disp.slurm}
- err = s.cmd.dispatcher.Run(ctx)
+ err = s.disp.Dispatcher.Run(ctx)
<-doneRun
c.Assert(err, Equals, context.Canceled)
- s.cmd.sqCheck.Stop()
+ s.disp.sqCheck.Stop()
- c.Check(slurm.didBatch, DeepEquals, expectBatch)
+ c.Check(s.slurm.didBatch, DeepEquals, expectBatch)
// There should be no queued containers now
err = arv.List("containers", params, &containers)
@@ -148,8 +151,8 @@ func (s *IntegrationSuite) integrationTest(c *C, slurm *slurmFake,
}
func (s *IntegrationSuite) TestNormal(c *C) {
+ s.slurm = slurmFake{queue: "zzzzz-dz642-queuedcontainer 9990 100\n"}
container := s.integrationTest(c,
- &slurmFake{queue: "zzzzz-dz642-queuedcontainer 9990 100\n"},
nil,
func(dispatcher *dispatch.Dispatcher, container arvados.Container) {
dispatcher.UpdateState(container.UUID, dispatch.Running)
@@ -160,11 +163,10 @@ func (s *IntegrationSuite) TestNormal(c *C) {
}
func (s *IntegrationSuite) TestCancel(c *C) {
- slurm := &slurmFake{queue: "zzzzz-dz642-queuedcontainer 9990 100\n"}
+ s.slurm = slurmFake{queue: "zzzzz-dz642-queuedcontainer 9990 100\n"}
readyToCancel := make(chan bool)
- slurm.onCancel = func() { <-readyToCancel }
+ s.slurm.onCancel = func() { <-readyToCancel }
container := s.integrationTest(c,
- slurm,
nil,
func(dispatcher *dispatch.Dispatcher, container arvados.Container) {
dispatcher.UpdateState(container.UUID, dispatch.Running)
@@ -177,12 +179,12 @@ func (s *IntegrationSuite) TestCancel(c *C) {
close(readyToCancel)
})
c.Check(container.State, Equals, arvados.ContainerStateCancelled)
- c.Check(len(slurm.didCancel) > 1, Equals, true)
- c.Check(slurm.didCancel[:2], DeepEquals, []string{"zzzzz-dz642-queuedcontainer", "zzzzz-dz642-queuedcontainer"})
+ c.Check(len(s.slurm.didCancel) > 1, Equals, true)
+ c.Check(s.slurm.didCancel[:2], DeepEquals, []string{"zzzzz-dz642-queuedcontainer", "zzzzz-dz642-queuedcontainer"})
}
func (s *IntegrationSuite) TestMissingFromSqueue(c *C) {
- container := s.integrationTest(c, &slurmFake{},
+ container := s.integrationTest(c,
[][]string{{
fmt.Sprintf("--job-name=%s", "zzzzz-dz642-queuedcontainer"),
fmt.Sprintf("--mem=%d", 11445),
@@ -198,8 +200,8 @@ func (s *IntegrationSuite) TestMissingFromSqueue(c *C) {
}
func (s *IntegrationSuite) TestSbatchFail(c *C) {
+ s.slurm = slurmFake{errBatch: errors.New("something terrible happened")}
container := s.integrationTest(c,
- &slurmFake{errBatch: errors.New("something terrible happened")},
[][]string{{"--job-name=zzzzz-dz642-queuedcontainer", "--mem=11445", "--cpus-per-task=4", "--tmp=45777", "--nice=9990"}},
func(dispatcher *dispatch.Dispatcher, container arvados.Container) {
dispatcher.UpdateState(container.UUID, dispatch.Running)
@@ -219,8 +221,8 @@ func (s *IntegrationSuite) TestSbatchFail(c *C) {
}
func (s *IntegrationSuite) TestChangePriority(c *C) {
- slurm := &slurmFake{queue: "zzzzz-dz642-queuedcontainer 9990 100\n"}
- container := s.integrationTest(c, slurm, nil,
+ s.slurm = slurmFake{queue: "zzzzz-dz642-queuedcontainer 9990 100\n"}
+ container := s.integrationTest(c, nil,
func(dispatcher *dispatch.Dispatcher, container arvados.Container) {
dispatcher.UpdateState(container.UUID, dispatch.Running)
time.Sleep(time.Second)
@@ -232,16 +234,17 @@ func (s *IntegrationSuite) TestChangePriority(c *C) {
dispatcher.UpdateState(container.UUID, dispatch.Complete)
})
c.Check(container.State, Equals, arvados.ContainerStateComplete)
- c.Assert(len(slurm.didRenice), Not(Equals), 0)
- c.Check(slurm.didRenice[len(slurm.didRenice)-1], DeepEquals, []string{"zzzzz-dz642-queuedcontainer", "4000"})
+ c.Assert(len(s.slurm.didRenice), Not(Equals), 0)
+ c.Check(s.slurm.didRenice[len(s.slurm.didRenice)-1], DeepEquals, []string{"zzzzz-dz642-queuedcontainer", "4000"})
}
type StubbedSuite struct {
- cmd command
+ disp Dispatcher
}
func (s *StubbedSuite) SetUpTest(c *C) {
- s.cmd = command{}
+ s.disp = Dispatcher{}
+ s.disp.setup()
}
func (s *StubbedSuite) TestAPIErrorGettingContainers(c *C) {
@@ -270,7 +273,7 @@ func (s *StubbedSuite) testWithServerStub(c *C, apiStubResponses map[string]arva
log.SetOutput(io.MultiWriter(buf, os.Stderr))
defer log.SetOutput(os.Stderr)
- s.cmd.CrunchRunCommand = []string{crunchCmd}
+ s.disp.CrunchRunCommand = []string{crunchCmd}
ctx, cancel := context.WithCancel(context.Background())
dispatcher := dispatch.Dispatcher{
@@ -282,7 +285,7 @@ func (s *StubbedSuite) testWithServerStub(c *C, apiStubResponses map[string]arva
disp.UpdateState(ctr.UUID, dispatch.Running)
disp.UpdateState(ctr.UUID, dispatch.Complete)
}()
- s.cmd.run(disp, ctr, status)
+ s.disp.runContainer(disp, ctr, status)
cancel()
},
}
@@ -301,7 +304,7 @@ func (s *StubbedSuite) testWithServerStub(c *C, apiStubResponses map[string]arva
}
func (s *StubbedSuite) TestNoSuchConfigFile(c *C) {
- err := s.cmd.readConfig("/nosuchdir89j7879/8hjwr7ojgyy7")
+ err := s.disp.readConfig("/nosuchdir89j7879/8hjwr7ojgyy7")
c.Assert(err, NotNil)
}
@@ -313,7 +316,7 @@ func (s *StubbedSuite) TestBadSbatchArgsConfig(c *C) {
_, err = tmpfile.Write([]byte(`{"SbatchArguments": "oops this is not a string array"}`))
c.Check(err, IsNil)
- err = s.cmd.readConfig(tmpfile.Name())
+ err = s.disp.readConfig(tmpfile.Name())
c.Assert(err, NotNil)
}
@@ -325,9 +328,9 @@ func (s *StubbedSuite) TestNoSuchArgInConfigIgnored(c *C) {
_, err = tmpfile.Write([]byte(`{"NoSuchArg": "Nobody loves me, not one tiny hunk."}`))
c.Check(err, IsNil)
- err = s.cmd.readConfig(tmpfile.Name())
+ err = s.disp.readConfig(tmpfile.Name())
c.Assert(err, IsNil)
- c.Check(0, Equals, len(s.cmd.SbatchArguments))
+ c.Check(0, Equals, len(s.disp.SbatchArguments))
}
func (s *StubbedSuite) TestReadConfig(c *C) {
@@ -340,9 +343,9 @@ func (s *StubbedSuite) TestReadConfig(c *C) {
_, err = tmpfile.Write([]byte(argsS))
c.Check(err, IsNil)
- err = s.cmd.readConfig(tmpfile.Name())
+ err = s.disp.readConfig(tmpfile.Name())
c.Assert(err, IsNil)
- c.Check(args, DeepEquals, s.cmd.SbatchArguments)
+ c.Check(args, DeepEquals, s.disp.SbatchArguments)
}
func (s *StubbedSuite) TestSbatchArgs(c *C) {
@@ -358,9 +361,9 @@ func (s *StubbedSuite) TestSbatchArgs(c *C) {
{"--arg1=v1", "--arg2"},
} {
c.Logf("%#v", defaults)
- s.cmd.SbatchArguments = defaults
+ s.disp.SbatchArguments = defaults
- args, err := s.cmd.sbatchArgs(container)
+ args, err := s.disp.sbatchArgs(container)
c.Check(args, DeepEquals, append(defaults, "--job-name=123", "--mem=239", "--cpus-per-task=2", "--tmp=0", "--nice=9990"))
c.Check(err, IsNil)
}
@@ -401,9 +404,9 @@ func (s *StubbedSuite) TestSbatchInstanceTypeConstraint(c *C) {
},
} {
c.Logf("%#v", trial)
- s.cmd.cluster = &arvados.Cluster{InstanceTypes: trial.types}
+ s.disp.cluster = &arvados.Cluster{InstanceTypes: trial.types}
- args, err := s.cmd.sbatchArgs(container)
+ args, err := s.disp.sbatchArgs(container)
c.Check(err, Equals, trial.err)
if trial.err == nil {
c.Check(args, DeepEquals, append([]string{"--job-name=123", "--mem=239", "--cpus-per-task=2", "--tmp=0", "--nice=9990"}, trial.sbatchArgs...))
@@ -419,7 +422,7 @@ func (s *StubbedSuite) TestSbatchPartition(c *C) {
Priority: 1,
}
- args, err := s.cmd.sbatchArgs(container)
+ args, err := s.disp.sbatchArgs(container)
c.Check(args, DeepEquals, []string{
"--job-name=123", "--mem=239", "--cpus-per-task=1", "--tmp=0", "--nice=9990",
"--partition=blurb,b2",
-----------------------------------------------------------------------
hooks/post-receive
--
More information about the arvados-commits
mailing list