Fix comments and comment on exported elements

togashidm · killianmuldoon · commit 85a21a1d89b1 · 2021-02-18T15:16:02.000Z
diff --git a/pkg/cache/autoupdating.go b/pkg/cache/autoupdating.go
@@ -113,7 +113,7 @@ func (n *AutoUpdatingCache) WriteMetric(metricName string, data metrics.NodeMetr
 	return nil
 }
 
-//Delete policy removes the policy removes the policy object at the given namespace/name string from the cache
+//DeletePolicy removes the policy removes the policy object at the given namespace/name string from the cache
 func (n *AutoUpdatingCache) DeletePolicy(namespace string, policyName string) error {
 	log.Print("deleting", fmt.Sprintf(policyPath, namespace, policyName))
 	n.delete(fmt.Sprintf(policyPath, namespace, policyName))
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
@@ -2,12 +2,14 @@ package cache
 
 type requestType uint
 
+//const for requestType value
 const (
 	READ requestType = iota
 	WRITE
 	DELETE
 )
 
+//Interface contains the baseline behaviour for a cache
 type Interface interface {
 	add(string, interface{})
 	delete(string)
diff --git a/pkg/cache/mocks.go b/pkg/cache/mocks.go
@@ -8,19 +8,23 @@ import (
 	"time"
 )
 
+//MockEmptySelfUpdatingCache returns auto updating cache
 func MockEmptySelfUpdatingCache() ReaderWriter {
 	n := NewAutoUpdatingCache()
 	go n.PeriodicUpdate(*time.NewTicker(time.Second), metrics.NewDummyMetricsClient(map[string]metrics.NodeMetricsInfo{}), map[string]interface{}{})
 	return n
 }
 
+//MockSelfUpdatingCache returns auto updating cache
 func MockSelfUpdatingCache() *AutoUpdatingCache {
 	n := MockEmptySelfUpdatingCache()
 	_ = n.WriteMetric("dummyMetric1", TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}))
 	_ = n.WriteMetric("dummyMetric2", TestNodeMetricCustomInfo([]string{"node 1", "node2"}, []int64{100, 200}))
 	_ = n.WriteMetric("dummyMetric3", TestNodeMetricCustomInfo([]string{"node Z", "node Y"}, []int64{8, 40000000}))
 	return n.(*AutoUpdatingCache)
 }
+
+//TestNodeMetricCustomInfo returns the node metrics information
 func TestNodeMetricCustomInfo(nodeNames []string, numbers []int64) metrics.NodeMetricsInfo {
 	n := metrics.NodeMetricsInfo{}
 	for i, name := range nodeNames {
diff --git a/pkg/cache/remote.go b/pkg/cache/remote.go
@@ -8,12 +8,13 @@ import (
 	"net/http"
 )
 
+//RemoteClient can send http requests to a single endpoint
 type RemoteClient struct {
 	endpoint string
 	http.Client
 }
 
-//Register endpoint adds an endpoint for the metrics getter to read from
+//RegisterEndpoint adds an endpoint for the metrics getter to read from
 func (r *RemoteClient) RegisterEndpoint(endpoint string) {
 	r.endpoint = endpoint
 }
diff --git a/pkg/cache/types.go b/pkg/cache/types.go
@@ -26,7 +26,7 @@ type ReaderWriter interface {
 	Writer
 }
 
-//TasCache describes functionality to periodically update all metrics in the metric cache.
+//SelfUpdating describes functionality to periodically update all metrics in the metric cache.
 type SelfUpdating interface {
 	PeriodicUpdate(time.Ticker, metrics.Client, map[string]interface{})
 }
diff --git a/pkg/controller/controller.go b/pkg/controller/controller.go
@@ -1,4 +1,4 @@
-//Provides a controller that can be used to watch policies in the Kuebrnetes API.
+//Package controller provides a controller that can be used to watch policies in the Kubernetes API.
 //It registers strategies from those policies to an enforcer.
 package controller
 
diff --git a/pkg/metrics/mocks.go b/pkg/metrics/mocks.go
@@ -11,7 +11,8 @@ import (
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	"time"
 )
-//Mocks used for testing in the metrics and other packages
+
+//DummyRestClientConfig  Mocks used for testing in the metrics and other packages
 func DummyRestClientConfig() *restclient.Config {
 	tmpFile, err := ioutil.TempFile("", "cmdtests_temp")
 	if err != nil {
@@ -28,22 +29,26 @@ func DummyRestClientConfig() *restclient.Config {
 	return restConfig
 }
 
+//DummyMetricsClient structured with a map of NodeMetricsInfo
 type DummyMetricsClient struct {
 	store *map[string]NodeMetricsInfo
 }
 
+//InstanceOfMockMetricClientMap refers to the metrics from Nodes
 var InstanceOfMockMetricClientMap = map[string]NodeMetricsInfo{
 	"dummyMetric1": TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}),
 	"dummyMetric2": TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}),
 	"dummyMetric3": TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}),
 }
 
