webhook_validation.go

package graphql

import (
	"encoding/json"
	"net/url"
	"unsafe"

	validation "github.com/go-ozzo/ozzo-validation/v4"
	"github.com/go-ozzo/ozzo-validation/v4/is"
	"github.com/kyma-incubator/compass/components/director/internal/model"
	"github.com/kyma-incubator/compass/components/director/pkg/apperrors"
	"github.com/kyma-incubator/compass/components/director/pkg/webhook"
)

var emptyApplicationLifecycleWebhookRequestObject = &webhook.ApplicationLifecycleWebhookRequestObject{
	Application: &Application{
		BaseEntity: &BaseEntity{},
	},
}

var emptyFormationConfigurationChangeInput = &webhook.FormationConfigurationChangeInput{
	Assignment:        &webhook.FormationAssignment{},
	ReverseAssignment: &webhook.FormationAssignment{},
	Formation: &model.Formation{
		Error: json.RawMessage{},
	},
	ApplicationTemplate: &webhook.ApplicationTemplateWithLabels{
		ApplicationTemplate: &model.ApplicationTemplate{},
		Labels:              map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
		TrustDetails: &webhook.TrustDetails{
			Subjects: []string{},
		},
	},
	Application: &webhook.ApplicationWithLabels{
		Application: &model.Application{
			BaseEntity: &model.BaseEntity{},
		},
		Labels: map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
	},
	Runtime: &webhook.RuntimeWithLabels{
		Runtime: &model.Runtime{},
		Labels:  map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
		TrustDetails: &webhook.TrustDetails{
			Subjects: []string{},
		},
	},
	RuntimeContext: &webhook.RuntimeContextWithLabels{
		RuntimeContext: &model.RuntimeContext{},
		Labels:         map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
	},
	CustomerTenantContext: &webhook.CustomerTenantContext{},
}

var emptyApplicationTenantMappingInput = &webhook.ApplicationTenantMappingInput{
	Assignment:        &webhook.FormationAssignment{},
	ReverseAssignment: &webhook.FormationAssignment{},
	Formation: &model.Formation{
		Error: json.RawMessage{},
	},
	SourceApplicationTemplate: &webhook.ApplicationTemplateWithLabels{
		ApplicationTemplate: &model.ApplicationTemplate{},
		Labels:              map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
		TrustDetails: &webhook.TrustDetails{
			Subjects: []string{},
		},
	},
	SourceApplication: &webhook.ApplicationWithLabels{
		Application: &model.Application{
			BaseEntity: &model.BaseEntity{},
		},
		Labels: map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
	},
	TargetApplicationTemplate: &webhook.ApplicationTemplateWithLabels{
		ApplicationTemplate: &model.ApplicationTemplate{},
		Labels:              map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
		TrustDetails: &webhook.TrustDetails{
			Subjects: []string{},
		},
	},
	TargetApplication: &webhook.ApplicationWithLabels{
		Application: &model.Application{
			BaseEntity: &model.BaseEntity{},
		},
		Labels: map[string]string{},
		Tenant: &webhook.TenantWithLabels{
			BusinessTenantMapping: &model.BusinessTenantMapping{},
			Labels:                map[string]string{},
		},
	},
	CustomerTenantContext: &webhook.CustomerTenantContext{},
}

var emptyFormationLifecycleInput = &webhook.FormationLifecycleInput{
	Formation:             &model.Formation{},
	CustomerTenantContext: &webhook.CustomerTenantContext{},
}

var webhookTemplateInputByType = map[WebhookType]webhook.TemplateInput{
	WebhookTypeRegisterApplication:      emptyApplicationLifecycleWebhookRequestObject,
	WebhookTypeUnregisterApplication:    emptyApplicationLifecycleWebhookRequestObject,
	WebhookTypeConfigurationChanged:     emptyFormationConfigurationChangeInput,
	WebhookTypeApplicationTenantMapping: emptyApplicationTenantMappingInput,
	WebhookTypeFormationLifecycle:       emptyFormationLifecycleInput,
}

