_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q8200 | NetworkGetOper | train | func (ac *APIController) NetworkGetOper(network *contivModel.NetworkInspect) error {
log.Infof("Received NetworkInspect: %+v", network)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
networkID := network.Config.NetworkName + "." + network.Config.TenantName
if err := nwCfg.Read(networkID); err != nil {
log.Errorf("Error fetching network from mastercfg: %s", networkID)
return err
}
network.Oper.AllocatedAddressesCount = nwCfg.EpAddrCount
network.Oper.AvailableIPAddresses = master.ListAvailableIPs(nwCfg)
network.Oper.AllocatedIPAddresses = master.ListAllocatedIPs(nwCfg)
network.Oper.ExternalPktTag = nwCfg.ExtPktTag
network.Oper.NumEndpoints = nwCfg.EpCount
network.Oper.PktTag = nwCfg.PktTag
network.Oper.NetworkTag = nwCfg.NetworkTag
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = stateDriver
epCfgs, err := readEp.ReadAll()
if err == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
if ep.NetID == networkID {
epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
epOper.MacAddress = ep.MacAddress
epOper.HomingHost = ep.HomingHost
epOper.IntfName = ep.IntfName
epOper.VtepIP = ep.VtepIP
epOper.Labels = fmt.Sprintf("%s", ep.Labels)
epOper.ContainerID = ep.ContainerID
epOper.ContainerName = ep.EPCommonName
network.Oper.Endpoints = append(network.Oper.Endpoints, epOper)
}
}
}
return nil
} | go | {
"resource": ""
} |
q8201 | NetworkUpdate | train | func (ac *APIController) NetworkUpdate(network, params *contivModel.Network) error {
log.Infof("Received NetworkUpdate: %+v, params: %+v", network, params)
return core.Errorf("Cant change network parameters after its created")
} | go | {
"resource": ""
} |
q8202 | NetworkDelete | train | func (ac *APIController) NetworkDelete(network *contivModel.Network) error {
log.Infof("Received NetworkDelete: %+v", network)
// Find the tenant
tenant := contivModel.FindTenant(network.TenantName)
if tenant == nil {
return core.Errorf("Tenant not found")
}
// if the network has associated epgs, fail the delete
epgCount := len(network.LinkSets.EndpointGroups)
if epgCount != 0 {
return core.Errorf("cannot delete %s has %d endpoint groups",
network.NetworkName, epgCount)
}
svcCount := len(network.LinkSets.Servicelbs)
if svcCount != 0 {
return core.Errorf("cannot delete %s has %d services ",
network.NetworkName, svcCount)
}
// In swarm-mode work-flow, if this is mapped to a docker network, reject delete
if master.GetClusterMode() == core.SwarmMode {
docknet, err := docknet.GetDocknetState(network.TenantName, network.NetworkName, "")
if err == nil {
return fmt.Errorf("cannot delete network %s mapped to docker network %s",
network.NetworkName, docknet.DocknetUUID)
}
if !strings.Contains(strings.ToLower(err.Error()), "key not found") {
log.Errorf("Error getting docknet state for %s.%s. (retval = %s)",
network.TenantName, network.NetworkName, err.Error())
return err
}
log.Infof("No docknet state for %s.%s. (retval = %s)",
network.TenantName, network.NetworkName, err.Error())
}
// Remove link
modeldb.RemoveLinkSet(&tenant.LinkSets.Networks, network)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Delete the network
networkID := network.NetworkName + "." + network.TenantName
err = master.DeleteNetworkID(stateDriver, networkID)
if err != nil {
log.Errorf("Error deleting network %s. Err: %v", network.NetworkName, err)
return err
}
// Save the tenant too since we removed the links
return tenant.Write()
} | go | {
"resource": ""
} |
q8203 | NetprofileCreate | train | func (ac *APIController) NetprofileCreate(netProfile *contivModel.Netprofile) error {
log.Infof("Received NetprofileCreate: %+v", netProfile)
// Check if the tenant exists
if netProfile.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
if netProfile.Burst > 0 && netProfile.Burst < 2 {
return core.Errorf("Invalid Burst size. burst size > 1500 bytes")
}
tenant := contivModel.FindTenant(netProfile.TenantName)
if tenant == nil {
return core.Errorf("Tenant not found")
}
// Setup links & Linksets.
modeldb.AddLink(&netProfile.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.NetProfiles, netProfile)
// Save the tenant in etcd - This writes to etcd.
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8204 | NetprofileUpdate | train | func (ac *APIController) NetprofileUpdate(profile, params *contivModel.Netprofile) error {
log.Infof("Received NetprofileUpdate: %+v, params: %+v", profile, params)
if params.Burst > 0 && params.Burst < 2 {
return core.Errorf("Invalid Burst size. burst size must be > 1500 bytes")
}
profile.Bandwidth = params.Bandwidth
profile.DSCP = params.DSCP
profile.Burst = params.Burst
for key := range profile.LinkSets.EndpointGroups {
// Find the corresponding epg
epg := contivModel.FindEndpointGroup(key)
if epg == nil {
return core.Errorf("EndpointGroups not found")
}
err := master.UpdateEndpointGroup(params.Bandwidth, epg.GroupName, epg.TenantName, params.DSCP, params.Burst)
if err != nil {
log.Errorf("Error updating the EndpointGroups: %s. Err: %v", epg.GroupName, err)
}
}
return nil
} | go | {
"resource": ""
} |
q8205 | NetprofileDelete | train | func (ac *APIController) NetprofileDelete(netProfile *contivModel.Netprofile) error {
log.Infof("Deleting Netprofile:%s", netProfile.ProfileName)
// Find Tenant
tenant := contivModel.FindTenant(netProfile.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", netProfile.TenantName)
}
// Check if any endpoint group is using the network policy
if len(netProfile.LinkSets.EndpointGroups) != 0 {
return core.Errorf("NetProfile is being used")
}
modeldb.RemoveLinkSet(&tenant.LinkSets.NetProfiles, netProfile)
return nil
} | go | {
"resource": ""
} |
q8206 | PolicyCreate | train | func (ac *APIController) PolicyCreate(policy *contivModel.Policy) error {
log.Infof("Received PolicyCreate: %+v", policy)
// Make sure tenant exists
if policy.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
tenant := contivModel.FindTenant(policy.TenantName)
if tenant == nil {
return core.Errorf("Tenant not found")
}
// Setup links
modeldb.AddLink(&policy.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.Policies, policy)
// Save the tenant too since we added the links
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8207 | PolicyGetOper | train | func (ac *APIController) PolicyGetOper(policy *contivModel.PolicyInspect) error {
log.Infof("Received PolicyInspect: %+v", policy)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// To hold total number of Endpoint count
var policyEPCount int
policyCfg := &mastercfg.EpgPolicy{}
policyCfg.StateDriver = stateDriver
// Policy is attached to EPG. So we need to fetch EPGs as well.
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
// Get all the Endpoints
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = stateDriver
epCfgs, epErr := readEp.ReadAll()
// Get all the EPGs on which this policy is applied
epgs := policy.Config.LinkSets.EndpointGroups
// Scan all the EPGs which are under this policy
for _, epg := range epgs {
log.Infof("EPG Object : %+v", epg)
// Reversing key from TenantName:EPGName to EPGName:TenantName
sList := strings.Split(epg.ObjKey, ":")
if sList == nil {
log.Errorf("EPG key %+v is not in valid format", epg.ObjKey)
return err
}
epgID := sList[1] + ":" + sList[0]
log.Infof("EPG ID : %s", epgID)
if err := epgCfg.Read(epgID); err != nil {
log.Errorf("Error fetching endpointGroup from mastercfg: %s", epgID)
return err
}
policyEPCount = policyEPCount + epgCfg.EpCount
if epErr == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
if ep.EndpointGroupKey == epgID {
epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
epOper.MacAddress = ep.MacAddress
epOper.HomingHost = ep.HomingHost
epOper.IntfName = ep.IntfName
epOper.VtepIP = ep.VtepIP
epOper.Labels = fmt.Sprintf("%s", ep.Labels)
epOper.ContainerID = ep.ContainerID
epOper.ContainerName = ep.EPCommonName
policy.Oper.Endpoints = append(policy.Oper.Endpoints, epOper)
}
}
}
} // End of main for loop
policy.Oper.NumEndpoints = policyEPCount
return nil
} | go | {
"resource": ""
} |
q8208 | PolicyUpdate | train | func (ac *APIController) PolicyUpdate(policy, params *contivModel.Policy) error {
log.Infof("Received PolicyUpdate: %+v, params: %+v", policy, params)
return nil
} | go | {
"resource": ""
} |
q8209 | PolicyDelete | train | func (ac *APIController) PolicyDelete(policy *contivModel.Policy) error {
log.Infof("Received PolicyDelete: %+v", policy)
// Find Tenant
tenant := contivModel.FindTenant(policy.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", policy.TenantName)
}
// Check if any endpoint group is using the Policy
if len(policy.LinkSets.EndpointGroups) != 0 {
return core.Errorf("Policy is being used")
}
// Delete all associated Rules
for key := range policy.LinkSets.Rules {
// delete the rule
err := contivModel.DeleteRule(key)
if err != nil {
log.Errorf("Error deleting the rule: %s. Err: %v", key, err)
}
}
//Remove Links
modeldb.RemoveLinkSet(&tenant.LinkSets.Policies, policy)
// Save the tenant too since we added the links
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8210 | RuleUpdate | train | func (ac *APIController) RuleUpdate(rule, params *contivModel.Rule) error {
log.Infof("Received RuleUpdate: %+v, params: %+v", rule, params)
return errors.New("can not update a rule after its created")
} | go | {
"resource": ""
} |
q8211 | RuleDelete | train | func (ac *APIController) RuleDelete(rule *contivModel.Rule) error {
var epg *contivModel.EndpointGroup
epg = nil
log.Infof("Received RuleDelete: %+v", rule)
policyKey := GetpolicyKey(rule.TenantName, rule.PolicyName)
// find the policy
policy := contivModel.FindPolicy(policyKey)
if policy == nil {
log.Errorf("Error finding policy %s", policyKey)
return core.Errorf("Policy not found")
}
// unlink the rule from policy
modeldb.RemoveLinkSet(&policy.LinkSets.Rules, rule)
err := policy.Write()
if err != nil {
return err
}
// unlink the rule from matching epg
epgKey := rule.Links.MatchEndpointGroup.ObjKey
if epgKey != "" {
epg = contivModel.FindEndpointGroup(epgKey)
if epg != nil {
modeldb.RemoveLinkSet(&epg.LinkSets.MatchRules, rule)
}
}
// Trigger policyDB Update
err = master.PolicyDelRule(policy, rule)
if err != nil {
log.Errorf("Error deleting rule %s to policy %s. Err: %v", rule.Key, policy.Key, err)
return err
}
// Update any affected app profiles
pMap := getAffectedProfs(policy, epg)
syncAppProfile(pMap)
return nil
} | go | {
"resource": ""
} |
q8212 | TenantCreate | train | func (ac *APIController) TenantCreate(tenant *contivModel.Tenant) error {
log.Infof("Received TenantCreate: %+v", tenant)
if tenant.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build tenant config
tenantCfg := intent.ConfigTenant{
Name: tenant.TenantName,
DefaultNetwork: tenant.DefaultNetwork,
}
// Create the tenant
err = master.CreateTenant(stateDriver, &tenantCfg)
if err != nil {
log.Errorf("Error creating tenant {%+v}. Err: %v", tenant, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8213 | getTenantNetworks | train | func getTenantNetworks(tenant *contivModel.TenantInspect) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
tenantID := tenant.Config.TenantName
numEPs := 0
s := []string{}
networkID := ""
for _, net := range tenant.Config.LinkSets.Networks {
networkID = net.ObjKey
log.Infof("network has ID %s", networkID)
s = strings.Split(networkID, ":")
if s[0] == tenantID {
networkID = s[1] + "." + s[0]
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
if err := nwCfg.Read(networkID); err != nil {
log.Errorf("Error fetching network from mastercfg: %s", networkID)
return err
}
numEPs = numEPs + nwCfg.EpCount
netOper := contivModel.NetworkOper{}
netOper.AllocatedAddressesCount = nwCfg.EpAddrCount
netOper.AvailableIPAddresses = master.ListAvailableIPs(nwCfg)
netOper.AllocatedIPAddresses = master.ListAllocatedIPs(nwCfg)
netOper.ExternalPktTag = nwCfg.ExtPktTag
netOper.PktTag = nwCfg.PktTag
netOper.NumEndpoints = nwCfg.EpCount
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = stateDriver
epCfgs, err := readEp.ReadAll()
if err == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
if ep.NetID == networkID {
epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
epOper.MacAddress = ep.MacAddress
epOper.HomingHost = ep.HomingHost
epOper.IntfName = ep.IntfName
epOper.VtepIP = ep.VtepIP
epOper.Labels = fmt.Sprintf("%s", ep.Labels)
epOper.ContainerID = ep.ContainerID
epOper.ContainerName = ep.EPCommonName
netOper.Endpoints = append(netOper.Endpoints, epOper)
}
}
}
tenant.Oper.Networks = append(tenant.Oper.Networks, netOper)
}
}
tenant.Oper.TotalEndpoints = numEPs
return nil
} | go | {
"resource": ""
} |
q8214 | getTenantEPGs | train | func getTenantEPGs(tenant *contivModel.TenantInspect) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
tenantID := tenant.Config.TenantName
s := []string{}
epgID := ""
for _, epg := range tenant.Config.LinkSets.EndpointGroups {
epgID = epg.ObjKey
log.Infof("EPG ID is %s", epgID)
s = strings.Split(epgID, ":")
if s[0] == tenantID {
epgID = s[1] + ":" + s[0]
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
if err := epgCfg.Read(epgID); err != nil {
log.Errorf("Error fetching epg from mastercfg: %s", epgID)
return err
}
epgOper := contivModel.EndpointGroupOper{}
epgOper.ExternalPktTag = epgCfg.ExtPktTag
epgOper.PktTag = epgCfg.PktTag
epgOper.NumEndpoints = epgCfg.EpCount
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = stateDriver
epCfgs, err := readEp.ReadAll()
if err == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
log.Infof("EndpointGroupKey is %s", ep.EndpointGroupKey)
if ep.EndpointGroupKey == epgID {
epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
epOper.MacAddress = ep.MacAddress
epOper.HomingHost = ep.HomingHost
epOper.IntfName = ep.IntfName
epOper.VtepIP = ep.VtepIP
epOper.Labels = fmt.Sprintf("%s", ep.Labels)
epOper.ContainerID = ep.ContainerID
epOper.ContainerName = ep.EPCommonName
epgOper.Endpoints = append(epgOper.Endpoints, epOper)
}
}
}
tenant.Oper.EndpointGroups = append(tenant.Oper.EndpointGroups, epgOper)
}
}
return nil
} | go | {
"resource": ""
} |
q8215 | TenantGetOper | train | func (ac *APIController) TenantGetOper(tenant *contivModel.TenantInspect) error {
log.Infof("Received TenantInspect: %+v", tenant)
tenant.Oper.TotalNetworks = len(tenant.Config.LinkSets.Networks)
tenant.Oper.TotalEPGs = len(tenant.Config.LinkSets.EndpointGroups)
tenant.Oper.TotalNetprofiles = len(tenant.Config.LinkSets.NetProfiles)
tenant.Oper.TotalPolicies = len(tenant.Config.LinkSets.Policies)
tenant.Oper.TotalAppProfiles = len(tenant.Config.LinkSets.AppProfiles)
tenant.Oper.TotalServicelbs = len(tenant.Config.LinkSets.Servicelbs)
//Get all the networks config and oper parmeters under this tenant
getTenantNetworks(tenant)
//Get all the EPGs config and oper parmeters under this tenant
getTenantEPGs(tenant)
return nil
} | go | {
"resource": ""
} |
q8216 | TenantUpdate | train | func (ac *APIController) TenantUpdate(tenant, params *contivModel.Tenant) error {
log.Infof("Received TenantUpdate: %+v, params: %+v", tenant, params)
return core.Errorf("Cant change tenant parameters after its created")
} | go | {
"resource": ""
} |
q8217 | TenantDelete | train | func (ac *APIController) TenantDelete(tenant *contivModel.Tenant) error {
log.Infof("Received TenantDelete: %+v", tenant)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// if the tenant has associated app profiles, fail the delete
profCount := len(tenant.LinkSets.AppProfiles)
if profCount != 0 {
return core.Errorf("cannot delete %s, has %d app profiles",
tenant.TenantName, profCount)
}
// if the tenant has associated epgs, fail the delete
epgCount := len(tenant.LinkSets.EndpointGroups)
if epgCount != 0 {
return core.Errorf("cannot delete %s has %d endpoint groups",
tenant.TenantName, epgCount)
}
// if the tenant has associated policies, fail the delete
policyCount := len(tenant.LinkSets.Policies)
if policyCount != 0 {
return core.Errorf("cannot delete %s has %d policies",
tenant.TenantName, policyCount)
}
npCount := len(tenant.LinkSets.NetProfiles)
if npCount != 0 {
return core.Errorf("Cannot delete %s has %d netprofiles", tenant.TenantName, npCount)
}
// if the tenant has associated networks, fail the delete
nwCount := len(tenant.LinkSets.Networks)
if nwCount != 0 {
return core.Errorf("cannot delete %s has %d networks",
tenant.TenantName, nwCount)
}
// Build tenant config
tenantCfg := intent.ConfigTenant{
Name: tenant.TenantName,
DefaultNetwork: tenant.DefaultNetwork,
}
// Delete the tenant
err = master.DeleteTenant(stateDriver, &tenantCfg)
if err != nil {
log.Errorf("Error deleting tenant %s. Err: %v", tenant.TenantName, err)
}
return nil
} | go | {
"resource": ""
} |
q8218 | BgpCreate | train | func (ac *APIController) BgpCreate(bgpCfg *contivModel.Bgp) error {
log.Infof("Received BgpCreate: %+v", bgpCfg)
if bgpCfg.Hostname == "" {
return core.Errorf("Invalid host name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build bgp config
bgpIntentCfg := intent.ConfigBgp{
Hostname: bgpCfg.Hostname,
RouterIP: bgpCfg.Routerip,
As: bgpCfg.As,
NeighborAs: bgpCfg.NeighborAs,
Neighbor: bgpCfg.Neighbor,
}
// Add the Bgp neighbor
err = master.AddBgp(stateDriver, &bgpIntentCfg)
if err != nil {
log.Errorf("Error creating Bgp neighbor {%+v}. Err: %v", bgpCfg.Neighbor, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8219 | BgpDelete | train | func (ac *APIController) BgpDelete(bgpCfg *contivModel.Bgp) error {
log.Infof("Received delete for Bgp config on {%+v} ", bgpCfg.Hostname)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
err = master.DeleteBgp(stateDriver, bgpCfg.Hostname)
if err != nil {
log.Errorf("Error Deleting Bgp neighbor. Err: %v", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8220 | BgpUpdate | train | func (ac *APIController) BgpUpdate(oldbgpCfg *contivModel.Bgp, NewbgpCfg *contivModel.Bgp) error {
log.Infof("Received BgpUpdate: %+v", NewbgpCfg)
if NewbgpCfg.Hostname == "" {
return core.Errorf("Invalid host name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build bgp config
bgpIntentCfg := intent.ConfigBgp{
Hostname: NewbgpCfg.Hostname,
RouterIP: NewbgpCfg.Routerip,
As: NewbgpCfg.As,
NeighborAs: NewbgpCfg.NeighborAs,
Neighbor: NewbgpCfg.Neighbor,
}
// Add the Bgp neighbor
err = master.AddBgp(stateDriver, &bgpIntentCfg)
if err != nil {
log.Errorf("Error creating Bgp neighbor {%+v}. Err: %v", NewbgpCfg.Neighbor, err)
return err
}
oldbgpCfg.Hostname = NewbgpCfg.Hostname
oldbgpCfg.Routerip = NewbgpCfg.Routerip
oldbgpCfg.As = NewbgpCfg.As
oldbgpCfg.NeighborAs = NewbgpCfg.NeighborAs
oldbgpCfg.Neighbor = NewbgpCfg.Neighbor
NewbgpCfg.Write()
return nil
} | go | {
"resource": ""
} |
q8221 | BgpGetOper | train | func (ac *APIController) BgpGetOper(bgp *contivModel.BgpInspect) error {
var obj BgpInspect
var host string
srvList, err := ac.objdbClient.GetService("netplugin")
if err != nil {
log.Errorf("Error getting netplugin nodes. Err: %v", err)
return err
}
for _, srv := range srvList {
if srv.Hostname == bgp.Config.Hostname {
host = srv.HostAddr
}
}
url := "http://" + host + ":9090/inspect/bgp"
r, err := http.Get(url)
if err != nil {
return err
}
defer r.Body.Close()
switch {
case r.StatusCode == int(404):
return errors.New("page not found")
case r.StatusCode == int(403):
return errors.New("access denied")
case r.StatusCode == int(500):
response, err := ioutil.ReadAll(r.Body)
if err != nil {
return err
}
return errors.New(string(response))
case r.StatusCode != int(200):
log.Debugf("GET Status '%s' status code %d \n", r.Status, r.StatusCode)
return errors.New(r.Status)
}
response, err := ioutil.ReadAll(r.Body)
if err != nil {
return err
}
if err := json.Unmarshal(response, &obj); err != nil {
return err
}
//Assuming bgp peer state will be only for one neighbor
if obj.Peers != nil {
nConf := obj.Peers[0]
bgp.Oper.NeighborStatus = string(nConf.State.SessionState)
bgp.Oper.AdminStatus = nConf.State.AdminState
}
if obj.Dsts != nil {
for _, dst := range obj.Dsts {
bgp.Oper.Routes = append(bgp.Oper.Routes, dst)
}
bgp.Oper.NumRoutes = len(bgp.Oper.Routes)
}
return nil
} | go | {
"resource": ""
} |
q8222 | ServiceLBCreate | train | func (ac *APIController) ServiceLBCreate(serviceCfg *contivModel.ServiceLB) error {
log.Infof("Received Service Load Balancer create: %+v", serviceCfg)
if serviceCfg.ServiceName == "" {
return core.Errorf("Invalid service name")
}
if len(serviceCfg.Selectors) == 0 {
return core.Errorf("Invalid selector options")
}
if !validatePorts(serviceCfg.Ports) {
return core.Errorf("Invalid Port maping . Port format is - Port:TargetPort:Protocol")
}
if serviceCfg.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
tenant := contivModel.FindTenant(serviceCfg.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", serviceCfg.TenantName)
}
network := contivModel.FindNetwork(serviceCfg.TenantName + ":" + serviceCfg.NetworkName)
if network == nil {
return core.Errorf("Network %s not found", serviceCfg.NetworkName)
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build service config
serviceIntentCfg := intent.ConfigServiceLB{
ServiceName: serviceCfg.ServiceName,
Tenant: serviceCfg.TenantName,
Network: serviceCfg.NetworkName,
IPAddress: serviceCfg.IpAddress,
}
serviceIntentCfg.Ports = append(serviceIntentCfg.Ports, serviceCfg.Ports...)
serviceIntentCfg.Selectors = make(map[string]string)
for _, selector := range serviceCfg.Selectors {
if validateSelectors(selector) {
key := strings.Split(selector, "=")[0]
value := strings.Split(selector, "=")[1]
serviceIntentCfg.Selectors[key] = value
} else {
return core.Errorf("Invalid selector %s. selector format is key1=value1", selector)
}
}
// Add the service object
err = master.CreateServiceLB(stateDriver, &serviceIntentCfg)
if err != nil {
log.Errorf("Error creating service {%+v}. Err: %v", serviceIntentCfg.ServiceName, err)
return err
}
// Setup links
if tenant != nil {
modeldb.AddLink(&serviceCfg.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.Servicelbs, serviceCfg)
tenant.Write()
}
// Setup links
if network != nil {
modeldb.AddLink(&serviceCfg.Links.Network, network)
modeldb.AddLinkSet(&network.LinkSets.Servicelbs, serviceCfg)
network.Write()
}
return nil
} | go | {
"resource": ""
} |
q8223 | ServiceLBUpdate | train | func (ac *APIController) ServiceLBUpdate(oldServiceCfg *contivModel.ServiceLB, serviceCfg *contivModel.ServiceLB) error {
log.Infof("Received Service Load Balancer update: %+v", serviceCfg)
err := ac.ServiceLBCreate(serviceCfg)
if err != nil {
return err
}
oldServiceCfg.ServiceName = serviceCfg.ServiceName
oldServiceCfg.TenantName = serviceCfg.TenantName
oldServiceCfg.NetworkName = serviceCfg.NetworkName
oldServiceCfg.IpAddress = serviceCfg.IpAddress
oldServiceCfg.Selectors = nil
oldServiceCfg.Ports = nil
oldServiceCfg.Selectors = append(oldServiceCfg.Selectors, serviceCfg.Selectors...)
oldServiceCfg.Ports = append(oldServiceCfg.Ports, serviceCfg.Ports...)
return nil
} | go | {
"resource": ""
} |
q8224 | ServiceLBDelete | train | func (ac *APIController) ServiceLBDelete(serviceCfg *contivModel.ServiceLB) error {
log.Info("Received Service Load Balancer delete : {%+v}", serviceCfg)
if serviceCfg.ServiceName == "" {
return core.Errorf("Invalid service name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Add the service object
err = master.DeleteServiceLB(stateDriver, serviceCfg.ServiceName, serviceCfg.TenantName)
if err != nil {
log.Errorf("Error deleting Service Load Balancer object {%+v}. Err: %v", serviceCfg.ServiceName, err)
return err
}
// Find the tenant
tenant := contivModel.FindTenant(serviceCfg.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", serviceCfg.TenantName)
}
modeldb.RemoveLinkSet(&tenant.LinkSets.Servicelbs, serviceCfg)
tenant.Write()
nwKey := serviceCfg.TenantName + ":" + serviceCfg.NetworkName
network := contivModel.FindNetwork(nwKey)
if network == nil {
return core.Errorf("Network %s not found in tenant %s", serviceCfg.NetworkName, serviceCfg.TenantName)
}
modeldb.RemoveLinkSet(&network.LinkSets.Servicelbs, serviceCfg)
network.Write()
return nil
} | go | {
"resource": ""
} |
q8225 | ServiceLBGetOper | train | func (ac *APIController) ServiceLBGetOper(serviceLB *contivModel.ServiceLBInspect) error {
log.Infof("Received Service load balancer inspect : %+v", serviceLB)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
serviceID := master.GetServiceID(serviceLB.Config.ServiceName, serviceLB.Config.TenantName)
service := mastercfg.ServiceLBDb[serviceID]
if service == nil {
return errors.New("invalid Service name. Oper state does not exist")
}
serviceLB.Oper.ServiceVip = service.IPAddress
count := 0
for _, provider := range service.Providers {
epCfg := &mastercfg.CfgEndpointState{}
epCfg.StateDriver = stateDriver
err := epCfg.Read(provider.EpIDKey)
if err != nil {
continue
}
epOper := contivModel.EndpointOper{}
epOper.Network = epCfg.NetID
epOper.EndpointID = epCfg.EndpointID
epOper.ServiceName = service.ServiceName //FIXME:fill in service name in endpoint
epOper.EndpointGroupID = epCfg.EndpointGroupID
epOper.EndpointGroupKey = epCfg.EndpointGroupKey
epOper.IpAddress = []string{epCfg.IPAddress, epCfg.IPv6Address}
epOper.MacAddress = epCfg.MacAddress
epOper.HomingHost = epCfg.HomingHost
epOper.IntfName = epCfg.IntfName
epOper.VtepIP = epCfg.VtepIP
epOper.Labels = fmt.Sprintf("%s", epCfg.Labels)
epOper.ContainerID = epCfg.ContainerID
epOper.ContainerName = epCfg.EPCommonName
serviceLB.Oper.Providers = append(serviceLB.Oper.Providers, epOper)
count++
epCfg = nil
}
serviceLB.Oper.NumProviders = count
return nil
} | go | {
"resource": ""
} |
q8226 | Init | train | func (p *NetPlugin) Init(pluginConfig Config) error {
var err error
if pluginConfig.Instance.HostLabel == "" {
return core.Errorf("empty host-label passed")
}
// initialize state driver
p.StateDriver, err = utils.GetStateDriver()
if err != nil {
p.StateDriver, err = utils.NewStateDriver(pluginConfig.Drivers.State, &pluginConfig.Instance)
if err != nil {
return err
}
}
defer func() {
if err != nil {
utils.ReleaseStateDriver()
}
}()
// set state driver in instance info
pluginConfig.Instance.StateDriver = p.StateDriver
err = InitGlobalSettings(p.StateDriver, &pluginConfig.Instance)
if err != nil {
return err
}
// initialize network driver
p.NetworkDriver, err = utils.NewNetworkDriver(pluginConfig.Drivers.Network, &pluginConfig.Instance)
if err != nil {
return err
}
p.PluginConfig = pluginConfig
defer func() {
if err != nil {
p.NetworkDriver.Deinit()
}
}()
return nil
} | go | {
"resource": ""
} |
q8227 | Deinit | train | func (p *NetPlugin) Deinit() {
p.Lock()
defer p.Unlock()
if p.NetworkDriver != nil {
p.NetworkDriver.Deinit()
p.NetworkDriver = nil
}
if p.StateDriver != nil {
utils.ReleaseStateDriver()
p.StateDriver = nil
}
} | go | {
"resource": ""
} |
q8228 | DeleteNetwork | train | func (p *NetPlugin) DeleteNetwork(id, subnet, nwType, encap string, pktTag, extPktTag int, Gw string, tenant string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteNetwork(id, subnet, nwType, encap, pktTag, extPktTag, Gw, tenant)
} | go | {
"resource": ""
} |
q8229 | FetchNetwork | train | func (p *NetPlugin) FetchNetwork(id string) (core.State, error) {
return nil, core.Errorf("Not implemented")
} | go | {
"resource": ""
} |
q8230 | CreateHostAccPort | train | func (p *NetPlugin) CreateHostAccPort(portName, globalIP string) (string, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.CreateHostAccPort(portName, globalIP, p.PluginConfig.Instance.HostPvtNW)
} | go | {
"resource": ""
} |
q8231 | DeleteHostAccPort | train | func (p *NetPlugin) DeleteHostAccPort(portName string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteHostAccPort(portName)
} | go | {
"resource": ""
} |
q8232 | DeletePeerHost | train | func (p *NetPlugin) DeletePeerHost(node core.ServiceInfo) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeletePeerHost(node)
} | go | {
"resource": ""
} |
q8233 | AddServiceLB | train | func (p *NetPlugin) AddServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddSvcSpec(servicename, spec)
} | go | {
"resource": ""
} |
q8234 | DeleteServiceLB | train | func (p *NetPlugin) DeleteServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DelSvcSpec(servicename, spec)
} | go | {
"resource": ""
} |
q8235 | GetEndpointStats | train | func (p *NetPlugin) GetEndpointStats() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GetEndpointStats()
} | go | {
"resource": ""
} |
q8236 | InspectState | train | func (p *NetPlugin) InspectState() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectState()
} | go | {
"resource": ""
} |
q8237 | InspectBgp | train | func (p *NetPlugin) InspectBgp() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectBgp()
} | go | {
"resource": ""
} |
q8238 | InspectNameserver | train | func (p *NetPlugin) InspectNameserver() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectNameserver()
} | go | {
"resource": ""
} |
q8239 | GlobalConfigUpdate | train | func (p *NetPlugin) GlobalConfigUpdate(cfg Config) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GlobalConfigUpdate(cfg.Instance)
} | go | {
"resource": ""
} |
q8240 | Reinit | train | func (p *NetPlugin) Reinit(cfg Config) {
var err error
p.Lock()
defer p.Unlock()
if p.NetworkDriver != nil {
logrus.Infof("Reinit de-initializing NetworkDriver")
p.NetworkDriver.Deinit()
p.NetworkDriver = nil
}
cfg.Instance.StateDriver, _ = utils.GetStateDriver()
p.NetworkDriver, err = utils.NewNetworkDriver(cfg.Drivers.Network, &cfg.Instance)
logrus.Infof("Reinit Initializing NetworkDriver")
if err != nil {
logrus.Errorf("Reinit De-initializing due to error: %v", err)
p.NetworkDriver.Deinit()
}
} | go | {
"resource": ""
} |
q8241 | DelSvcSpec | train | func (p *NetPlugin) DelSvcSpec(svcName string, spec *core.ServiceSpec) {
p.Lock()
defer p.Unlock()
p.NetworkDriver.DelSvcSpec(svcName, spec)
} | go | {
"resource": ""
} |
q8242 | AddPolicyRule | train | func (p *NetPlugin) AddPolicyRule(id string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddPolicyRule(id)
} | go | {
"resource": ""
} |
q8243 | InitK8SServiceWatch | train | func InitK8SServiceWatch(listenAddr string, isLeader func() bool) error {
npLog = log.WithField("k8s", "netpolicy")
npLog.Infof("Create contiv client at http://%s", listenAddr)
contivClient, err := client.NewContivClient("http://" + listenAddr)
if err != nil {
npLog.Errorf("failed to create contivclient %s", err)
return err
}
k8sClientSet, err := k8sutils.SetUpK8SClient()
if err != nil {
npLog.Fatalf("failed to init K8S client, %v", err)
return err
}
kubeNet := k8sContext{contivClient: contivClient, k8sClientSet: k8sClientSet, isLeader: isLeader}
go kubeNet.handleK8sEvents()
return nil
} | go | {
"resource": ""
} |
q8244 | MarshalBinary | train | func (p *Point) MarshalBinary() ([]byte, error) {
var buf bytes.Buffer
err := binary.Write(&buf, binary.LittleEndian, p.lat)
if err != nil {
return nil, fmt.Errorf("unable to encode lat %v: %v", p.lat, err)
}
err = binary.Write(&buf, binary.LittleEndian, p.lng)
if err != nil {
return nil, fmt.Errorf("unable to encode lng %v: %v", p.lng, err)
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q8245 | MarshalJSON | train | func (p *Point) MarshalJSON() ([]byte, error) {
res := fmt.Sprintf(`{"lat":%v, "lng":%v}`, p.lat, p.lng)
return []byte(res), nil
} | go | {
"resource": ""
} |
q8246 | UnmarshalJSON | train | func (p *Point) UnmarshalJSON(data []byte) error {
// TODO throw an error if there is an issue parsing the body.
dec := json.NewDecoder(bytes.NewReader(data))
var values map[string]float64
err := dec.Decode(&values)
if err != nil {
log.Print(err)
return err
}
*p = *NewPoint(values["lat"], values["lng"])
return nil
} | go | {
"resource": ""
} |
q8247 | HandleWithSQL | train | func HandleWithSQL() (*SQLMapper, error) {
sqlConf, sqlConfErr := GetSQLConf()
if sqlConfErr == nil {
s := &SQLMapper{conf: sqlConf}
db, err := sql.Open(s.conf.driver, s.conf.openStr)
if err != nil {
panic(err)
}
s.sqlConn = db
return s, err
}
return nil, sqlConfErr
} | go | {
"resource": ""
} |
q8248 | Geocode | train | func (g *OpenCageGeocoder) Geocode(address string) (*Point, error) {
queryStr, err := opencageGeocodeQueryStr(address)
if err != nil {
return nil, err
}
data, err := g.Request(queryStr)
if err != nil {
return nil, err
}
res := &opencageGeocodeResponse{}
json.Unmarshal(data, res)
if len(res.Results) == 0 {
return nil, opencageZeroResultsError
}
lat := res.Results[0].Geometry.Lat
lng := res.Results[0].Geometry.Lng
point := &Point{
lat: lat,
lng: lng,
}
return point, nil
} | go | {
"resource": ""
} |
q8249 | Geocode | train | func (g *MapQuestGeocoder) Geocode(address string) (*Point, error) {
queryStr, err := mapquestGeocodeQueryStr(address)
if err != nil {
return nil, err
}
data, err := g.Request(queryStr)
if err != nil {
return nil, err
}
res := []*mapQuestGeocodeResponse{}
json.Unmarshal(data, &res)
if len(res) == 0 {
return &Point{}, mapquestZeroResultsError
}
lat, err := strconv.ParseFloat(res[0].Lat, 64)
if err != nil {
return nil, err
}
lng, err := strconv.ParseFloat(res[0].Lng, 64)
if err != nil {
return nil, err
}
p := &Point{
lat: lat,
lng: lng,
}
return p, nil
} | go | {
"resource": ""
} |
q8250 | confFromYamlFile | train | func confFromYamlFile(config *yaml.File, goEnv string) (*SQLConf, error) {
// TODO Refactor this into a more generic method of retrieving info
// Get driver
driver, driveError := config.Get(fmt.Sprintf("%s.driver", goEnv))
if driveError != nil {
return nil, driveError
}
// Get openStr
openStr, openStrError := config.Get(fmt.Sprintf("%s.openStr", goEnv))
if openStrError != nil {
return nil, openStrError
}
// Get table
table, tableError := config.Get(fmt.Sprintf("%s.table", goEnv))
if tableError != nil {
return nil, tableError
}
// Get latCol
latCol, latColError := config.Get(fmt.Sprintf("%s.latCol", goEnv))
if latColError != nil {
return nil, latColError
}
// Get lngCol
lngCol, lngColError := config.Get(fmt.Sprintf("%s.lngCol", goEnv))
if lngColError != nil {
return nil, lngColError
}
sqlConf := &SQLConf{driver: driver, openStr: openStr, table: table, latCol: latCol, lngCol: lngCol}
return sqlConf, nil
} | go | {
"resource": ""
} |
q8251 | Contains | train | func (p *Polygon) Contains(point *Point) bool {
if !p.IsClosed() {
return false
}
start := len(p.points) - 1
end := 0
contains := p.intersectsWithRaycast(point, p.points[start], p.points[end])
for i := 1; i < len(p.points); i++ {
if p.intersectsWithRaycast(point, p.points[i-1], p.points[i]) {
contains = !contains
}
}
return contains
} | go | {
"resource": ""
} |
q8252 | New | train | func New(limit int) SizedWaitGroup {
size := math.MaxInt32 // 2^32 - 1
if limit > 0 {
size = limit
}
return SizedWaitGroup{
Size: size,
current: make(chan struct{}, size),
wg: sync.WaitGroup{},
}
} | go | {
"resource": ""
} |
q8253 | AddWithContext | train | func (s *SizedWaitGroup) AddWithContext(ctx context.Context) error {
select {
case <-ctx.Done():
return ctx.Err()
case s.current <- struct{}{}:
break
}
s.wg.Add(1)
return nil
} | go | {
"resource": ""
} |
q8254 | PrettyOptions | train | func PrettyOptions(json []byte, opts *Options) []byte {
if opts == nil {
opts = DefaultOptions
}
buf := make([]byte, 0, len(json))
if len(opts.Prefix) != 0 {
buf = append(buf, opts.Prefix...)
}
buf, _, _, _ = appendPrettyAny(buf, json, 0, true,
opts.Width, opts.Prefix, opts.Indent, opts.SortKeys,
0, 0, -1)
if len(buf) > 0 {
buf = append(buf, '\n')
}
return buf
} | go | {
"resource": ""
} |
q8255 | Ugly | train | func Ugly(json []byte) []byte {
buf := make([]byte, 0, len(json))
return ugly(buf, json)
} | go | {
"resource": ""
} |
q8256 | writeBlockSkip | train | func (d *compressor) writeBlockSkip(tok tokens, index int, eof bool) error {
if index > 0 || eof {
if d.blockStart <= index {
window := d.window[d.blockStart:index]
// If we removed less than a 64th of all literals
// we huffman compress the block.
if int(tok.n) > len(window)-int(tok.n>>6) {
d.w.writeBlockHuff(eof, window)
} else {
// Write a dynamic huffman block.
d.w.writeBlockDynamic(tok.tokens[:tok.n], eof, window)
}
} else {
d.w.writeBlock(tok.tokens[:tok.n], eof, nil)
}
d.blockStart = index
return d.w.err
}
return nil
} | go | {
"resource": ""
} |
q8257 | findMatch | train | func (d *compressor) findMatch(pos int, prevHead int, prevLength int, lookahead int) (length, offset int, ok bool) {
minMatchLook := maxMatchLength
if lookahead < minMatchLook {
minMatchLook = lookahead
}
win := d.window[0 : pos+minMatchLook]
// We quit when we get a match that's at least nice long
nice := len(win) - pos
if d.nice < nice {
nice = d.nice
}
// If we've got a match that's good enough, only look in 1/4 the chain.
tries := d.chain
length = prevLength
if length >= d.good {
tries >>= 2
}
wEnd := win[pos+length]
wPos := win[pos:]
minIndex := pos - windowSize
for i := prevHead; tries > 0; tries-- {
if wEnd == win[i+length] {
n := matchLen(win[i:], wPos, minMatchLook)
if n > length && (n > minMatchLength || pos-i <= 4096) {
length = n
offset = pos - i
ok = true
if n >= nice {
// The match is good enough that we don't try to find a better one.
break
}
wEnd = win[pos+n]
}
}
if i == minIndex {
// hashPrev[i & windowMask] has already been overwritten, so stop now.
break
}
i = int(d.hashPrev[i&windowMask]) - d.hashOffset
if i < minIndex || i < 0 {
break
}
}
return
} | go | {
"resource": ""
} |
q8258 | bulkHash4 | train | func bulkHash4(b []byte, dst []uint32) {
if len(b) < minMatchLength {
return
}
hb := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
dst[0] = (hb * hashmul) >> (32 - hashBits)
end := len(b) - minMatchLength + 1
for i := 1; i < end; i++ {
hb = (hb << 8) | uint32(b[i+3])
dst[i] = (hb * hashmul) >> (32 - hashBits)
}
} | go | {
"resource": ""
} |
q8259 | matchLen | train | func matchLen(a, b []byte, max int) int {
a = a[:max]
b = b[:len(a)]
for i, av := range a {
if b[i] != av {
return i
}
}
return max
} | go | {
"resource": ""
} |
q8260 | fillBlock | train | func (d *compressor) fillBlock(b []byte) int {
n := copy(d.window[d.windowEnd:], b)
d.windowEnd += n
return n
} | go | {
"resource": ""
} |
q8261 | write | train | func (d *compressor) write(b []byte) (n int, err error) {
if d.err != nil {
return 0, d.err
}
n = len(b)
for len(b) > 0 {
d.step(d)
b = b[d.fill(d, b):]
if d.err != nil {
return 0, d.err
}
}
return n, d.err
} | go | {
"resource": ""
} |
q8262 | reset | train | func (d *compressor) reset(w io.Writer) {
d.w.reset(w)
d.sync = false
d.err = nil
// We only need to reset a few things for Snappy.
if d.snap != nil {
d.snap.Reset()
d.windowEnd = 0
d.tokens.n = 0
return
}
switch d.compressionLevel.chain {
case 0:
// level was NoCompression or ConstantCompresssion.
d.windowEnd = 0
default:
d.chainHead = -1
for i := range d.hashHead {
d.hashHead[i] = 0
}
for i := range d.hashPrev {
d.hashPrev[i] = 0
}
d.hashOffset = 1
d.index, d.windowEnd = 0, 0
d.blockStart, d.byteAvailable = 0, false
d.tokens.n = 0
d.length = minMatchLength - 1
d.offset = 0
d.hash = 0
d.ii = 0
d.maxInsertIndex = 0
}
} | go | {
"resource": ""
} |
q8263 | NewWriterDict | train | func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error) {
dw := &dictWriter{w}
zw, err := NewWriter(dw, level)
if err != nil {
return nil, err
}
zw.d.fillWindow(dict)
zw.dict = append(zw.dict, dict...) // duplicate dictionary for Reset method.
return zw, err
} | go | {
"resource": ""
} |
q8264 | Write | train | func (w *Writer) Write(data []byte) (n int, err error) {
return w.d.write(data)
} | go | {
"resource": ""
} |
q8265 | Reset | train | func (w *Writer) Reset(dst io.Writer) {
if dw, ok := w.d.w.writer.(*dictWriter); ok {
// w was created with NewWriterDict
dw.w = dst
w.d.reset(dw)
w.d.fillWindow(w.dict)
} else {
// w was created with NewWriter
w.d.reset(dst)
}
} | go | {
"resource": ""
} |
q8266 | ResetDict | train | func (w *Writer) ResetDict(dst io.Writer, dict []byte) {
w.dict = dict
w.d.reset(dst)
w.d.fillWindow(w.dict)
} | go | {
"resource": ""
} |
q8267 | noEOF | train | func noEOF(err error) error {
if err == io.EOF {
return io.ErrUnexpectedEOF
}
return err
} | go | {
"resource": ""
} |
q8268 | NewReader | train | func NewReader(r io.Reader) (*Reader, error) {
z := new(Reader)
if err := z.Reset(r); err != nil {
return nil, err
}
return z, nil
} | go | {
"resource": ""
} |
q8269 | Reset | train | func (z *Reader) Reset(r io.Reader) error {
*z = Reader{
decompressor: z.decompressor,
multistream: true,
}
if rr, ok := r.(flate.Reader); ok {
z.r = rr
} else {
z.r = bufio.NewReader(r)
}
z.Header, z.err = z.readHeader()
return z.err
} | go | {
"resource": ""
} |
q8270 | readHeader | train | func (z *Reader) readHeader() (hdr Header, err error) {
if _, err = io.ReadFull(z.r, z.buf[:10]); err != nil {
// RFC 1952, section 2.2, says the following:
// A gzip file consists of a series of "members" (compressed data sets).
//
// Other than this, the specification does not clarify whether a
// "series" is defined as "one or more" or "zero or more". To err on the
// side of caution, Go interprets this to mean "zero or more".
// Thus, it is okay to return io.EOF here.
return hdr, err
}
if z.buf[0] != gzipID1 || z.buf[1] != gzipID2 || z.buf[2] != gzipDeflate {
return hdr, ErrHeader
}
flg := z.buf[3]
hdr.ModTime = time.Unix(int64(le.Uint32(z.buf[4:8])), 0)
// z.buf[8] is XFL and is currently ignored.
hdr.OS = z.buf[9]
z.digest = crc32.ChecksumIEEE(z.buf[:10])
if flg&flagExtra != 0 {
if _, err = io.ReadFull(z.r, z.buf[:2]); err != nil {
return hdr, noEOF(err)
}
z.digest = crc32.Update(z.digest, crc32.IEEETable, z.buf[:2])
data := make([]byte, le.Uint16(z.buf[:2]))
if _, err = io.ReadFull(z.r, data); err != nil {
return hdr, noEOF(err)
}
z.digest = crc32.Update(z.digest, crc32.IEEETable, data)
hdr.Extra = data
}
var s string
if flg&flagName != 0 {
if s, err = z.readString(); err != nil {
return hdr, err
}
hdr.Name = s
}
if flg&flagComment != 0 {
if s, err = z.readString(); err != nil {
return hdr, err
}
hdr.Comment = s
}
if flg&flagHdrCrc != 0 {
if _, err = io.ReadFull(z.r, z.buf[:2]); err != nil {
return hdr, noEOF(err)
}
digest := le.Uint16(z.buf[:2])
if digest != uint16(z.digest) {
return hdr, ErrHeader
}
}
z.digest = 0
if z.decompressor == nil {
z.decompressor = flate.NewReader(z.r)
} else {
z.decompressor.(flate.Resetter).Reset(z.r, nil)
}
return hdr, nil
} | go | {
"resource": ""
} |
q8271 | Read | train | func (z *Reader) Read(p []byte) (n int, err error) {
if z.err != nil {
return 0, z.err
}
n, z.err = z.decompressor.Read(p)
z.digest = crc32.Update(z.digest, crc32.IEEETable, p[:n])
z.size += uint32(n)
if z.err != io.EOF {
// In the normal case we return here.
return n, z.err
}
// Finished file; check checksum and size.
if _, err := io.ReadFull(z.r, z.buf[:8]); err != nil {
z.err = noEOF(err)
return n, z.err
}
digest := le.Uint32(z.buf[:4])
size := le.Uint32(z.buf[4:8])
if digest != z.digest || size != z.size {
z.err = ErrChecksum
return n, z.err
}
z.digest, z.size = 0, 0
// File is ok; check if there is another.
if !z.multistream {
return n, io.EOF
}
z.err = nil // Remove io.EOF
if _, z.err = z.readHeader(); z.err != nil {
return n, z.err
}
// Read from next file, if necessary.
if n > 0 {
return n, nil
}
return z.Read(p)
} | go | {
"resource": ""
} |
q8272 | addBits16NC | train | func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
b.nBits += bits
} | go | {
"resource": ""
} |
q8273 | addBits16ZeroNC | train | func (b *bitWriter) addBits16ZeroNC(value uint16, bits uint8) {
if bits == 0 {
return
}
value <<= (16 - bits) & 15
value >>= (16 - bits) & 15
b.bitContainer |= uint64(value) << (b.nBits & 63)
b.nBits += bits
} | go | {
"resource": ""
} |
q8274 | flush32 | train | func (b *bitWriter) flush32() {
if b.nBits < 32 {
return
}
b.out = append(b.out,
byte(b.bitContainer),
byte(b.bitContainer>>8),
byte(b.bitContainer>>16),
byte(b.bitContainer>>24))
b.nBits -= 32
b.bitContainer >>= 32
} | go | {
"resource": ""
} |
q8275 | flushAlign | train | func (b *bitWriter) flushAlign() {
nbBytes := (b.nBits + 7) >> 3
for i := uint8(0); i < nbBytes; i++ {
b.out = append(b.out, byte(b.bitContainer>>(i*8)))
}
b.nBits = 0
b.bitContainer = 0
} | go | {
"resource": ""
} |
q8276 | reset | train | func (b *bitWriter) reset(out []byte) {
b.bitContainer = 0
b.nBits = 0
b.out = out
} | go | {
"resource": ""
} |
q8277 | NewWriter | train | func NewWriter(w io.Writer) *Writer {
z, _ := NewWriterLevel(w, DefaultCompression)
return z
} | go | {
"resource": ""
} |
q8278 | NewWriterLevel | train | func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
if level < HuffmanOnly || level > BestCompression {
return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
}
z := new(Writer)
z.init(w, level)
return z, nil
} | go | {
"resource": ""
} |
q8279 | Reset | train | func (z *Writer) Reset(w io.Writer) {
z.init(w, z.level)
} | go | {
"resource": ""
} |
q8280 | writeBytes | train | func (z *Writer) writeBytes(b []byte) error {
if len(b) > 0xffff {
return errors.New("gzip.Write: Extra data is too large")
}
le.PutUint16(z.buf[:2], uint16(len(b)))
_, err := z.w.Write(z.buf[:2])
if err != nil {
return err
}
_, err = z.w.Write(b)
return err
} | go | {
"resource": ""
} |
q8281 | Write | train | func (z *Writer) Write(p []byte) (int, error) {
if z.err != nil {
return 0, z.err
}
var n int
// Write the GZIP header lazily.
if !z.wroteHeader {
z.wroteHeader = true
z.buf[0] = gzipID1
z.buf[1] = gzipID2
z.buf[2] = gzipDeflate
z.buf[3] = 0
if z.Extra != nil {
z.buf[3] |= 0x04
}
if z.Name != "" {
z.buf[3] |= 0x08
}
if z.Comment != "" {
z.buf[3] |= 0x10
}
le.PutUint32(z.buf[4:8], uint32(z.ModTime.Unix()))
if z.level == BestCompression {
z.buf[8] = 2
} else if z.level == BestSpeed {
z.buf[8] = 4
} else {
z.buf[8] = 0
}
z.buf[9] = z.OS
n, z.err = z.w.Write(z.buf[:10])
if z.err != nil {
return n, z.err
}
if z.Extra != nil {
z.err = z.writeBytes(z.Extra)
if z.err != nil {
return n, z.err
}
}
if z.Name != "" {
z.err = z.writeString(z.Name)
if z.err != nil {
return n, z.err
}
}
if z.Comment != "" {
z.err = z.writeString(z.Comment)
if z.err != nil {
return n, z.err
}
}
if z.compressor == nil {
z.compressor, _ = flate.NewWriter(z.w, z.level)
}
}
z.size += uint32(len(p))
z.digest = crc32.Update(z.digest, crc32.IEEETable, p)
n, z.err = z.compressor.Write(p)
return n, z.err
} | go | {
"resource": ""
} |
q8282 | Flush | train | func (z *Writer) Flush() error {
if z.err != nil {
return z.err
}
if z.closed {
return nil
}
if !z.wroteHeader {
z.Write(nil)
if z.err != nil {
return z.err
}
}
z.err = z.compressor.Flush()
return z.err
} | go | {
"resource": ""
} |
q8283 | reset | train | func (b *blockDec) reset(br byteBuffer, windowSize uint64) error {
b.WindowSize = windowSize
tmp := br.readSmall(3)
if tmp == nil {
if debug {
println("Reading block header:", io.ErrUnexpectedEOF)
}
return io.ErrUnexpectedEOF
}
bh := uint32(tmp[0]) | (uint32(tmp[1]) << 8) | (uint32(tmp[2]) << 16)
b.Last = bh&1 != 0
b.Type = blockType((bh >> 1) & 3)
// find size.
cSize := int(bh >> 3)
switch b.Type {
case blockTypeReserved:
return ErrReservedBlockType
case blockTypeRLE:
b.RLESize = uint32(cSize)
cSize = 1
case blockTypeCompressed:
if debug {
println("Data size on stream:", cSize)
}
b.RLESize = 0
if cSize > maxCompressedBlockSize || uint64(cSize) > b.WindowSize {
if debug {
printf("compressed block too big: %+v\n", b)
}
return ErrCompressedSizeTooBig
}
default:
b.RLESize = 0
}
// Read block data.
if cap(b.data) < cSize {
if b.lowMem {
b.data = make([]byte, 0, cSize)
} else {
b.data = make([]byte, 0, maxBlockSize)
}
}
if cap(b.dst) <= maxBlockSize {
b.dst = make([]byte, 0, maxBlockSize+1)
}
var err error
b.data, err = br.readBig(cSize, b.data[:0])
if err != nil {
if debug {
println("Reading block:", err)
}
return err
}
return nil
} | go | {
"resource": ""
} |
q8284 | sendErr | train | func (b *blockDec) sendErr(err error) {
b.Last = true
b.Type = blockTypeReserved
b.err = err
b.input <- struct{}{}
} | go | {
"resource": ""
} |
q8285 | Close | train | func (b *blockDec) Close() {
close(b.input)
close(b.history)
close(b.result)
} | go | {
"resource": ""
} |
q8286 | startDecoder | train | func (b *blockDec) startDecoder() {
for range b.input {
//println("blockDec: Got block input")
switch b.Type {
case blockTypeRLE:
if cap(b.dst) < int(b.RLESize) {
if b.lowMem {
b.dst = make([]byte, b.RLESize)
} else {
b.dst = make([]byte, maxBlockSize)
}
}
o := decodeOutput{
d: b,
b: b.dst[:b.RLESize],
err: nil,
}
v := b.data[0]
for i := range o.b {
o.b[i] = v
}
hist := <-b.history
hist.append(o.b)
b.result <- o
case blockTypeRaw:
o := decodeOutput{
d: b,
b: b.data,
err: nil,
}
hist := <-b.history
hist.append(o.b)
b.result <- o
case blockTypeCompressed:
b.dst = b.dst[:0]
err := b.decodeCompressed(nil)
o := decodeOutput{
d: b,
b: b.dst,
err: err,
}
if debug {
println("Decompressed to", len(b.dst), "bytes, error:", err)
}
b.result <- o
case blockTypeReserved:
// Used for returning errors.
<-b.history
b.result <- decodeOutput{
d: b,
b: nil,
err: b.err,
}
default:
panic("Invalid block type")
}
if debug {
println("blockDec: Finished block")
}
}
} | go | {
"resource": ""
} |
q8287 | decodeBuf | train | func (b *blockDec) decodeBuf(hist *history) error {
switch b.Type {
case blockTypeRLE:
if cap(b.dst) < int(b.RLESize) {
if b.lowMem {
b.dst = make([]byte, b.RLESize)
} else {
b.dst = make([]byte, maxBlockSize)
}
}
b.dst = b.dst[:b.RLESize]
v := b.data[0]
for i := range b.dst {
b.dst[i] = v
}
hist.appendKeep(b.dst)
return nil
case blockTypeRaw:
hist.appendKeep(b.data)
return nil
case blockTypeCompressed:
saved := b.dst
b.dst = hist.b
hist.b = nil
err := b.decodeCompressed(hist)
if debug {
println("Decompressed to total", len(b.dst), "bytes, error:", err)
}
hist.b = b.dst
b.dst = saved
return err
case blockTypeReserved:
// Used for returning errors.
return b.err
default:
panic("Invalid block type")
}
} | go | {
"resource": ""
} |
q8288 | init | train | func (b *bitReader) init(in []byte) error {
if len(in) < 1 {
return errors.New("corrupt stream: too short")
}
b.in = in
b.off = uint(len(in))
// The highest bit of the last byte indicates where to start
v := in[len(in)-1]
if v == 0 {
return errors.New("corrupt stream, did not find end of stream")
}
b.bitsRead = 64
b.value = 0
b.fill()
b.fill()
b.bitsRead += 8 - uint8(highBits(uint32(v)))
return nil
} | go | {
"resource": ""
} |
q8289 | close | train | func (b *bitReader) close() error {
// Release reference.
b.in = nil
if b.bitsRead > 64 {
return io.ErrUnexpectedEOF
}
return nil
} | go | {
"resource": ""
} |
q8290 | RegisterDecompressor | train | func RegisterDecompressor(method uint16, d Decompressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := decompressors[method]; ok {
panic("decompressor already registered")
}
decompressors[method] = d
} | go | {
"resource": ""
} |
q8291 | RegisterCompressor | train | func RegisterCompressor(method uint16, comp Compressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := compressors[method]; ok {
panic("compressor already registered")
}
compressors[method] = comp
} | go | {
"resource": ""
} |
q8292 | init | train | func (s *sequenceDec) init(br *bitReader) error {
if s.fse == nil {
return errors.New("sequence decoder not defined")
}
s.state.init(br, s.fse.actualTableLog, s.fse.dt[:1<<s.fse.actualTableLog])
return nil
} | go | {
"resource": ""
} |
q8293 | initialize | train | func (s *sequenceDecs) initialize(br *bitReader, hist *history, literals, out []byte) error {
if err := s.litLengths.init(br); err != nil {
return errors.New("litLengths:" + err.Error())
}
if err := s.offsets.init(br); err != nil {
return errors.New("litLengths:" + err.Error())
}
if err := s.matchLengths.init(br); err != nil {
return errors.New("matchLengths:" + err.Error())
}
s.literals = literals
s.hist = hist.b
s.prevOffset = hist.recentOffsets
s.maxBits = s.litLengths.fse.maxBits + s.offsets.fse.maxBits + s.matchLengths.fse.maxBits
s.out = out
return nil
} | go | {
"resource": ""
} |
q8294 | nextFast | train | func (s *sequenceDecs) nextFast(br *bitReader) (ll, mo, ml int) {
// Final will not read from stream.
ll, llB := s.litLengths.state.final()
ml, mlB := s.matchLengths.state.final()
mo, moB := s.offsets.state.final()
// extra bits are stored in reverse order.
br.fillFast()
if s.maxBits <= 32 {
mo += br.getBits(moB)
ml += br.getBits(mlB)
ll += br.getBits(llB)
} else {
mo += br.getBits(moB)
br.fillFast()
// matchlength+literal length, max 32 bits
ml += br.getBits(mlB)
ll += br.getBits(llB)
}
// mo = s.adjustOffset(mo, ll, moB)
// Inlined for rather big speedup
if moB > 1 {
s.prevOffset[2] = s.prevOffset[1]
s.prevOffset[1] = s.prevOffset[0]
s.prevOffset[0] = mo
return
}
if ll == 0 {
// There is an exception though, when current sequence's literals_length = 0.
// In this case, repeated offsets are shifted by one, so an offset_value of 1 means Repeated_Offset2,
// an offset_value of 2 means Repeated_Offset3, and an offset_value of 3 means Repeated_Offset1 - 1_byte.
mo++
}
if mo == 0 {
mo = s.prevOffset[0]
return
}
var temp int
if mo == 3 {
temp = s.prevOffset[0] - 1
} else {
temp = s.prevOffset[mo]
}
if temp == 0 {
// 0 is not valid; input is corrupted; force offset to 1
println("temp was 0")
temp = 1
}
if mo != 1 {
s.prevOffset[2] = s.prevOffset[1]
}
s.prevOffset[1] = s.prevOffset[0]
s.prevOffset[0] = temp
mo = temp
return
} | go | {
"resource": ""
} |
q8295 | mergeHistory | train | func (s *sequenceDecs) mergeHistory(hist *sequenceDecs) (*sequenceDecs, error) {
for i := uint(0); i < 3; i++ {
var sNew, sHist *sequenceDec
switch i {
default:
// same as "case 0":
sNew = &s.litLengths
sHist = &hist.litLengths
case 1:
sNew = &s.offsets
sHist = &hist.offsets
case 2:
sNew = &s.matchLengths
sHist = &hist.matchLengths
}
if sNew.repeat {
if sHist.fse == nil {
return nil, fmt.Errorf("sequence stream %d, repeat requested, but no history", i)
}
continue
}
if sNew.fse == nil {
return nil, fmt.Errorf("sequence stream %d, no fse found", i)
}
if sHist.fse != nil && !sHist.fse.preDefined {
fseDecoderPool.Put(sHist.fse)
}
sHist.fse = sNew.fse
}
return hist, nil
} | go | {
"resource": ""
} |
q8296 | Compress1X | train | func Compress1X(in []byte, s *Scratch) (out []byte, reUsed bool, err error) {
s, err = s.prepare(in)
if err != nil {
return nil, false, err
}
return compress(in, s, s.compress1X)
} | go | {
"resource": ""
} |
q8297 | Compress4X | train | func Compress4X(in []byte, s *Scratch) (out []byte, reUsed bool, err error) {
s, err = s.prepare(in)
if err != nil {
return nil, false, err
}
if false {
// TODO: compress4Xp only slightly faster.
const parallelThreshold = 8 << 10
if len(in) < parallelThreshold || runtime.GOMAXPROCS(0) == 1 {
return compress(in, s, s.compress4X)
}
return compress(in, s, s.compress4Xp)
}
return compress(in, s, s.compress4X)
} | go | {
"resource": ""
} |
q8298 | compress4Xp | train | func (s *Scratch) compress4Xp(src []byte) ([]byte, error) {
if len(src) < 12 {
return nil, ErrIncompressible
}
// Add placeholder for output length
s.Out = s.Out[:6]
segmentSize := (len(src) + 3) / 4
var wg sync.WaitGroup
var errs [4]error
wg.Add(4)
for i := 0; i < 4; i++ {
toDo := src
if len(toDo) > segmentSize {
toDo = toDo[:segmentSize]
}
src = src[len(toDo):]
// Separate goroutine for each block.
go func(i int) {
s.tmpOut[i], errs[i] = s.compress1xDo(s.tmpOut[i][:0], toDo)
wg.Done()
}(i)
}
wg.Wait()
for i := 0; i < 4; i++ {
if errs[i] != nil {
return nil, errs[i]
}
o := s.tmpOut[i]
// Write compressed length as little endian before block.
if i < 3 {
// Last length is not written.
s.Out[i*2] = byte(len(o))
s.Out[i*2+1] = byte(len(o) >> 8)
}
// Write output.
s.Out = append(s.Out, o...)
}
return s.Out, nil
} | go | {
"resource": ""
} |
q8299 | minTableLog | train | func (s *Scratch) minTableLog() uint8 {
minBitsSrc := highBit32(uint32(s.br.remain()-1)) + 1
minBitsSymbols := highBit32(uint32(s.symbolLen-1)) + 2
if minBitsSrc < minBitsSymbols {
return uint8(minBitsSrc)
}
return uint8(minBitsSymbols)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.