feat: introduce fallback-less v2 policies

internal/enginenetx/bridgespolicy.go

@@ -64,6 +64,26 @@ func (p *bridgesPolicy) LookupTactics(ctx context.Context, domain, port string)
 	)
 }
 
+// bridgesPolicyV2 is a policy where we use bridges for communicating
+// with the OONI backend, i.e., api.ooni.io.
+//
+// A bridge is an IP address that can route traffic from and to
+// the OONI backend and accepts any SNI.
+//
+// The zero value is invalid; please, init MANDATORY fields.
+//
+// This is v2 of the bridgesPolicy because the previous implementation
+// incorporated mixing logic, while now the mixing happens outside
+// of this policy, this giving us much more flexibility.
+type bridgesPolicyV2 struct{}
+
+var _ httpsDialerPolicy = &bridgesPolicyV2{}
+
+// LookupTactics implements httpsDialerPolicy.
+func (p *bridgesPolicyV2) LookupTactics(ctx context.Context, domain, port string) <-chan *httpsDialerTactic {
+	return bridgesTacticsForDomain(domain, port)
+}
+
 var bridgesPolicyTestHelpersDomains = []string{
 	"0.th.ooni.org",
 	"1.th.ooni.org",
@@ -72,6 +92,9 @@ var bridgesPolicyTestHelpersDomains = []string{
 	"d33d1gs9kpq1c5.cloudfront.net",
 }
 
+// TODO(bassosimone): the rewriting of test helper tactics should happen elsewhere
+// once we stop using the bridgesPolicy (i.e., version 1)
+
 func maybeRewriteTestHelpersTactics(input <-chan *httpsDialerTactic) <-chan *httpsDialerTactic {
 	out := make(chan *httpsDialerTactic)
 

internal/enginenetx/statspolicy.go

@@ -56,6 +56,28 @@ func (p *statsPolicy) LookupTactics(ctx context.Context, domain string, port str
 	)))
 }
 
+// statsPolicyV2 is a policy that schedules tactics already known
+// to work based on the previously collected stats.
+//
+// The zero value of this struct is invalid; please, make sure
+// you fill all the fields marked as MANDATORY.
+//
+// This is v2 of the statsPolicy because the previous implementation
+// incorporated mixing logic, while now the mixing happens outside
+// of this policy, this giving us much more flexibility.
+type statsPolicyV2 struct {
+	// Stats is the MANDATORY stats manager.
+	Stats *statsManager
+}
+
+var _ httpsDialerPolicy = &statsPolicyV2{}
+
+// LookupTactics implements httpsDialerPolicy.
+func (p *statsPolicyV2) LookupTactics(ctx context.Context, domain string, port string) <-chan *httpsDialerTactic {
+	// avoid emitting nil tactics and duplicate tactics
+	return streamTacticsFromSlice(statsPolicyFilterStatsTactics(p.Stats.LookupTactics(domain, port)))
+}
+
 func statsPolicyFilterStatsTactics(tactics []*statsTactic, good bool) (out []*httpsDialerTactic) {
 	// when good is false, it means p.Stats.LookupTactics failed
 	if !good {

internal/enginenetx/userpolicy.go

@@ -123,3 +123,81 @@ func userPolicyRemoveNilEntries(input []*httpsDialerTactic) (output []*httpsDial
 	}
 	return
 }
+
+// userPolicyV2 is an [httpsDialerPolicy] incorporating verbatim
+// a user policy loaded from the engine's key-value store.
+//
+// This policy is very useful for exploration and experimentation.
+//
+// This is v2 of the userPolicy because the previous implementation
+// incorporated mixing logic, while now the mixing happens outside
+// of this policy, this giving us much more flexibility.
+type userPolicyV2 struct {
+	// Root is the root of the user policy loaded from disk.
+	Root *userPolicyRoot
+}
+
+// newUserPolicyV2 attempts to constructs a user policy. The typical error case is the one
+// in which there's no httpsDialerUserPolicyKey in the key-value store.
+func newUserPolicyV2(kvStore model.KeyValueStore) (*userPolicyV2, error) {
+	// attempt to read the user policy bytes from the kvstore
+	data, err := kvStore.Get(userPolicyKey)
+	if err != nil {
+		return nil, err
+	}
+
+	// attempt to parse the user policy using human-readable JSON
+	var root userPolicyRoot
+	if err := hujsonx.Unmarshal(data, &root); err != nil {
+		return nil, err
+	}
+
+	// make sure the version is OK
+	if root.Version != userPolicyVersion {
+		err := fmt.Errorf(
+			"%s: %w: expected=%d got=%d",
+			userPolicyKey,
+			errUserPolicyWrongVersion,
+			userPolicyVersion,
+			root.Version,
+		)
+		return nil, err
+	}
+
+	out := &userPolicyV2{Root: &root}
+	return out, nil
+}
+
+var _ httpsDialerPolicy = &userPolicyV2{}
+
+// LookupTactics implements httpsDialerPolicy.
+func (ldp *userPolicyV2) LookupTactics(ctx context.Context, domain string, port string) <-chan *httpsDialerTactic {
+	// create the output channel
+	out := make(chan *httpsDialerTactic)
+
+	go func() {
+		// make sure we close the output channel
+		defer close(out)
+
+		// check whether an entry exists in the user-provided map, which MAY be nil
+		// if/when the user has chosen their policy to be as such
+		tactics, found := ldp.Root.DomainEndpoints[net.JoinHostPort(domain, port)]
+		if !found {
+			return
+		}
+
+		// note that we also need to fallback when the tactics contains an empty list
+		// or a list that only contains nil entries
+		tactics = userPolicyRemoveNilEntries(tactics)
+		if len(tactics) <= 0 {
+			return
+		}
+
+		// emit all the user-configured tactics
+		for _, tactic := range tactics {
+			out <- tactic
+		}
+	}()
+
+	return out
+}