// Validate missing godoc
func (i WebhookInput) Validate() error {
	if err := validation.ValidateStruct(&i,
		validation.Field(&i.Type, validation.Required, validation.In(WebhookTypeConfigurationChanged, WebhookTypeApplicationTenantMapping, WebhookTypeRegisterApplication, WebhookTypeUnregisterApplication, WebhookTypeOpenResourceDiscovery, WebhookTypeOpenResourceDiscoveryStatic, WebhookTypeFormationLifecycle, WebhookTypeSystemFieldDiscovery)),
		validation.Field(&i.URL, is.URL, validation.RuneLength(0, longStringLengthLimit)),
		validation.Field(&i.CorrelationIDKey, validation.RuneLength(0, longStringLengthLimit)),
		validation.Field(&i.Mode, validation.In(WebhookModeSync, WebhookModeAsync, WebhookModeAsyncCallback), validation.When(i.Type == WebhookTypeConfigurationChanged || i.Type == WebhookTypeApplicationTenantMapping || i.Type == WebhookTypeFormationLifecycle, validation.In(WebhookModeSync, WebhookModeAsyncCallback)).Else(validation.NotIn(WebhookModeAsyncCallback))),
		validation.Field(&i.RetryInterval, validation.Min(0)),
		validation.Field(&i.Timeout, validation.Min(0)),
		validation.Field(&i.Auth),
	); err != nil {
		return err
	}

	if i.URL == nil && i.URLTemplate == nil {
		return apperrors.NewInvalidDataError("missing webhook url")
	}

	if i.URL != nil && i.URLTemplate != nil {
		return apperrors.NewInvalidDataError("cannot provide both webhook url and url template")
	}

	if i.URL != nil {
		_, err := url.ParseRequestURI(*i.URL)
		if err != nil {
			return apperrors.NewInvalidDataError("failed to parse webhook url: %s", err)
		}
	}

	requestObject := webhookTemplateInputByType[i.Type]
	if i.URLTemplate != nil {
		if requestObject == nil {
			return apperrors.NewInvalidDataError("missing template input for type: %s", i.Type)
		}
		if _, err := requestObject.ParseURLTemplate(i.URLTemplate); err != nil {
			return apperrors.NewInvalidDataError("failed to parse webhook url template: %s", err)
		}
	}

	if i.InputTemplate != nil {
		if requestObject == nil {
			return apperrors.NewInvalidDataError("missing template input for type: %s", i.Type)
		}
		if _, err := requestObject.ParseInputTemplate(i.InputTemplate); err != nil {
			return apperrors.NewInvalidDataError("failed to parse webhook input template: %s", err)
		}
	}

	if i.HeaderTemplate != nil {
		if requestObject == nil {
			return apperrors.NewInvalidDataError("missing template input for type: %s", i.Type)
		}
		if _, err := requestObject.ParseHeadersTemplate(i.HeaderTemplate); err != nil {
			return apperrors.NewInvalidDataError("failed to parse webhook headers template: %s", err)
		}
	}

	if i.OutputTemplate == nil && isOutTemplateMandatory(i.Type) {
		return apperrors.NewInvalidDataError("outputTemplate is required for type: %v", i.Type)
	}

	var responseObject webhook.ResponseObject
	if i.OutputTemplate != nil {
		if _, err := responseObject.ParseOutputTemplate(i.OutputTemplate); err != nil {
			return apperrors.NewInvalidDataError("failed to parse webhook output template: %s", err)
		}
	}

	if i.Mode != nil && *i.Mode == WebhookModeAsync {
		if i.StatusTemplate != nil {
			if _, err := responseObject.ParseStatusTemplate(i.StatusTemplate); err != nil {
				return apperrors.NewInvalidDataError("failed to parse webhook status template: %s", err)
			}
		} else {
			return apperrors.NewInvalidDataError("missing webhook status template")
		}
	}

	return nil
}

// GetAddress returns the memory address of the Webhook in the form of an uninterpreted type(integer number)
// Currently, it's used in some formation constraints input templates, so we could propagate the memory address to the formation constraints operators and later on to modify/update it.
func (w *Webhook) GetAddress() uintptr {
	return uintptr(unsafe.Pointer(w))
}

func isOutTemplateMandatory(webhookType WebhookType) bool {
	switch webhookType {
	case WebhookTypeRegisterApplication,
		WebhookTypeUnregisterApplication:
		return true
	default:
		return false
	}
}