Merge pull request #2 from somatech1/feature/script_service

feature: support for new service type - script

Author: rsfreitas

apis/services/native/native.go

@@ -7,12 +7,12 @@ import (
 // ServiceAPI corresponds to the API that a native service must implement in
 // its main structure.
 type ServiceAPI interface {
-	// Run must put the service in execution. It can block and wait for some
+	// Start must put the service in execution. It can block and wait for some
 	// signal to finish, which should be done in the Stop call. If it needs
 	// a loop, i.e., execute forever, it must be done at the service level.
 	// One way to do it is to use ctx.Done() to check if the loop needs to
 	// finish.
-	Run(ctx context.Context) error
+	Start(ctx context.Context) error
 
 	// Stop should end the Run execution.
 	Stop(ctx context.Context) error

apis/services/script/script.go

@@ -0,0 +1,20 @@
+package script
+
+import (
+	"context"
+)
+
+// ServiceAPI corresponds to the API that a script service must implement in
+// its main structure.
+type ServiceAPI interface {
+	// Run must be the service function where things happen. It is executed
+	// only once and the service terminates.
+	//
+	// Services should avoid blocking this function since there are other
+	// type of services for this purpose.
+	Run(ctx context.Context) error
+
+	// Cleanup must clean or finish anything that was initialized or any resource
+	// that need to be released.
+	Cleanup(ctx context.Context) error
+}

components/definition/definition.go

@@ -2,7 +2,6 @@ package definition
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -18,7 +17,7 @@ import (
 // features it will have when executing.
 type Definitions struct {
 	Name     string                 `toml:"name" validate:"required"`
-	Types    []string               `toml:"types" validate:"required,dive,service_type"`
+	Types    []string               `toml:"types" validate:"required,single_script,no_duplicated_service,dive,service_type"`
 	Version  string                 `toml:"version" validate:"required,version"`
 	Language string                 `toml:"language" validate:"required,oneof=go rust"`
 	Product  string                 `toml:"product" validate:"required,oneof=SDS SWORD PIKE"`
@@ -110,11 +109,15 @@ func (d *Definitions) Validate() error {
 		return err
 	}
 
-	if err := validate.RegisterValidationCtx("collector_name", validateCollectorName); err != nil {
+	if err := validate.RegisterValidationCtx("service_type", validateServiceType); err != nil {
 		return err
 	}
 
-	if err := validate.RegisterValidationCtx("service_type", validateServiceType); err != nil {
+	if err := validate.RegisterValidationCtx("single_script", ensureScriptTypeIsUnique); err != nil {
+		return err
+	}
+
+	if err := validate.RegisterValidationCtx("no_duplicated_service", checkDuplicatedServices); err != nil {
 		return err
 	}
 
@@ -125,17 +128,6 @@ func (d *Definitions) Validate() error {
 		return err
 	}
 
-	types := make(map[string]bool)
-	for _, t := range d.Types {
-		_, ok := types[t]
-		if !ok {
-			types[t] = true
-		}
-		if ok {
-			return errors.New("cannot have duplicated service types")
-		}
-	}
-
 	for _, svc := range d.externalServices {
 		if err := svc.Validate(); err != nil {
 			return err

components/definition/definition_test.go

@@ -17,6 +17,31 @@ func TestDefinitionsValidation(t *testing.T) {
 		ErrorAssertion  func(err error, msgAndArgs ...interface{}) bool
 		CustomAssertion func(defs *Definitions)
 	}{
+		{
+			Title: "should succeed with script type alone",
+			TomlDefinitions: `
+name = "example"
+types = ["script"]
+version = "v1.0.0"
+language = "go"
+product = "SDS"
+`,
+			ErrorAssertion: a.NoError,
+		},
+		{
+			Title: "should not have script service type with other types",
+			TomlDefinitions: `
+name = "example"
+types = ["grpc", "http", "script"]
+version = "v1.0.0"
+language = "go"
+product = "SDS"
+`,
+			ErrorAssertion: a.Error,
+			Expected: []string{
+				"failed on the 'single_script' tag",
+			},
+		},
 		{
 			Title: "should not have duplicated service types",
 			TomlDefinitions: `
@@ -28,7 +53,7 @@ product = "SDS"
 `,
 			ErrorAssertion: a.Error,
 			Expected: []string{
-				"cannot have duplicated service types",
+				"failed on the 'no_duplicated_service' tag",
 			},
 		},
 		{
@@ -113,40 +138,6 @@ emitted_events = [ "VEHICLE_CREATED" ]
 			DefsAssertion:  a.NotNil,
 			ErrorAssertion: a.Error,
 		},
-		{
-			Title: "should fail with wrong tracing names",
-			TomlDefinitions: `
-name = "service_test"
-types = ["grpc"]
-version = "v0.1.0"
-language = "go"
-product = "SDS"
-
-[features.database]
-kind = "mongo"
-ttl = 0
-
-[[features.tracing.collectors]]
-name = "error01"
-kind = "counter"
-description = "just a simple error counter"
-
-[[features.tracing.collectors]]
-name = "error02 abc"
-kind = "counter"
-description = "another simple error counter"
-
-[[features.tracing.collectors]]
-name = "error02-abc-EFG"
-kind = "counter"
-description = "another simple error counter"
-`,
-			ErrorAssertion: a.Error,
-			Expected: []string{
-				"Key: 'Definitions.Features.Tracing.Collectors[1].Name' Error:Field validation for 'Name' failed on the 'collector_name' tag",
-				"Key: 'Definitions.Features.Tracing.Collectors[2].Name' Error:Field validation for 'Name' failed on the 'collector_name' tag",
-			},
-		},
 		{
 			Title: "succeed with service custom settings",
 			TomlDefinitions: `

components/definition/types.go

@@ -10,6 +10,7 @@ var (
 	ServiceType_gRPC   = CreateServiceType("grpc")
 	ServiceType_HTTP   = CreateServiceType("http")
 	ServiceType_Native = CreateServiceType("native")
+	ServiceType_Script = CreateServiceType("script")
 )
 
 const (
@@ -71,6 +72,7 @@ func SupportedServiceTypes() []string {
 		ServiceType_gRPC,
 		ServiceType_HTTP,
 		ServiceType_Native,
+		ServiceType_Script,
 	}
 
 	for _, t := range types {

components/definition/types_test.go

@@ -10,7 +10,7 @@ func TestSupportedServiceTypes(t *testing.T) {
 	t.Run("should have all supported services", func(t *testing.T) {
 		types := SupportedServiceTypes()
 		a := assert.New(t)
-		a.Equal(7, len(types))
+		a.Equal(4, len(types))
 	})
 }
 

components/definition/validators.go

@@ -3,9 +3,9 @@ package definition
 import (
 	"context"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
-	"unicode"
 
 	"github.com/go-playground/validator/v10"
 )
@@ -14,26 +14,6 @@ func validateVersion(_ context.Context, fl validator.FieldLevel) bool {
 	return ValidateVersion(fl.Field().String())
 }
 
-// validateCollectorName checks if a name corresponds to a valid tracing
-// collector name, i.e., low letters or digits in snake case format.
-func validateCollectorName(_ context.Context, fl validator.FieldLevel) bool {
-	if name := fl.Field().String(); name != "" {
-		for _, c := range name {
-			isChar := unicode.IsLetter(c) && unicode.IsLower(c)
-
-			if !isChar && !unicode.IsNumber(c) && c != '_' {
-				return false
-			}
-		}
-
-		return true
-	}
-
-	// We don't accept empty names.
-	return false
-
-}
-
 // ValidateVersion is a helper function to validate the version format used by
 // services.
 func ValidateVersion(input string) bool {
@@ -76,3 +56,34 @@ func validatePort(port string) bool {
 	_, err := strconv.ParseInt(port, 10, 32)
 	return err == nil
 }
+
+// ensureScriptTypeIsUnique validates if the 'script' service type is alone in
+// tht list.
+func ensureScriptTypeIsUnique(_ context.Context, fl validator.FieldLevel) bool {
+	if list, ok := fl.Field().Interface().([]string); ok {
+		index := slices.Index(list, ServiceType_Script.String())
+		if index != -1 && len(list) > 1 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// checkDuplicatedServices validates if the list contains duplicated elements.
+func checkDuplicatedServices(_ context.Context, fl validator.FieldLevel) bool {
+	if list, ok := fl.Field().Interface().([]string); ok {
+		types := make(map[string]bool)
+		for _, t := range list {
+			_, ok := types[t]
+			if !ok {
+				types[t] = true
+			}
+			if ok {
+				return false
+			}
+		}
+	}
+
+	return true
+}

components/options/script.go

@@ -0,0 +1,11 @@
+package options
+
+import (
+	"github.com/somatech1/mikros/components/definition"
+)
+
+type ScriptServiceOptions struct{}
+
+func (s *ScriptServiceOptions) Kind() definition.ServiceType {
+	return definition.ServiceType_Script
+}

internal/services/native/native.go

@@ -50,7 +50,7 @@ func (s *Server) Run(_ context.Context, srv interface{}) error {
 	s.svc = svc
 
 	// And put it to run.
-	return svc.Run(s.ctx)
+	return svc.Start(s.ctx)
 }
 
 func (s *Server) Stop(ctx context.Context) error {

internal/services/script/script.go

@@ -0,0 +1,59 @@
+package script
+
+import (
+	"context"
+	"errors"
+
+	loggerApi "github.com/somatech1/mikros/apis/logger"
+	"github.com/somatech1/mikros/apis/services/script"
+	"github.com/somatech1/mikros/components/definition"
+	"github.com/somatech1/mikros/components/logger"
+	"github.com/somatech1/mikros/components/plugin"
+)
+
+type Server struct {
+	svc    script.ServiceAPI
+	ctx    context.Context
+	cancel context.CancelFunc
+}
+
+func New() *Server {
+	return &Server{}
+}
+
+func (s *Server) Name() string {
+	return definition.ServiceType_Script.String()
+}
+
+func (s *Server) Initialize(ctx context.Context, _ *plugin.ServiceOptions) error {
+	cctx, cancel := context.WithCancel(ctx)
+
+	s.ctx = cctx
+	s.cancel = cancel
+
+	return nil
+}
+
+func (s *Server) Info() []loggerApi.Attribute {
+	return []loggerApi.Attribute{
+		logger.String("service.mode", definition.ServiceType_Native.String()),
+	}
+}
+
+func (s *Server) Run(_ context.Context, srv interface{}) error {
+	svc, ok := srv.(script.ServiceAPI)
+	if !ok {
+		return errors.New("server object does not implement the script.ServiceAPI interface")
+	}
+
+	// Holds a reference to the service, so we can stop it later.
+	s.svc = svc
+
+	// And put it to run.
+	return svc.Run(s.ctx)
+}
+
+func (s *Server) Stop(ctx context.Context) error {
+	s.cancel()
+	return s.svc.Cleanup(ctx)
+}