TMP Prop

Author: sleshchenko

pkg/library/command.go

@@ -26,11 +26,11 @@ func getCommandType(command v1alpha1.Command) (v1alpha1.CommandType, error) {
 	return command.CommandType, nil
 }
 
-func getCommandsForIds(ids []string, commands []v1alpha1.Command) ([]v1alpha1.Command, error) {
+func getCommandsForIDs(ids []string, commands []v1alpha1.Command) ([]v1alpha1.Command, error) {
 	var resolvedCommands []v1alpha1.Command
 
 	for _, id := range ids {
-		resolvedCommand, err := getCommandById(id, commands)
+		resolvedCommand, err := getCommandByID(id, commands)
 		if err != nil {
 			return nil, err
 		}
@@ -40,48 +40,49 @@ func getCommandsForIds(ids []string, commands []v1alpha1.Command) ([]v1alpha1.Co
 	return resolvedCommands, nil
 }
 
-func getCommandById(id string, commands []v1alpha1.Command) (*v1alpha1.Command, error) {
+func getCommandByID(id string, commands []v1alpha1.Command) (*v1alpha1.Command, error) {
 	for _, command := range commands {
-		commandKey, err := command.Key()
+		commandID, err := command.Key()
 		if err != nil {
 			return nil, err
 		}
-		if commandKey == id {
+		if commandID == id {
 			return &command, nil
 		}
 	}
 	return nil, fmt.Errorf("no command with key %s is defined", id)
 }
 
-func commandListToComponentKeys(commands []v1alpha1.Command) (map[string]bool, error) {
-	componentKeys := map[string]bool{}
+func commandListToComponentID(commands []v1alpha1.Command) (map[string]bool, error) {
+	componentIDs := map[string]bool{}
 	for _, command := range commands {
 		commandType, err := getCommandType(command)
 		if err != nil {
 			return nil, err
 		}
 		switch commandType {
 		case v1alpha1.ApplyCommandType:
-			componentKeys[command.Apply.Component] = true
+			componentIDs[command.Apply.Component] = true
 		case v1alpha1.ExecCommandType:
 			// TODO: This will require special handling (how do we handle prestart exec?)
-			componentKeys[command.Exec.Component] = true
+			componentIDs[command.Exec.Component] = true
 		case v1alpha1.CompositeCommandType:
 			// TODO: Handle composite commands: what if an init command is composite and refers to other commands
 		default: // Ignore
 		}
 	}
-	return componentKeys, nil
+	return componentIDs, nil
 }
 
-func removeCommandsByKeys(keys []string, commands []v1alpha1.Command) ([]v1alpha1.Command, error) {
+func removeCommandsByIDs(IDs []string, commands []v1alpha1.Command) ([]v1alpha1.Command, error) {
+	toRemove := stringListToMap(IDs)
 	var filtered []v1alpha1.Command
 	for _, command := range commands {
 		key, err := command.Key()
 		if err != nil {
 			return nil, err
 		}
-		if !listContains(key, keys) {
+		if !toRemove[key] {
 			filtered = append(filtered, command)
 		}
 	}

pkg/library/common.go

@@ -12,6 +12,14 @@
 
 package library
 
+func stringListToMap(list []string) map[string]bool {
+	res := map[string]bool{}
+	for _, item := range list {
+		res[item] = true
+	}
+	return res
+}
+
 func listContains(query string, list []string) bool {
 	for _, elem := range list {
 		if query == elem {

pkg/library/lifecycle.go

@@ -30,27 +30,27 @@ func GetInitContainers(devfile v1alpha1.DevWorkspaceTemplateSpecContent) (initCo
 		return nil, components, nil
 	}
 
-	initCommands, err := getCommandsForIds(events.PreStart, commands)
+	initCommands, err := getCommandsForIDs(events.PreStart, commands)
 	if err != nil {
 		return nil, nil, err
 	}
 	// Check that commands in PreStart lifecycle binding are supported
 	if err = checkEventCommandsValidity(initCommands); err != nil {
 		return nil, nil, err
 	}
-	initComponentKeys, err := commandListToComponentKeys(initCommands)
+	initComponentIDs, err := commandListToComponentID(initCommands)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// Need to also consider components that are *both* init containers and in the main deployment
 	// Example: component is referenced in both a prestart event and a regular, non-prestart command
 	// TODO: Figure out details of handling postStop commands, since they should not be included in main deployment
-	nonInitCommands, err := removeCommandsByKeys(events.PreStart, commands)
+	nonInitCommands, err := removeCommandsByIDs(events.PreStart, commands)
 	if err != nil {
 		return nil, nil, err
 	}
-	mainComponentKeys, err := commandListToComponentKeys(nonInitCommands)
+	mainComponentIDs, err := commandListToComponentID(nonInitCommands)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -60,9 +60,9 @@ func GetInitContainers(devfile v1alpha1.DevWorkspaceTemplateSpecContent) (initCo
 		if err != nil {
 			return nil, nil, err
 		}
-		if initComponentKeys[componentID] {
+		if initComponentIDs[componentID] {
 			initContainers = append(initContainers, component)
-			if mainComponentKeys[componentID] {
+			if mainComponentIDs[componentID] {
 				// Component is *also* a main component.
 				mainComponents = append(mainComponents, component)
 			}

pkg/library/lifecycle_test.go

@@ -61,6 +61,11 @@ func TestGetInitContainers(t *testing.T) {
 		t.Run(tt.Name, func(t *testing.T) {
 			// sanity check that file reads correctly.
 			assert.True(t, len(tt.Input.Components) > 0, "Input defines no components")
+			if tt.Output.ErrRegexp != nil && len(*tt.Output.ErrRegexp) > 0 &&
+				(len(tt.Output.InitContainers) > 0 || len(tt.Output.MainContainers) > 0) {
+				t.Fatal("No init containers or main containers could be configured when error is expected")
+			}
+
 			gotInitContainers, gotMainComponents, err := GetInitContainers(tt.Input)
 			if tt.Output.ErrRegexp != nil && assert.Error(t, err) {
 				assert.Regexp(t, *tt.Output.ErrRegexp, err.Error(), "Error message should match")

pkg/library/testdata/lifecycle/prestart_exec_command.yaml

@@ -18,12 +18,4 @@ input:
       - "test_command"
 
 output:
-  initContainers:
-    - container:
-        name: test-container1
-        image: my-image
-  mainContainers:
-    - container:
-        name: test-container2
-        image: my-image
   errRegexp: "only apply-type commands are supported in the prestart lifecycle binding"