func BootstrappingTasksExist(c config.Cpi) error { tasksBytes, err := rackhdapi.RetrieveTasks(c) if err != nil { return fmt.Errorf("unable to retrieve tasks: %s", err) } tasks := []bootstrapTask{} err = json.Unmarshal(tasksBytes, &tasks) foundTasks := map[string]interface{}{} for i := range tasks { switch tasks[i].Name { case SetPxeBootTaskName: options := obmServiceOptions{} properties := setPxeBootTaskProperties{} err = json.Unmarshal(tasks[i].Options, &options) if err != nil { return fmt.Errorf("error unmarshalling pxe boot task options: %s", err) } err = json.Unmarshal(tasks[i].Properties, &properties) if err != nil { return fmt.Errorf("error unmarshalling pxe boot task properties: %s", err) } t := setPxeBootTask{TaskStub: tasks[i].TaskStub, setPxeBootTaskOptionsContainer: &setPxeBootTaskOptionsContainer{}, setPxeBootTaskPropertiesContainer: &setPxeBootTaskPropertiesContainer{}, } t.Options = options t.Properties = properties foundTasks[SetPxeBootTaskName] = t case RebootNodeTaskName: options := obmServiceOptions{} properties := rebootNodeTaskProperties{} err = json.Unmarshal(tasks[i].Options, &options) if err != nil { return fmt.Errorf("error unmarshalling reboot task options: %s", err) } err = json.Unmarshal(tasks[i].Properties, &properties) if err != nil { return fmt.Errorf("error unmarshalling pxe boot task properties: %s", err) } t := rebootNodeTask{ TaskStub: tasks[i].TaskStub, rebootNodeTaskOptionsContainer: &rebootNodeTaskOptionsContainer{}, rebootNodeTaskPropertiesContainer: &rebootNodeTaskPropertiesContainer{}, } t.Options = options t.Properties = properties foundTasks[RebootNodeTaskName] = t case BootstrapUbuntuTaskName: options := bootstrapUbuntuTaskOptions{} properties := bootstrapUbuntuTaskProperties{} err = json.Unmarshal(tasks[i].Options, &options) if err != nil { return fmt.Errorf("error unmarshalling bootstrap ubuntu task options: %s", err) } err = json.Unmarshal(tasks[i].Properties, &properties) if err != nil { return fmt.Errorf("error unmarshalling bootstrap ubuntu task properties: %s", err) } t := bootstrapUbuntuTask{ TaskStub: tasks[i].TaskStub, bootstrapUbuntuTaskOptionsContainer: &bootstrapUbuntuTaskOptionsContainer{}, bootstrapUbuntuTaskPropertiesContainer: &bootstrapUbuntuTaskPropertiesContainer{}, } t.Options = options t.Properties = properties foundTasks[BootstrapUbuntuTaskName] = t } if len(foundTasks) == requiredTaskLength { break } } if len(foundTasks) != requiredTaskLength { return fmt.Errorf("Did not find the expected number of required bootstrapping tasks: %d, found %v", requiredTaskLength, foundTasks) } if !setPxeBootTaskIsExpected(foundTasks[SetPxeBootTaskName].(setPxeBootTask)) { return fmt.Errorf("Set PXE boot task has unexpected form: %v", foundTasks[SetPxeBootTaskName]) } if !rebootNodeTaskIsExpected(foundTasks[RebootNodeTaskName].(rebootNodeTask)) { return fmt.Errorf("Reboot node task has unexpected form: %v", foundTasks[RebootNodeTaskName]) } if !bootstrapUbuntuIsExpected(foundTasks[BootstrapUbuntuTaskName].(bootstrapUbuntuTask)) { return fmt.Errorf("Bootstrap Ubuntu task has unexpected form: %v", foundTasks[BootstrapUbuntuTaskName]) } return nil }
fakeTaskStub := rackhdapi.TaskStub{ Name: fmt.Sprintf("Task.CF.Fake.%s", uuid), UnusedName: rackhdapi.DefaultUnusedName, } fakeTask := struct { *rackhdapi.TaskStub *rackhdapi.OptionContainer }{ TaskStub: &fakeTaskStub, OptionContainer: &rackhdapi.OptionContainer{}, } fakeTaskBytes, err := json.Marshal(fakeTask) Expect(err).ToNot(HaveOccurred()) err = rackhdapi.PublishTask(cpiConfig, fakeTaskBytes) Expect(err).ToNot(HaveOccurred()) taskLibraryBytes, err := rackhdapi.RetrieveTasks(cpiConfig) Expect(err).ToNot(HaveOccurred()) taskLibrary := []rackhdapi.TaskStub{} err = json.Unmarshal(taskLibraryBytes, &taskLibrary) Expect(err).ToNot(HaveOccurred()) Expect(taskLibrary).To(ContainElement(fakeTaskStub)) }) }) })