_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q7900 | CreatePolicy | train | func CreatePolicy(obj *Policy) error {
// Validate parameters
err := ValidatePolicy(obj)
if err != nil {
log.Errorf("ValidatePolicy retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.PolicyCb == nil {
log.Errorf("No callback registered for policy object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.policyMutex.Lock()
key := collections.policys[obj.Key]
collections.policyMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.PolicyCb.PolicyUpdate(collections.policys[obj.Key], obj)
if err != nil {
log.Errorf("PolicyUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.policyMutex.Lock()
saveObj = collections.policys[obj.Key]
collections.policyMutex.Unlock()
} else {
// save it in cache
collections.policyMutex.Lock()
collections.policys[obj.Key] = obj
collections.policyMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.PolicyCb.PolicyCreate(obj)
if err != nil {
log.Errorf("PolicyCreate retruned error for: %+v. Err: %v", obj, err)
collections.policyMutex.Lock()
delete(collections.policys, obj.Key)
collections.policyMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.policyMutex.Lock()
err = saveObj.Write()
collections.policyMutex.Unlock()
if err != nil {
log.Errorf("Error saving policy %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7901 | FindPolicy | train | func FindPolicy(key string) *Policy {
collections.policyMutex.Lock()
defer collections.policyMutex.Unlock()
obj := collections.policys[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7902 | DeletePolicy | train | func DeletePolicy(key string) error {
collections.policyMutex.Lock()
obj := collections.policys[key]
collections.policyMutex.Unlock()
if obj == nil {
log.Errorf("policy %s not found", key)
return errors.New("policy not found")
}
// Check if we handle this object
if objCallbackHandler.PolicyCb == nil {
log.Errorf("No callback registered for policy object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.PolicyCb.PolicyDelete(obj)
if err != nil {
log.Errorf("PolicyDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.policyMutex.Lock()
err = obj.Delete()
collections.policyMutex.Unlock()
if err != nil {
log.Errorf("Error deleting policy %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.policyMutex.Lock()
delete(collections.policys, key)
collections.policyMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7903 | ValidatePolicy | train | func ValidatePolicy(obj *Policy) error {
collections.policyMutex.Lock()
defer collections.policyMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.PolicyName
if obj.Key != keyStr {
log.Errorf("Expecting Policy Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.PolicyName) > 64 {
return errors.New("policyName string too long")
}
policyNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if policyNameMatch.MatchString(obj.PolicyName) == false {
return errors.New("policyName string invalid format")
}
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long")
}
tenantNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if tenantNameMatch.MatchString(obj.TenantName) == false {
return errors.New("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7904 | CreateRule | train | func CreateRule(obj *Rule) error {
// Validate parameters
err := ValidateRule(obj)
if err != nil {
log.Errorf("ValidateRule retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.RuleCb == nil {
log.Errorf("No callback registered for rule object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.ruleMutex.Lock()
key := collections.rules[obj.Key]
collections.ruleMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.RuleCb.RuleUpdate(collections.rules[obj.Key], obj)
if err != nil {
log.Errorf("RuleUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.ruleMutex.Lock()
saveObj = collections.rules[obj.Key]
collections.ruleMutex.Unlock()
} else {
// save it in cache
collections.ruleMutex.Lock()
collections.rules[obj.Key] = obj
collections.ruleMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.RuleCb.RuleCreate(obj)
if err != nil {
log.Errorf("RuleCreate retruned error for: %+v. Err: %v", obj, err)
collections.ruleMutex.Lock()
delete(collections.rules, obj.Key)
collections.ruleMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.ruleMutex.Lock()
err = saveObj.Write()
collections.ruleMutex.Unlock()
if err != nil {
log.Errorf("Error saving rule %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7905 | FindRule | train | func FindRule(key string) *Rule {
collections.ruleMutex.Lock()
defer collections.ruleMutex.Unlock()
obj := collections.rules[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7906 | DeleteRule | train | func DeleteRule(key string) error {
collections.ruleMutex.Lock()
obj := collections.rules[key]
collections.ruleMutex.Unlock()
if obj == nil {
log.Errorf("rule %s not found", key)
return errors.New("rule not found")
}
// Check if we handle this object
if objCallbackHandler.RuleCb == nil {
log.Errorf("No callback registered for rule object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.RuleCb.RuleDelete(obj)
if err != nil {
log.Errorf("RuleDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.ruleMutex.Lock()
err = obj.Delete()
collections.ruleMutex.Unlock()
if err != nil {
log.Errorf("Error deleting rule %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.ruleMutex.Lock()
delete(collections.rules, key)
collections.ruleMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7907 | ValidateRule | train | func ValidateRule(obj *Rule) error {
collections.ruleMutex.Lock()
defer collections.ruleMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.PolicyName + ":" + obj.RuleID
if obj.Key != keyStr {
log.Errorf("Expecting Rule Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
actionMatch := regexp.MustCompile("^(allow|deny)$")
if actionMatch.MatchString(obj.Action) == false {
return errors.New("action string invalid format")
}
directionMatch := regexp.MustCompile("^(in|out)$")
if directionMatch.MatchString(obj.Direction) == false {
return errors.New("direction string invalid format")
}
if len(obj.FromEndpointGroup) > 64 {
return errors.New("fromEndpointGroup string too long")
}
fromEndpointGroupMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])?$")
if fromEndpointGroupMatch.MatchString(obj.FromEndpointGroup) == false {
return errors.New("fromEndpointGroup string invalid format")
}
fromIpAddressMatch := regexp.MustCompile("^(((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})(\\-(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9]))?(/(3[0-1]|2[0-9]|1[0-9]|[1-9]))?)?$")
if fromIpAddressMatch.MatchString(obj.FromIpAddress) == false {
return errors.New("fromIpAddress string invalid format")
}
if len(obj.FromNetwork) > 64 {
return errors.New("fromNetwork string too long")
}
fromNetworkMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])?$")
if fromNetworkMatch.MatchString(obj.FromNetwork) == false {
return errors.New("fromNetwork string invalid format")
}
if len(obj.PolicyName) > 64 {
return errors.New("policyName string too long")
}
policyNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if policyNameMatch.MatchString(obj.PolicyName) == false {
return errors.New("policyName string invalid format")
}
if obj.Port > 65535 {
return errors.New("port Value Out of bound")
}
if obj.Priority == 0 {
obj.Priority = 1
}
if obj.Priority < 1 {
return errors.New("priority Value Out of bound")
}
if obj.Priority > 100 {
return errors.New("priority Value Out of bound")
}
protocolMatch := regexp.MustCompile("^(tcp|udp|icmp||[0-9]{1,3}?)$")
if protocolMatch.MatchString(obj.Protocol) == false {
return errors.New("protocol string invalid format")
}
if len(obj.RuleID) > 64 {
return errors.New("ruleId string too long")
}
ruleIdMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if ruleIdMatch.MatchString(obj.RuleID) == false {
return errors.New("ruleId string invalid format")
}
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long")
}
tenantNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if tenantNameMatch.MatchString(obj.TenantName) == false {
return errors.New("tenantName string invalid format")
}
if len(obj.ToEndpointGroup) > 64 {
return errors.New("toEndpointGroup string too long")
}
toEndpointGroupMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])?$")
if toEndpointGroupMatch.MatchString(obj.ToEndpointGroup) == false {
return errors.New("toEndpointGroup string invalid format")
}
toIpAddressMatch := regexp.MustCompile("^(((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})(\\-(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9]))?(/(3[0-1]|2[0-9]|1[0-9]|[1-9]))?)?$")
if toIpAddressMatch.MatchString(obj.ToIpAddress) == false {
return errors.New("toIpAddress string invalid format")
}
if len(obj.ToNetwork) > 64 {
return errors.New("toNetwork string too long")
}
toNetworkMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])?$")
if toNetworkMatch.MatchString(obj.ToNetwork) == false {
return errors.New("toNetwork string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7908 | GetOperServiceLB | train | func GetOperServiceLB(obj *ServiceLBInspect) error {
// Check if we handle this object
if objCallbackHandler.ServiceLBCb == nil {
log.Errorf("No callback registered for serviceLB object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.ServiceLBCb.ServiceLBGetOper(obj)
if err != nil {
log.Errorf("ServiceLBDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7909 | CreateServiceLB | train | func CreateServiceLB(obj *ServiceLB) error {
// Validate parameters
err := ValidateServiceLB(obj)
if err != nil {
log.Errorf("ValidateServiceLB retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.ServiceLBCb == nil {
log.Errorf("No callback registered for serviceLB object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.serviceLBMutex.Lock()
key := collections.serviceLBs[obj.Key]
collections.serviceLBMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.ServiceLBCb.ServiceLBUpdate(collections.serviceLBs[obj.Key], obj)
if err != nil {
log.Errorf("ServiceLBUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.serviceLBMutex.Lock()
saveObj = collections.serviceLBs[obj.Key]
collections.serviceLBMutex.Unlock()
} else {
// save it in cache
collections.serviceLBMutex.Lock()
collections.serviceLBs[obj.Key] = obj
collections.serviceLBMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.ServiceLBCb.ServiceLBCreate(obj)
if err != nil {
log.Errorf("ServiceLBCreate retruned error for: %+v. Err: %v", obj, err)
collections.serviceLBMutex.Lock()
delete(collections.serviceLBs, obj.Key)
collections.serviceLBMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.serviceLBMutex.Lock()
err = saveObj.Write()
collections.serviceLBMutex.Unlock()
if err != nil {
log.Errorf("Error saving serviceLB %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7910 | FindServiceLB | train | func FindServiceLB(key string) *ServiceLB {
collections.serviceLBMutex.Lock()
defer collections.serviceLBMutex.Unlock()
obj := collections.serviceLBs[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7911 | DeleteServiceLB | train | func DeleteServiceLB(key string) error {
collections.serviceLBMutex.Lock()
obj := collections.serviceLBs[key]
collections.serviceLBMutex.Unlock()
if obj == nil {
log.Errorf("serviceLB %s not found", key)
return errors.New("serviceLB not found")
}
// Check if we handle this object
if objCallbackHandler.ServiceLBCb == nil {
log.Errorf("No callback registered for serviceLB object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.ServiceLBCb.ServiceLBDelete(obj)
if err != nil {
log.Errorf("ServiceLBDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.serviceLBMutex.Lock()
err = obj.Delete()
collections.serviceLBMutex.Unlock()
if err != nil {
log.Errorf("Error deleting serviceLB %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.serviceLBMutex.Lock()
delete(collections.serviceLBs, key)
collections.serviceLBMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7912 | ValidateServiceLB | train | func ValidateServiceLB(obj *ServiceLB) error {
collections.serviceLBMutex.Lock()
defer collections.serviceLBMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.ServiceName
if obj.Key != keyStr {
log.Errorf("Expecting ServiceLB Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.IpAddress) > 15 {
return errors.New("ipAddress string too long")
}
ipAddressMatch := regexp.MustCompile("^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})?$")
if ipAddressMatch.MatchString(obj.IpAddress) == false {
return errors.New("ipAddress string invalid format")
}
if len(obj.NetworkName) > 64 {
return errors.New("networkName string too long")
}
networkNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if networkNameMatch.MatchString(obj.NetworkName) == false {
return errors.New("networkName string invalid format")
}
if len(obj.ServiceName) > 256 {
return errors.New("serviceName string too long")
}
serviceNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if serviceNameMatch.MatchString(obj.ServiceName) == false {
return errors.New("serviceName string invalid format")
}
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long")
}
tenantNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if tenantNameMatch.MatchString(obj.TenantName) == false {
return errors.New("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7913 | GetOperTenant | train | func GetOperTenant(obj *TenantInspect) error {
// Check if we handle this object
if objCallbackHandler.TenantCb == nil {
log.Errorf("No callback registered for tenant object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.TenantCb.TenantGetOper(obj)
if err != nil {
log.Errorf("TenantDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7914 | CreateTenant | train | func CreateTenant(obj *Tenant) error {
// Validate parameters
err := ValidateTenant(obj)
if err != nil {
log.Errorf("ValidateTenant retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.TenantCb == nil {
log.Errorf("No callback registered for tenant object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.tenantMutex.Lock()
key := collections.tenants[obj.Key]
collections.tenantMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.TenantCb.TenantUpdate(collections.tenants[obj.Key], obj)
if err != nil {
log.Errorf("TenantUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.tenantMutex.Lock()
saveObj = collections.tenants[obj.Key]
collections.tenantMutex.Unlock()
} else {
// save it in cache
collections.tenantMutex.Lock()
collections.tenants[obj.Key] = obj
collections.tenantMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.TenantCb.TenantCreate(obj)
if err != nil {
log.Errorf("TenantCreate retruned error for: %+v. Err: %v", obj, err)
collections.tenantMutex.Lock()
delete(collections.tenants, obj.Key)
collections.tenantMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.tenantMutex.Lock()
err = saveObj.Write()
collections.tenantMutex.Unlock()
if err != nil {
log.Errorf("Error saving tenant %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7915 | FindTenant | train | func FindTenant(key string) *Tenant {
collections.tenantMutex.Lock()
defer collections.tenantMutex.Unlock()
obj := collections.tenants[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7916 | DeleteTenant | train | func DeleteTenant(key string) error {
collections.tenantMutex.Lock()
obj := collections.tenants[key]
collections.tenantMutex.Unlock()
if obj == nil {
log.Errorf("tenant %s not found", key)
return errors.New("tenant not found")
}
// Check if we handle this object
if objCallbackHandler.TenantCb == nil {
log.Errorf("No callback registered for tenant object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.TenantCb.TenantDelete(obj)
if err != nil {
log.Errorf("TenantDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.tenantMutex.Lock()
err = obj.Delete()
collections.tenantMutex.Unlock()
if err != nil {
log.Errorf("Error deleting tenant %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.tenantMutex.Lock()
delete(collections.tenants, key)
collections.tenantMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7917 | ValidateTenant | train | func ValidateTenant(obj *Tenant) error {
collections.tenantMutex.Lock()
defer collections.tenantMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName
if obj.Key != keyStr {
log.Errorf("Expecting Tenant Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.DefaultNetwork) > 64 {
return errors.New("defaultNetwork string too long")
}
defaultNetworkMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])?$")
if defaultNetworkMatch.MatchString(obj.DefaultNetwork) == false {
return errors.New("defaultNetwork string invalid format")
}
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long")
}
tenantNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if tenantNameMatch.MatchString(obj.TenantName) == false {
return errors.New("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7918 | CreateVolume | train | func CreateVolume(obj *Volume) error {
// Validate parameters
err := ValidateVolume(obj)
if err != nil {
log.Errorf("ValidateVolume retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.VolumeCb == nil {
log.Errorf("No callback registered for volume object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.volumeMutex.Lock()
key := collections.volumes[obj.Key]
collections.volumeMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.VolumeCb.VolumeUpdate(collections.volumes[obj.Key], obj)
if err != nil {
log.Errorf("VolumeUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.volumeMutex.Lock()
saveObj = collections.volumes[obj.Key]
collections.volumeMutex.Unlock()
} else {
// save it in cache
collections.volumeMutex.Lock()
collections.volumes[obj.Key] = obj
collections.volumeMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.VolumeCb.VolumeCreate(obj)
if err != nil {
log.Errorf("VolumeCreate retruned error for: %+v. Err: %v", obj, err)
collections.volumeMutex.Lock()
delete(collections.volumes, obj.Key)
collections.volumeMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.volumeMutex.Lock()
err = saveObj.Write()
collections.volumeMutex.Unlock()
if err != nil {
log.Errorf("Error saving volume %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7919 | FindVolume | train | func FindVolume(key string) *Volume {
collections.volumeMutex.Lock()
defer collections.volumeMutex.Unlock()
obj := collections.volumes[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7920 | DeleteVolume | train | func DeleteVolume(key string) error {
collections.volumeMutex.Lock()
obj := collections.volumes[key]
collections.volumeMutex.Unlock()
if obj == nil {
log.Errorf("volume %s not found", key)
return errors.New("volume not found")
}
// Check if we handle this object
if objCallbackHandler.VolumeCb == nil {
log.Errorf("No callback registered for volume object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.VolumeCb.VolumeDelete(obj)
if err != nil {
log.Errorf("VolumeDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.volumeMutex.Lock()
err = obj.Delete()
collections.volumeMutex.Unlock()
if err != nil {
log.Errorf("Error deleting volume %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.volumeMutex.Lock()
delete(collections.volumes, key)
collections.volumeMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7921 | ValidateVolume | train | func ValidateVolume(obj *Volume) error {
collections.volumeMutex.Lock()
defer collections.volumeMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.VolumeName
if obj.Key != keyStr {
log.Errorf("Expecting Volume Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
return nil
} | go | {
"resource": ""
} |
q7922 | CreateVolumeProfile | train | func CreateVolumeProfile(obj *VolumeProfile) error {
// Validate parameters
err := ValidateVolumeProfile(obj)
if err != nil {
log.Errorf("ValidateVolumeProfile retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.VolumeProfileCb == nil {
log.Errorf("No callback registered for volumeProfile object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.volumeProfileMutex.Lock()
key := collections.volumeProfiles[obj.Key]
collections.volumeProfileMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.VolumeProfileCb.VolumeProfileUpdate(collections.volumeProfiles[obj.Key], obj)
if err != nil {
log.Errorf("VolumeProfileUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.volumeProfileMutex.Lock()
saveObj = collections.volumeProfiles[obj.Key]
collections.volumeProfileMutex.Unlock()
} else {
// save it in cache
collections.volumeProfileMutex.Lock()
collections.volumeProfiles[obj.Key] = obj
collections.volumeProfileMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.VolumeProfileCb.VolumeProfileCreate(obj)
if err != nil {
log.Errorf("VolumeProfileCreate retruned error for: %+v. Err: %v", obj, err)
collections.volumeProfileMutex.Lock()
delete(collections.volumeProfiles, obj.Key)
collections.volumeProfileMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.volumeProfileMutex.Lock()
err = saveObj.Write()
collections.volumeProfileMutex.Unlock()
if err != nil {
log.Errorf("Error saving volumeProfile %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7923 | FindVolumeProfile | train | func FindVolumeProfile(key string) *VolumeProfile {
collections.volumeProfileMutex.Lock()
defer collections.volumeProfileMutex.Unlock()
obj := collections.volumeProfiles[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7924 | DeleteVolumeProfile | train | func DeleteVolumeProfile(key string) error {
collections.volumeProfileMutex.Lock()
obj := collections.volumeProfiles[key]
collections.volumeProfileMutex.Unlock()
if obj == nil {
log.Errorf("volumeProfile %s not found", key)
return errors.New("volumeProfile not found")
}
// Check if we handle this object
if objCallbackHandler.VolumeProfileCb == nil {
log.Errorf("No callback registered for volumeProfile object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.VolumeProfileCb.VolumeProfileDelete(obj)
if err != nil {
log.Errorf("VolumeProfileDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.volumeProfileMutex.Lock()
err = obj.Delete()
collections.volumeProfileMutex.Unlock()
if err != nil {
log.Errorf("Error deleting volumeProfile %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.volumeProfileMutex.Lock()
delete(collections.volumeProfiles, key)
collections.volumeProfileMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7925 | ValidateVolumeProfile | train | func ValidateVolumeProfile(obj *VolumeProfile) error {
collections.volumeProfileMutex.Lock()
defer collections.volumeProfileMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.VolumeProfileName
if obj.Key != keyStr {
log.Errorf("Expecting VolumeProfile Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
return nil
} | go | {
"resource": ""
} |
q7926 | NewAgent | train | func NewAgent(pluginConfig *plugin.Config) *Agent {
opts := pluginConfig.Instance
netPlugin := &plugin.NetPlugin{}
// init cluster state
err := cluster.Init(pluginConfig.Drivers.State, []string{opts.DbURL})
if err != nil {
log.Fatalf("Error initializing cluster. Err: %v", err)
}
// Init the driver plugins..
err = netPlugin.Init(*pluginConfig)
if err != nil {
log.Fatalf("Failed to initialize the plugin. Error: %s", err)
}
// Initialize appropriate plugin
switch opts.PluginMode {
case core.SwarmMode:
fallthrough
case core.Docker:
dockplugin.InitDockPlugin(netPlugin, opts.PluginMode)
case core.Kubernetes:
k8splugin.InitCNIServer(netPlugin)
case core.Test:
// nothing to do. internal mode for testing
default:
log.Fatalf("Unknown plugin mode -- should be %s | %s | %s",
core.Docker, core.SwarmMode, core.Kubernetes)
}
// init mesos plugin
mesosplugin.InitPlugin(netPlugin)
// create a new agent
agent := &Agent{
netPlugin: netPlugin,
pluginConfig: pluginConfig,
}
return agent
} | go | {
"resource": ""
} |
q7927 | ProcessCurrentState | train | func (ag *Agent) ProcessCurrentState() error {
opts := ag.pluginConfig.Instance
readNet := &mastercfg.CfgNetworkState{}
readNet.StateDriver = ag.netPlugin.StateDriver
netCfgs, err := readNet.ReadAll()
if err == nil {
for idx, netCfg := range netCfgs {
net := netCfg.(*mastercfg.CfgNetworkState)
log.Debugf("read net key[%d] %s, populating state \n", idx, net.ID)
processNetEvent(ag.netPlugin, net, false, opts)
if net.NwType == "infra" {
processInfraNwCreate(ag.netPlugin, net, opts)
}
}
}
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = ag.netPlugin.StateDriver
epCfgs, err := readEp.ReadAll()
if err == nil {
for idx, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
log.Debugf("read ep key[%d] %s, populating state \n", idx, ep.ID)
processEpState(ag.netPlugin, opts, ep.ID)
}
}
readBgp := &mastercfg.CfgBgpState{}
readBgp.StateDriver = ag.netPlugin.StateDriver
bgpCfgs, err := readBgp.ReadAll()
if err == nil {
for idx, bgpCfg := range bgpCfgs {
bgp := bgpCfg.(*mastercfg.CfgBgpState)
log.Debugf("read bgp key[%d] %s, populating state \n", idx, bgp.Hostname)
processBgpEvent(ag.netPlugin, opts, bgp.Hostname, false)
}
}
readEpg := mastercfg.EndpointGroupState{}
readEpg.StateDriver = ag.netPlugin.StateDriver
epgCfgs, err := readEpg.ReadAll()
if err == nil {
for idx, epgCfg := range epgCfgs {
epg := epgCfg.(*mastercfg.EndpointGroupState)
log.Infof("Read epg key[%d] %s, populating state \n", idx, epg.GroupName)
processEpgEvent(ag.netPlugin, opts, epg.ID, false)
}
}
readServiceLb := &mastercfg.CfgServiceLBState{}
readServiceLb.StateDriver = ag.netPlugin.StateDriver
serviceLbCfgs, err := readServiceLb.ReadAll()
if err == nil {
for idx, serviceLbCfg := range serviceLbCfgs {
serviceLb := serviceLbCfg.(*mastercfg.CfgServiceLBState)
log.Debugf("read svc key[%d] %s for tenant %s, populating state \n", idx,
serviceLb.ServiceName, serviceLb.Tenant)
processServiceLBEvent(ag.netPlugin, serviceLb, false)
}
}
readSvcProviders := &mastercfg.SvcProvider{}
readSvcProviders.StateDriver = ag.netPlugin.StateDriver
svcProviders, err := readSvcProviders.ReadAll()
if err == nil {
for idx, providers := range svcProviders {
svcProvider := providers.(*mastercfg.SvcProvider)
log.Infof("read svc provider[%d] %s , populating state \n", idx,
svcProvider.ServiceName)
processSvcProviderUpdEvent(ag.netPlugin, svcProvider, false)
}
}
return nil
} | go | {
"resource": ""
} |
q7928 | PostInit | train | func (ag *Agent) PostInit() error {
opts := ag.pluginConfig.Instance
// Initialize clustering
err := cluster.RunLoop(ag.netPlugin, opts.CtrlIP, opts.VtepIP, opts.HostLabel)
if err != nil {
log.Errorf("Error starting cluster run loop")
}
// start service REST requests
ag.serveRequests()
return nil
} | go | {
"resource": ""
} |
q7929 | HandleEvents | train | func (ag *Agent) HandleEvents() error {
opts := ag.pluginConfig.Instance
recvErr := make(chan error, 1)
go handleNetworkEvents(ag.netPlugin, opts, recvErr)
go handleBgpEvents(ag.netPlugin, opts, recvErr)
go handleEndpointEvents(ag.netPlugin, opts, recvErr)
go handleEpgEvents(ag.netPlugin, opts, recvErr)
go handleServiceLBEvents(ag.netPlugin, opts, recvErr)
go handleSvcProviderUpdEvents(ag.netPlugin, opts, recvErr)
go handleGlobalCfgEvents(ag.netPlugin, opts, recvErr)
go handlePolicyRuleEvents(ag.netPlugin, opts, recvErr)
if ag.pluginConfig.Instance.PluginMode == core.Docker ||
ag.pluginConfig.Instance.PluginMode == core.SwarmMode {
go ag.monitorDockerEvents(recvErr)
} else if ag.pluginConfig.Instance.PluginMode == core.Kubernetes {
// start watching kubernetes events
k8splugin.InitKubServiceWatch(ag.netPlugin)
}
err := <-recvErr
if err != nil {
time.Sleep(1 * time.Second)
log.Errorf("Failure occurred. Error: %s", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7930 | serveRequests | train | func (ag *Agent) serveRequests() {
listenURL := ":9090"
router := mux.NewRouter()
// Add REST routes
s := router.Methods("GET").Subrouter()
s.HandleFunc("/svcstats", func(w http.ResponseWriter, r *http.Request) {
stats, err := ag.netPlugin.GetEndpointStats()
if err != nil {
log.Errorf("Error fetching stats from driver. Err: %v", err)
http.Error(w, "Error fetching stats from driver", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(stats)
})
s.HandleFunc("/inspect/driver", func(w http.ResponseWriter, r *http.Request) {
driverState, err := ag.netPlugin.InspectState()
if err != nil {
log.Errorf("Error fetching driver state. Err: %v", err)
http.Error(w, "Error fetching driver state", http.StatusInternalServerError)
return
}
w.Write(driverState)
})
s.HandleFunc("/inspect/bgp", func(w http.ResponseWriter, r *http.Request) {
bgpState, err := ag.netPlugin.InspectBgp()
if err != nil {
log.Errorf("Error fetching bgp. Err: %v", err)
http.Error(w, "Error fetching bgp", http.StatusInternalServerError)
return
}
w.Write(bgpState)
})
s.HandleFunc("/inspect/nameserver", func(w http.ResponseWriter, r *http.Request) {
ns, err := ag.netPlugin.NetworkDriver.InspectNameserver()
if err != nil {
log.Errorf("Error fetching nameserver state. Err: %v", err)
http.Error(w, "Error fetching nameserver state", http.StatusInternalServerError)
return
}
w.Write(ns)
})
s = router.Methods("Delete").Subrouter()
s.HandleFunc("/debug/reclaimEndpoint/{id}", utils.MakeHTTPHandler(ag.ReclaimEndpointHandler))
// Create HTTP server and listener
server := &http.Server{Handler: router}
listener, err := net.Listen("tcp", listenURL)
if nil != err {
log.Fatalln(err)
}
log.Infof("Netplugin listening on %s", listenURL)
// start server
go server.Serve(listener)
} | go | {
"resource": ""
} |
q7931 | ReclaimEndpointHandler | train | func (ag *Agent) ReclaimEndpointHandler(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
epID := vars["id"]
// delete the endpoint
err := ag.netPlugin.DeleteEndpoint(epID)
if err != nil {
log.Errorf("Error deleting endpoint %v. Err: %v", epID, err)
http.Error(w, fmt.Sprintf("failed to delete endpoint: %+v", epID), 0)
return nil, err
}
return nil, nil
} | go | {
"resource": ""
} |
q7932 | applyConfig | train | func applyConfig(cl *contivClient.ContivClient) error {
data, err := ioutil.ReadFile(configPath())
if err != nil {
return fmt.Errorf("failed to read config file: %v", err)
}
nc := Config{}
if err := json.Unmarshal(data, &nc); err != nil {
return fmt.Errorf("failed to unmarshal JSON: %v", err)
}
// add the token header we use to authenticate
if err := cl.SetAuthToken(nc.Token); err != nil {
return fmt.Errorf("failed to set auth token: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q7933 | configPath | train | func configPath() string {
var homeDir string
// this fails for static binaries
usr, err := user.Current()
if err == nil {
homeDir = usr.HomeDir
}
// this should work where we don't have static binaries
if err != nil {
homeDir = os.Getenv("HOME")
}
// panic if we've failed to retrieve the home directory
if homeDir == "" {
panic(errHomeDirectoryNotSet)
}
return usr.HomeDir + "/.netctl/config.json"
} | go | {
"resource": ""
} |
q7934 | writeConfig | train | func writeConfig(ctx *cli.Context, data []byte) {
dir := filepath.Dir(configPath())
// try to create the netctl config directory but ignore "already exists" errors.
// only the user should be able to read the contents of this directory
if err := os.Mkdir(dir, 0700); err != nil && !os.IsExist(err) {
errExit(ctx, exitIO, err.Error(), false)
}
// only the user should be able to read the config file
if err := ioutil.WriteFile(configPath(), data, 0600); err != nil {
errExit(ctx, exitIO, err.Error(), false)
}
} | go | {
"resource": ""
} |
q7935 | getDockerHost | train | func getDockerHost() string {
dockerHost := os.Getenv("DOCKER_HOST")
if dockerHost == "" {
if runtime.GOOS == "windows" {
// If we do not have a host, default to TCP socket on Windows
dockerHost = fmt.Sprintf("tcp://%s:%d", DefaultHTTPHost, DefaultHTTPPort)
} else {
// If we do not have a host, default to unix socket
dockerHost = fmt.Sprintf("unix://%s", DefaultUnixSocket)
}
}
return dockerHost
} | go | {
"resource": ""
} |
q7936 | AddLbService | train | func (ens *NetpluginNameServer) AddLbService(tenant string, name string, v4name string) {
if len(v4name) > 0 {
dnsLog.Infof("add k8s service %s ip %s", name, v4name)
if tenant == K8sDefaultTenant {
ens.k8sService.Set(name, nameRecord{v4Record: net.ParseIP(v4name)})
} else {
mc := mastercfg.CfgServiceLBState{
Tenant: tenant,
ServiceName: name,
IPAddress: v4name,
}
ens.addService(&mc)
}
}
} | go | {
"resource": ""
} |
q7937 | DelLbService | train | func (ens *NetpluginNameServer) DelLbService(tenant string, name string) {
dnsLog.Infof("delete k8s service %s ", name)
if tenant == K8sDefaultTenant {
ens.k8sService.Remove(name)
} else {
mc := mastercfg.CfgServiceLBState{
Tenant: tenant,
ServiceName: name,
}
ens.delService(&mc)
}
} | go | {
"resource": ""
} |
q7938 | InspectState | train | func (ens *NetpluginNameServer) InspectState() (interface{}, error) {
s := struct {
SvcChan int `json:"serviceQueue"`
EpChan int `json:"endpointQueue"`
Dtbl map[string]map[string]map[string][]string `json:"dnsRecords"`
Stats map[string]map[string]uint64 `json:"stats"`
}{SvcChan: len(ens.svcChan), EpChan: len(ens.epChan),
Dtbl: ens.inspectNameRecord(), Stats: ens.inspectStats()}
return &s, nil
} | go | {
"resource": ""
} |
q7939 | NsLookup | train | func (ens *NetpluginNameServer) NsLookup(nsq []byte, vrfPtr *string) ([]byte, error) {
tenant := *vrfPtr
req := new(dns.Msg)
err := req.Unpack(nsq)
if err != nil {
ens.incTenantStats(tenant, "invalidQuery")
return nil, err
}
// no fancy requests
if req.Response {
ens.incTenantStats(tenant, "invalidQuery")
return nil, errors.New("")
}
if req.IsTsig() != nil {
ens.incTenantStats(tenant, "invalidQuery")
return nil, errors.New("")
}
d, err := ens.serveNameRecord(tenant, req)
if err != nil {
logrus.Infof("no name record: %s", err)
ens.incTenantStats(tenant, "noNameRecord")
return nil, err
}
ens.incTenantStats(tenant, "foundNameRecord")
return d, err
} | go | {
"resource": ""
} |
q7940 | Init | train | func (ens *NetpluginNameServer) Init(sd core.StateDriver) error {
dnsLog = logrus.WithField("module", "nameserver")
ens.bucketSize = 64
ens.stateDriver = sd
// don't change buffering
ens.epChan = make(chan core.WatchState, 64)
ens.epErrChan = make(chan error)
ens.svcChan = make(chan core.WatchState, 8)
ens.svcErrChan = make(chan error)
ens.buckets = make([]tenantBucket, ens.bucketSize)
ens.k8sService = cmap.New()
for i := uint(0); i < ens.bucketSize; i++ {
ens.buckets[i].tenantTables = make(map[string]*dnsTables)
ens.stats.tenantStats = make(map[string]map[string]uint64)
}
ens.epKeyPath = mastercfg.StateConfigPath + "eps/"
ens.svcKeyPath = mastercfg.StateConfigPath + "serviceLB/"
go ens.processStateEvent()
go ens.startSvcWatch()
go ens.startEndpointWatch()
ens.readStateStore()
dnsLog.Infof("nameserver started")
return nil
} | go | {
"resource": ""
} |
q7941 | AddBgp | train | func AddBgp(stateDriver core.StateDriver, bgpCfg *intent.ConfigBgp) error {
log.Infof("Adding bgp neighbor {%v}", bgpCfg)
aci, _ := IsAciConfigured()
if aci {
log.Errorf("Invalid configuration. Not supported in ACI fabric mode.")
return errors.New("not supported in ACI fabric mode")
}
bgpState := &mastercfg.CfgBgpState{}
bgpState.Hostname = bgpCfg.Hostname
bgpState.RouterIP = bgpCfg.RouterIP
bgpState.As = bgpCfg.As
bgpState.NeighborAs = bgpCfg.NeighborAs
bgpState.Neighbor = bgpCfg.Neighbor
bgpState.StateDriver = stateDriver
bgpState.ID = bgpCfg.Hostname
return bgpState.Write()
} | go | {
"resource": ""
} |
q7942 | DeleteBgp | train | func DeleteBgp(stateDriver core.StateDriver, hostname string) error {
log.Infof("Deleting bgp neighbor for {%v}", hostname)
bgpState := &mastercfg.CfgBgpState{}
bgpState.StateDriver = stateDriver
err := bgpState.Read(hostname)
if err != nil {
log.Errorf("Error reading bgp config for hostname %s", hostname)
return err
}
err = bgpState.Clear()
if err != nil {
log.Errorf("Error deleing Bgp config for hostname %s", hostname)
return err
}
return nil
} | go | {
"resource": ""
} |
q7943 | NewLock | train | func (ep *EtcdClient) NewLock(name string, myID string, ttl uint64) (LockInterface, error) {
watchCtx, watchCancel := context.WithCancel(context.Background())
// Create a lock
return &etcdLock{
name: name,
myID: myID,
ttl: time.Duration(ttl) * time.Second,
kapi: ep.kapi,
eventChan: make(chan LockEvent, 1),
stopChan: make(chan bool, 1),
watchCh: make(chan *client.Response, 1),
watchCtx: watchCtx,
watchCancel: watchCancel,
mutex: new(sync.Mutex),
}, nil
} | go | {
"resource": ""
} |
q7944 | waitForLock | train | func (lk *etcdLock) waitForLock() {
// If timeout is not specified, set it to high value
timeoutIntvl := time.Second * time.Duration(20000)
if lk.timeout != 0 {
timeoutIntvl = time.Second * time.Duration(lk.timeout)
}
log.Infof("Waiting to acquire lock (%s/%s)", lk.name, lk.myID)
// Create a timer
timer := time.NewTimer(timeoutIntvl)
defer timer.Stop()
// Wait for changes
for {
// wait on watch channel for holder to release the lock
select {
case <-timer.C:
lk.mutex.Lock()
if lk.timeout != 0 {
lk.mutex.Unlock()
log.Infof("Lock timeout on lock %s/%s", lk.name, lk.myID)
lk.eventChan <- LockEvent{EventType: LockAcquireTimeout}
log.Infof("Lock acquire timed out. Stopping lock")
lk.watchCancel()
// Release the lock
lk.Release()
return
}
lk.mutex.Unlock()
case watchResp := <-lk.watchCh:
if watchResp != nil {
log.Debugf("Received watch notification(%s/%s): %+v", lk.name, lk.myID, watchResp)
if watchResp.Action == "expire" || watchResp.Action == "delete" ||
watchResp.Action == "compareAndDelete" {
log.Infof("Retrying to acquire lock")
return
}
}
case <-lk.stopChan:
log.Infof("Stopping lock")
lk.watchCancel()
return
}
}
} | go | {
"resource": ""
} |
q7945 | watchLock | train | func (lk *etcdLock) watchLock() {
keyName := "/contiv.io/lock/" + lk.name
watcher := lk.kapi.Watcher(keyName, nil)
if watcher == nil {
log.Errorf("Error creating the watcher")
return
}
for {
resp, err := watcher.Next(lk.watchCtx)
if err != nil && (err.Error() == client.ErrClusterUnavailable.Error() ||
strings.Contains(err.Error(), "context canceled")) {
log.Infof("Stopping watch on key %s", keyName)
return
} else if err != nil {
log.Errorf("Error watching the key %s, Err %v.", keyName, err)
} else {
log.Debugf("Got Watch Resp: %+v", resp)
// send the event to watch channel
lk.watchCh <- resp
}
lk.mutex.Lock()
// If the lock is released, we are done
if lk.isReleased {
lk.mutex.Unlock()
return
}
lk.mutex.Unlock()
}
} | go | {
"resource": ""
} |
q7946 | initHelper | train | func initHelper(driverRegistry map[string]driverConfigTypes, driverName string) (core.Driver, error) {
if _, ok := driverRegistry[driverName]; ok {
driverType := driverRegistry[driverName].DriverType
driver := reflect.New(driverType).Interface()
return driver, nil
}
return nil, core.Errorf("Failed to find a registered driver for: %s", driverName)
} | go | {
"resource": ""
} |
q7947 | NewStateDriver | train | func NewStateDriver(name string, instInfo *core.InstanceInfo) (core.StateDriver, error) {
if name == "" || instInfo == nil {
return nil, core.Errorf("invalid driver name or configuration passed.")
}
if gStateDriver != nil {
return nil, core.Errorf("statedriver instance already exists.")
}
driver, err := initHelper(stateDriverRegistry, name)
if err != nil {
return nil, err
}
d := driver.(core.StateDriver)
err = d.Init(instInfo)
if err != nil {
return nil, err
}
gStateDriver = d
return d, nil
} | go | {
"resource": ""
} |
q7948 | GetStateDriver | train | func GetStateDriver() (core.StateDriver, error) {
if gStateDriver == nil {
return nil, core.Errorf("statedriver has not been not created.")
}
return gStateDriver, nil
} | go | {
"resource": ""
} |
q7949 | NewNetworkDriver | train | func NewNetworkDriver(name string, instInfo *core.InstanceInfo) (core.NetworkDriver, error) {
if name == "" || instInfo == nil {
return nil, core.Errorf("invalid driver name or configuration passed.")
}
driver, err := initHelper(networkDriverRegistry, name)
if err != nil {
return nil, err
}
d := driver.(core.NetworkDriver)
err = d.Init(instInfo)
if err != nil {
return nil, err
}
return d, nil
} | go | {
"resource": ""
} |
q7950 | BuildNetworkFlags | train | func BuildNetworkFlags(binary string) []cli.Flag {
binUpper := strings.ToUpper(binary)
binLower := strings.ToLower(binary)
return []cli.Flag{
cli.StringFlag{
Name: "mode, plugin-mode, cluster-mode",
EnvVar: fmt.Sprintf("CONTIV_%s_MODE", binUpper),
Usage: fmt.Sprintf("set %s mode, options: [docker, kubernetes, swarm-mode]", binLower),
},
cli.StringFlag{
Name: "netmode, network-mode",
EnvVar: fmt.Sprintf("CONTIV_%s_NET_MODE", binUpper),
Usage: fmt.Sprintf("set %s network mode, options: [vlan, vxlan]", binLower),
},
cli.StringFlag{
Name: "fwdmode, forward-mode",
EnvVar: fmt.Sprintf("CONTIV_%s_FORWARD_MODE", binUpper),
Usage: fmt.Sprintf("set %s forwarding network mode, options: [bridge, routing]", binLower),
},
/*
// only ovs is supported
// TODO: turn it on when having more than one backend supported
cli.StringFlag {
Name: "driver, net-driver",
Value: "ovs",
EnvVar: "CONTIV_NETPLUGIN_DRIVER",
Usage: "set netplugin key-value store url, options: [ovs, vpp]",
}
*/
}
} | go | {
"resource": ""
} |
q7951 | BuildLogFlags | train | func BuildLogFlags(binary string) []cli.Flag {
binUpper := strings.ToUpper(binary)
binLower := strings.ToLower(binary)
return []cli.Flag{
cli.StringFlag{
Name: "log-level",
Value: "INFO",
EnvVar: fmt.Sprintf("CONTIV_%s_LOG_LEVEL", binUpper),
Usage: fmt.Sprintf("set %s log level, options: [DEBUG, INFO, WARN, ERROR]", binLower),
},
cli.BoolFlag{
Name: "use-json-log, json-log",
EnvVar: fmt.Sprintf("CONTIV_%s_USE_JSON_LOG", binUpper),
Usage: fmt.Sprintf("set %s log format to json if this flag is provided", binLower),
},
cli.BoolFlag{
Name: "use-syslog, syslog",
EnvVar: fmt.Sprintf("CONTIV_%s_USE_SYSLOG", binUpper),
Usage: fmt.Sprintf("set %s send log to syslog if this flag is provided", binLower),
},
cli.StringFlag{
Name: "syslog-url",
Value: "udp://127.0.0.1:514",
EnvVar: fmt.Sprintf("CONTIV_%s_SYSLOG_URL", binUpper),
Usage: fmt.Sprintf("set %s syslog url in format protocol://ip:port", binLower),
},
}
} | go | {
"resource": ""
} |
q7952 | InitLogging | train | func InitLogging(binary string, ctx *cli.Context) error {
logLevel, err := logrus.ParseLevel(ctx.String("log-level"))
if err != nil {
return err
}
logrus.SetLevel(logLevel)
logrus.Infof("Using %v log level: %v", binary, logLevel)
if ctx.Bool("use-syslog") {
syslogURL := ctx.String("syslog-url")
if err := configureSyslog(binary, logLevel, syslogURL); err != nil {
return err
}
logrus.Infof("Using %v syslog config: %v", binary, syslogURL)
} else {
logrus.Infof("Using %v syslog config: nil", binary)
}
if ctx.Bool("use-json-log") {
logrus.SetFormatter(&logrus.JSONFormatter{})
logrus.Infof("Using %v log format: json", binary)
} else {
logrus.SetFormatter(&logrus.TextFormatter{FullTimestamp: true, TimestampFormat: time.StampNano})
logrus.Infof("Using %v log format: text", binary)
}
return nil
} | go | {
"resource": ""
} |
q7953 | ValidateDBOptions | train | func ValidateDBOptions(binary string, ctx *cli.Context) (*DBConfigs, error) {
var storeDriver string
var storeURL string
var storeURLs string
etcdURLs := ctx.String("etcd")
consulURLs := ctx.String("consul")
if etcdURLs != "" && consulURLs != "" {
return nil, fmt.Errorf("ambiguous %s db endpoints, both etcd and consul specified: etcd: %s, consul: %s", binary, etcdURLs, consulURLs)
} else if etcdURLs == "" && consulURLs == "" {
// if neither etcd or consul is set, try etcd at http://127.0.0.1:2379
storeDriver = "etcd"
storeURLs = "http://127.0.0.1:2379"
} else if etcdURLs != "" {
storeDriver = "etcd"
storeURLs = etcdURLs
} else {
storeDriver = "consul"
storeURLs = consulURLs
}
for _, endpoint := range FilterEmpty(strings.Split(storeURLs, ",")) {
_, err := url.Parse(endpoint)
if err != nil {
return nil, fmt.Errorf("invalid %s %v endpoint: %v", binary, storeDriver, endpoint)
}
// TODO: support multi-endpoints
storeURL = endpoint
logrus.Infof("Using %s state db endpoints: %v: %v", binary, storeDriver, storeURL)
break
}
if storeURL == "" {
return nil, fmt.Errorf("invalid %s %s endpoints: empty", binary, storeDriver)
}
return &DBConfigs{
StoreDriver: storeDriver,
StoreURL: storeURL,
}, nil
} | go | {
"resource": ""
} |
q7954 | ValidateNetworkOptions | train | func ValidateNetworkOptions(binary string, ctx *cli.Context) (*NetworkConfigs, error) {
// 1. validate and set plugin mode
pluginMode := strings.ToLower(ctx.String("mode"))
switch pluginMode {
case core.Docker, core.Kubernetes, core.SwarmMode, core.Test:
logrus.Infof("Using %s mode: %v", binary, pluginMode)
case "":
return nil, fmt.Errorf("%s mode is not set", binary)
default:
return nil, fmt.Errorf("unknown %s mode: %v", binary, pluginMode)
}
// 2. validate and set network mode
networkMode := strings.ToLower(ctx.String("netmode"))
switch networkMode {
case "vlan", "vxlan":
logrus.Infof("Using %s network mode: %v", binary, networkMode)
case "":
return nil, fmt.Errorf("%s network mode is not set", binary)
default:
return nil, fmt.Errorf("unknown %s network mode: %v", binary, networkMode)
}
// 3. validate forwarding mode
forwardMode := strings.ToLower(ctx.String("fwdmode"))
if forwardMode == "" {
return nil, fmt.Errorf("unknown %s forwarding mode: %v", binary, forwardMode)
} else if forwardMode != "bridge" && forwardMode != "routing" {
return nil, fmt.Errorf("%s forwarding mode is not set", binary)
} else if networkMode == "vxlan" && forwardMode == "bridge" {
return nil, fmt.Errorf("invalid %s forwarding mode: %q (network mode: %q)", binary, forwardMode, networkMode)
}
// vxlan/vlan+routing, vlan+bridge are valid combinations
logrus.Infof("Using %s forwarding mode: %v", binary, forwardMode)
return &NetworkConfigs{
Mode: pluginMode,
NetworkMode: networkMode,
ForwardMode: forwardMode,
}, nil
} | go | {
"resource": ""
} |
q7955 | FlattenFlags | train | func FlattenFlags(flagSlices ...[]cli.Flag) []cli.Flag {
var flags []cli.Flag
for _, slice := range flagSlices {
flags = append(flags, slice...)
}
return flags
} | go | {
"resource": ""
} |
q7956 | FilterEmpty | train | func FilterEmpty(stringSlice []string) []string {
var result []string
for _, str := range stringSlice {
if str != "" {
result = append(result, str)
}
}
return result
} | go | {
"resource": ""
} |
q7957 | FetchSysAttrs | train | func FetchSysAttrs() error {
output, err := ioutil.ReadFile("/etc/os-release")
if err != nil {
log.Errorf("Error reading the /etc/os-release Error: %s Output: \n%s\n", err, output)
return err
}
strOutput := string(output)
if strings.Contains(strOutput, "CentOS") {
SysAttrs.OsType = "centos"
} else if strings.Contains(strOutput, "Ubuntu") {
SysAttrs.OsType = "ubuntu"
} else {
SysAttrs.OsType = "unsupported"
}
// fetch the system memory, disk, and other attributes
return err
} | go | {
"resource": ""
} |
q7958 | NewNodeProxy | train | func NewNodeProxy() (*NodeSvcProxy, error) {
ipTablesPath, err := osexec.LookPath("iptables")
if err != nil {
return nil, err
}
// Install contiv chain and jump
out, err := osexec.Command(ipTablesPath, "-w", iptablesWaitLock,
"-t", "nat", "-N", contivNPChain).CombinedOutput()
if err != nil {
if !strings.Contains(string(out), "Chain already exists") {
log.Errorf("Failed to setup contiv nodeport chain %v out: %s",
err, out)
return nil, err
}
}
_, err = osexec.Command(ipTablesPath, "-w", iptablesWaitLock, "-t", "nat",
"-C", "PREROUTING", "-m", "addrtype", "--dst-type", "LOCAL", "-j",
contivNPChain).CombinedOutput()
if err != nil {
out, err = osexec.Command(ipTablesPath, "-w", iptablesWaitLock,
"-t", "nat", "-I", "PREROUTING", "-m", "addrtype", "--dst-type",
"LOCAL", "-j", contivNPChain).CombinedOutput()
if err != nil {
log.Errorf("Failed to setup contiv nodeport chain jump %v out: %s",
err, out)
return nil, err
}
}
// Flush any old rules we might have added. They will get re-added
// if the service is still active
osexec.Command(ipTablesPath, "-w", iptablesWaitLock, "-t", "nat", "-F",
contivNPChain).CombinedOutput()
proxy := NodeSvcProxy{}
proxy.SvcMap = make(map[string]core.ServiceSpec)
proxy.ProvMap = make(map[string]Presence)
proxy.LocalIP = make(map[string]string)
proxy.ipTablesPath = ipTablesPath
proxy.natRules = make(map[string][]string)
return &proxy, nil
} | go | {
"resource": ""
} |
q7959 | DeleteLocalIP | train | func (p *NodeSvcProxy) DeleteLocalIP(globalIP string) {
// strip cidr
globalIP = strings.Split(globalIP, "/")[0]
p.Mutex.Lock()
defer p.Mutex.Unlock()
delete(p.LocalIP, globalIP)
} | go | {
"resource": ""
} |
q7960 | AddLocalIP | train | func (p *NodeSvcProxy) AddLocalIP(globalIP, localIP string) {
// strip cidr
globalIP = strings.Split(globalIP, "/")[0]
localIP = strings.Split(localIP, "/")[0]
p.Mutex.Lock()
defer p.Mutex.Unlock()
p.LocalIP[globalIP] = localIP
} | go | {
"resource": ""
} |
q7961 | AddSvcSpec | train | func (p *NodeSvcProxy) AddSvcSpec(svcName string, spec *core.ServiceSpec) error {
p.Mutex.Lock()
defer p.Mutex.Unlock()
log.Infof("Node proxy AddSvcSpec: %s", svcName)
// Determine if this is a node service
isNodeSvc := false
for _, port := range spec.Ports {
if port.NodePort != 0 && port.Protocol == "TCP" {
isNodeSvc = true
if p.detectClash(svcName, port.NodePort) {
return nil
}
}
}
if !isNodeSvc {
p.deleteSvc(svcName) // delete it if it exists
return nil
}
p.SvcMap[svcName] = *spec
p.syncSvc(svcName)
return nil
} | go | {
"resource": ""
} |
q7962 | DelSvcSpec | train | func (p *NodeSvcProxy) DelSvcSpec(svcName string, spec *core.ServiceSpec) error {
p.Mutex.Lock()
defer p.Mutex.Unlock()
p.deleteSvc(svcName) // delete it if it exists
return nil
} | go | {
"resource": ""
} |
q7963 | readLoginCredentials | train | func readLoginCredentials(ctx *cli.Context) (string, string) {
fmt.Print("Username: ")
reader := bufio.NewReader(os.Stdin)
username, err := reader.ReadString('\n')
if err != nil {
errExit(ctx, exitIO, err.Error(), false)
}
username = strings.TrimSpace(username) // ReadString includes the newline
if len(username) == 0 {
errExit(ctx, exitInvalid, "you must specify a username", false)
}
fmt.Print("Password: ")
// use terminal.ReadPassword() so there's no echoing of what's typed
bytePassword, err := terminal.ReadPassword(0) // fd 0 = stdin
if err != nil {
errExit(ctx, exitIO, err.Error(), false)
}
password := string(bytePassword)
fmt.Println("")
return username, password
} | go | {
"resource": ""
} |
q7964 | addBgp | train | func addBgp(ctx *cli.Context) {
if len(ctx.Args()) < 1 {
errExit(ctx, exitHelp, "Host name required", true)
}
hostname := ctx.Args()[0]
routerip := ctx.String("router-ip")
asid := ctx.String("as")
neighboras := ctx.String("neighbor-as")
neighbor := ctx.String("neighbor")
//Error checks
_, _, err := net.ParseCIDR(routerip)
if err != nil {
errExit(ctx, exitHelp, "Wrong CIDR format. Enter in x.x.x.x/len format", true)
}
ip := net.ParseIP(neighbor)
if ip == nil {
errExit(ctx, exitHelp, "Wrong IP format. Enter in x.x.x.x format", true)
}
if routerip == "" || asid == "" || neighbor == "" || neighboras == "" {
errExit(ctx, exitHelp, "Missing attributes", true)
}
errCheck(ctx, getClient(ctx).BgpPost(&contivClient.Bgp{
As: asid,
Hostname: hostname,
Neighbor: neighbor,
NeighborAs: neighboras,
Routerip: routerip,
}))
} | go | {
"resource": ""
} |
q7965 | deleteBgp | train | func deleteBgp(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
errExit(ctx, exitHelp, "Host name required", true)
}
hostname := ctx.Args()[0]
fmt.Printf("Deleting Bgp router config: %s\n", hostname)
errCheck(ctx, getClient(ctx).BgpDelete(hostname))
} | go | {
"resource": ""
} |
q7966 | listBgp | train | func listBgp(ctx *cli.Context) {
if len(ctx.Args()) != 0 {
errExit(ctx, exitHelp, "More arguments than required", true)
}
bgpList, err := getClient(ctx).BgpList()
errCheck(ctx, err)
if ctx.Bool("json") {
dumpJSONList(ctx, bgpList)
} else if ctx.Bool("quite") {
bgpName := ""
for _, bgp := range *bgpList {
bgpName += bgp.Hostname + "\n"
}
os.Stdout.WriteString(bgpName)
} else {
writer := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
defer writer.Flush()
writer.Write([]byte("HostName\tRouterIP\tAS\tNeighbor\tNeighborAS\n"))
writer.Write([]byte("---------\t--------\t-------\t--------\t-------\n"))
for _, group := range *bgpList {
writer.Write(
[]byte(fmt.Sprintf("%v\t%v\t%v\t%v\t%v\n",
group.Hostname,
group.Routerip,
group.As,
group.Neighbor,
group.NeighborAs,
)))
}
}
} | go | {
"resource": ""
} |
q7967 | createServiceLB | train | func createServiceLB(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
errExit(ctx, exitHelp, "Service name required", true)
}
serviceName := ctx.Args()[0]
serviceSubnet := ctx.String("network")
tenantName := ctx.String("tenant")
if len(tenantName) == 0 {
tenantName = "default"
}
selectors := ctx.StringSlice("selector")
ports := ctx.StringSlice("port")
ipAddress := ctx.String("preferred-ip")
service := &contivClient.ServiceLB{
ServiceName: serviceName,
TenantName: tenantName,
NetworkName: serviceSubnet,
IpAddress: ipAddress,
}
service.Selectors = append(service.Selectors, selectors...)
service.Ports = append(service.Ports, ports...)
errCheck(ctx, getClient(ctx).ServiceLBPost(service))
fmt.Printf("Creating ServiceLB %s:%s\n", tenantName, serviceName)
} | go | {
"resource": ""
} |
q7968 | deleteServiceLB | train | func deleteServiceLB(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
errExit(ctx, exitHelp, "Service name required", true)
}
serviceName := ctx.Args()[0]
tenantName := ctx.String("tenant")
if len(tenantName) == 0 {
tenantName = "default"
}
fmt.Printf("Deleting Service %s,%s\n", serviceName, tenantName)
errCheck(ctx, getClient(ctx).ServiceLBDelete(tenantName, serviceName))
} | go | {
"resource": ""
} |
q7969 | listServiceLB | train | func listServiceLB(ctx *cli.Context) {
tenantName := ctx.String("tenant")
if len(tenantName) == 0 {
tenantName = "default"
}
_, err := getClient(ctx).TenantGet(tenantName)
errCheck(ctx, err)
svcList, err := getClient(ctx).ServiceLBList()
errCheck(ctx, err)
filtered := []*contivClient.ServiceLB{}
if ctx.Bool("all") {
filtered = *svcList
} else {
for _, svc := range *svcList {
if svc.TenantName == tenantName {
filtered = append(filtered, svc)
}
}
}
if ctx.Bool("json") {
dumpJSONList(ctx, filtered)
} else if ctx.Bool("quiet") {
services := ""
for _, service := range filtered {
services += service.ServiceName + "\n"
}
os.Stdout.WriteString(services)
} else {
writer := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
defer writer.Flush()
writer.Write([]byte("ServiceName\tTenant\tNetwork\tSelectors\n"))
writer.Write([]byte("---------\t--------\t-------\t-------\n"))
for _, group := range filtered {
writer.Write(
[]byte(fmt.Sprintf("%v\t%v\t%v\t%v\t\n",
group.ServiceName,
group.TenantName,
group.NetworkName,
group.Selectors,
)))
}
}
} | go | {
"resource": ""
} |
q7970 | GetService | train | func (cp *ConsulClient) GetService(srvName string) ([]ServiceInfo, error) {
keyName := "contiv.io/service/" + srvName + "/"
srvList, _, err := cp.getServiceInstances(keyName, 0)
return srvList, err
} | go | {
"resource": ""
} |
q7971 | WatchService | train | func (cp *ConsulClient) WatchService(srvName string, eventCh chan WatchServiceEvent, stopCh chan bool) error {
keyName := "contiv.io/service/" + srvName + "/"
// Run in background
go func() {
var currSrvMap = make(map[string]ServiceInfo)
// Get current list of services
srvList, lastIdx, err := cp.getServiceInstances(keyName, 0)
if err != nil {
log.Errorf("Error getting service instances for (%s): Err: %v", srvName, err)
} else {
// for each instance trigger an add event
for _, srvInfo := range srvList {
eventCh <- WatchServiceEvent{
EventType: WatchServiceEventAdd,
ServiceInfo: srvInfo,
}
// Add the service to local cache
srvKey := srvInfo.HostAddr + ":" + strconv.Itoa(srvInfo.Port)
currSrvMap[srvKey] = srvInfo
}
}
// Loop till asked to stop
for {
// Check if we should quit
select {
case <-stopCh:
return
default:
// Read the service instances
srvList, lastIdx, err = cp.getServiceInstances(keyName, lastIdx)
if err != nil {
if api.IsServerError(err) || strings.Contains(err.Error(), "EOF") || strings.Contains(err.Error(), "connection refused") {
log.Warnf("Consul service watch: server error: %v Retrying..", err)
} else {
log.Errorf("Error getting service instances for (%s): Err: %v. Exiting watch", srvName, err)
}
// Wait a little and continue
time.Sleep(5 * time.Second)
continue
} else {
log.Debugf("Got consul srv list: {%+v}. Curr: {%+v}", srvList, currSrvMap)
var newSrvMap = make(map[string]ServiceInfo)
// Check if there are any new services
for _, srvInfo := range srvList {
srvKey := srvInfo.HostAddr + ":" + strconv.Itoa(srvInfo.Port)
// If the entry didnt exists previously, trigger add event
if _, ok := currSrvMap[srvKey]; !ok {
log.Debugf("Sending add event for srv: %v", srvInfo)
eventCh <- WatchServiceEvent{
EventType: WatchServiceEventAdd,
ServiceInfo: srvInfo,
}
}
// create new service map
newSrvMap[srvKey] = srvInfo
}
// for all entries in old service list, see if we need to delete any
for _, srvInfo := range currSrvMap {
srvKey := srvInfo.HostAddr + ":" + strconv.Itoa(srvInfo.Port)
// if the entry does not exists in new list, delete it
if _, ok := newSrvMap[srvKey]; !ok {
log.Debugf("Sending delete event for srv: %v", srvInfo)
eventCh <- WatchServiceEvent{
EventType: WatchServiceEventDel,
ServiceInfo: srvInfo,
}
}
}
// set new srv map as the current
currSrvMap = newSrvMap
}
}
}
}()
return nil
} | go | {
"resource": ""
} |
q7972 | DeregisterService | train | func (cp *ConsulClient) DeregisterService(serviceInfo ServiceInfo) error {
keyName := "contiv.io/service/" + serviceInfo.ServiceName + "/" +
serviceInfo.HostAddr + ":" + strconv.Itoa(serviceInfo.Port)
// Find it in the database
srvState := cp.serviceDb[keyName]
if srvState == nil {
log.Errorf("Could not find the service in db %s", keyName)
return errors.New("Service not found")
}
log.Infof("Deregistering service key: %s, value: %+v", keyName, serviceInfo)
// stop the refresh thread and delete service
close(srvState.stopChan)
delete(cp.serviceDb, keyName)
// Delete the service instance
_, err := cp.client.KV().Delete(keyName, nil)
if err != nil {
log.Errorf("Error deleting key %s. Err: %v", keyName, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7973 | getServiceInstances | train | func (cp *ConsulClient) getServiceInstances(key string, waitIdx uint64) ([]ServiceInfo, uint64, error) {
var srvcList []ServiceInfo
// Get the object from consul client
kvs, meta, err := cp.client.KV().List(key, &api.QueryOptions{WaitIndex: waitIdx})
if err != nil {
log.Errorf("Error getting key %s. Err: %v", key, err)
return nil, 0, err
}
// Consul returns success and a nil kv when a key is not found,
// translate it to 'Key not found' error
if kvs == nil {
return []ServiceInfo{}, meta.LastIndex, nil
}
// Parse each node in the directory
for _, kv := range kvs {
var respSrvc ServiceInfo
// Parse JSON response
err = json.Unmarshal([]byte(kv.Value), &respSrvc)
if err != nil {
log.Errorf("Error parsing object %+v, Err %v", kv, err)
return nil, 0, err
}
srvcList = append(srvcList, respSrvc)
}
return srvcList, meta.LastIndex, nil
} | go | {
"resource": ""
} |
q7974 | DeleteEndpointGroup | train | func DeleteEndpointGroup(tenantName, groupName string) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
epgKey := mastercfg.GetEndpointGroupKey(groupName, tenantName)
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
err = epgCfg.Read(epgKey)
if err != nil {
log.Errorf("error reading EPG key %s. Error: %s", epgKey, err)
return err
}
if epgCfg.EpCount != 0 {
return core.Errorf("Error: EPG %s has active endpoints", groupName)
}
networkID := epgCfg.NetworkName + "." + epgCfg.TenantName
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
err = nwCfg.Read(networkID)
if err != nil {
log.Errorf("Could not find network %s. Err: %v", networkID, err)
return err
}
// Delete the endpoint group state
gstate.GlobalMutex.Lock()
defer gstate.GlobalMutex.Unlock()
gCfg := gstate.Cfg{}
gCfg.StateDriver = stateDriver
err = gCfg.Read(epgCfg.TenantName)
if err != nil {
log.Errorf("error reading tenant cfg state. Error: %s", err)
return err
}
// if aci mode we allocate per-epg vlan. free it here.
aciMode, aErr := IsAciConfigured()
if aErr != nil {
return aErr
}
if aciMode {
if epgCfg.PktTagType == "vlan" {
err = gCfg.FreeVLAN(uint(epgCfg.PktTag))
if err != nil {
return err
}
log.Debugf("Freed vlan %v\n", epgCfg.PktTag)
}
}
// mark it as unused
if len(epgCfg.IPPool) > 0 {
netutils.ClearIPAddrRange(&nwCfg.IPAllocMap, epgCfg.IPPool, nwCfg.SubnetIP, nwCfg.SubnetLen)
if err = nwCfg.Write(); err != nil {
log.Errorf("error writing nw config after releasing subnet. Error: %v", err)
return err
}
}
// Delete endpoint group
err = epgCfg.Clear()
if err != nil {
log.Errorf("error writing epGroup config. Error: %v", err)
return err
}
if GetClusterMode() == core.Docker {
return docknet.DeleteDockNet(epgCfg.TenantName, epgCfg.NetworkName, epgCfg.GroupName)
}
return nil
} | go | {
"resource": ""
} |
q7975 | UpdateEndpointGroup | train | func UpdateEndpointGroup(bandwidth, groupName, tenantName string, Dscp, burst int) error {
// Get the state driver - get the etcd driver state
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
key := mastercfg.GetEndpointGroupKey(groupName, tenantName)
if key == "" {
return errors.New("error finding endpointGroup key ")
}
// Read etcd driver
epCfg := mastercfg.EndpointGroupState{}
epCfg.StateDriver = stateDriver
err = epCfg.Read(key)
if err != nil {
log.Errorf("Error finding endpointgroup %s. Err: %v", key, err)
return err
}
//update the epGroup state
epCfg.DSCP = Dscp
epCfg.Bandwidth = bandwidth
epCfg.Burst = burst
//Write to etcd
return epCfg.Write()
} | go | {
"resource": ""
} |
q7976 | SvcProviderUpdate | train | func SvcProviderUpdate(serviceID string, isDelete bool) error {
providerList := []string{}
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
svcProvider := &mastercfg.SvcProvider{}
svcProvider.StateDriver = stateDriver
if _, present := mastercfg.ServiceLBDb[serviceID]; !present {
svcProvider.ID = serviceID
return svcProvider.Clear()
}
for _, provider := range mastercfg.ServiceLBDb[serviceID].Providers {
providerList = append(providerList, provider.IPAddress)
}
//empty the current provider list
svcProvider.Providers = nil
//update to the latest provider list
svcProvider.Providers = append(svcProvider.Providers, providerList...)
svcProvider.ServiceName = serviceID
svcProvider.ID = serviceID
log.Infof("Updating service providers with {%v} on service %s", svcProvider.Providers, serviceID)
return svcProvider.Write()
} | go | {
"resource": ""
} |
q7977 | ErrIfKeyExists | train | func ErrIfKeyExists(err error) error {
if err == nil || strings.Contains(err.Error(), "key not found") {
return nil
}
return err
} | go | {
"resource": ""
} |
q7978 | ReadAll | train | func (r *AutoVLANCfgResource) ReadAll() ([]core.State, error) {
return r.StateDriver.ReadAllState(vLANResourceConfigPathPrefix, r,
json.Unmarshal)
} | go | {
"resource": ""
} |
q7979 | Allocate | train | func (r *AutoVLANCfgResource) Allocate(reqVal interface{}) (interface{}, error) {
oper := &AutoVLANOperResource{}
oper.StateDriver = r.StateDriver
err := oper.Read(r.ID)
if err != nil {
return nil, err
}
var vlan uint
if (reqVal != nil) && (reqVal.(uint) != 0) {
vlan = reqVal.(uint)
if !oper.FreeVLANs.Test(vlan) {
return nil, fmt.Errorf("requested vlan not available - vlan:%d", vlan)
}
} else {
ok := false
vlan, ok = oper.FreeVLANs.NextSet(0)
if !ok {
return nil, errors.New("no vlans available")
}
}
oper.FreeVLANs.Clear(vlan)
err = oper.Write()
if err != nil {
return nil, err
}
return vlan, nil
} | go | {
"resource": ""
} |
q7980 | Deallocate | train | func (r *AutoVLANCfgResource) Deallocate(value interface{}) error {
oper := &AutoVLANOperResource{}
oper.StateDriver = r.StateDriver
err := oper.Read(r.ID)
if err != nil {
return err
}
vlan, ok := value.(uint)
if !ok {
return core.Errorf("Invalid type for vlan value")
}
if oper.FreeVLANs.Test(vlan) {
return nil
}
oper.FreeVLANs.Set(vlan)
return oper.Write()
} | go | {
"resource": ""
} |
q7981 | ReadAll | train | func (r *AutoVLANOperResource) ReadAll() ([]core.State, error) {
return r.StateDriver.ReadAllState(vLANResourceOperPathPrefix, r,
json.Unmarshal)
} | go | {
"resource": ""
} |
q7982 | DeleteHostAccPort | train | func (d *OvsDriver) DeleteHostAccPort(id string) error {
sw, found := d.switchDb["host"]
if found {
operEp := &drivers.OperEndpointState{}
operEp.StateDriver = d.oper.StateDriver
err := operEp.Read(id)
if err != nil {
return err
}
d.HostProxy.DeleteLocalIP(operEp.IPAddress)
portName := operEp.PortName
intfName := netutils.GetHostIntfName(portName)
return sw.DelHostPort(intfName, false)
}
return errors.New("host bridge not found")
} | go | {
"resource": ""
} |
q7983 | CreateHostAccPort | train | func (d *OvsDriver) CreateHostAccPort(portName, globalIP string, net int) (string, error) {
sw, found := d.switchDb["host"]
if found {
num := strings.Replace(portName, "hport", "", 1)
intfNum, err := strconv.Atoi(num)
if err != nil {
return "", err
}
hostIP, err := sw.AddHostPort(portName, intfNum, net, false)
if err == nil {
d.HostProxy.AddLocalIP(globalIP, hostIP)
return hostIP, nil
}
}
return "", errors.New("host bridge not found")
} | go | {
"resource": ""
} |
q7984 | Deinit | train | func (d *OvsDriver) Deinit() {
log.Infof("Cleaning up ovsdriver")
// cleanup both vlan and vxlan OVS instances
if d.switchDb["vlan"] != nil {
d.switchDb["vlan"].RemoveUplinks()
d.switchDb["vlan"].Delete()
}
if d.switchDb["vxlan"] != nil {
d.switchDb["vxlan"].DelHostPort(hostPortName, true)
d.switchDb["vxlan"].Delete()
}
} | go | {
"resource": ""
} |
q7985 | CreateNetwork | train | func (d *OvsDriver) CreateNetwork(id string) error {
cfgNw := mastercfg.CfgNetworkState{}
cfgNw.StateDriver = d.oper.StateDriver
err := cfgNw.Read(id)
if err != nil {
log.Errorf("Failed to read net %s \n", cfgNw.ID)
return err
}
log.Infof("create net %+v \n", cfgNw)
// Find the switch based on network type
var sw *OvsSwitch
if cfgNw.PktTagType == "vxlan" {
sw = d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
return sw.CreateNetwork(uint16(cfgNw.PktTag), uint32(cfgNw.ExtPktTag), cfgNw.Gateway, cfgNw.Tenant)
} | go | {
"resource": ""
} |
q7986 | DeleteNetwork | train | func (d *OvsDriver) DeleteNetwork(id, subnet, nwType, encap string, pktTag, extPktTag int, gateway string, tenant string) error {
log.Infof("delete net %s, nwType %s, encap %s, tags: %d/%d", id, nwType, encap, pktTag, extPktTag)
// Find the switch based on network type
var sw *OvsSwitch
if encap == "vxlan" {
sw = d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
// Delete infra nw endpoint if present
if nwType == "infra" {
hostName, _ := os.Hostname()
epID := id + "-" + hostName
epOper := drivers.OperEndpointState{}
epOper.StateDriver = d.oper.StateDriver
err := epOper.Read(epID)
if err == nil {
err = sw.DeletePort(&epOper, true)
if err != nil {
log.Errorf("Error deleting endpoint: %+v. Err: %v", epOper, err)
}
epOper.Clear()
}
}
return sw.DeleteNetwork(uint16(pktTag), uint32(extPktTag), gateway, tenant)
} | go | {
"resource": ""
} |
q7987 | UpdateEndpointGroup | train | func (d *OvsDriver) UpdateEndpointGroup(id string) error {
log.Infof("Received endpoint group update for %s", id)
var (
err error
epgBandwidth int64
sw *OvsSwitch
)
//gets the EndpointGroupState object
cfgEpGroup := &mastercfg.EndpointGroupState{}
cfgEpGroup.StateDriver = d.oper.StateDriver
err = cfgEpGroup.Read(id)
if err != nil {
return err
}
if cfgEpGroup.ID != "" {
if cfgEpGroup.Bandwidth != "" {
epgBandwidth = netutils.ConvertBandwidth(cfgEpGroup.Bandwidth)
}
d.oper.localEpInfoMutex.Lock()
defer d.oper.localEpInfoMutex.Unlock()
for _, epInfo := range d.oper.LocalEpInfo {
if epInfo.EpgKey == id {
log.Debugf("Applying bandwidth: %s on: %s ", cfgEpGroup.Bandwidth, epInfo.Ovsportname)
// Find the switch based on network type
if epInfo.BridgeType == "vxlan" {
sw = d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
// update the endpoint in ovs switch
err = sw.UpdateEndpoint(epInfo.Ovsportname, cfgEpGroup.Burst, cfgEpGroup.DSCP, epgBandwidth)
if err != nil {
log.Errorf("Error adding bandwidth %v , err: %+v", epgBandwidth, err)
return err
}
}
}
}
return err
} | go | {
"resource": ""
} |
q7988 | DeleteEndpoint | train | func (d *OvsDriver) DeleteEndpoint(id string) error {
epOper := drivers.OperEndpointState{}
epOper.StateDriver = d.oper.StateDriver
err := epOper.Read(id)
if err != nil {
return err
}
defer func() {
epOper.Clear()
}()
// Get the network state
cfgNw := mastercfg.CfgNetworkState{}
cfgNw.StateDriver = d.oper.StateDriver
err = cfgNw.Read(epOper.NetID)
if err != nil {
return err
}
// Find the switch based on network type
var sw *OvsSwitch
if cfgNw.PktTagType == "vxlan" {
sw = d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
skipVethPair := (cfgNw.NwType == "infra")
err = sw.DeletePort(&epOper, skipVethPair)
if err != nil {
log.Errorf("Error deleting endpoint: %+v. Err: %v", epOper, err)
}
d.oper.localEpInfoMutex.Lock()
delete(d.oper.LocalEpInfo, id)
d.oper.localEpInfoMutex.Unlock()
err = d.oper.Write()
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q7989 | AddPeerHost | train | func (d *OvsDriver) AddPeerHost(node core.ServiceInfo) error {
// Nothing to do if this is our own IP
if node.HostAddr == d.localIP {
return nil
}
log.Infof("CreatePeerHost for %+v", node)
// Add the VTEP for the peer in vxlan switch.
err := d.switchDb["vxlan"].CreateVtep(node.HostAddr)
if err != nil {
log.Errorf("Error adding the VTEP %s. Err: %s", node.HostAddr, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7990 | DeletePeerHost | train | func (d *OvsDriver) DeletePeerHost(node core.ServiceInfo) error {
// Nothing to do if this is our own IP
if node.HostAddr == d.localIP {
return nil
}
log.Infof("DeletePeerHost for %+v", node)
// Remove the VTEP for the peer in vxlan switch.
err := d.switchDb["vxlan"].DeleteVtep(node.HostAddr)
if err != nil {
log.Errorf("Error deleting the VTEP %s. Err: %s", node.HostAddr, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7991 | AddBgp | train | func (d *OvsDriver) AddBgp(id string) error {
var sw *OvsSwitch
cfg := mastercfg.CfgBgpState{}
cfg.StateDriver = d.oper.StateDriver
err := cfg.Read(id)
if err != nil {
log.Errorf("Failed to read router state %s \n", cfg.Hostname)
return err
}
log.Infof("Create Bgp :%+v", cfg)
// Find the switch based on network type
sw = d.switchDb["vlan"]
return sw.AddBgp(cfg.Hostname, cfg.RouterIP, cfg.As, cfg.NeighborAs, cfg.Neighbor)
} | go | {
"resource": ""
} |
q7992 | DeleteBgp | train | func (d *OvsDriver) DeleteBgp(id string) error {
log.Infof("Delete Bgp Neighbor %s \n", id)
//FixME: We are not maintaining oper state for Bgp
//Need to Revisit again
// Find the switch based on network type
var sw *OvsSwitch
sw = d.switchDb["vlan"]
return sw.DeleteBgp()
} | go | {
"resource": ""
} |
q7993 | convSvcSpec | train | func convSvcSpec(spec *core.ServiceSpec) *ofnet.ServiceSpec {
pSpec := make([]ofnet.PortSpec, len(spec.Ports))
for ix, p := range spec.Ports {
pSpec[ix].Protocol = p.Protocol
pSpec[ix].SvcPort = p.SvcPort
pSpec[ix].ProvPort = p.ProvPort
}
ofnetSS := ofnet.ServiceSpec{
IpAddress: spec.IPAddress,
Ports: pSpec,
}
return &ofnetSS
} | go | {
"resource": ""
} |
q7994 | AddSvcSpec | train | func (d *OvsDriver) AddSvcSpec(svcName string, spec *core.ServiceSpec) error {
log.Infof("AddSvcSpec: %s", svcName)
ss := convSvcSpec(spec)
errs := ""
for _, sw := range d.switchDb {
log.Infof("sw AddSvcSpec: %s", svcName)
err := sw.AddSvcSpec(svcName, ss)
if err != nil {
errs += err.Error()
}
}
err := d.HostProxy.AddSvcSpec(svcName, spec)
if err != nil {
errs += err.Error()
}
if errs != "" {
return errors.New(errs)
}
d.nameServer.AddLbService(nameserver.K8sDefaultTenant, svcName, spec.IPAddress)
return nil
} | go | {
"resource": ""
} |
q7995 | DelSvcSpec | train | func (d *OvsDriver) DelSvcSpec(svcName string, spec *core.ServiceSpec) error {
ss := convSvcSpec(spec)
errs := ""
for _, sw := range d.switchDb {
err := sw.DelSvcSpec(svcName, ss)
if err != nil {
errs += err.Error()
}
}
err := d.HostProxy.DelSvcSpec(svcName, spec)
if err != nil {
errs += err.Error()
}
if errs != "" {
return errors.New(errs)
}
d.nameServer.DelLbService(nameserver.K8sDefaultTenant, svcName)
return nil
} | go | {
"resource": ""
} |
q7996 | GetEndpointStats | train | func (d *OvsDriver) GetEndpointStats() ([]byte, error) {
vxlanStats, err := d.switchDb["vxlan"].GetEndpointStats()
if err != nil {
log.Errorf("Error getting vxlan stats. Err: %v", err)
return []byte{}, err
}
vlanStats, err := d.switchDb["vlan"].GetEndpointStats()
if err != nil {
log.Errorf("Error getting vlan stats. Err: %v", err)
return []byte{}, err
}
// combine the maps
for key, val := range vxlanStats {
vlanStats[key] = val
}
jsonStats, err := json.Marshal(vlanStats)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return jsonStats, err
}
return jsonStats, nil
} | go | {
"resource": ""
} |
q7997 | InspectState | train | func (d *OvsDriver) InspectState() ([]byte, error) {
driverState := make(map[string]interface{})
// get vlan switch state
vlanState, err := d.switchDb["vlan"].InspectState()
if err != nil {
return []byte{}, err
}
// get vxlan switch state
vxlanState, err := d.switchDb["vxlan"].InspectState()
if err != nil {
return []byte{}, err
}
// build the map
driverState["vlan"] = vlanState
driverState["vxlan"] = vxlanState
// json marshall the map
jsonState, err := json.Marshal(driverState)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return []byte{}, err
}
return jsonState, nil
} | go | {
"resource": ""
} |
q7998 | InspectBgp | train | func (d *OvsDriver) InspectBgp() ([]byte, error) {
// get vlan switch state
bgpState, err := d.switchDb["vlan"].InspectBgp()
if err != nil {
return []byte{}, err
}
// json marshall the map
jsonState, err := json.Marshal(bgpState)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return []byte{}, err
}
return jsonState, nil
} | go | {
"resource": ""
} |
q7999 | GlobalConfigUpdate | train | func (d *OvsDriver) GlobalConfigUpdate(inst core.InstanceInfo) error {
// convert the netplugin config to ofnet config
// currently, its only ArpMode
var cfg ofnet.OfnetGlobalConfig
switch inst.ArpMode {
case "flood":
cfg.ArpMode = ofnet.ArpFlood
default:
// set the default to proxy for graceful upgrade
cfg.ArpMode = ofnet.ArpProxy
}
errs := ""
for _, sw := range d.switchDb {
err := sw.GlobalConfigUpdate(cfg)
if err != nil {
errs += err.Error()
}
}
if errs != "" {
return errors.New(errs)
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.