f3c80c4eef
Protobuf Refactoring for Multi-Module Cleanliness This commit includes the following: Moves all packages that were within proto/ to proto/private Rewrites imports to account for the packages being moved Adds in buf.work.yaml to enable buf workspaces Names the proto-public buf module so that we can override the Go package imports within proto/buf.yaml Bumps the buf version dependency to 1.14.0 (I was trying out the version to see if it would get around an issue - it didn't but it also doesn't break things and it seemed best to keep up with the toolchain changes) Why: In the future we will need to consume other protobuf dependencies such as the Google HTTP annotations for openapi generation or grpc-gateway usage. There were some recent changes to have our own ratelimiting annotations. The two combined were not working when I was trying to use them together (attempting to rebase another branch) Buf workspaces should be the solution to the problem Buf workspaces means that each module will have generated Go code that embeds proto file names relative to the proto dir and not the top level repo root. This resulted in proto file name conflicts in the Go global protobuf type registry. The solution to that was to add in a private/ directory into the path within the proto/ directory. That then required rewriting all the imports. Is this safe? AFAICT yes The gRPC wire protocol doesn't seem to care about the proto file names (although the Go grpc code does tack on the proto file name as Metadata in the ServiceDesc) Other than imports, there were no changes to any generated code as a result of this.
515 lines
16 KiB
Go
515 lines
16 KiB
Go
package pbconfigentry
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
|
|
"github.com/hashicorp/consul/acl"
|
|
"github.com/hashicorp/consul/agent/structs"
|
|
"github.com/hashicorp/consul/proto/private/pbcommon"
|
|
"github.com/hashicorp/consul/types"
|
|
)
|
|
|
|
// Function variables to support proto generation
|
|
// This allows for using functions in the local package without having to generate imports
|
|
var EnvoyExtensionsToStructs = pbcommon.EnvoyExtensionsToStructs
|
|
var EnvoyExtensionsFromStructs = pbcommon.EnvoyExtensionsFromStructs
|
|
|
|
func ConfigEntryToStructs(s *ConfigEntry) structs.ConfigEntry {
|
|
switch s.Kind {
|
|
case Kind_KindMeshConfig:
|
|
var target structs.MeshConfigEntry
|
|
MeshConfigToStructs(s.GetMeshConfig(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindServiceResolver:
|
|
var target structs.ServiceResolverConfigEntry
|
|
target.Name = s.Name
|
|
|
|
ServiceResolverToStructs(s.GetServiceResolver(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindIngressGateway:
|
|
var target structs.IngressGatewayConfigEntry
|
|
target.Name = s.Name
|
|
|
|
IngressGatewayToStructs(s.GetIngressGateway(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindServiceIntentions:
|
|
var target structs.ServiceIntentionsConfigEntry
|
|
target.Name = s.Name
|
|
|
|
ServiceIntentionsToStructs(s.GetServiceIntentions(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindAPIGateway:
|
|
var target structs.APIGatewayConfigEntry
|
|
target.Name = s.Name
|
|
|
|
APIGatewayToStructs(s.GetAPIGateway(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindBoundAPIGateway:
|
|
var target structs.BoundAPIGatewayConfigEntry
|
|
target.Name = s.Name
|
|
|
|
BoundAPIGatewayToStructs(s.GetBoundAPIGateway(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindTCPRoute:
|
|
var target structs.TCPRouteConfigEntry
|
|
target.Name = s.Name
|
|
|
|
TCPRouteToStructs(s.GetTCPRoute(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindHTTPRoute:
|
|
var target structs.HTTPRouteConfigEntry
|
|
target.Name = s.Name
|
|
|
|
HTTPRouteToStructs(s.GetHTTPRoute(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindInlineCertificate:
|
|
var target structs.InlineCertificateConfigEntry
|
|
target.Name = s.Name
|
|
|
|
InlineCertificateToStructs(s.GetInlineCertificate(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
case Kind_KindServiceDefaults:
|
|
var target structs.ServiceConfigEntry
|
|
target.Name = s.Name
|
|
|
|
ServiceDefaultsToStructs(s.GetServiceDefaults(), &target)
|
|
pbcommon.RaftIndexToStructs(s.RaftIndex, &target.RaftIndex)
|
|
pbcommon.EnterpriseMetaToStructs(s.EnterpriseMeta, &target.EnterpriseMeta)
|
|
return &target
|
|
default:
|
|
panic(fmt.Sprintf("unable to convert ConfigEntry of kind %s to structs", s.Kind))
|
|
}
|
|
}
|
|
|
|
func ConfigEntryFromStructs(s structs.ConfigEntry) *ConfigEntry {
|
|
configEntry := &ConfigEntry{
|
|
Name: s.GetName(),
|
|
EnterpriseMeta: pbcommon.NewEnterpriseMetaFromStructs(*s.GetEnterpriseMeta()),
|
|
}
|
|
|
|
var raftIndex pbcommon.RaftIndex
|
|
pbcommon.RaftIndexFromStructs(s.GetRaftIndex(), &raftIndex)
|
|
configEntry.RaftIndex = &raftIndex
|
|
|
|
switch v := s.(type) {
|
|
case *structs.MeshConfigEntry:
|
|
var meshConfig MeshConfig
|
|
MeshConfigFromStructs(v, &meshConfig)
|
|
|
|
configEntry.Kind = Kind_KindMeshConfig
|
|
configEntry.Entry = &ConfigEntry_MeshConfig{
|
|
MeshConfig: &meshConfig,
|
|
}
|
|
case *structs.ServiceResolverConfigEntry:
|
|
var serviceResolver ServiceResolver
|
|
ServiceResolverFromStructs(v, &serviceResolver)
|
|
|
|
configEntry.Kind = Kind_KindServiceResolver
|
|
configEntry.Entry = &ConfigEntry_ServiceResolver{
|
|
ServiceResolver: &serviceResolver,
|
|
}
|
|
case *structs.IngressGatewayConfigEntry:
|
|
var ingressGateway IngressGateway
|
|
IngressGatewayFromStructs(v, &ingressGateway)
|
|
|
|
configEntry.Kind = Kind_KindIngressGateway
|
|
configEntry.Entry = &ConfigEntry_IngressGateway{
|
|
IngressGateway: &ingressGateway,
|
|
}
|
|
case *structs.ServiceIntentionsConfigEntry:
|
|
var serviceIntentions ServiceIntentions
|
|
ServiceIntentionsFromStructs(v, &serviceIntentions)
|
|
|
|
configEntry.Kind = Kind_KindServiceIntentions
|
|
configEntry.Entry = &ConfigEntry_ServiceIntentions{
|
|
ServiceIntentions: &serviceIntentions,
|
|
}
|
|
case *structs.ServiceConfigEntry:
|
|
var serviceDefaults ServiceDefaults
|
|
ServiceDefaultsFromStructs(v, &serviceDefaults)
|
|
|
|
configEntry.Kind = Kind_KindServiceDefaults
|
|
configEntry.Entry = &ConfigEntry_ServiceDefaults{
|
|
ServiceDefaults: &serviceDefaults,
|
|
}
|
|
case *structs.APIGatewayConfigEntry:
|
|
var apiGateway APIGateway
|
|
APIGatewayFromStructs(v, &apiGateway)
|
|
|
|
configEntry.Kind = Kind_KindAPIGateway
|
|
configEntry.Entry = &ConfigEntry_APIGateway{
|
|
APIGateway: &apiGateway,
|
|
}
|
|
case *structs.BoundAPIGatewayConfigEntry:
|
|
var apiGateway BoundAPIGateway
|
|
BoundAPIGatewayFromStructs(v, &apiGateway)
|
|
|
|
configEntry.Kind = Kind_KindBoundAPIGateway
|
|
configEntry.Entry = &ConfigEntry_BoundAPIGateway{
|
|
BoundAPIGateway: &apiGateway,
|
|
}
|
|
case *structs.TCPRouteConfigEntry:
|
|
var route TCPRoute
|
|
TCPRouteFromStructs(v, &route)
|
|
|
|
configEntry.Kind = Kind_KindTCPRoute
|
|
configEntry.Entry = &ConfigEntry_TCPRoute{
|
|
TCPRoute: &route,
|
|
}
|
|
case *structs.HTTPRouteConfigEntry:
|
|
var route HTTPRoute
|
|
HTTPRouteFromStructs(v, &route)
|
|
|
|
configEntry.Kind = Kind_KindHTTPRoute
|
|
configEntry.Entry = &ConfigEntry_HTTPRoute{
|
|
HTTPRoute: &route,
|
|
}
|
|
case *structs.InlineCertificateConfigEntry:
|
|
var cert InlineCertificate
|
|
InlineCertificateFromStructs(v, &cert)
|
|
|
|
configEntry.Kind = Kind_KindInlineCertificate
|
|
configEntry.Entry = &ConfigEntry_InlineCertificate{
|
|
InlineCertificate: &cert,
|
|
}
|
|
default:
|
|
panic(fmt.Sprintf("unable to convert %T to proto", s))
|
|
}
|
|
|
|
return configEntry
|
|
}
|
|
|
|
func tlsVersionToStructs(s string) types.TLSVersion {
|
|
return types.TLSVersion(s)
|
|
}
|
|
|
|
func tlsVersionFromStructs(t types.TLSVersion) string {
|
|
return t.String()
|
|
}
|
|
|
|
func cipherSuitesToStructs(cs []string) []types.TLSCipherSuite {
|
|
cipherSuites := make([]types.TLSCipherSuite, len(cs))
|
|
for idx, suite := range cs {
|
|
cipherSuites[idx] = types.TLSCipherSuite(suite)
|
|
}
|
|
return cipherSuites
|
|
}
|
|
|
|
func cipherSuitesFromStructs(cs []types.TLSCipherSuite) []string {
|
|
cipherSuites := make([]string, len(cs))
|
|
for idx, suite := range cs {
|
|
cipherSuites[idx] = suite.String()
|
|
}
|
|
return cipherSuites
|
|
}
|
|
|
|
func enterpriseMetaToStructs(m *pbcommon.EnterpriseMeta) acl.EnterpriseMeta {
|
|
var entMeta acl.EnterpriseMeta
|
|
pbcommon.EnterpriseMetaToStructs(m, &entMeta)
|
|
return entMeta
|
|
}
|
|
|
|
func enterpriseMetaFromStructs(m acl.EnterpriseMeta) *pbcommon.EnterpriseMeta {
|
|
return pbcommon.NewEnterpriseMetaFromStructs(m)
|
|
}
|
|
|
|
func timeFromStructs(t *time.Time) *timestamppb.Timestamp {
|
|
if t == nil {
|
|
return nil
|
|
}
|
|
return timestamppb.New(*t)
|
|
}
|
|
|
|
func timeToStructs(ts *timestamppb.Timestamp) *time.Time {
|
|
if ts == nil {
|
|
return nil
|
|
}
|
|
t := ts.AsTime()
|
|
return &t
|
|
}
|
|
|
|
func intentionActionFromStructs(a structs.IntentionAction) IntentionAction {
|
|
if a == structs.IntentionActionAllow {
|
|
return IntentionAction_Allow
|
|
}
|
|
return IntentionAction_Deny
|
|
}
|
|
|
|
func intentionActionToStructs(a IntentionAction) structs.IntentionAction {
|
|
if a == IntentionAction_Allow {
|
|
return structs.IntentionActionAllow
|
|
}
|
|
return structs.IntentionActionDeny
|
|
}
|
|
|
|
func intentionSourceTypeFromStructs(_ structs.IntentionSourceType) IntentionSourceType {
|
|
return IntentionSourceType_Consul
|
|
}
|
|
|
|
func intentionSourceTypeToStructs(_ IntentionSourceType) structs.IntentionSourceType {
|
|
return structs.IntentionSourceConsul
|
|
}
|
|
|
|
func pointerToIntFromInt32(i32 int32) *int {
|
|
i := int(i32)
|
|
return &i
|
|
}
|
|
|
|
func int32FromPointerToInt(i *int) int32 {
|
|
if i != nil {
|
|
return int32(*i)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func pointerToUint32FromUint32(ui32 uint32) *uint32 {
|
|
i := ui32
|
|
return &i
|
|
}
|
|
|
|
func uint32FromPointerToUint32(i *uint32) uint32 {
|
|
if i != nil {
|
|
return *i
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func proxyModeFromStructs(a structs.ProxyMode) ProxyMode {
|
|
switch a {
|
|
case structs.ProxyModeDefault:
|
|
return ProxyMode_ProxyModeDefault
|
|
case structs.ProxyModeTransparent:
|
|
return ProxyMode_ProxyModeTransparent
|
|
case structs.ProxyModeDirect:
|
|
return ProxyMode_ProxyModeDirect
|
|
default:
|
|
return ProxyMode_ProxyModeDefault
|
|
}
|
|
}
|
|
|
|
func proxyModeToStructs(a ProxyMode) structs.ProxyMode {
|
|
switch a {
|
|
case ProxyMode_ProxyModeDefault:
|
|
return structs.ProxyModeDefault
|
|
case ProxyMode_ProxyModeTransparent:
|
|
return structs.ProxyModeTransparent
|
|
case ProxyMode_ProxyModeDirect:
|
|
return structs.ProxyModeDirect
|
|
default:
|
|
return structs.ProxyModeDefault
|
|
}
|
|
}
|
|
|
|
func meshGatewayModeFromStructs(a structs.MeshGatewayMode) MeshGatewayMode {
|
|
switch a {
|
|
case structs.MeshGatewayModeDefault:
|
|
return MeshGatewayMode_MeshGatewayModeDefault
|
|
case structs.MeshGatewayModeNone:
|
|
return MeshGatewayMode_MeshGatewayModeNone
|
|
case structs.MeshGatewayModeLocal:
|
|
return MeshGatewayMode_MeshGatewayModeLocal
|
|
case structs.MeshGatewayModeRemote:
|
|
return MeshGatewayMode_MeshGatewayModeRemote
|
|
default:
|
|
return MeshGatewayMode_MeshGatewayModeDefault
|
|
}
|
|
}
|
|
|
|
func meshGatewayModeToStructs(a MeshGatewayMode) structs.MeshGatewayMode {
|
|
switch a {
|
|
case MeshGatewayMode_MeshGatewayModeDefault:
|
|
return structs.MeshGatewayModeDefault
|
|
case MeshGatewayMode_MeshGatewayModeNone:
|
|
return structs.MeshGatewayModeNone
|
|
case MeshGatewayMode_MeshGatewayModeLocal:
|
|
return structs.MeshGatewayModeLocal
|
|
case MeshGatewayMode_MeshGatewayModeRemote:
|
|
return structs.MeshGatewayModeRemote
|
|
default:
|
|
return structs.MeshGatewayModeDefault
|
|
}
|
|
}
|
|
|
|
func apiGatewayProtocolFromStructs(a structs.APIGatewayListenerProtocol) APIGatewayListenerProtocol {
|
|
switch a {
|
|
case structs.ListenerProtocolHTTP:
|
|
return APIGatewayListenerProtocol_ListenerProtocolHTTP
|
|
case structs.ListenerProtocolTCP:
|
|
return APIGatewayListenerProtocol_ListenerProtocolTCP
|
|
default:
|
|
return APIGatewayListenerProtocol_ListenerProtocolHTTP
|
|
}
|
|
}
|
|
|
|
func apiGatewayProtocolToStructs(a APIGatewayListenerProtocol) structs.APIGatewayListenerProtocol {
|
|
switch a {
|
|
case APIGatewayListenerProtocol_ListenerProtocolHTTP:
|
|
return structs.ListenerProtocolHTTP
|
|
case APIGatewayListenerProtocol_ListenerProtocolTCP:
|
|
return structs.ListenerProtocolTCP
|
|
default:
|
|
return structs.ListenerProtocolHTTP
|
|
}
|
|
}
|
|
|
|
func httpMatchMethodFromStructs(a structs.HTTPMatchMethod) HTTPMatchMethod {
|
|
switch a {
|
|
case structs.HTTPMatchMethodAll:
|
|
return HTTPMatchMethod_HTTPMatchMethodAll
|
|
case structs.HTTPMatchMethodConnect:
|
|
return HTTPMatchMethod_HTTPMatchMethodConnect
|
|
case structs.HTTPMatchMethodDelete:
|
|
return HTTPMatchMethod_HTTPMatchMethodDelete
|
|
case structs.HTTPMatchMethodGet:
|
|
return HTTPMatchMethod_HTTPMatchMethodGet
|
|
case structs.HTTPMatchMethodHead:
|
|
return HTTPMatchMethod_HTTPMatchMethodHead
|
|
case structs.HTTPMatchMethodOptions:
|
|
return HTTPMatchMethod_HTTPMatchMethodOptions
|
|
case structs.HTTPMatchMethodPatch:
|
|
return HTTPMatchMethod_HTTPMatchMethodPatch
|
|
case structs.HTTPMatchMethodPost:
|
|
return HTTPMatchMethod_HTTPMatchMethodPost
|
|
case structs.HTTPMatchMethodPut:
|
|
return HTTPMatchMethod_HTTPMatchMethodPut
|
|
case structs.HTTPMatchMethodTrace:
|
|
return HTTPMatchMethod_HTTPMatchMethodTrace
|
|
default:
|
|
return HTTPMatchMethod_HTTPMatchMethodAll
|
|
}
|
|
}
|
|
|
|
func httpMatchMethodToStructs(a HTTPMatchMethod) structs.HTTPMatchMethod {
|
|
switch a {
|
|
case HTTPMatchMethod_HTTPMatchMethodAll:
|
|
return structs.HTTPMatchMethodAll
|
|
case HTTPMatchMethod_HTTPMatchMethodConnect:
|
|
return structs.HTTPMatchMethodConnect
|
|
case HTTPMatchMethod_HTTPMatchMethodDelete:
|
|
return structs.HTTPMatchMethodDelete
|
|
case HTTPMatchMethod_HTTPMatchMethodGet:
|
|
return structs.HTTPMatchMethodGet
|
|
case HTTPMatchMethod_HTTPMatchMethodHead:
|
|
return structs.HTTPMatchMethodHead
|
|
case HTTPMatchMethod_HTTPMatchMethodOptions:
|
|
return structs.HTTPMatchMethodOptions
|
|
case HTTPMatchMethod_HTTPMatchMethodPatch:
|
|
return structs.HTTPMatchMethodPatch
|
|
case HTTPMatchMethod_HTTPMatchMethodPost:
|
|
return structs.HTTPMatchMethodPost
|
|
case HTTPMatchMethod_HTTPMatchMethodPut:
|
|
return structs.HTTPMatchMethodPut
|
|
case HTTPMatchMethod_HTTPMatchMethodTrace:
|
|
return structs.HTTPMatchMethodTrace
|
|
default:
|
|
return structs.HTTPMatchMethodAll
|
|
}
|
|
}
|
|
|
|
func httpHeaderMatchFromStructs(a structs.HTTPHeaderMatchType) HTTPHeaderMatchType {
|
|
switch a {
|
|
case structs.HTTPHeaderMatchExact:
|
|
return HTTPHeaderMatchType_HTTPHeaderMatchExact
|
|
case structs.HTTPHeaderMatchPrefix:
|
|
return HTTPHeaderMatchType_HTTPHeaderMatchPrefix
|
|
case structs.HTTPHeaderMatchPresent:
|
|
return HTTPHeaderMatchType_HTTPHeaderMatchPresent
|
|
case structs.HTTPHeaderMatchRegularExpression:
|
|
return HTTPHeaderMatchType_HTTPHeaderMatchRegularExpression
|
|
case structs.HTTPHeaderMatchSuffix:
|
|
return HTTPHeaderMatchType_HTTPHeaderMatchSuffix
|
|
default:
|
|
return HTTPHeaderMatchType_HTTPHeaderMatchExact
|
|
}
|
|
}
|
|
|
|
func httpHeaderMatchToStructs(a HTTPHeaderMatchType) structs.HTTPHeaderMatchType {
|
|
switch a {
|
|
case HTTPHeaderMatchType_HTTPHeaderMatchExact:
|
|
return structs.HTTPHeaderMatchExact
|
|
case HTTPHeaderMatchType_HTTPHeaderMatchPrefix:
|
|
return structs.HTTPHeaderMatchPrefix
|
|
case HTTPHeaderMatchType_HTTPHeaderMatchPresent:
|
|
return structs.HTTPHeaderMatchPresent
|
|
case HTTPHeaderMatchType_HTTPHeaderMatchRegularExpression:
|
|
return structs.HTTPHeaderMatchRegularExpression
|
|
case HTTPHeaderMatchType_HTTPHeaderMatchSuffix:
|
|
return structs.HTTPHeaderMatchSuffix
|
|
default:
|
|
return structs.HTTPHeaderMatchExact
|
|
}
|
|
}
|
|
|
|
func httpPathMatchFromStructs(a structs.HTTPPathMatchType) HTTPPathMatchType {
|
|
switch a {
|
|
case structs.HTTPPathMatchExact:
|
|
return HTTPPathMatchType_HTTPPathMatchExact
|
|
case structs.HTTPPathMatchPrefix:
|
|
return HTTPPathMatchType_HTTPPathMatchPrefix
|
|
case structs.HTTPPathMatchRegularExpression:
|
|
return HTTPPathMatchType_HTTPPathMatchRegularExpression
|
|
default:
|
|
return HTTPPathMatchType_HTTPPathMatchExact
|
|
}
|
|
}
|
|
|
|
func httpPathMatchToStructs(a HTTPPathMatchType) structs.HTTPPathMatchType {
|
|
switch a {
|
|
case HTTPPathMatchType_HTTPPathMatchExact:
|
|
return structs.HTTPPathMatchExact
|
|
case HTTPPathMatchType_HTTPPathMatchPrefix:
|
|
return structs.HTTPPathMatchPrefix
|
|
case HTTPPathMatchType_HTTPPathMatchRegularExpression:
|
|
return structs.HTTPPathMatchRegularExpression
|
|
default:
|
|
return structs.HTTPPathMatchExact
|
|
}
|
|
}
|
|
|
|
func httpQueryMatchFromStructs(a structs.HTTPQueryMatchType) HTTPQueryMatchType {
|
|
switch a {
|
|
case structs.HTTPQueryMatchExact:
|
|
return HTTPQueryMatchType_HTTPQueryMatchExact
|
|
case structs.HTTPQueryMatchPresent:
|
|
return HTTPQueryMatchType_HTTPQueryMatchPresent
|
|
case structs.HTTPQueryMatchRegularExpression:
|
|
return HTTPQueryMatchType_HTTPQueryMatchRegularExpression
|
|
default:
|
|
return HTTPQueryMatchType_HTTPQueryMatchExact
|
|
}
|
|
}
|
|
|
|
func httpQueryMatchToStructs(a HTTPQueryMatchType) structs.HTTPQueryMatchType {
|
|
switch a {
|
|
case HTTPQueryMatchType_HTTPQueryMatchExact:
|
|
return structs.HTTPQueryMatchExact
|
|
case HTTPQueryMatchType_HTTPQueryMatchPresent:
|
|
return structs.HTTPQueryMatchPresent
|
|
case HTTPQueryMatchType_HTTPQueryMatchRegularExpression:
|
|
return structs.HTTPQueryMatchRegularExpression
|
|
default:
|
|
return structs.HTTPQueryMatchExact
|
|
}
|
|
}
|