+//NewDummyMetricsClient receives the Node metrics and return the map values of client
 func NewDummyMetricsClient(cache map[string]NodeMetricsInfo) Client {
 	return DummyMetricsClient{
 		&cache,
 	}
 }
 
+//GetNodeMetric returns the NodeMetricsInfo of a metric when it exists.
 func (d DummyMetricsClient) GetNodeMetric(metricName string) (NodeMetricsInfo, error) {
 	s := *d.store
 	if v, ok := s[metricName]; ok {
@@ -52,6 +57,7 @@ func (d DummyMetricsClient) GetNodeMetric(metricName string) (NodeMetricsInfo, e
 	return nil, errors.New("metric not found")
 }
 
+//TestNodeMetricCustomInfo returns slice with NodeMetrics from a arrays of nodesNames and numbers.
 func TestNodeMetricCustomInfo(nodeNames []string, numbers []int64) NodeMetricsInfo {
 	n := NodeMetricsInfo{}
 	for i, name := range nodeNames {
diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go
@@ -1,4 +1,4 @@
-//Logic for the scheduler extender - including the server it starts and prioritize + filter methods - is implemented in this package.
+//Package scheduler extender logic contains code to respond call from the http endpoint.
 package scheduler
 
 import (
@@ -22,12 +22,12 @@ import (
 	"time"
 )
 
-//Metrics Extender holds information on the cache holding scheduling strategies and metrics.
+//MetricsExtender holds information on the cache holding scheduling strategies and metrics.
 type MetricsExtender struct {
 	cache cache.Reader
 }
 
-//Returns a new metric Extender with the cache passed to it.
+//NewMetricsExtender returns a new metric Extender with the cache passed to it.
 func NewMetricsExtender(newCache cache.Reader) MetricsExtender {
 	return MetricsExtender{
 		cache: newCache,
@@ -274,7 +274,7 @@ func checkSymLinks(filename string) error {
 	return nil
 }
 
-// startHttpServer starts the HTTP server needed for scheduler.
+// StartServer starts the HTTP server needed for scheduler.
 // It registers the handlers and checks for existing telemetry policies.
 func (m MetricsExtender) StartServer(port string, certFile string, keyFile string, unsafe bool) {
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { m.errorHandler(w, r) })
diff --git a/pkg/scheduler/types.go b/pkg/scheduler/types.go
@@ -5,8 +5,8 @@ import (
 	"net/http"
 )
 
-//A scheduler extender has the capabilities needed to prioritize and filter nodes based on http requests.
-type SchedulerExtender interface {
+//ExtenderScheduler has the capabilities needed to prioritize and filter nodes based on http requests.
+type ExtenderScheduler interface {
 	Prioritize(w http.ResponseWriter, r *http.Request)
 	Filter(w http.ResponseWriter, r *http.Request)
 }
diff --git a/pkg/strategies/core/enforcer.go b/pkg/strategies/core/enforcer.go
@@ -30,6 +30,7 @@ func (e *MetricEnforcer) RegisterStrategyType(str Interface) {
 	e.RegisteredStrategies[str.StrategyType()] = map[Interface]interface{}{}
 }
 
+//IsRegistered checks to see if a passed strategy is already being enforced
 func (e *MetricEnforcer) IsRegistered(str string) bool {
 	e.Lock()
 	defer e.Unlock()
@@ -57,6 +58,7 @@ func (e *MetricEnforcer) RegisteredStrategyTypes() []string {
 	return output
 }
 
+//RemoveStrategy will take a strategy out of the enforcer if it's currently registered
 func (e *MetricEnforcer) RemoveStrategy(str Interface, strategyType string) {
 	e.Lock()
 	defer e.Unlock()
diff --git a/pkg/strategies/core/mocks.go b/pkg/strategies/core/mocks.go
@@ -4,27 +4,37 @@ import (
 	"github.com/intel/telemetry-aware-scheduling/pkg/cache"
 )
 
-//Here we have a mock strategy that is used in the tests for the core and other packages.
+//MockStrategy is used in the tests for the core and other packages.
 type MockStrategy struct {
 	StrategyTypeMock string
 }
 
+//Violated gets the cache values from MockStrategy and returns the map interface
 func (v *MockStrategy) Violated(cache cache.Reader) map[string]interface{} {
 	return map[string]interface{}{}
 }
+
+//Enforce returns 0 value and nil error
 func (v *MockStrategy) Enforce(enforcer *MetricEnforcer, cache cache.Reader) (int, error) {
 	return 0, nil
 }
 
+//StrategyType returns the Strategy type of the mock
 func (v *MockStrategy) StrategyType() string {
 	return v.StrategyTypeMock
 }
+
+//Equals returns the value of checking if the strategy types are the same.
 func (v *MockStrategy) Equals(o Interface) bool {
 	return v.StrategyType() == o.StrategyType()
 }
+
+//GetPolicyName gets the mock strategy policy name
 func (v *MockStrategy) GetPolicyName() string {
 	return "mock-policy"
 }
+
+//SetPolicyName sets the policy name of the mock strategy
 func (v *MockStrategy) SetPolicyName( policyName string)  {
 	return
 }
diff --git a/pkg/strategies/deschedule/strategy.go b/pkg/strategies/deschedule/strategy.go
@@ -1,4 +1,4 @@
-//The deschedule strategy, violations conditions and enforcement behavior are defined in this package.
+//Package deschedule provides the deschedule strategy. Violation conditions and enforcement behavior are defined here.
 //When a node is violating the deschedule strategy, the enforcer labels it as violating.
 //This label can then be used externally to act on the strategy violation.
 package deschedule
@@ -11,11 +11,12 @@ import (
 	"log"
 )
 
+//StrategyType is set to de-schedule.
 const (
 	StrategyType = "deschedule"
 )
 
-//Interface type for descheduling from a single policy.
+//Strategy type for de-scheduling from a single policy.
 type Strategy telempol.TASPolicyStrategy
 
 //StrategyType returns the name of the strategy type. This is used to place it in the registry.
diff --git a/pkg/strategies/dontschedule/strategy.go b/pkg/strategies/dontschedule/strategy.go
@@ -10,11 +10,14 @@ import (
 	"log"
 )
 
+//Strategy represents the TAS policy strategies.
 type Strategy telemetryPolicyV1.TASPolicyStrategy
 
+//StrategyType is set to not schedule
 const (
 	StrategyType = "dontschedule"
 )
+
 //Violated compares the list of rules against the metric values pulled from the cache.
 //If any single rule is violated the method returns a set of nodes that are currently in violation.
 func (d *Strategy) Violated(cache cache.Reader) map[string]interface{} {
@@ -35,15 +38,18 @@ func (d *Strategy) Violated(cache cache.Reader) map[string]interface{} {
 	}
 	return violatingNodes
 }
-//Unimplemented for dontschedule
+
+//Enforce unimplemented for dontschedule.
 func (d *Strategy) Enforce(enforcer *core.MetricEnforcer, cache cache.Reader) (int, error) {
 	return 0, nil
 }
-//Returns the strategy type constant
+
+//StrategyType returns the strategy type constant
 func (d *Strategy) StrategyType() string {
 	return StrategyType
 }
-//Naive equals implementation which checks to see if all rules and the policy name are equal for this strategy and another.
+
+//Equals implementation which checks to see if all rules and the policy name are equal for this strategy and another.
 //Used to avoid duplications and to find the correct strategy for deletions in the index.
 func (d *Strategy) Equals( other core.Interface) bool {
 	OtherDontScheduleStrategy, ok := other.(*Strategy)
@@ -65,11 +71,13 @@ func (d *Strategy) Equals( other core.Interface) bool {
 	return false
 
 }
-//Sets a connected policy name for this strategy.
+
+//SetPolicyName sets a connected policy name for this strategy.
 func (d *Strategy) SetPolicyName(policyName string) {
 	d.PolicyName = policyName
 }
-//Returns the set policy name for this strategy.
+
+//GetPolicyName returns the set policy name for this strategy.
 func (d *Strategy) GetPolicyName() string {
 	return d.PolicyName
 }
diff --git a/pkg/strategies/scheduleonmetric/strategy.go b/pkg/strategies/scheduleonmetric/strategy.go
@@ -8,8 +8,10 @@ import (
 	telemetryPolicyV1 "github.com/intel/telemetry-aware-scheduling/pkg/telemetrypolicy/api/v1alpha1"
 )
 
+//Strategy represents the TAS policy strategies
 type Strategy telemetryPolicyV1.TASPolicyStrategy
 
+//StrategyType is set to schedule.
 const (
 	StrategyType = "scheduleonmetric"
 )
@@ -19,10 +21,12 @@ func (d *Strategy) Violated(cache cache.Reader) map[string]interface{} {
 	violatingNodes := map[string]interface{}{}
 	return violatingNodes
 }
+
 //Enforce is unimplemented
 func (d *Strategy) Enforce(enforcer *core.MetricEnforcer, cache cache.Reader) (int, error) {
 	return 0, nil
 }
+
 //StrategyType returns the constant name of the strategy used to index it for other objects.
 func (d *Strategy) StrategyType() string {
 	return StrategyType
@@ -51,11 +55,12 @@ func (d *Strategy) Equals(other core.Interface) bool {
 
 }
 
-//Returns the policy name associated with this strategys.
+//GetPolicyName returns the policy name associated with this strategy.
 func (d *Strategy) GetPolicyName() string {
 	return d.PolicyName
 }
-//Sets the policy name for this strategy
+
+//SetPolicyName sets the policy name for this strategy.
 func (d *Strategy) SetPolicyName(policyName string) {
 	d.PolicyName = policyName
 }
diff --git a/pkg/telemetrypolicy/api/v1alpha1/types.go b/pkg/telemetrypolicy/api/v1alpha1/types.go
@@ -1,17 +1,18 @@
-//Describes the structure of the Telemetry Policy CRD.
+//Package v1alpha1 describes the structure of the Telemetry Policy CRD.
 package v1alpha1
 
 import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
+//Defines key values for policy CRD
 const (
 	Plural  = "taspolicies"
 	Group   = "telemetry.intel.com"
 	Version = "v1alpha1"
 )
 
-// TASpolicy is the Schema for the taspolicies API
+// TASPolicy is the Schema for the taspolicies API
 type TASPolicy struct {
 	metav1.TypeMeta   `json:",inline"`
 	metav1.ObjectMeta `json:"metadata,omitempty"`
@@ -33,7 +34,7 @@ type TASPolicyRule struct {
 	Target     int64  `json:"target"`
 }
 
-//Spec for a TAS policy is a map of strategies indexed by their strategy type name i.e. scheduleonmetric, dontschedule.
+//TASPolicySpec is a map of strategies indexed by their strategy type name i.e. scheduleonmetric, dontschedule.
 type TASPolicySpec struct {
 	Strategies map[string]TASPolicyStrategy `json:"strategies"`
 }
diff --git a/pkg/telemetrypolicy/client/v1alpha1/client.go b/pkg/telemetrypolicy/client/v1alpha1/client.go
@@ -54,7 +54,7 @@ func (client *Client) Create(obj *telemetrypolicy.TASPolicy) (*telemetrypolicy.T
 	return &result, err
 }
 
-//updateWithData changes the information contained in a given Telemetry Policy
+//Update changes the information contained in a given Telemetry Policy
 func (client *Client) Update(obj *telemetrypolicy.TASPolicy) (*telemetrypolicy.TASPolicy, error) {
 	var result telemetrypolicy.TASPolicy
 	err := client.rest.Put().Namespace(obj.Namespace).Resource(client.plural).Body(obj).Name(obj.Name).Do().Into(&result)
@@ -68,7 +68,7 @@ func (client *Client) Get(name string, namespace string) (*telemetrypolicy.TASPo
 	return &result, err
 }
 
-//delete removes a telemetry policy of the given name, with the passed options, from Kubernetes.
+//Delete removes a telemetry policy of the given name, with the passed options, from Kubernetes.
 func (client *Client) Delete(name string, options *metav1.DeleteOptions) error {
 	return client.rest.Delete().Namespace(client.namespace).Resource(client.plural).Name(name).Body(options).Do().Error()
 }
diff --git a/pkg/telemetrypolicy/client/v1alpha1/types.go b/pkg/telemetrypolicy/client/v1alpha1/types.go
@@ -1,4 +1,4 @@
-//Package telemetrypolicy/api/client provides an interface to interact with Policy CRD through a custom Client.
+//Package client telemetrypolicy/api/client provides an interface to interact with Policy CRD through a custom Client.
 package client
 
 import (

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ func (n *AutoUpdatingCache) WriteMetric(metricName string, data metrics.NodeMetr`
`113`	`113`	`return nil`
`114`	`114`	`}`
`115`	`115`
`116`		`-//Delete policy removes the policy removes the policy object at the given namespace/name string from the cache`
	`116`	`+//DeletePolicy removes the policy removes the policy object at the given namespace/name string from the cache`
`117`	`117`	`func (n *AutoUpdatingCache) DeletePolicy(namespace string, policyName string) error {`
`118`	`118`	`log.Print("deleting", fmt.Sprintf(policyPath, namespace, policyName))`
`119`	`119`	`n.delete(fmt.Sprintf(policyPath, namespace, policyName))`
Original file line number	Diff line number	Diff line change
`@@ -8,12 +8,13 @@ import (`
`8`	`8`	`"net/http"`
`9`	`9`	`)`
`10`	`10`
	`11`	`+//RemoteClient can send http requests to a single endpoint`
`11`	`12`	`type RemoteClient struct {`
`12`	`13`	`endpoint string`
`13`	`14`	`http.Client`
`14`	`15`	`}`
`15`	`16`
`16`		`-//Register endpoint adds an endpoint for the metrics getter to read from`
	`17`	`+//RegisterEndpoint adds an endpoint for the metrics getter to read from`
`17`	`18`	`func (r *RemoteClient) RegisterEndpoint(endpoint string) {`
`18`	`19`	`r.endpoint = endpoint`
`19`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ type ReaderWriter interface {`
`26`	`26`	`Writer`
`27`	`27`	`}`
`28`	`28`
`29`		`-//TasCache describes functionality to periodically update all metrics in the metric cache.`
	`29`	`+//SelfUpdating describes functionality to periodically update all metrics in the metric cache.`
`30`	`30`	`type SelfUpdating interface {`
`31`	`31`	`PeriodicUpdate(time.Ticker, metrics.Client, map[string]interface{})`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-//Provides a controller that can be used to watch policies in the Kuebrnetes API.`
	`1`	`+//Package controller provides a controller that can be used to watch policies in the Kubernetes API.`
`2`	`2`	`//It registers strategies from those policies to an enforcer.`
`3`	`3`	`package controller`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,8 @@ import (`
`11`	`11`	`clientcmdapi "k8s.io/client-go/tools/clientcmd/api"`
`12`	`12`	`"time"`
`13`	`13`	`)`
`14`		`-//Mocks used for testing in the metrics and other packages`
	`14`	`+`
	`15`	`+//DummyRestClientConfig Mocks used for testing in the metrics and other packages`
`15`	`16`	`func DummyRestClientConfig() *restclient.Config {`
`16`	`17`	`tmpFile, err := ioutil.TempFile("", "cmdtests_temp")`
`17`	`18`	`if err != nil {`
`@@ -28,22 +29,26 @@ func DummyRestClientConfig() *restclient.Config {`
`28`	`29`	`return restConfig`
`29`	`30`	`}`
`30`	`31`
	`32`	`+//DummyMetricsClient structured with a map of NodeMetricsInfo`
`31`	`33`	`type DummyMetricsClient struct {`
`32`	`34`	`store *map[string]NodeMetricsInfo`
`33`	`35`	`}`
`34`	`36`
	`37`	`+//InstanceOfMockMetricClientMap refers to the metrics from Nodes`
`35`	`38`	`var InstanceOfMockMetricClientMap = map[string]NodeMetricsInfo{`
`36`	`39`	`"dummyMetric1": TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}),`
`37`	`40`	`"dummyMetric2": TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}),`
`38`	`41`	`"dummyMetric3": TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}),`
`39`	`42`	`}`
`40`	`43`
	`44`	`+//NewDummyMetricsClient receives the Node metrics and return the map values of client`
`41`	`45`	`func NewDummyMetricsClient(cache map[string]NodeMetricsInfo) Client {`
`42`	`46`	`return DummyMetricsClient{`
`43`	`47`	`&cache,`
`44`	`48`	`}`
`45`	`49`	`}`
`46`	`50`
	`51`	`+//GetNodeMetric returns the NodeMetricsInfo of a metric when it exists.`
`47`	`52`	`func (d DummyMetricsClient) GetNodeMetric(metricName string) (NodeMetricsInfo, error) {`
`48`	`53`	`s := *d.store`
`49`	`54`	`if v, ok := s[metricName]; ok {`
`@@ -52,6 +57,7 @@ func (d DummyMetricsClient) GetNodeMetric(metricName string) (NodeMetricsInfo, e`
`52`	`57`	`return nil, errors.New("metric not found")`
`53`	`58`	`}`
`54`	`59`
	`60`	`+//TestNodeMetricCustomInfo returns slice with NodeMetrics from a arrays of nodesNames and numbers.`
`55`	`61`	`func TestNodeMetricCustomInfo(nodeNames []string, numbers []int64) NodeMetricsInfo {`
`56`	`62`	`n := NodeMetricsInfo{}`
`57`	`63`	`for i, name := range nodeNames {`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,8 @@ import (`
`5`	`5`	`"net/http"`
`6`	`6`	`)`
`7`	`7`
`8`		`-//A scheduler extender has the capabilities needed to prioritize and filter nodes based on http requests.`
`9`		`-type SchedulerExtender interface {`
	`8`	`+//ExtenderScheduler has the capabilities needed to prioritize and filter nodes based on http requests.`
	`9`	`+type ExtenderScheduler interface {`
`10`	`10`	`Prioritize(w http.ResponseWriter, r *http.Request)`
`11`	`11`	`Filter(w http.ResponseWriter, r *http.Request)`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ func (e *MetricEnforcer) RegisterStrategyType(str Interface) {`
`30`	`30`	`e.RegisteredStrategies[str.StrategyType()] = map[Interface]interface{}{}`
`31`	`31`	`}`
`32`	`32`
	`33`	`+//IsRegistered checks to see if a passed strategy is already being enforced`
`33`	`34`	`func (e *MetricEnforcer) IsRegistered(str string) bool {`
`34`	`35`	`e.Lock()`
`35`	`36`	`defer e.Unlock()`
`@@ -57,6 +58,7 @@ func (e *MetricEnforcer) RegisteredStrategyTypes() []string {`
`57`	`58`	`return output`
`58`	`59`	`}`
`59`	`60`
	`61`	`+//RemoveStrategy will take a strategy out of the enforcer if it's currently registered`
`60`	`62`	`func (e *MetricEnforcer) RemoveStrategy(str Interface, strategyType string) {`
`61`	`63`	`e.Lock()`
`62`	`64`	`defer e.Unlock()`