[azservicebus] Add support for DefaultRule when creating a Subscription (Azure#20888)

Add `DefaultRule` field to `SubscriptionProperties`, allowing for a rule to take immediate effect when the subscription is created.

Contributed by @StrawbrryFlurry

Author: StrawbrryFlurry

sdk/messaging/azservicebus/CHANGELOG.md

@@ -1,10 +1,11 @@
 # Release History
 
-## 1.3.1 (2023-06-06)
+## 1.4.0 (2023-06-06)
 
 ### Features Added
 
-- TBD, pending customer PR.
+- `admin.SubscriptionProperties` now allow for a `DefaultRule` to be set. This allows Subscriptions to be created with an immediate filter/action. 
+  Contributed by @StrawbrryFlurry. (PR#20888)
 
 ## 1.3.0 (2023-05-09)
 

sdk/messaging/azservicebus/admin/admin_client_rules.go

@@ -208,7 +208,7 @@ func (ac *Client) GetRule(ctx context.Context, topicName string, subscriptionNam
 		return mapATOMError[GetRuleResponse](err)
 	}
 
-	props, err := ac.newRuleProperties(ruleEnv)
+	props, err := ac.newRulePropertiesFromEnvelope(ruleEnv)
 
 	if err != nil {
 		return nil, err
@@ -240,7 +240,7 @@ func (ac *Client) NewListRulesPager(topicName string, subscriptionName string, o
 	}
 
 	ep := &entityPager[atom.RuleFeed, atom.RuleEnvelope, RuleProperties]{
-		convertFn:    ac.newRuleProperties,
+		convertFn:    ac.newRulePropertiesFromEnvelope,
 		baseFragment: fmt.Sprintf("/%s/Subscriptions/%s/Rules/", topicName, subscriptionName),
 		maxPageSize:  pageSize,
 		em:           ac.em,
@@ -304,107 +304,25 @@ func (ac *Client) DeleteRule(ctx context.Context, topicName string, subscription
 }
 
 func (ac *Client) createOrUpdateRule(ctx context.Context, topicName string, subscriptionName string, putProps RuleProperties, creating bool) (*RuleProperties, *http.Response, error) {
-	ruleDesc := atom.RuleDescription{}
-
-	theirFilter := putProps.Filter
-
-	if theirFilter != nil {
-		switch actualFilter := theirFilter.(type) {
-		case *FalseFilter:
-			ruleDesc.Filter = &atom.FilterDescription{
-				Type:          "FalseFilter",
-				SQLExpression: to.Ptr("1=0"),
-			}
-		case *TrueFilter:
-			ruleDesc.Filter = &atom.FilterDescription{
-				Type:          "TrueFilter",
-				SQLExpression: to.Ptr("1=1"),
-			}
-		case *SQLFilter:
-			params, err := publicSQLParametersToInternal(actualFilter.Parameters)
-
-			if err != nil {
-				return nil, nil, err
-			}
-
-			ruleDesc.Filter = &atom.FilterDescription{
-				Type:          "SqlFilter",
-				SQLExpression: &actualFilter.Expression,
-				Parameters:    params,
-			}
-		case *CorrelationFilter:
-			appProps, err := publicSQLParametersToInternal(actualFilter.ApplicationProperties)
-
-			if err != nil {
-				return nil, nil, err
-			}
-
-			ruleDesc.Filter = &atom.FilterDescription{
-				Type: "CorrelationFilter",
-				CorrelationFilter: atom.CorrelationFilter{
-					ContentType:      actualFilter.ContentType,
-					CorrelationID:    actualFilter.CorrelationID,
-					MessageID:        actualFilter.MessageID,
-					ReplyTo:          actualFilter.ReplyTo,
-					ReplyToSessionID: actualFilter.ReplyToSessionID,
-					SessionID:        actualFilter.SessionID,
-					Label:            actualFilter.Subject,
-					To:               actualFilter.To,
-					Properties:       appProps,
-				},
-			}
-		case *UnknownRuleFilter:
-			fd, err := convertUnknownRuleFilterToFilterDescription(actualFilter)
-
-			if err != nil {
-				return nil, nil, err
-			}
-
-			ruleDesc.Filter = fd
-		default:
-			return nil, nil, fmt.Errorf("invalid type ('%T') for Rule.Filter", theirFilter)
-		}
-	} else {
-		ruleDesc.Filter = &atom.FilterDescription{
-			Type:          "TrueFilter",
-			SQLExpression: to.Ptr("1=1"),
-		}
+	ruleDesc := atom.RuleDescription{
+		Name: makeRuleNameForProperties(&putProps),
 	}
 
-	theirAction := putProps.Action
-
-	if theirAction != nil {
-		switch actualAction := theirAction.(type) {
-		case *SQLAction:
-			params, err := publicSQLParametersToInternal(actualAction.Parameters)
+	filter, err := convertRuleFilterToFilterDescription(&putProps.Filter)
 
-			if err != nil {
-				return nil, nil, err
-			}
+	if err != nil {
+		return nil, nil, err
+	}
 
-			ruleDesc.Action = &atom.ActionDescription{
-				Type:          "SqlRuleAction",
-				SQLExpression: actualAction.Expression,
-				Parameters:    params,
-			}
-		case *UnknownRuleAction:
-			ad, err := convertUnknownRuleActionToActionDescription(actualAction)
+	ruleDesc.Filter = filter
 
-			if err != nil {
-				return nil, nil, err
-			}
+	action, err := convertRuleActionToActionDescription(&putProps.Action)
 
-			ruleDesc.Action = ad
-		default:
-			return nil, nil, fmt.Errorf("invalid type ('%T') for Rule.Action", theirAction)
-		}
+	if err != nil {
+		return nil, nil, err
 	}
 
-	ruleDesc.Name = "$Default"
-
-	if putProps.Name != "" {
-		ruleDesc.Name = putProps.Name
-	}
+	ruleDesc.Action = action
 
 	if !creating {
 		ctx = runtime.WithHTTPHeader(ctx, http.Header{
@@ -422,16 +340,120 @@ func (ac *Client) createOrUpdateRule(ctx context.Context, topicName string, subs
 		return nil, nil, err
 	}
 
-	respProps, err := ac.newRuleProperties(respEnv)
+	respProps, err := ac.newRulePropertiesFromEnvelope(respEnv)
 
 	return respProps, httpResp, err
 }
 
-func (ac *Client) newRuleProperties(env *atom.RuleEnvelope) (*RuleProperties, error) {
+func makeRuleNameForProperties(properties *RuleProperties) string {
+	if properties.Name != "" {
+		return properties.Name
+	}
+
+	return "$Default"
+}
+
+func convertRuleFilterToFilterDescription(filter *RuleFilter) (*atom.FilterDescription, error) {
+	if *filter == nil {
+		return &atom.FilterDescription{
+			Type:          "TrueFilter",
+			SQLExpression: to.Ptr("1=1"),
+		}, nil
+	}
+
+	switch actualFilter := (*filter).(type) {
+	case *FalseFilter:
+		return &atom.FilterDescription{
+			Type:          "FalseFilter",
+			SQLExpression: to.Ptr("1=0"),
+		}, nil
+	case *TrueFilter:
+		return &atom.FilterDescription{
+			Type:          "TrueFilter",
+			SQLExpression: to.Ptr("1=1"),
+		}, nil
+	case *SQLFilter:
+		params, err := publicSQLParametersToInternal(actualFilter.Parameters)
+
+		if err != nil {
+			return nil, err
+		}
+
+		return &atom.FilterDescription{
+			Type:          "SqlFilter",
+			SQLExpression: &actualFilter.Expression,
+			Parameters:    params,
+		}, nil
+	case *CorrelationFilter:
+		appProps, err := publicSQLParametersToInternal(actualFilter.ApplicationProperties)
+
+		if err != nil {
+			return nil, err
+		}
+
+		return &atom.FilterDescription{
+			Type: "CorrelationFilter",
+			CorrelationFilter: atom.CorrelationFilter{
+				ContentType:      actualFilter.ContentType,
+				CorrelationID:    actualFilter.CorrelationID,
+				MessageID:        actualFilter.MessageID,
+				ReplyTo:          actualFilter.ReplyTo,
+				ReplyToSessionID: actualFilter.ReplyToSessionID,
+				SessionID:        actualFilter.SessionID,
+				Label:            actualFilter.Subject,
+				To:               actualFilter.To,
+				Properties:       appProps,
+			},
+		}, nil
+	case *UnknownRuleFilter:
+		filterDefinition, err := convertUnknownRuleFilterToFilterDescription(actualFilter)
+
+		if err != nil {
+			return nil, err
+		}
+
+		return filterDefinition, nil
+	default:
+		return nil, fmt.Errorf("invalid type ('%T') for Rule.Filter", filter)
+	}
+}
+
+func convertRuleActionToActionDescription(action *RuleAction) (*atom.ActionDescription, error) {
+	if *action == nil {
+		return nil, nil
+	}
+
+	switch actualAction := (*action).(type) {
+	case *SQLAction:
+		params, err := publicSQLParametersToInternal(actualAction.Parameters)
+
+		if err != nil {
+			return nil, err
+		}
+
+		return &atom.ActionDescription{
+			Type:          "SqlRuleAction",
+			SQLExpression: actualAction.Expression,
+			Parameters:    params,
+		}, nil
+	case *UnknownRuleAction:
+		ad, err := convertUnknownRuleActionToActionDescription(actualAction)
+
+		if err != nil {
+			return nil, err
+		}
+
+		return ad, nil
+	default:
+		return nil, fmt.Errorf("invalid type ('%T') for Rule.Action", &action)
+	}
+}
+
+func (ac *Client) newRulePropertiesFromEnvelope(env *atom.RuleEnvelope) (*RuleProperties, error) {
 	desc := env.Content.RuleDescription
 
 	props := RuleProperties{
-		Name: env.Title,
+		Name: desc.Name,
 	}
 
 	switch desc.Filter.Type {

sdk/messaging/azservicebus/admin/admin_client_subscription.go

@@ -62,6 +62,9 @@ type SubscriptionProperties struct {
 
 	// UserMetadata is custom metadata that user can associate with the subscription.
 	UserMetadata *string
+
+	// DefaultRule is a rule that is added to the subscription as soon as it is created.
+	DefaultRule *RuleProperties
 }
 
 // SubscriptionRuntimeProperties represent dynamic properties of a subscription, such as the ActiveMessageCount.
@@ -338,7 +341,11 @@ func (ac *Client) createOrUpdateSubscriptionImpl(ctx context.Context, topicName
 		props = &SubscriptionProperties{}
 	}
 
-	env := newSubscriptionEnvelope(props, ac.em.TokenProvider())
+	env, err := newSubscriptionEnvelope(props, ac.em.TokenProvider())
+
+	if err != nil {
+		return nil, nil, err
+	}
 
 	if !creating {
 		ctx = runtime.WithHTTPHeader(ctx, http.Header{
@@ -367,7 +374,13 @@ func (ac *Client) createOrUpdateSubscriptionImpl(ctx context.Context, topicName
 	return &item.SubscriptionProperties, resp, nil
 }
 
-func newSubscriptionEnvelope(props *SubscriptionProperties, tokenProvider auth.TokenProvider) *atom.SubscriptionEnvelope {
+func newSubscriptionEnvelope(props *SubscriptionProperties, tokenProvider auth.TokenProvider) (*atom.SubscriptionEnvelope, error) {
+	defaultRuleDescription, err := newDefaultRuleDescription(props.DefaultRule)
+
+	if err != nil {
+		return nil, err
+	}
+
 	desc := &atom.SubscriptionDescription{
 		DefaultMessageTimeToLive:                  props.DefaultMessageTimeToLive,
 		LockDuration:                              props.LockDuration,
@@ -380,12 +393,39 @@ func newSubscriptionEnvelope(props *SubscriptionProperties, tokenProvider auth.T
 		UserMetadata:                              props.UserMetadata,
 		EnableBatchedOperations:                   props.EnableBatchedOperations,
 		AutoDeleteOnIdle:                          props.AutoDeleteOnIdle,
-		// TODO: when we get rule serialization in place.
-		// DefaultRuleDescription:                    props.DefaultRuleDescription,
-		// are these attributes just not valid anymore?
+		DefaultRuleDescription:                    defaultRuleDescription,
+	}
+
+	return atom.WrapWithSubscriptionEnvelope(desc), nil
+}
+
+func newDefaultRuleDescription(properties *RuleProperties) (*atom.DefaultRuleDescription, error) {
+	if properties == nil {
+		return nil, nil
 	}
 
-	return atom.WrapWithSubscriptionEnvelope(desc)
+	ruleDescription := atom.DefaultRuleDescription{
+		Name: makeRuleNameForProperties(properties),
+	}
+
+	filter, err := convertRuleFilterToFilterDescription(&properties.Filter)
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Filter can never be nil because it's default is TrueFilter
+	ruleDescription.Filter = filter
+
+	action, err := convertRuleActionToActionDescription(&properties.Action)
+
+	if err != nil {
+		return nil, err
+	}
+
+	ruleDescription.Action = action
+
+	return &ruleDescription, nil
 }
 
 func newSubscriptionItem(env *atom.SubscriptionEnvelope, topicName string) (*SubscriptionPropertiesItem, error) {