add httpcall provider to processing events

pkg/api/GetHosts.go

@@ -15,10 +15,10 @@ package api
 import (
 	"context"
 	"fmt"
+	"slices"
 
 	"github.com/maksim-paskal/kubernetes-manager/pkg/config"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/telemetry"
-	"github.com/maksim-paskal/kubernetes-manager/pkg/utils"
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -47,11 +47,11 @@ func (e *Environment) GetHosts(ctx context.Context) ([]string, []string, error)
 		for _, rule := range ingress.Spec.Rules {
 			host := fmt.Sprintf("%s://%s", *config.Get().IngressHostDefaultProtocol, rule.Host)
 			if ingress.Annotations != nil && ingress.Annotations[config.LabelType] == HostTypeInternal {
-				if !utils.StringInSlice(host, hostsInternal) {
+				if !slices.Contains(hostsInternal, host) {
 					hostsInternal = append(hostsInternal, host)
 				}
 			} else {
-				if !utils.StringInSlice(host, hostsDefaults) {
+				if !slices.Contains(hostsDefaults, host) {
 					hostsDefaults = append(hostsDefaults, host)
 				}
 			}

pkg/api/GetKubeconfig.go

@@ -33,7 +33,10 @@ type GetClusterKubeconfigResult struct {
 	Token       string
 }
 
-func (r *GetClusterKubeconfigResult) GetRawFileContent() ([]byte, error) {
+func (r *GetClusterKubeconfigResult) GetRawFileContent(ctx context.Context) ([]byte, error) {
+	ctx, span := telemetry.Start(ctx, "api.GetRawFileContent")
+	defer span.End()
+
 	kubeConfig := `apiVersion: v1
 clusters:
 - cluster:
@@ -53,7 +56,7 @@ users:
   user:
     token: "{{ .Token }}"`
 
-	result, err := utils.GetTemplatedResult(kubeConfig, r)
+	result, err := utils.GetTemplatedResult(ctx, kubeConfig, r)
 	if err != nil {
 		return nil, errors.Wrap(err, "error getting templated string")
 	}

pkg/api/GetRemoteServers.go

@@ -141,7 +141,7 @@ func GetRemoteServers(ctx context.Context) ([]*GetRemoteServerItem, error) {
 				Description: link.Description,
 			}
 
-			urlFormatted, err := utils.GetTemplatedResult(link.URL, item)
+			urlFormatted, err := utils.GetTemplatedResult(ctx, link.URL, item)
 			if err != nil {
 				log.WithError(err).Errorf("error parsing link %s", link.URL)
 				links[id].URL = link.URL

pkg/api/ScaleDownDelay.go

@@ -14,11 +14,15 @@ package api
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"github.com/maksim-paskal/kubernetes-manager/pkg/config"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/telemetry"
+	"github.com/maksim-paskal/kubernetes-manager/pkg/types"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/utils"
+	"github.com/maksim-paskal/kubernetes-manager/pkg/webhook"
+	log "github.com/sirupsen/logrus"
 )
 
 func (e *Environment) ScaleDownDelay(ctx context.Context, durationTime time.Duration) error {
@@ -37,5 +41,18 @@ func (e *Environment) ScaleDownDelay(ctx context.Context, durationTime time.Dura
 		return err
 	}
 
+	err = webhook.NewEvent(ctx, types.WebhookMessage{
+		Event:     types.EventPrestop,
+		Namespace: e.Namespace,
+		Cluster:   e.Cluster,
+		Reason:    fmt.Sprintf("Delayed for %s ...", durationTime.String()),
+		Properties: map[string]string{
+			"slackEmoji": ":calendar:",
+		},
+	})
+	if err != nil {
+		log.WithError(err).Error("error while sending webhook")
+	}
+
 	return nil
 }

pkg/api/environment.go

@@ -173,7 +173,7 @@ func (e *Environment) loadFromNamespace(ctx context.Context, namespace corev1.Na
 
 	// namespace description
 	if description, ok := e.NamespaceAnnotations[config.LabelDescription]; ok {
-		namespaceDescription, err := utils.GetTemplatedResult(description, e)
+		namespaceDescription, err := utils.GetTemplatedResult(ctx, description, e)
 		if err != nil {
 			return errors.Wrap(err, "can not parse description")
 		}

pkg/api/getGitlabProjects.go

@@ -14,13 +14,13 @@ package api
 
 import (
 	"context"
+	"slices"
 	"sort"
 	"strconv"
 
 	"github.com/maksim-paskal/kubernetes-manager/pkg/client"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/config"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/telemetry"
-	"github.com/maksim-paskal/kubernetes-manager/pkg/utils"
 	"github.com/pkg/errors"
 	"github.com/xanzy/go-gitlab"
 )
@@ -105,10 +105,10 @@ func GetGitlabProjects(ctx context.Context, profile string, namespace string) ([
 			SelectedBranch: projectProfile.GetProjectSelectedBranch(project.ID),
 		}
 
-		exclude := utils.StringInSlice(strconv.Itoa(item.ProjectID), exludeProjects)
+		exclude := slices.Contains(exludeProjects, strconv.Itoa(item.ProjectID))
 
 		// if project in includes it must be always shown
-		if utils.StringInSlice(strconv.Itoa(item.ProjectID), includeProjects) {
+		if slices.Contains(includeProjects, strconv.Itoa(item.ProjectID)) {
 			exclude = false
 		}
 

pkg/api/getServices.go

@@ -15,11 +15,11 @@ package api
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 
 	"github.com/maksim-paskal/kubernetes-manager/pkg/telemetry"
-	"github.com/maksim-paskal/kubernetes-manager/pkg/utils"
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -117,7 +117,7 @@ func getFilteredLabels(labels map[string]string) string {
 	result := make([]string, 0)
 
 	for key, value := range labels {
-		if utils.StringInSlice(key, allowedServiceLabels) {
+		if slices.Contains(allowedServiceLabels, key) {
 			result = append(result, fmt.Sprintf("%s=%s", key, value))
 		}
 	}

pkg/api/scaleALL.go

@@ -28,22 +28,41 @@ func (e *Environment) ScaleALL(ctx context.Context, replicas int32) error {
 	ctx, span := telemetry.Start(ctx, "api.ScaleALL")
 	defer span.End()
 
+	// if scaleDown do nothing if environment have not pods
+	if replicas == 0 {
+		podInfo, err := e.GetPodsInfo(ctx)
+		if err != nil {
+			return errors.Wrap(err, "error while getting pods info")
+		}
+
+		if podInfo.PodsTotal == 0 {
+			return nil
+		}
+	}
+
 	processWebhook := make(chan error)
 	processScale := make(chan error)
 
 	go func() {
 		eventType := types.EventStart
+		eventReason := "Starting ..."
+		eventEmoji := ":white_check_mark:"
+
 		if replicas == 0 {
 			eventType = types.EventStop
+			eventReason = "Stopping ..."
+			eventEmoji = ":no_entry:"
 		}
 
-		processWebhook <- webhook.NewEvent(
-			ctx,
-			types.WebhookMessage{
-				Event:     eventType,
-				Namespace: e.Namespace,
-				Cluster:   e.Cluster,
-			})
+		processWebhook <- webhook.NewEvent(ctx, types.WebhookMessage{
+			Event:     eventType,
+			Namespace: e.Namespace,
+			Cluster:   e.Cluster,
+			Reason:    eventReason,
+			Properties: map[string]string{
+				"slackEmoji": eventEmoji,
+			},
+		})
 	}()
 
 	go func() {

pkg/api/startNewEnvironment.go

@@ -15,6 +15,7 @@ package api
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 
@@ -32,11 +33,22 @@ import (
 type StartNewEnvironmentInput struct {
 	Profile  string
 	Services string
-	User     string
 	Cluster  string
 	Name     string
 }
 
+func (input *StartNewEnvironmentInput) GetUser(ctx context.Context) string {
+	ctx, span := telemetry.Start(ctx, "api.GetUser")
+	defer span.End()
+
+	security, ok := ctx.Value(types.ContextSecurityKey).(types.ContextSecurity)
+	if ok {
+		return security.Owner
+	}
+
+	return ""
+}
+
 func (input *StartNewEnvironmentInput) GetNamespace() (string, error) {
 	namespace, err := GetNamespaceByServices(input.GetProfile(), input.Services)
 	if err != nil {
@@ -55,7 +67,10 @@ func (input *StartNewEnvironmentInput) GetID() (string, error) {
 	return fmt.Sprintf("%s:%s", input.Cluster, namespace), nil
 }
 
-func (input *StartNewEnvironmentInput) Validation() error {
+func (input *StartNewEnvironmentInput) Validation(ctx context.Context) error {
+	ctx, span := telemetry.Start(ctx, "api.Validation")
+	defer span.End()
+
 	if len(input.Cluster) == 0 {
 		return errors.Wrap(errCreateNewBranchMissingInput, "cluster is required")
 	}
@@ -64,7 +79,7 @@ func (input *StartNewEnvironmentInput) Validation() error {
 		return errors.Wrap(errCreateNewBranchMissingInput, "services is required")
 	}
 
-	if len(input.User) == 0 {
+	if len(input.GetUser(ctx)) == 0 {
 		return errors.Wrap(errCreateNewBranchMissingInput, "user is required")
 	}
 
@@ -91,7 +106,7 @@ func (input *StartNewEnvironmentInput) Validation() error {
 	}
 
 	for _, required := range input.GetProfile().GetRequired() {
-		if !utils.StringInSlice(required, selectedProjectIDs) {
+		if !slices.Contains(selectedProjectIDs, required) {
 			return errors.Wrapf(errCreateNewBranchMissingInput, "required service is missing")
 		}
 	}
@@ -155,7 +170,7 @@ func processCreateNewBranch(ctx context.Context, input *StartNewEnvironmentInput
 	ctx, span := telemetry.Start(ctx, "api.processCreateNewBranch")
 	defer span.End()
 
-	if err := input.Validation(); err != nil {
+	if err := input.Validation(ctx); err != nil {
 		return nil, errors.Wrap(err, "error validating")
 	}
 
@@ -258,7 +273,7 @@ func NewEnvironment(ctx context.Context, input *StartNewEnvironmentInput) (*Envi
 
 	namespace.ObjectMeta.Labels[config.Namespace] = config.TrueValue
 
-	creatorLabel := fmt.Sprintf("%s-%s", config.LabelNamespaceCreator, input.User)
+	creatorLabel := fmt.Sprintf("%s-%s", config.LabelNamespaceCreator, input.GetUser(ctx))
 	namespace.ObjectMeta.Labels[creatorLabel] = config.TrueValue
 
 	_, err = clientset.CoreV1().Namespaces().Create(ctx, &namespace, metav1.CreateOptions{})

pkg/api/startNewEnvironment_test.go

@@ -13,12 +13,14 @@ limitations under the License.
 package api_test
 
 import (
+	"context"
 	"fmt"
 	"strings"
 	"testing"
 
 	"github.com/maksim-paskal/kubernetes-manager/pkg/api"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/config"
+	"github.com/maksim-paskal/kubernetes-manager/pkg/types"
 )
 
 func TestValidation(t *testing.T) {
@@ -33,19 +35,20 @@ func TestValidation(t *testing.T) {
 	valid = append(valid, api.StartNewEnvironmentInput{
 		Profile:  "test",
 		Services: "1:test;2:test2;3:test3",
-		User:     "test",
-		Cluster:  "test",
+
+		Cluster: "test",
 	})
 
 	valid = append(valid, api.StartNewEnvironmentInput{
 		Profile:  "test",
 		Services: "1:test",
-		User:     "test1",
 		Cluster:  "test2",
 	})
 
+	ctx := context.WithValue(context.Background(), types.ContextSecurityKey, types.ContextSecurity{Owner: "test"})
+
 	for _, input := range valid {
-		if err := input.Validation(); err != nil {
+		if err := input.Validation(ctx); err != nil {
 			t.Fatal(err)
 		}
 

pkg/batch/batch.go

@@ -19,7 +19,9 @@ import (
 	"github.com/maksim-paskal/kubernetes-manager/pkg/api"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/config"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/telemetry"
+	"github.com/maksim-paskal/kubernetes-manager/pkg/types"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/utils"
+	"github.com/maksim-paskal/kubernetes-manager/pkg/webhook"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 	"go.opentelemetry.io/otel/trace"
@@ -31,6 +33,10 @@ func Schedule(ctx context.Context) {
 	ctx, span := telemetry.Start(ctx, "batch.Schedule")
 	defer span.End()
 
+	ctx = context.WithValue(ctx, types.ContextSecurityKey, types.ContextSecurity{
+		Owner: "BatchOperations",
+	})
+
 	ticker := time.NewTicker(config.Get().GetBatchShedulePeriod())
 
 	for ctx.Err() == nil {
@@ -80,6 +86,22 @@ func scaleDownALL(ctx context.Context) error {
 				return errors.Wrap(err, "error reload environment")
 			}
 
+			if environment.NeedToScaleDown(time.Now(), 1) {
+				message := types.WebhookMessage{
+					Event:     types.EventPrestop,
+					Namespace: environment.Namespace,
+					Cluster:   environment.Cluster,
+					Reason:    "Will be scaled down soon...",
+					Properties: map[string]string{
+						"slackEmoji": ":warning:",
+					},
+				}
+
+				if err := webhook.NewEvent(ctx, message); err != nil {
+					log.WithError(err).Error()
+				}
+			}
+
 			if !environment.NeedToScaleDown(time.Now(), 0) {
 				return nil
 			}

pkg/config/config.go

@@ -19,10 +19,12 @@ import (
 	"fmt"
 	"os"
 	"regexp"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
+	"github.com/maksim-paskal/kubernetes-manager/pkg/types"
 	"github.com/maksim-paskal/kubernetes-manager/pkg/utils"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
@@ -157,7 +159,7 @@ func (p *ProjectProfile) GetInclude() []string {
 }
 
 func (p *ProjectProfile) IsProjectRequired(projectID int) bool {
-	return utils.StringInSlice(strconv.Itoa(projectID), p.GetRequired())
+	return slices.Contains(p.GetRequired(), strconv.Itoa(projectID))
 }
 
 func (p *ProjectProfile) GetProjectSelectedBranch(projectID int) string {
@@ -188,10 +190,10 @@ type NamespaceMeta struct {
 }
 
 type WebHook struct {
-	Provider  string
-	Config    interface{}
-	Cluster   string
-	Namespace string
+	Provider string
+	Config   interface{}
+	IDS      []string
+	Events   []types.Event
 }
 
 type Snapshot struct {