github.com/Tyktechnologies/tyk@v2.9.5+incompatible/gateway/coprocess_helpers.go (about)

     1  package gateway
     2  
     3  import (
     4  	"encoding/json"
     5  	"sync"
     6  
     7  	"github.com/sirupsen/logrus"
     8  
     9  	"github.com/TykTechnologies/tyk/coprocess"
    10  	"github.com/TykTechnologies/tyk/user"
    11  )
    12  
    13  // TykSessionState takes a coprocess.SessionState (as returned by the Protocol Buffer binding), and outputs a standard Tyk SessionState.
    14  func TykSessionState(session *coprocess.SessionState) *user.SessionState {
    15  	accessDefinitions := make(map[string]user.AccessDefinition, len(session.AccessRights))
    16  
    17  	for key, protoAccDef := range session.AccessRights {
    18  		allowedUrls := make([]user.AccessSpec, len(protoAccDef.AllowedUrls))
    19  		for _, protoAllowedURL := range protoAccDef.AllowedUrls {
    20  			allowedUrls = append(allowedUrls, user.AccessSpec{
    21  				URL:     protoAllowedURL.Url,
    22  				Methods: protoAllowedURL.Methods,
    23  			})
    24  		}
    25  		accessDefinitions[key] = user.AccessDefinition{
    26  			APIName:     protoAccDef.ApiName,
    27  			APIID:       protoAccDef.ApiId,
    28  			Versions:    protoAccDef.Versions,
    29  			AllowedURLs: allowedUrls,
    30  		}
    31  	}
    32  
    33  	var basicAuthData struct {
    34  		Password string        `json:"password" msg:"password"`
    35  		Hash     user.HashType `json:"hash_type" msg:"hash_type"`
    36  	}
    37  	if session.GetBasicAuthData() != nil {
    38  		basicAuthData.Password = session.GetBasicAuthData().Password
    39  		basicAuthData.Hash = user.HashType(session.GetBasicAuthData().Hash)
    40  	}
    41  
    42  	var jwtData struct {
    43  		Secret string `json:"secret" msg:"secret"`
    44  	}
    45  	if session.GetJwtData() != nil {
    46  		jwtData.Secret = session.JwtData.Secret
    47  	}
    48  
    49  	var monitor struct {
    50  		TriggerLimits []float64 `json:"trigger_limits" msg:"trigger_limits"`
    51  	}
    52  
    53  	if session.Monitor != nil {
    54  		monitor.TriggerLimits = session.Monitor.TriggerLimits
    55  	}
    56  
    57  	metadata := make(map[string]interface{})
    58  	if session.Metadata != nil {
    59  		for k, v := range session.Metadata {
    60  			metadata[k] = v
    61  		}
    62  	}
    63  
    64  	return &user.SessionState{
    65  		LastCheck:               session.LastCheck,
    66  		Allowance:               session.Allowance,
    67  		Rate:                    session.Rate,
    68  		Per:                     session.Per,
    69  		Expires:                 session.Expires,
    70  		QuotaMax:                session.QuotaMax,
    71  		QuotaRenews:             session.QuotaRenews,
    72  		QuotaRemaining:          session.QuotaRemaining,
    73  		QuotaRenewalRate:        session.QuotaRenewalRate,
    74  		AccessRights:            accessDefinitions,
    75  		OrgID:                   session.OrgId,
    76  		OauthClientID:           session.OauthClientId,
    77  		OauthKeys:               session.OauthKeys,
    78  		Certificate:             session.Certificate,
    79  		BasicAuthData:           basicAuthData,
    80  		JWTData:                 jwtData,
    81  		HMACEnabled:             session.HmacEnabled,
    82  		HmacSecret:              session.HmacSecret,
    83  		IsInactive:              session.IsInactive,
    84  		ApplyPolicyID:           session.ApplyPolicyId,
    85  		ApplyPolicies:           session.ApplyPolicies,
    86  		DataExpires:             session.DataExpires,
    87  		MetaData:                metadata,
    88  		Monitor:                 monitor,
    89  		EnableDetailedRecording: session.EnableDetailedRecording,
    90  		Tags:                    session.Tags,
    91  		Alias:                   session.Alias,
    92  		LastUpdated:             session.LastUpdated,
    93  		IdExtractorDeadline:     session.IdExtractorDeadline,
    94  		SessionLifetime:         session.SessionLifetime,
    95  		Mutex:                   &sync.RWMutex{},
    96  	}
    97  }
    98  
    99  // ProtoSessionState takes a standard SessionState and outputs a SessionState object compatible with Protocol Buffers.
   100  func ProtoSessionState(session *user.SessionState) *coprocess.SessionState {
   101  
   102  	accessDefinitions := make(map[string]*coprocess.AccessDefinition, len(session.GetAccessRights()))
   103  
   104  	for key, accessDefinition := range session.GetAccessRights() {
   105  		var allowedUrls []*coprocess.AccessSpec
   106  		for _, allowedURL := range accessDefinition.AllowedURLs {
   107  			accessSpec := &coprocess.AccessSpec{
   108  				Url:     allowedURL.URL,
   109  				Methods: allowedURL.Methods,
   110  			}
   111  			allowedUrls = append(allowedUrls, accessSpec)
   112  		}
   113  
   114  		accessDefinitions[key] = &coprocess.AccessDefinition{
   115  			ApiName:     accessDefinition.APIName,
   116  			ApiId:       accessDefinition.APIID,
   117  			Versions:    accessDefinition.Versions,
   118  			AllowedUrls: allowedUrls,
   119  		}
   120  	}
   121  
   122  	basicAuthData := &coprocess.BasicAuthData{
   123  		Password: session.BasicAuthData.Password,
   124  		Hash:     string(session.BasicAuthData.Hash),
   125  	}
   126  	jwtData := &coprocess.JWTData{
   127  		Secret: session.JWTData.Secret,
   128  	}
   129  	monitor := &coprocess.Monitor{
   130  		TriggerLimits: session.Monitor.TriggerLimits,
   131  	}
   132  
   133  	metadata := make(map[string]string)
   134  	if len(session.GetMetaData()) > 0 {
   135  		for k, v := range session.GetMetaData() {
   136  			switch v.(type) {
   137  			case string:
   138  				metadata[k] = v.(string)
   139  			default:
   140  				jsonValue, err := json.Marshal(v)
   141  				if err != nil {
   142  					log.WithFields(logrus.Fields{
   143  						"prefix": "coprocess",
   144  					}).WithError(err).Error("Couldn't encode session metadata")
   145  					continue
   146  				}
   147  				metadata[k] = string(jsonValue)
   148  			}
   149  		}
   150  	}
   151  
   152  	return &coprocess.SessionState{
   153  		LastCheck:               session.LastCheck,
   154  		Allowance:               session.Allowance,
   155  		Rate:                    session.Rate,
   156  		Per:                     session.Per,
   157  		Expires:                 session.Expires,
   158  		QuotaMax:                session.QuotaMax,
   159  		QuotaRenews:             session.QuotaRenews,
   160  		QuotaRemaining:          session.QuotaRemaining,
   161  		QuotaRenewalRate:        session.QuotaRenewalRate,
   162  		AccessRights:            accessDefinitions,
   163  		OrgId:                   session.OrgID,
   164  		OauthClientId:           session.OauthClientID,
   165  		OauthKeys:               session.OauthKeys,
   166  		BasicAuthData:           basicAuthData,
   167  		JwtData:                 jwtData,
   168  		HmacEnabled:             session.HMACEnabled,
   169  		HmacSecret:              session.HmacSecret,
   170  		IsInactive:              session.IsInactive,
   171  		ApplyPolicyId:           session.ApplyPolicyID,
   172  		ApplyPolicies:           session.ApplyPolicies,
   173  		DataExpires:             session.DataExpires,
   174  		Monitor:                 monitor,
   175  		Metadata:                metadata,
   176  		EnableDetailedRecording: session.EnableDetailedRecording,
   177  		Tags:                    session.Tags,
   178  		Alias:                   session.Alias,
   179  		LastUpdated:             session.LastUpdated,
   180  		IdExtractorDeadline:     session.IdExtractorDeadline,
   181  		SessionLifetime:         session.SessionLifetime,
   182  	}
   183  }
   184  
   185  // ProtoMap is a helper function for maps with string slice values.
   186  func ProtoMap(inputMap map[string][]string) map[string]string {
   187  	newMap := make(map[string]string)
   188  
   189  	if inputMap != nil {
   190  		for k, v := range inputMap {
   191  			newMap[k] = v[0]
   192  		}
   193  	}
   194  
   195  	return newMap
   196  }