feat!: change registry spec to imagespec

container-engine-lib/lib/backend_interface/objects/service/service_config_test.go

@@ -2,11 +2,11 @@ package service
 
 import (
 	"encoding/json"
+	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/image_registry_spec"
 	"testing"
 	"time"
 
 	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/image_build_spec"
-	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/image_registry_spec"
 	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/nix_build_spec"
 	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/port_spec"
 	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/service_directory"

core/server/api_container/server/startosis_engine/kurtosis_builtins.go

@@ -114,7 +114,7 @@ func KurtosisTypeConstructors() []*starlark.Builtin {
 		starlark.NewBuiltin(service_config.ReadyConditionTypeName, service_config.NewReadyConditionType().CreateBuiltin()),
 		starlark.NewBuiltin(service_config.ImageBuildSpecTypeName, service_config.NewImageBuildSpecType().CreateBuiltin()),
 		starlark.NewBuiltin(service_config.NixBuildSpecTypeName, service_config.NewNixBuildSpecType().CreateBuiltin()),
-		starlark.NewBuiltin(service_config.ImageRegistrySpecTypeName, service_config.NewImageRegistrySpec().CreateBuiltin()),
+		starlark.NewBuiltin(service_config.ImageSpecTypeName, service_config.NewImageSpec().CreateBuiltin()),
 		starlark.NewBuiltin(service_config.UserTypeName, service_config.NewUserType().CreateBuiltin()),
 		starlark.NewBuiltin(service_config.TolerationTypeName, service_config.NewTolerationType().CreateBuiltin()),
 	}

core/server/api_container/server/startosis_engine/kurtosis_starlark_framework/test_engine/service_config_image_spec_minimal_test.go

@@ -0,0 +1,80 @@
+package test_engine
+
+import (
+	"fmt"
+	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/image_registry_spec"
+	"testing"
+
+	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/port_spec"
+	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/service"
+	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/service_network"
+	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/startosis_engine/kurtosis_starlark_framework/builtin_argument"
+	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/startosis_engine/kurtosis_types/service_config"
+	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/startosis_engine/startosis_packages"
+	"github.com/stretchr/testify/require"
+)
+
+type serviceConfigImageSpecMinimalTest struct {
+	*testing.T
+	serviceNetwork         *service_network.MockServiceNetwork
+	packageContentProvider *startosis_packages.MockPackageContentProvider
+}
+
+func (suite *KurtosisTypeConstructorTestSuite) TestServiceConfigWithImageSpecImageOnly() {
+	suite.run(&serviceConfigImageSpecMinimalTest{
+		T:                      suite.T(),
+		serviceNetwork:         suite.serviceNetwork,
+		packageContentProvider: suite.packageContentProvider,
+	})
+}
+
+func (t *serviceConfigImageSpecMinimalTest) GetStarlarkCode() string {
+	imageSpec := fmt.Sprintf("%s(%s=%q)",
+		service_config.ImageSpecTypeName,
+		service_config.ImageAttr,
+		testContainerImageName,
+	)
+	return fmt.Sprintf("%s(%s=%s)",
+		service_config.ServiceConfigTypeName,
+		service_config.ImageAttr, imageSpec)
+}
+
+func (t *serviceConfigImageSpecMinimalTest) Assert(typeValue builtin_argument.KurtosisValueType) {
+	serviceConfigStarlark, ok := typeValue.(*service_config.ServiceConfig)
+	require.True(t, ok)
+
+	serviceConfig, interpretationErr := serviceConfigStarlark.ToKurtosisType(
+		t.serviceNetwork,
+		testModuleMainFileLocator,
+		testModulePackageId,
+		t.packageContentProvider,
+		testNoPackageReplaceOptions)
+	require.Nil(t, interpretationErr)
+
+	expectedImageRegistrySpec := image_registry_spec.NewImageRegistrySpec(testContainerImageName, "", "", "")
+	expectedServiceConfig, err := service.CreateServiceConfig(
+		testContainerImageName,
+		nil,
+		expectedImageRegistrySpec,
+		nil,
+		map[string]*port_spec.PortSpec{},
+		map[string]*port_spec.PortSpec{},
+		nil,
+		nil,
+		map[string]string{},
+		nil,
+		nil,
+		0,
+		0,
+		service_config.DefaultPrivateIPAddrPlaceholder,
+		0,
+		0,
+		map[string]string{},
+		nil,
+		nil,
+		map[string]string{},
+	)
+	require.NoError(t, err)
+	require.Equal(t, expectedServiceConfig, serviceConfig)
+	require.Equal(t, expectedImageRegistrySpec, serviceConfig.GetImageRegistrySpec())
+}

core/server/api_container/server/startosis_engine/kurtosis_starlark_framework/test_engine/service_config_image_registry_spec_test.go → core/server/api_container/server/startosis_engine/kurtosis_starlark_framework/test_engine/service_config_image_spec_test.go

@@ -2,9 +2,9 @@ package test_engine
 
 import (
 	"fmt"
+	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/image_registry_spec"
 	"testing"
 
-	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/image_registry_spec"
 	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/port_spec"
 	"github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/service"
 	"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/service_network"
@@ -14,38 +14,38 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-type serviceConfigImageRegistrySpecTest struct {
+type serviceConfigImageSpecTest struct {
 	*testing.T
 	serviceNetwork         *service_network.MockServiceNetwork
 	packageContentProvider *startosis_packages.MockPackageContentProvider
 }
 
-func (suite *KurtosisTypeConstructorTestSuite) TestServiceConfigWithImageRegistrySpec() {
-	suite.run(&serviceConfigImageRegistrySpecTest{
+func (suite *KurtosisTypeConstructorTestSuite) TestServiceConfigWithImageSpecWithRegistry() {
+	suite.run(&serviceConfigImageSpecTest{
 		T:                      suite.T(),
 		serviceNetwork:         suite.serviceNetwork,
 		packageContentProvider: suite.packageContentProvider,
 	})
 }
 
-func (t *serviceConfigImageRegistrySpecTest) GetStarlarkCode() string {
-	imageRegistrySpec := fmt.Sprintf("%s(%s=%q, %s=%q, %s=%q, %s=%q)",
-		service_config.ImageRegistrySpecTypeName,
+func (t *serviceConfigImageSpecTest) GetStarlarkCode() string {
+	imageSpec := fmt.Sprintf("%s(%s=%q, %s=%q, %s=%q, %s=%q)",
+		service_config.ImageSpecTypeName,
 		service_config.ImageAttr,
 		testContainerImageName,
-		service_config.RegistryAddrAttr,
+		service_config.ImageRegistryAttr,
 		testRegistryAddr,
-		service_config.RegistryUsernameAttr,
+		service_config.ImageRegistryUsernameAttr,
 		testRegistryUsername,
-		service_config.RegistryPasswordAttr,
+		service_config.ImageRegistryPasswordAttr,
 		testRegistryPassword,
 	)
 	return fmt.Sprintf("%s(%s=%s)",
 		service_config.ServiceConfigTypeName,
-		service_config.ImageAttr, imageRegistrySpec)
+		service_config.ImageAttr, imageSpec)
 }
 
-func (t *serviceConfigImageRegistrySpecTest) Assert(typeValue builtin_argument.KurtosisValueType) {
+func (t *serviceConfigImageSpecTest) Assert(typeValue builtin_argument.KurtosisValueType) {
 	serviceConfigStarlark, ok := typeValue.(*service_config.ServiceConfig)
 	require.True(t, ok)
 

core/server/api_container/server/startosis_engine/kurtosis_types/service_config/image_registry_spec.go → core/server/api_container/server/startosis_engine/kurtosis_types/service_config/image_spec.go

@@ -10,49 +10,50 @@ import (
 )
 
 const (
-	ImageRegistrySpecTypeName = "ImageRegistrySpec"
+	ImageSpecTypeName = "ImageSpec"
 
-	RegistryImageAttr    = "image"
-	RegistryAddrAttr     = "registry"
-	RegistryUsernameAttr = "username"
-	RegistryPasswordAttr = "password"
+	ImageSpecImageAttr        = "image"
+	ImageRegistryAttr         = "registry"
+	ImageRegistryUsernameAttr = "username"
+	ImageRegistryPasswordAttr = "password"
 )
 
-func NewImageRegistrySpec() *kurtosis_type_constructor.KurtosisTypeConstructor {
+func NewImageSpec() *kurtosis_type_constructor.KurtosisTypeConstructor {
+
 	return &kurtosis_type_constructor.KurtosisTypeConstructor{
 		KurtosisBaseBuiltin: &kurtosis_starlark_framework.KurtosisBaseBuiltin{
-			Name: ImageRegistrySpecTypeName,
+			Name: ImageSpecTypeName,
 			Arguments: []*builtin_argument.BuiltinArgument{
 				{
-					Name:              RegistryImageAttr,
+					Name:              ImageSpecImageAttr,
 					IsOptional:        false,
 					ZeroValueProvider: builtin_argument.ZeroValueProvider[starlark.String],
 					Validator: func(value starlark.Value) *startosis_errors.InterpretationError {
-						return builtin_argument.NonEmptyString(value, RegistryImageAttr)
+						return builtin_argument.NonEmptyString(value, ImageSpecImageAttr)
 					},
 				},
 				{
-					Name:              RegistryAddrAttr,
-					IsOptional:        false,
+					Name:              ImageRegistryAttr,
+					IsOptional:        true,
 					ZeroValueProvider: builtin_argument.ZeroValueProvider[starlark.String],
 					Validator: func(value starlark.Value) *startosis_errors.InterpretationError {
-						return builtin_argument.NonEmptyString(value, RegistryAddrAttr)
+						return builtin_argument.NonEmptyString(value, ImageRegistryAttr)
 					},
 				},
 				{
-					Name:              RegistryUsernameAttr,
-					IsOptional:        false,
+					Name:              ImageRegistryUsernameAttr,
+					IsOptional:        true,
 					ZeroValueProvider: builtin_argument.ZeroValueProvider[starlark.String],
 					Validator: func(value starlark.Value) *startosis_errors.InterpretationError {
-						return builtin_argument.NonEmptyString(value, RegistryUsernameAttr)
+						return builtin_argument.NonEmptyString(value, ImageRegistryUsernameAttr)
 					},
 				},
 				{
-					Name:              RegistryPasswordAttr,
-					IsOptional:        false,
+					Name:              ImageRegistryPasswordAttr,
+					IsOptional:        true,
 					ZeroValueProvider: builtin_argument.ZeroValueProvider[starlark.String],
 					Validator: func(value starlark.Value) *startosis_errors.InterpretationError {
-						return builtin_argument.NonEmptyString(value, RegistryUsernameAttr)
+						return builtin_argument.NonEmptyString(value, ImageRegistryUsernameAttr)
 					},
 				},
 			},
@@ -62,103 +63,100 @@ func NewImageRegistrySpec() *kurtosis_type_constructor.KurtosisTypeConstructor {
 }
 
 func instantiateImageRegistrySpec(arguments *builtin_argument.ArgumentValuesSet) (builtin_argument.KurtosisValueType, *startosis_errors.InterpretationError) {
-	kurtosisValueType, err := kurtosis_type_constructor.CreateKurtosisStarlarkTypeDefault(ImageRegistrySpecTypeName, arguments)
+	kurtosisValueType, err := kurtosis_type_constructor.CreateKurtosisStarlarkTypeDefault(ImageSpecTypeName, arguments)
 	if err != nil {
 		return nil, err
 	}
-	return &ImageRegistrySpec{
+	return &ImageSpec{
 		KurtosisValueTypeDefault: kurtosisValueType,
 	}, nil
 }
 
-// ImageRegistrySpec is a starlark.Value that holds all the information to log in to a Docker registry
-type ImageRegistrySpec struct {
+// ImageSpec is a starlark.Value that holds all the information to log in to a Docker registry
+type ImageSpec struct {
 	*kurtosis_type_constructor.KurtosisValueTypeDefault
 }
 
-func (irs *ImageRegistrySpec) Copy() (builtin_argument.KurtosisValueType, error) {
+func (irs *ImageSpec) Copy() (builtin_argument.KurtosisValueType, error) {
 	copiedValueType, err := irs.KurtosisValueTypeDefault.Copy()
 	if err != nil {
 		return nil, err
 	}
-	return &ImageRegistrySpec{
+	return &ImageSpec{
 		KurtosisValueTypeDefault: copiedValueType,
 	}, nil
 }
 
 // GetImage returns the image that needs to be pulled
-func (irs *ImageRegistrySpec) GetImage() (string, *startosis_errors.InterpretationError) {
-	image, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, RegistryImageAttr)
+func (irs *ImageSpec) GetImage() (string, *startosis_errors.InterpretationError) {
+	image, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, ImageAttr)
 	if interpretationErr != nil {
 		return "", interpretationErr
 	}
 	if !found {
 		return "", startosis_errors.NewInterpretationError("Required attribute '%s' could not be found on type '%s'",
-			RegistryImageAttr, ImageRegistrySpecTypeName)
+			ImageAttr, ImageSpecTypeName)
 	}
 	imageStr := image.GoString()
 	return imageStr, nil
 }
 
-// GetPassword returns the password of the account for the registry
-func (irs *ImageRegistrySpec) GetPassword() (string, *startosis_errors.InterpretationError) {
-	password, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, RegistryPasswordAttr)
+// GetPasswordIfSet returns the password of the account for the registry
+func (irs *ImageSpec) GetPasswordIfSet() (string, *startosis_errors.InterpretationError) {
+	password, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, ImageRegistryPasswordAttr)
+	if !found {
+		return "", nil
+	}
 	if interpretationErr != nil {
 		return "", interpretationErr
 	}
-	if !found {
-		return "", startosis_errors.NewInterpretationError("Required attribute '%s' could not be found on type '%s'",
-			RegistryPasswordAttr, ImageRegistrySpecTypeName)
-	}
 	passwordStr := password.GoString()
 	return passwordStr, nil
 }
 
-// GetRegistryAddr returns the address of the registry from which the image has to be pulled
-func (irs *ImageRegistrySpec) GetRegistryAddr() (string, *startosis_errors.InterpretationError) {
-	registryAddr, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, RegistryAddrAttr)
+// GetRegistryAddrIfSet returns the address of the registry from which the image has to be pulled
+func (irs *ImageSpec) GetRegistryAddrIfSet() (string, *startosis_errors.InterpretationError) {
+	registryAddr, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, ImageRegistryAttr)
+	if !found {
+		return "", nil
+	}
 	if interpretationErr != nil {
 		return "", interpretationErr
 	}
-	if !found {
-		return "", startosis_errors.NewInterpretationError("Required attribute '%s' could not be found on type '%s'",
-			RegistryAddrAttr, ImageRegistrySpecTypeName)
-	}
 	registryAddrStr := registryAddr.GoString()
 	return registryAddrStr, nil
 }
 
-// GetUsername returns the address of the registry from which the image has to be pulled
-func (irs *ImageRegistrySpec) GetUsername() (string, *startosis_errors.InterpretationError) {
-	registryAddr, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, RegistryUsernameAttr)
+// GetUsernameIfSet returns the address of the registry from which the image has to be pulled
+func (irs *ImageSpec) GetUsernameIfSet() (string, *startosis_errors.InterpretationError) {
+	registryAddr, found, interpretationErr := kurtosis_type_constructor.ExtractAttrValue[starlark.String](irs.KurtosisValueTypeDefault, ImageRegistryUsernameAttr)
+	if !found {
+		return "", nil
+	}
 	if interpretationErr != nil {
 		return "", interpretationErr
 	}
-	if !found {
-		return "", startosis_errors.NewInterpretationError("Required attribute '%s' could not be found on type '%s'",
-			RegistryUsernameAttr, ImageRegistrySpecTypeName)
-	}
 	registryAddrStr := registryAddr.GoString()
 	return registryAddrStr, nil
 }
 
-func (irs *ImageRegistrySpec) ToKurtosisType() (*image_registry_spec.ImageRegistrySpec, *startosis_errors.InterpretationError) {
+func (irs *ImageSpec) ToKurtosisType() (*image_registry_spec.ImageRegistrySpec, *startosis_errors.InterpretationError) {
 	image, err := irs.GetImage()
 	if err != nil {
 		return nil, err
 	}
 
-	username, err := irs.GetUsername()
+	username, err := irs.GetUsernameIfSet()
 	if err != nil {
 		return nil, err
 	}
 
-	password, err := irs.GetPassword()
+	password, err := irs.GetPasswordIfSet()
 	if err != nil {
 		return nil, err
 	}
 
-	registryAddr, err := irs.GetRegistryAddr()
+	registryAddr, err := irs.GetRegistryAddrIfSet()
 	if err != nil {
 		return nil, err
 	}