id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
8,200 | contiv/netplugin | netmaster/objApi/apiController.go | NetworkGetOper | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"NetworkGetOper",
"(",
"network",
"*",
"contivModel",
".",
"NetworkInspect",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"network",
")",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"nwCfg",
":=",
"&",
"mastercfg",
".",
"CfgNetworkState",
"{",
"}",
"\n",
"nwCfg",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"networkID",
":=",
"network",
".",
"Config",
".",
"NetworkName",
"+",
"\"",
"\"",
"+",
"network",
".",
"Config",
".",
"TenantName",
"\n",
"if",
"err",
":=",
"nwCfg",
".",
"Read",
"(",
"networkID",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"networkID",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"network",
".",
"Oper",
".",
"AllocatedAddressesCount",
"=",
"nwCfg",
".",
"EpAddrCount",
"\n",
"network",
".",
"Oper",
".",
"AvailableIPAddresses",
"=",
"master",
".",
"ListAvailableIPs",
"(",
"nwCfg",
")",
"\n",
"network",
".",
"Oper",
".",
"AllocatedIPAddresses",
"=",
"master",
".",
"ListAllocatedIPs",
"(",
"nwCfg",
")",
"\n",
"network",
".",
"Oper",
".",
"ExternalPktTag",
"=",
"nwCfg",
".",
"ExtPktTag",
"\n",
"network",
".",
"Oper",
".",
"NumEndpoints",
"=",
"nwCfg",
".",
"EpCount",
"\n",
"network",
".",
"Oper",
".",
"PktTag",
"=",
"nwCfg",
".",
"PktTag",
"\n",
"network",
".",
"Oper",
".",
"NetworkTag",
"=",
"nwCfg",
".",
"NetworkTag",
"\n\n",
"readEp",
":=",
"&",
"mastercfg",
".",
"CfgEndpointState",
"{",
"}",
"\n",
"readEp",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"epCfgs",
",",
"err",
":=",
"readEp",
".",
"ReadAll",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"epCfg",
":=",
"range",
"epCfgs",
"{",
"ep",
":=",
"epCfg",
".",
"(",
"*",
"mastercfg",
".",
"CfgEndpointState",
")",
"\n",
"if",
"ep",
".",
"NetID",
"==",
"networkID",
"{",
"epOper",
":=",
"contivModel",
".",
"EndpointOper",
"{",
"}",
"\n",
"epOper",
".",
"Network",
"=",
"ep",
".",
"NetID",
"\n",
"epOper",
".",
"EndpointID",
"=",
"ep",
".",
"EndpointID",
"\n",
"epOper",
".",
"ServiceName",
"=",
"ep",
".",
"ServiceName",
"\n",
"epOper",
".",
"EndpointGroupID",
"=",
"ep",
".",
"EndpointGroupID",
"\n",
"epOper",
".",
"EndpointGroupKey",
"=",
"ep",
".",
"EndpointGroupKey",
"\n",
"epOper",
".",
"IpAddress",
"=",
"[",
"]",
"string",
"{",
"ep",
".",
"IPAddress",
",",
"ep",
".",
"IPv6Address",
"}",
"\n",
"epOper",
".",
"MacAddress",
"=",
"ep",
".",
"MacAddress",
"\n",
"epOper",
".",
"HomingHost",
"=",
"ep",
".",
"HomingHost",
"\n",
"epOper",
".",
"IntfName",
"=",
"ep",
".",
"IntfName",
"\n",
"epOper",
".",
"VtepIP",
"=",
"ep",
".",
"VtepIP",
"\n",
"epOper",
".",
"Labels",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ep",
".",
"Labels",
")",
"\n",
"epOper",
".",
"ContainerID",
"=",
"ep",
".",
"ContainerID",
"\n",
"epOper",
".",
"ContainerName",
"=",
"ep",
".",
"EPCommonName",
"\n",
"network",
".",
"Oper",
".",
"Endpoints",
"=",
"append",
"(",
"network",
".",
"Oper",
".",
"Endpoints",
",",
"epOper",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // NetworkGetOper inspects network | [
"NetworkGetOper",
"inspects",
"network"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1142-L1193 |
8,201 | contiv/netplugin | netmaster/objApi/apiController.go | NetworkUpdate | 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 | 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")
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"NetworkUpdate",
"(",
"network",
",",
"params",
"*",
"contivModel",
".",
"Network",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"network",
",",
"params",
")",
"\n",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
]
| // NetworkUpdate updates network | [
"NetworkUpdate",
"updates",
"network"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1196-L1199 |
8,202 | contiv/netplugin | netmaster/objApi/apiController.go | NetworkDelete | 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 | 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()
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"NetworkDelete",
"(",
"network",
"*",
"contivModel",
".",
"Network",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"network",
")",
"\n\n",
"// Find the tenant",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"network",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if the network has associated epgs, fail the delete",
"epgCount",
":=",
"len",
"(",
"network",
".",
"LinkSets",
".",
"EndpointGroups",
")",
"\n",
"if",
"epgCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"network",
".",
"NetworkName",
",",
"epgCount",
")",
"\n",
"}",
"\n\n",
"svcCount",
":=",
"len",
"(",
"network",
".",
"LinkSets",
".",
"Servicelbs",
")",
"\n",
"if",
"svcCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"network",
".",
"NetworkName",
",",
"svcCount",
")",
"\n",
"}",
"\n\n",
"// 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",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"network",
".",
"NetworkName",
",",
"docknet",
".",
"DocknetUUID",
")",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"strings",
".",
"ToLower",
"(",
"err",
".",
"Error",
"(",
")",
")",
",",
"\"",
"\"",
")",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"network",
".",
"TenantName",
",",
"network",
".",
"NetworkName",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"network",
".",
"TenantName",
",",
"network",
".",
"NetworkName",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Remove link",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"Networks",
",",
"network",
")",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Delete the network",
"networkID",
":=",
"network",
".",
"NetworkName",
"+",
"\"",
"\"",
"+",
"network",
".",
"TenantName",
"\n",
"err",
"=",
"master",
".",
"DeleteNetworkID",
"(",
"stateDriver",
",",
"networkID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"network",
".",
"NetworkName",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Save the tenant too since we removed the links",
"return",
"tenant",
".",
"Write",
"(",
")",
"\n",
"}"
]
| // NetworkDelete deletes network | [
"NetworkDelete",
"deletes",
"network"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1202-L1259 |
8,203 | contiv/netplugin | netmaster/objApi/apiController.go | NetprofileCreate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"NetprofileCreate",
"(",
"netProfile",
"*",
"contivModel",
".",
"Netprofile",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"netProfile",
")",
"\n\n",
"// Check if the tenant exists",
"if",
"netProfile",
".",
"TenantName",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"netProfile",
".",
"Burst",
">",
"0",
"&&",
"netProfile",
".",
"Burst",
"<",
"2",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"netProfile",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Setup links & Linksets.",
"modeldb",
".",
"AddLink",
"(",
"&",
"netProfile",
".",
"Links",
".",
"Tenant",
",",
"tenant",
")",
"\n",
"modeldb",
".",
"AddLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"NetProfiles",
",",
"netProfile",
")",
"\n\n",
"// Save the tenant in etcd - This writes to etcd.",
"err",
":=",
"tenant",
".",
"Write",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // NetprofileCreate creates the network rule | [
"NetprofileCreate",
"creates",
"the",
"network",
"rule"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1262-L1291 |
8,204 | contiv/netplugin | netmaster/objApi/apiController.go | NetprofileUpdate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"NetprofileUpdate",
"(",
"profile",
",",
"params",
"*",
"contivModel",
".",
"Netprofile",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"profile",
",",
"params",
")",
"\n\n",
"if",
"params",
".",
"Burst",
">",
"0",
"&&",
"params",
".",
"Burst",
"<",
"2",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"profile",
".",
"Bandwidth",
"=",
"params",
".",
"Bandwidth",
"\n",
"profile",
".",
"DSCP",
"=",
"params",
".",
"DSCP",
"\n",
"profile",
".",
"Burst",
"=",
"params",
".",
"Burst",
"\n\n",
"for",
"key",
":=",
"range",
"profile",
".",
"LinkSets",
".",
"EndpointGroups",
"{",
"// Find the corresponding epg",
"epg",
":=",
"contivModel",
".",
"FindEndpointGroup",
"(",
"key",
")",
"\n",
"if",
"epg",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"master",
".",
"UpdateEndpointGroup",
"(",
"params",
".",
"Bandwidth",
",",
"epg",
".",
"GroupName",
",",
"epg",
".",
"TenantName",
",",
"params",
".",
"DSCP",
",",
"params",
".",
"Burst",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"epg",
".",
"GroupName",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // NetprofileUpdate updates the netprofile | [
"NetprofileUpdate",
"updates",
"the",
"netprofile"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1294-L1317 |
8,205 | contiv/netplugin | netmaster/objApi/apiController.go | NetprofileDelete | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"NetprofileDelete",
"(",
"netProfile",
"*",
"contivModel",
".",
"Netprofile",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"netProfile",
".",
"ProfileName",
")",
"\n\n",
"// Find Tenant",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"netProfile",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"netProfile",
".",
"TenantName",
")",
"\n",
"}",
"\n",
"// Check if any endpoint group is using the network policy",
"if",
"len",
"(",
"netProfile",
".",
"LinkSets",
".",
"EndpointGroups",
")",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"NetProfiles",
",",
"netProfile",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // NetprofileDelete deletes netprofile | [
"NetprofileDelete",
"deletes",
"netprofile"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1320-L1335 |
8,206 | contiv/netplugin | netmaster/objApi/apiController.go | PolicyCreate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"PolicyCreate",
"(",
"policy",
"*",
"contivModel",
".",
"Policy",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"policy",
")",
"\n\n",
"// Make sure tenant exists",
"if",
"policy",
".",
"TenantName",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"policy",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Setup links",
"modeldb",
".",
"AddLink",
"(",
"&",
"policy",
".",
"Links",
".",
"Tenant",
",",
"tenant",
")",
"\n",
"modeldb",
".",
"AddLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"Policies",
",",
"policy",
")",
"\n\n",
"// Save the tenant too since we added the links",
"err",
":=",
"tenant",
".",
"Write",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // PolicyCreate creates policy | [
"PolicyCreate",
"creates",
"policy"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1338-L1363 |
8,207 | contiv/netplugin | netmaster/objApi/apiController.go | PolicyGetOper | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"PolicyGetOper",
"(",
"policy",
"*",
"contivModel",
".",
"PolicyInspect",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"policy",
")",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// To hold total number of Endpoint count",
"var",
"policyEPCount",
"int",
"\n\n",
"policyCfg",
":=",
"&",
"mastercfg",
".",
"EpgPolicy",
"{",
"}",
"\n",
"policyCfg",
".",
"StateDriver",
"=",
"stateDriver",
"\n\n",
"// Policy is attached to EPG. So we need to fetch EPGs as well.",
"epgCfg",
":=",
"&",
"mastercfg",
".",
"EndpointGroupState",
"{",
"}",
"\n",
"epgCfg",
".",
"StateDriver",
"=",
"stateDriver",
"\n\n",
"// Get all the Endpoints",
"readEp",
":=",
"&",
"mastercfg",
".",
"CfgEndpointState",
"{",
"}",
"\n",
"readEp",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"epCfgs",
",",
"epErr",
":=",
"readEp",
".",
"ReadAll",
"(",
")",
"\n\n",
"// Get all the EPGs on which this policy is applied",
"epgs",
":=",
"policy",
".",
"Config",
".",
"LinkSets",
".",
"EndpointGroups",
"\n\n",
"// Scan all the EPGs which are under this policy",
"for",
"_",
",",
"epg",
":=",
"range",
"epgs",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"epg",
")",
"\n\n",
"// Reversing key from TenantName:EPGName to EPGName:TenantName",
"sList",
":=",
"strings",
".",
"Split",
"(",
"epg",
".",
"ObjKey",
",",
"\"",
"\"",
")",
"\n",
"if",
"sList",
"==",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"epg",
".",
"ObjKey",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"epgID",
":=",
"sList",
"[",
"1",
"]",
"+",
"\"",
"\"",
"+",
"sList",
"[",
"0",
"]",
"\n\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"epgID",
")",
"\n\n",
"if",
"err",
":=",
"epgCfg",
".",
"Read",
"(",
"epgID",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"epgID",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"policyEPCount",
"=",
"policyEPCount",
"+",
"epgCfg",
".",
"EpCount",
"\n\n",
"if",
"epErr",
"==",
"nil",
"{",
"for",
"_",
",",
"epCfg",
":=",
"range",
"epCfgs",
"{",
"ep",
":=",
"epCfg",
".",
"(",
"*",
"mastercfg",
".",
"CfgEndpointState",
")",
"\n",
"if",
"ep",
".",
"EndpointGroupKey",
"==",
"epgID",
"{",
"epOper",
":=",
"contivModel",
".",
"EndpointOper",
"{",
"}",
"\n",
"epOper",
".",
"Network",
"=",
"ep",
".",
"NetID",
"\n",
"epOper",
".",
"EndpointID",
"=",
"ep",
".",
"EndpointID",
"\n",
"epOper",
".",
"ServiceName",
"=",
"ep",
".",
"ServiceName",
"\n",
"epOper",
".",
"EndpointGroupID",
"=",
"ep",
".",
"EndpointGroupID",
"\n",
"epOper",
".",
"EndpointGroupKey",
"=",
"ep",
".",
"EndpointGroupKey",
"\n",
"epOper",
".",
"IpAddress",
"=",
"[",
"]",
"string",
"{",
"ep",
".",
"IPAddress",
",",
"ep",
".",
"IPv6Address",
"}",
"\n",
"epOper",
".",
"MacAddress",
"=",
"ep",
".",
"MacAddress",
"\n",
"epOper",
".",
"HomingHost",
"=",
"ep",
".",
"HomingHost",
"\n",
"epOper",
".",
"IntfName",
"=",
"ep",
".",
"IntfName",
"\n",
"epOper",
".",
"VtepIP",
"=",
"ep",
".",
"VtepIP",
"\n",
"epOper",
".",
"Labels",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ep",
".",
"Labels",
")",
"\n",
"epOper",
".",
"ContainerID",
"=",
"ep",
".",
"ContainerID",
"\n",
"epOper",
".",
"ContainerName",
"=",
"ep",
".",
"EPCommonName",
"\n",
"policy",
".",
"Oper",
".",
"Endpoints",
"=",
"append",
"(",
"policy",
".",
"Oper",
".",
"Endpoints",
",",
"epOper",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"// End of main for loop",
"\n\n",
"policy",
".",
"Oper",
".",
"NumEndpoints",
"=",
"policyEPCount",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // PolicyGetOper inspects policy | [
"PolicyGetOper",
"inspects",
"policy"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1366-L1441 |
8,208 | contiv/netplugin | netmaster/objApi/apiController.go | PolicyUpdate | func (ac *APIController) PolicyUpdate(policy, params *contivModel.Policy) error {
log.Infof("Received PolicyUpdate: %+v, params: %+v", policy, params)
return nil
} | go | func (ac *APIController) PolicyUpdate(policy, params *contivModel.Policy) error {
log.Infof("Received PolicyUpdate: %+v, params: %+v", policy, params)
return nil
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"PolicyUpdate",
"(",
"policy",
",",
"params",
"*",
"contivModel",
".",
"Policy",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"policy",
",",
"params",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // PolicyUpdate updates policy | [
"PolicyUpdate",
"updates",
"policy"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1444-L1447 |
8,209 | contiv/netplugin | netmaster/objApi/apiController.go | PolicyDelete | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"PolicyDelete",
"(",
"policy",
"*",
"contivModel",
".",
"Policy",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"policy",
")",
"\n\n",
"// Find Tenant",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"policy",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"policy",
".",
"TenantName",
")",
"\n",
"}",
"\n\n",
"// Check if any endpoint group is using the Policy",
"if",
"len",
"(",
"policy",
".",
"LinkSets",
".",
"EndpointGroups",
")",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Delete all associated Rules",
"for",
"key",
":=",
"range",
"policy",
".",
"LinkSets",
".",
"Rules",
"{",
"// delete the rule",
"err",
":=",
"contivModel",
".",
"DeleteRule",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"//Remove Links",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"Policies",
",",
"policy",
")",
"\n\n",
"// Save the tenant too since we added the links",
"err",
":=",
"tenant",
".",
"Write",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // PolicyDelete deletes policy | [
"PolicyDelete",
"deletes",
"policy"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1450-L1484 |
8,210 | contiv/netplugin | netmaster/objApi/apiController.go | RuleUpdate | 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 | 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")
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"RuleUpdate",
"(",
"rule",
",",
"params",
"*",
"contivModel",
".",
"Rule",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"rule",
",",
"params",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
]
| // RuleUpdate updates the rule within a policy | [
"RuleUpdate",
"updates",
"the",
"rule",
"within",
"a",
"policy"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1688-L1691 |
8,211 | contiv/netplugin | netmaster/objApi/apiController.go | RuleDelete | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"RuleDelete",
"(",
"rule",
"*",
"contivModel",
".",
"Rule",
")",
"error",
"{",
"var",
"epg",
"*",
"contivModel",
".",
"EndpointGroup",
"\n\n",
"epg",
"=",
"nil",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"rule",
")",
"\n\n",
"policyKey",
":=",
"GetpolicyKey",
"(",
"rule",
".",
"TenantName",
",",
"rule",
".",
"PolicyName",
")",
"\n\n",
"// find the policy",
"policy",
":=",
"contivModel",
".",
"FindPolicy",
"(",
"policyKey",
")",
"\n",
"if",
"policy",
"==",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"policyKey",
")",
"\n",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// unlink the rule from policy",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"policy",
".",
"LinkSets",
".",
"Rules",
",",
"rule",
")",
"\n",
"err",
":=",
"policy",
".",
"Write",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// unlink the rule from matching epg",
"epgKey",
":=",
"rule",
".",
"Links",
".",
"MatchEndpointGroup",
".",
"ObjKey",
"\n",
"if",
"epgKey",
"!=",
"\"",
"\"",
"{",
"epg",
"=",
"contivModel",
".",
"FindEndpointGroup",
"(",
"epgKey",
")",
"\n",
"if",
"epg",
"!=",
"nil",
"{",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"epg",
".",
"LinkSets",
".",
"MatchRules",
",",
"rule",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Trigger policyDB Update",
"err",
"=",
"master",
".",
"PolicyDelRule",
"(",
"policy",
",",
"rule",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rule",
".",
"Key",
",",
"policy",
".",
"Key",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Update any affected app profiles",
"pMap",
":=",
"getAffectedProfs",
"(",
"policy",
",",
"epg",
")",
"\n",
"syncAppProfile",
"(",
"pMap",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // RuleDelete deletes the rule within a policy | [
"RuleDelete",
"deletes",
"the",
"rule",
"within",
"a",
"policy"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1694-L1737 |
8,212 | contiv/netplugin | netmaster/objApi/apiController.go | TenantCreate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"TenantCreate",
"(",
"tenant",
"*",
"contivModel",
".",
"Tenant",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"tenant",
")",
"\n\n",
"if",
"tenant",
".",
"TenantName",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Build tenant config",
"tenantCfg",
":=",
"intent",
".",
"ConfigTenant",
"{",
"Name",
":",
"tenant",
".",
"TenantName",
",",
"DefaultNetwork",
":",
"tenant",
".",
"DefaultNetwork",
",",
"}",
"\n\n",
"// Create the tenant",
"err",
"=",
"master",
".",
"CreateTenant",
"(",
"stateDriver",
",",
"&",
"tenantCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // TenantCreate creates a tenant | [
"TenantCreate",
"creates",
"a",
"tenant"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1740-L1767 |
8,213 | contiv/netplugin | netmaster/objApi/apiController.go | getTenantNetworks | 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 | 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
} | [
"func",
"getTenantNetworks",
"(",
"tenant",
"*",
"contivModel",
".",
"TenantInspect",
")",
"error",
"{",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"tenantID",
":=",
"tenant",
".",
"Config",
".",
"TenantName",
"\n",
"numEPs",
":=",
"0",
"\n",
"s",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"networkID",
":=",
"\"",
"\"",
"\n",
"for",
"_",
",",
"net",
":=",
"range",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"Networks",
"{",
"networkID",
"=",
"net",
".",
"ObjKey",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"networkID",
")",
"\n",
"s",
"=",
"strings",
".",
"Split",
"(",
"networkID",
",",
"\"",
"\"",
")",
"\n",
"if",
"s",
"[",
"0",
"]",
"==",
"tenantID",
"{",
"networkID",
"=",
"s",
"[",
"1",
"]",
"+",
"\"",
"\"",
"+",
"s",
"[",
"0",
"]",
"\n",
"nwCfg",
":=",
"&",
"mastercfg",
".",
"CfgNetworkState",
"{",
"}",
"\n",
"nwCfg",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"if",
"err",
":=",
"nwCfg",
".",
"Read",
"(",
"networkID",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"networkID",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"numEPs",
"=",
"numEPs",
"+",
"nwCfg",
".",
"EpCount",
"\n",
"netOper",
":=",
"contivModel",
".",
"NetworkOper",
"{",
"}",
"\n",
"netOper",
".",
"AllocatedAddressesCount",
"=",
"nwCfg",
".",
"EpAddrCount",
"\n",
"netOper",
".",
"AvailableIPAddresses",
"=",
"master",
".",
"ListAvailableIPs",
"(",
"nwCfg",
")",
"\n",
"netOper",
".",
"AllocatedIPAddresses",
"=",
"master",
".",
"ListAllocatedIPs",
"(",
"nwCfg",
")",
"\n",
"netOper",
".",
"ExternalPktTag",
"=",
"nwCfg",
".",
"ExtPktTag",
"\n",
"netOper",
".",
"PktTag",
"=",
"nwCfg",
".",
"PktTag",
"\n",
"netOper",
".",
"NumEndpoints",
"=",
"nwCfg",
".",
"EpCount",
"\n",
"readEp",
":=",
"&",
"mastercfg",
".",
"CfgEndpointState",
"{",
"}",
"\n",
"readEp",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"epCfgs",
",",
"err",
":=",
"readEp",
".",
"ReadAll",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"epCfg",
":=",
"range",
"epCfgs",
"{",
"ep",
":=",
"epCfg",
".",
"(",
"*",
"mastercfg",
".",
"CfgEndpointState",
")",
"\n",
"if",
"ep",
".",
"NetID",
"==",
"networkID",
"{",
"epOper",
":=",
"contivModel",
".",
"EndpointOper",
"{",
"}",
"\n",
"epOper",
".",
"Network",
"=",
"ep",
".",
"NetID",
"\n",
"epOper",
".",
"EndpointID",
"=",
"ep",
".",
"EndpointID",
"\n",
"epOper",
".",
"ServiceName",
"=",
"ep",
".",
"ServiceName",
"\n",
"epOper",
".",
"EndpointGroupID",
"=",
"ep",
".",
"EndpointGroupID",
"\n",
"epOper",
".",
"EndpointGroupKey",
"=",
"ep",
".",
"EndpointGroupKey",
"\n",
"epOper",
".",
"IpAddress",
"=",
"[",
"]",
"string",
"{",
"ep",
".",
"IPAddress",
",",
"ep",
".",
"IPv6Address",
"}",
"\n",
"epOper",
".",
"MacAddress",
"=",
"ep",
".",
"MacAddress",
"\n",
"epOper",
".",
"HomingHost",
"=",
"ep",
".",
"HomingHost",
"\n",
"epOper",
".",
"IntfName",
"=",
"ep",
".",
"IntfName",
"\n",
"epOper",
".",
"VtepIP",
"=",
"ep",
".",
"VtepIP",
"\n",
"epOper",
".",
"Labels",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ep",
".",
"Labels",
")",
"\n",
"epOper",
".",
"ContainerID",
"=",
"ep",
".",
"ContainerID",
"\n",
"epOper",
".",
"ContainerName",
"=",
"ep",
".",
"EPCommonName",
"\n",
"netOper",
".",
"Endpoints",
"=",
"append",
"(",
"netOper",
".",
"Endpoints",
",",
"epOper",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"tenant",
".",
"Oper",
".",
"Networks",
"=",
"append",
"(",
"tenant",
".",
"Oper",
".",
"Networks",
",",
"netOper",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"tenant",
".",
"Oper",
".",
"TotalEndpoints",
"=",
"numEPs",
"\n",
"return",
"nil",
"\n",
"}"
]
| // Get all the networks inside tenant | [
"Get",
"all",
"the",
"networks",
"inside",
"tenant"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1770-L1833 |
8,214 | contiv/netplugin | netmaster/objApi/apiController.go | getTenantEPGs | 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 | 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
} | [
"func",
"getTenantEPGs",
"(",
"tenant",
"*",
"contivModel",
".",
"TenantInspect",
")",
"error",
"{",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"tenantID",
":=",
"tenant",
".",
"Config",
".",
"TenantName",
"\n",
"s",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"epgID",
":=",
"\"",
"\"",
"\n",
"for",
"_",
",",
"epg",
":=",
"range",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"EndpointGroups",
"{",
"epgID",
"=",
"epg",
".",
"ObjKey",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"epgID",
")",
"\n",
"s",
"=",
"strings",
".",
"Split",
"(",
"epgID",
",",
"\"",
"\"",
")",
"\n",
"if",
"s",
"[",
"0",
"]",
"==",
"tenantID",
"{",
"epgID",
"=",
"s",
"[",
"1",
"]",
"+",
"\"",
"\"",
"+",
"s",
"[",
"0",
"]",
"\n",
"epgCfg",
":=",
"&",
"mastercfg",
".",
"EndpointGroupState",
"{",
"}",
"\n",
"epgCfg",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"if",
"err",
":=",
"epgCfg",
".",
"Read",
"(",
"epgID",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"epgID",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"epgOper",
":=",
"contivModel",
".",
"EndpointGroupOper",
"{",
"}",
"\n",
"epgOper",
".",
"ExternalPktTag",
"=",
"epgCfg",
".",
"ExtPktTag",
"\n",
"epgOper",
".",
"PktTag",
"=",
"epgCfg",
".",
"PktTag",
"\n",
"epgOper",
".",
"NumEndpoints",
"=",
"epgCfg",
".",
"EpCount",
"\n\n",
"readEp",
":=",
"&",
"mastercfg",
".",
"CfgEndpointState",
"{",
"}",
"\n",
"readEp",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"epCfgs",
",",
"err",
":=",
"readEp",
".",
"ReadAll",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"epCfg",
":=",
"range",
"epCfgs",
"{",
"ep",
":=",
"epCfg",
".",
"(",
"*",
"mastercfg",
".",
"CfgEndpointState",
")",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"ep",
".",
"EndpointGroupKey",
")",
"\n",
"if",
"ep",
".",
"EndpointGroupKey",
"==",
"epgID",
"{",
"epOper",
":=",
"contivModel",
".",
"EndpointOper",
"{",
"}",
"\n",
"epOper",
".",
"Network",
"=",
"ep",
".",
"NetID",
"\n",
"epOper",
".",
"EndpointID",
"=",
"ep",
".",
"EndpointID",
"\n",
"epOper",
".",
"ServiceName",
"=",
"ep",
".",
"ServiceName",
"\n",
"epOper",
".",
"EndpointGroupID",
"=",
"ep",
".",
"EndpointGroupID",
"\n",
"epOper",
".",
"EndpointGroupKey",
"=",
"ep",
".",
"EndpointGroupKey",
"\n",
"epOper",
".",
"IpAddress",
"=",
"[",
"]",
"string",
"{",
"ep",
".",
"IPAddress",
",",
"ep",
".",
"IPv6Address",
"}",
"\n",
"epOper",
".",
"MacAddress",
"=",
"ep",
".",
"MacAddress",
"\n",
"epOper",
".",
"HomingHost",
"=",
"ep",
".",
"HomingHost",
"\n",
"epOper",
".",
"IntfName",
"=",
"ep",
".",
"IntfName",
"\n",
"epOper",
".",
"VtepIP",
"=",
"ep",
".",
"VtepIP",
"\n",
"epOper",
".",
"Labels",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ep",
".",
"Labels",
")",
"\n",
"epOper",
".",
"ContainerID",
"=",
"ep",
".",
"ContainerID",
"\n",
"epOper",
".",
"ContainerName",
"=",
"ep",
".",
"EPCommonName",
"\n",
"epgOper",
".",
"Endpoints",
"=",
"append",
"(",
"epgOper",
".",
"Endpoints",
",",
"epOper",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"tenant",
".",
"Oper",
".",
"EndpointGroups",
"=",
"append",
"(",
"tenant",
".",
"Oper",
".",
"EndpointGroups",
",",
"epgOper",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // Get all the EPGs inside tenant | [
"Get",
"all",
"the",
"EPGs",
"inside",
"tenant"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1836-L1895 |
8,215 | contiv/netplugin | netmaster/objApi/apiController.go | TenantGetOper | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"TenantGetOper",
"(",
"tenant",
"*",
"contivModel",
".",
"TenantInspect",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"tenant",
")",
"\n\n",
"tenant",
".",
"Oper",
".",
"TotalNetworks",
"=",
"len",
"(",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"Networks",
")",
"\n",
"tenant",
".",
"Oper",
".",
"TotalEPGs",
"=",
"len",
"(",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"EndpointGroups",
")",
"\n",
"tenant",
".",
"Oper",
".",
"TotalNetprofiles",
"=",
"len",
"(",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"NetProfiles",
")",
"\n",
"tenant",
".",
"Oper",
".",
"TotalPolicies",
"=",
"len",
"(",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"Policies",
")",
"\n",
"tenant",
".",
"Oper",
".",
"TotalAppProfiles",
"=",
"len",
"(",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"AppProfiles",
")",
"\n",
"tenant",
".",
"Oper",
".",
"TotalServicelbs",
"=",
"len",
"(",
"tenant",
".",
"Config",
".",
"LinkSets",
".",
"Servicelbs",
")",
"\n\n",
"//Get all the networks config and oper parmeters under this tenant",
"getTenantNetworks",
"(",
"tenant",
")",
"\n\n",
"//Get all the EPGs config and oper parmeters under this tenant",
"getTenantEPGs",
"(",
"tenant",
")",
"\n\n",
"return",
"nil",
"\n\n",
"}"
]
| // TenantGetOper inspects tenant | [
"TenantGetOper",
"inspects",
"tenant"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1898-L1916 |
8,216 | contiv/netplugin | netmaster/objApi/apiController.go | TenantUpdate | 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 | 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")
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"TenantUpdate",
"(",
"tenant",
",",
"params",
"*",
"contivModel",
".",
"Tenant",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"tenant",
",",
"params",
")",
"\n\n",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
]
| // TenantUpdate updates a tenant | [
"TenantUpdate",
"updates",
"a",
"tenant"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1919-L1923 |
8,217 | contiv/netplugin | netmaster/objApi/apiController.go | TenantDelete | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"TenantDelete",
"(",
"tenant",
"*",
"contivModel",
".",
"Tenant",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"tenant",
")",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// if the tenant has associated app profiles, fail the delete",
"profCount",
":=",
"len",
"(",
"tenant",
".",
"LinkSets",
".",
"AppProfiles",
")",
"\n",
"if",
"profCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
".",
"TenantName",
",",
"profCount",
")",
"\n",
"}",
"\n",
"// if the tenant has associated epgs, fail the delete",
"epgCount",
":=",
"len",
"(",
"tenant",
".",
"LinkSets",
".",
"EndpointGroups",
")",
"\n",
"if",
"epgCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
".",
"TenantName",
",",
"epgCount",
")",
"\n",
"}",
"\n",
"// if the tenant has associated policies, fail the delete",
"policyCount",
":=",
"len",
"(",
"tenant",
".",
"LinkSets",
".",
"Policies",
")",
"\n",
"if",
"policyCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
".",
"TenantName",
",",
"policyCount",
")",
"\n",
"}",
"\n",
"npCount",
":=",
"len",
"(",
"tenant",
".",
"LinkSets",
".",
"NetProfiles",
")",
"\n",
"if",
"npCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
".",
"TenantName",
",",
"npCount",
")",
"\n",
"}",
"\n",
"// if the tenant has associated networks, fail the delete",
"nwCount",
":=",
"len",
"(",
"tenant",
".",
"LinkSets",
".",
"Networks",
")",
"\n",
"if",
"nwCount",
"!=",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
".",
"TenantName",
",",
"nwCount",
")",
"\n",
"}",
"\n\n",
"// Build tenant config",
"tenantCfg",
":=",
"intent",
".",
"ConfigTenant",
"{",
"Name",
":",
"tenant",
".",
"TenantName",
",",
"DefaultNetwork",
":",
"tenant",
".",
"DefaultNetwork",
",",
"}",
"\n\n",
"// Delete the tenant",
"err",
"=",
"master",
".",
"DeleteTenant",
"(",
"stateDriver",
",",
"&",
"tenantCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tenant",
".",
"TenantName",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // TenantDelete deletes a tenant | [
"TenantDelete",
"deletes",
"a",
"tenant"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1926-L1977 |
8,218 | contiv/netplugin | netmaster/objApi/apiController.go | BgpCreate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"BgpCreate",
"(",
"bgpCfg",
"*",
"contivModel",
".",
"Bgp",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"bgpCfg",
")",
"\n\n",
"if",
"bgpCfg",
".",
"Hostname",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Build bgp config",
"bgpIntentCfg",
":=",
"intent",
".",
"ConfigBgp",
"{",
"Hostname",
":",
"bgpCfg",
".",
"Hostname",
",",
"RouterIP",
":",
"bgpCfg",
".",
"Routerip",
",",
"As",
":",
"bgpCfg",
".",
"As",
",",
"NeighborAs",
":",
"bgpCfg",
".",
"NeighborAs",
",",
"Neighbor",
":",
"bgpCfg",
".",
"Neighbor",
",",
"}",
"\n\n",
"// Add the Bgp neighbor",
"err",
"=",
"master",
".",
"AddBgp",
"(",
"stateDriver",
",",
"&",
"bgpIntentCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"bgpCfg",
".",
"Neighbor",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| //BgpCreate add bgp neighbor | [
"BgpCreate",
"add",
"bgp",
"neighbor"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L1980-L2009 |
8,219 | contiv/netplugin | netmaster/objApi/apiController.go | BgpDelete | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"BgpDelete",
"(",
"bgpCfg",
"*",
"contivModel",
".",
"Bgp",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"bgpCfg",
".",
"Hostname",
")",
"\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"master",
".",
"DeleteBgp",
"(",
"stateDriver",
",",
"bgpCfg",
".",
"Hostname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| //BgpDelete deletes bgp neighbor | [
"BgpDelete",
"deletes",
"bgp",
"neighbor"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2012-L2027 |
8,220 | contiv/netplugin | netmaster/objApi/apiController.go | BgpUpdate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"BgpUpdate",
"(",
"oldbgpCfg",
"*",
"contivModel",
".",
"Bgp",
",",
"NewbgpCfg",
"*",
"contivModel",
".",
"Bgp",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"NewbgpCfg",
")",
"\n\n",
"if",
"NewbgpCfg",
".",
"Hostname",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Build bgp config",
"bgpIntentCfg",
":=",
"intent",
".",
"ConfigBgp",
"{",
"Hostname",
":",
"NewbgpCfg",
".",
"Hostname",
",",
"RouterIP",
":",
"NewbgpCfg",
".",
"Routerip",
",",
"As",
":",
"NewbgpCfg",
".",
"As",
",",
"NeighborAs",
":",
"NewbgpCfg",
".",
"NeighborAs",
",",
"Neighbor",
":",
"NewbgpCfg",
".",
"Neighbor",
",",
"}",
"\n\n",
"// Add the Bgp neighbor",
"err",
"=",
"master",
".",
"AddBgp",
"(",
"stateDriver",
",",
"&",
"bgpIntentCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"NewbgpCfg",
".",
"Neighbor",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"oldbgpCfg",
".",
"Hostname",
"=",
"NewbgpCfg",
".",
"Hostname",
"\n",
"oldbgpCfg",
".",
"Routerip",
"=",
"NewbgpCfg",
".",
"Routerip",
"\n",
"oldbgpCfg",
".",
"As",
"=",
"NewbgpCfg",
".",
"As",
"\n",
"oldbgpCfg",
".",
"NeighborAs",
"=",
"NewbgpCfg",
".",
"NeighborAs",
"\n",
"oldbgpCfg",
".",
"Neighbor",
"=",
"NewbgpCfg",
".",
"Neighbor",
"\n\n",
"NewbgpCfg",
".",
"Write",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| //BgpUpdate updates bgp config | [
"BgpUpdate",
"updates",
"bgp",
"config"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2030-L2068 |
8,221 | contiv/netplugin | netmaster/objApi/apiController.go | BgpGetOper | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"BgpGetOper",
"(",
"bgp",
"*",
"contivModel",
".",
"BgpInspect",
")",
"error",
"{",
"var",
"obj",
"BgpInspect",
"\n",
"var",
"host",
"string",
"\n\n",
"srvList",
",",
"err",
":=",
"ac",
".",
"objdbClient",
".",
"GetService",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"srv",
":=",
"range",
"srvList",
"{",
"if",
"srv",
".",
"Hostname",
"==",
"bgp",
".",
"Config",
".",
"Hostname",
"{",
"host",
"=",
"srv",
".",
"HostAddr",
"\n",
"}",
"\n",
"}",
"\n\n",
"url",
":=",
"\"",
"\"",
"+",
"host",
"+",
"\"",
"\"",
"\n",
"r",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"r",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"switch",
"{",
"case",
"r",
".",
"StatusCode",
"==",
"int",
"(",
"404",
")",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"case",
"r",
".",
"StatusCode",
"==",
"int",
"(",
"403",
")",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"case",
"r",
".",
"StatusCode",
"==",
"int",
"(",
"500",
")",
":",
"response",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"errors",
".",
"New",
"(",
"string",
"(",
"response",
")",
")",
"\n",
"case",
"r",
".",
"StatusCode",
"!=",
"int",
"(",
"200",
")",
":",
"log",
".",
"Debugf",
"(",
"\"",
"\\n",
"\"",
",",
"r",
".",
"Status",
",",
"r",
".",
"StatusCode",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"r",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"response",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"response",
",",
"&",
"obj",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"//Assuming bgp peer state will be only for one neighbor",
"if",
"obj",
".",
"Peers",
"!=",
"nil",
"{",
"nConf",
":=",
"obj",
".",
"Peers",
"[",
"0",
"]",
"\n",
"bgp",
".",
"Oper",
".",
"NeighborStatus",
"=",
"string",
"(",
"nConf",
".",
"State",
".",
"SessionState",
")",
"\n",
"bgp",
".",
"Oper",
".",
"AdminStatus",
"=",
"nConf",
".",
"State",
".",
"AdminState",
"\n",
"}",
"\n\n",
"if",
"obj",
".",
"Dsts",
"!=",
"nil",
"{",
"for",
"_",
",",
"dst",
":=",
"range",
"obj",
".",
"Dsts",
"{",
"bgp",
".",
"Oper",
".",
"Routes",
"=",
"append",
"(",
"bgp",
".",
"Oper",
".",
"Routes",
",",
"dst",
")",
"\n",
"}",
"\n",
"bgp",
".",
"Oper",
".",
"NumRoutes",
"=",
"len",
"(",
"bgp",
".",
"Oper",
".",
"Routes",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| //BgpGetOper inspects the oper state of bgp object | [
"BgpGetOper",
"inspects",
"the",
"oper",
"state",
"of",
"bgp",
"object"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2071-L2133 |
8,222 | contiv/netplugin | netmaster/objApi/apiController.go | ServiceLBCreate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"ServiceLBCreate",
"(",
"serviceCfg",
"*",
"contivModel",
".",
"ServiceLB",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"serviceCfg",
")",
"\n\n",
"if",
"serviceCfg",
".",
"ServiceName",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"serviceCfg",
".",
"Selectors",
")",
"==",
"0",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"validatePorts",
"(",
"serviceCfg",
".",
"Ports",
")",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"serviceCfg",
".",
"TenantName",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"serviceCfg",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serviceCfg",
".",
"TenantName",
")",
"\n",
"}",
"\n\n",
"network",
":=",
"contivModel",
".",
"FindNetwork",
"(",
"serviceCfg",
".",
"TenantName",
"+",
"\"",
"\"",
"+",
"serviceCfg",
".",
"NetworkName",
")",
"\n",
"if",
"network",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serviceCfg",
".",
"NetworkName",
")",
"\n",
"}",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Build service config",
"serviceIntentCfg",
":=",
"intent",
".",
"ConfigServiceLB",
"{",
"ServiceName",
":",
"serviceCfg",
".",
"ServiceName",
",",
"Tenant",
":",
"serviceCfg",
".",
"TenantName",
",",
"Network",
":",
"serviceCfg",
".",
"NetworkName",
",",
"IPAddress",
":",
"serviceCfg",
".",
"IpAddress",
",",
"}",
"\n",
"serviceIntentCfg",
".",
"Ports",
"=",
"append",
"(",
"serviceIntentCfg",
".",
"Ports",
",",
"serviceCfg",
".",
"Ports",
"...",
")",
"\n\n",
"serviceIntentCfg",
".",
"Selectors",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"for",
"_",
",",
"selector",
":=",
"range",
"serviceCfg",
".",
"Selectors",
"{",
"if",
"validateSelectors",
"(",
"selector",
")",
"{",
"key",
":=",
"strings",
".",
"Split",
"(",
"selector",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"value",
":=",
"strings",
".",
"Split",
"(",
"selector",
",",
"\"",
"\"",
")",
"[",
"1",
"]",
"\n",
"serviceIntentCfg",
".",
"Selectors",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"else",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"selector",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// Add the service object",
"err",
"=",
"master",
".",
"CreateServiceLB",
"(",
"stateDriver",
",",
"&",
"serviceIntentCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serviceIntentCfg",
".",
"ServiceName",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"// Setup links",
"if",
"tenant",
"!=",
"nil",
"{",
"modeldb",
".",
"AddLink",
"(",
"&",
"serviceCfg",
".",
"Links",
".",
"Tenant",
",",
"tenant",
")",
"\n",
"modeldb",
".",
"AddLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"Servicelbs",
",",
"serviceCfg",
")",
"\n",
"tenant",
".",
"Write",
"(",
")",
"\n",
"}",
"\n\n",
"// Setup links",
"if",
"network",
"!=",
"nil",
"{",
"modeldb",
".",
"AddLink",
"(",
"&",
"serviceCfg",
".",
"Links",
".",
"Network",
",",
"network",
")",
"\n",
"modeldb",
".",
"AddLinkSet",
"(",
"&",
"network",
".",
"LinkSets",
".",
"Servicelbs",
",",
"serviceCfg",
")",
"\n",
"network",
".",
"Write",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n\n",
"}"
]
| //ServiceLBCreate creates service object | [
"ServiceLBCreate",
"creates",
"service",
"object"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2136-L2213 |
8,223 | contiv/netplugin | netmaster/objApi/apiController.go | ServiceLBUpdate | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"ServiceLBUpdate",
"(",
"oldServiceCfg",
"*",
"contivModel",
".",
"ServiceLB",
",",
"serviceCfg",
"*",
"contivModel",
".",
"ServiceLB",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"serviceCfg",
")",
"\n",
"err",
":=",
"ac",
".",
"ServiceLBCreate",
"(",
"serviceCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"oldServiceCfg",
".",
"ServiceName",
"=",
"serviceCfg",
".",
"ServiceName",
"\n",
"oldServiceCfg",
".",
"TenantName",
"=",
"serviceCfg",
".",
"TenantName",
"\n",
"oldServiceCfg",
".",
"NetworkName",
"=",
"serviceCfg",
".",
"NetworkName",
"\n",
"oldServiceCfg",
".",
"IpAddress",
"=",
"serviceCfg",
".",
"IpAddress",
"\n",
"oldServiceCfg",
".",
"Selectors",
"=",
"nil",
"\n",
"oldServiceCfg",
".",
"Ports",
"=",
"nil",
"\n",
"oldServiceCfg",
".",
"Selectors",
"=",
"append",
"(",
"oldServiceCfg",
".",
"Selectors",
",",
"serviceCfg",
".",
"Selectors",
"...",
")",
"\n",
"oldServiceCfg",
".",
"Ports",
"=",
"append",
"(",
"oldServiceCfg",
".",
"Ports",
",",
"serviceCfg",
".",
"Ports",
"...",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| //ServiceLBUpdate updates service object | [
"ServiceLBUpdate",
"updates",
"service",
"object"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2216-L2231 |
8,224 | contiv/netplugin | netmaster/objApi/apiController.go | ServiceLBDelete | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"ServiceLBDelete",
"(",
"serviceCfg",
"*",
"contivModel",
".",
"ServiceLB",
")",
"error",
"{",
"log",
".",
"Info",
"(",
"\"",
"\"",
",",
"serviceCfg",
")",
"\n\n",
"if",
"serviceCfg",
".",
"ServiceName",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Add the service object",
"err",
"=",
"master",
".",
"DeleteServiceLB",
"(",
"stateDriver",
",",
"serviceCfg",
".",
"ServiceName",
",",
"serviceCfg",
".",
"TenantName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serviceCfg",
".",
"ServiceName",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"// Find the tenant",
"tenant",
":=",
"contivModel",
".",
"FindTenant",
"(",
"serviceCfg",
".",
"TenantName",
")",
"\n",
"if",
"tenant",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serviceCfg",
".",
"TenantName",
")",
"\n",
"}",
"\n\n",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"tenant",
".",
"LinkSets",
".",
"Servicelbs",
",",
"serviceCfg",
")",
"\n",
"tenant",
".",
"Write",
"(",
")",
"\n\n",
"nwKey",
":=",
"serviceCfg",
".",
"TenantName",
"+",
"\"",
"\"",
"+",
"serviceCfg",
".",
"NetworkName",
"\n",
"network",
":=",
"contivModel",
".",
"FindNetwork",
"(",
"nwKey",
")",
"\n",
"if",
"network",
"==",
"nil",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"serviceCfg",
".",
"NetworkName",
",",
"serviceCfg",
".",
"TenantName",
")",
"\n",
"}",
"\n",
"modeldb",
".",
"RemoveLinkSet",
"(",
"&",
"network",
".",
"LinkSets",
".",
"Servicelbs",
",",
"serviceCfg",
")",
"\n",
"network",
".",
"Write",
"(",
")",
"\n\n",
"return",
"nil",
"\n\n",
"}"
]
| //ServiceLBDelete deletes service object | [
"ServiceLBDelete",
"deletes",
"service",
"object"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2234-L2273 |
8,225 | contiv/netplugin | netmaster/objApi/apiController.go | ServiceLBGetOper | 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 | 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
} | [
"func",
"(",
"ac",
"*",
"APIController",
")",
"ServiceLBGetOper",
"(",
"serviceLB",
"*",
"contivModel",
".",
"ServiceLBInspect",
")",
"error",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"serviceLB",
")",
"\n\n",
"// Get the state driver",
"stateDriver",
",",
"err",
":=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"serviceID",
":=",
"master",
".",
"GetServiceID",
"(",
"serviceLB",
".",
"Config",
".",
"ServiceName",
",",
"serviceLB",
".",
"Config",
".",
"TenantName",
")",
"\n",
"service",
":=",
"mastercfg",
".",
"ServiceLBDb",
"[",
"serviceID",
"]",
"\n",
"if",
"service",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"serviceLB",
".",
"Oper",
".",
"ServiceVip",
"=",
"service",
".",
"IPAddress",
"\n",
"count",
":=",
"0",
"\n",
"for",
"_",
",",
"provider",
":=",
"range",
"service",
".",
"Providers",
"{",
"epCfg",
":=",
"&",
"mastercfg",
".",
"CfgEndpointState",
"{",
"}",
"\n",
"epCfg",
".",
"StateDriver",
"=",
"stateDriver",
"\n",
"err",
":=",
"epCfg",
".",
"Read",
"(",
"provider",
".",
"EpIDKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"epOper",
":=",
"contivModel",
".",
"EndpointOper",
"{",
"}",
"\n",
"epOper",
".",
"Network",
"=",
"epCfg",
".",
"NetID",
"\n",
"epOper",
".",
"EndpointID",
"=",
"epCfg",
".",
"EndpointID",
"\n",
"epOper",
".",
"ServiceName",
"=",
"service",
".",
"ServiceName",
"//FIXME:fill in service name in endpoint",
"\n",
"epOper",
".",
"EndpointGroupID",
"=",
"epCfg",
".",
"EndpointGroupID",
"\n",
"epOper",
".",
"EndpointGroupKey",
"=",
"epCfg",
".",
"EndpointGroupKey",
"\n",
"epOper",
".",
"IpAddress",
"=",
"[",
"]",
"string",
"{",
"epCfg",
".",
"IPAddress",
",",
"epCfg",
".",
"IPv6Address",
"}",
"\n",
"epOper",
".",
"MacAddress",
"=",
"epCfg",
".",
"MacAddress",
"\n",
"epOper",
".",
"HomingHost",
"=",
"epCfg",
".",
"HomingHost",
"\n",
"epOper",
".",
"IntfName",
"=",
"epCfg",
".",
"IntfName",
"\n",
"epOper",
".",
"VtepIP",
"=",
"epCfg",
".",
"VtepIP",
"\n",
"epOper",
".",
"Labels",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"epCfg",
".",
"Labels",
")",
"\n",
"epOper",
".",
"ContainerID",
"=",
"epCfg",
".",
"ContainerID",
"\n",
"epOper",
".",
"ContainerName",
"=",
"epCfg",
".",
"EPCommonName",
"\n",
"serviceLB",
".",
"Oper",
".",
"Providers",
"=",
"append",
"(",
"serviceLB",
".",
"Oper",
".",
"Providers",
",",
"epOper",
")",
"\n",
"count",
"++",
"\n",
"epCfg",
"=",
"nil",
"\n",
"}",
"\n",
"serviceLB",
".",
"Oper",
".",
"NumProviders",
"=",
"count",
"\n",
"return",
"nil",
"\n\n",
"}"
]
| //ServiceLBGetOper inspects the oper state of service lb object | [
"ServiceLBGetOper",
"inspects",
"the",
"oper",
"state",
"of",
"service",
"lb",
"object"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/objApi/apiController.go#L2276-L2320 |
8,226 | contiv/netplugin | netplugin/plugin/netplugin.go | Init | 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 | 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
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"Init",
"(",
"pluginConfig",
"Config",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"pluginConfig",
".",
"Instance",
".",
"HostLabel",
"==",
"\"",
"\"",
"{",
"return",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// initialize state driver",
"p",
".",
"StateDriver",
",",
"err",
"=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"p",
".",
"StateDriver",
",",
"err",
"=",
"utils",
".",
"NewStateDriver",
"(",
"pluginConfig",
".",
"Drivers",
".",
"State",
",",
"&",
"pluginConfig",
".",
"Instance",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"ReleaseStateDriver",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"// set state driver in instance info",
"pluginConfig",
".",
"Instance",
".",
"StateDriver",
"=",
"p",
".",
"StateDriver",
"\n",
"err",
"=",
"InitGlobalSettings",
"(",
"p",
".",
"StateDriver",
",",
"&",
"pluginConfig",
".",
"Instance",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// initialize network driver",
"p",
".",
"NetworkDriver",
",",
"err",
"=",
"utils",
".",
"NewNetworkDriver",
"(",
"pluginConfig",
".",
"Drivers",
".",
"Network",
",",
"&",
"pluginConfig",
".",
"Instance",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"p",
".",
"PluginConfig",
"=",
"pluginConfig",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"p",
".",
"NetworkDriver",
".",
"Deinit",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // Init initializes the NetPlugin instance via the configuration string passed. | [
"Init",
"initializes",
"the",
"NetPlugin",
"instance",
"via",
"the",
"configuration",
"string",
"passed",
"."
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L56-L97 |
8,227 | contiv/netplugin | netplugin/plugin/netplugin.go | Deinit | 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 | 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
}
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"Deinit",
"(",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"p",
".",
"NetworkDriver",
"!=",
"nil",
"{",
"p",
".",
"NetworkDriver",
".",
"Deinit",
"(",
")",
"\n",
"p",
".",
"NetworkDriver",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"p",
".",
"StateDriver",
"!=",
"nil",
"{",
"utils",
".",
"ReleaseStateDriver",
"(",
")",
"\n",
"p",
".",
"StateDriver",
"=",
"nil",
"\n",
"}",
"\n",
"}"
]
| // Deinit is a destructor for the NetPlugin configuration. | [
"Deinit",
"is",
"a",
"destructor",
"for",
"the",
"NetPlugin",
"configuration",
"."
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L100-L112 |
8,228 | contiv/netplugin | netplugin/plugin/netplugin.go | DeleteNetwork | 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 | 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)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"DeleteNetwork",
"(",
"id",
",",
"subnet",
",",
"nwType",
",",
"encap",
"string",
",",
"pktTag",
",",
"extPktTag",
"int",
",",
"Gw",
"string",
",",
"tenant",
"string",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"DeleteNetwork",
"(",
"id",
",",
"subnet",
",",
"nwType",
",",
"encap",
",",
"pktTag",
",",
"extPktTag",
",",
"Gw",
",",
"tenant",
")",
"\n",
"}"
]
| // DeleteNetwork deletes a network provided by the ID. | [
"DeleteNetwork",
"deletes",
"a",
"network",
"provided",
"by",
"the",
"ID",
"."
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L122-L126 |
8,229 | contiv/netplugin | netplugin/plugin/netplugin.go | FetchNetwork | func (p *NetPlugin) FetchNetwork(id string) (core.State, error) {
return nil, core.Errorf("Not implemented")
} | go | func (p *NetPlugin) FetchNetwork(id string) (core.State, error) {
return nil, core.Errorf("Not implemented")
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"FetchNetwork",
"(",
"id",
"string",
")",
"(",
"core",
".",
"State",
",",
"error",
")",
"{",
"return",
"nil",
",",
"core",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
]
| // FetchNetwork retrieves a network's state given an ID. | [
"FetchNetwork",
"retrieves",
"a",
"network",
"s",
"state",
"given",
"an",
"ID",
"."
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L129-L131 |
8,230 | contiv/netplugin | netplugin/plugin/netplugin.go | CreateHostAccPort | 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 | func (p *NetPlugin) CreateHostAccPort(portName, globalIP string) (string, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.CreateHostAccPort(portName, globalIP, p.PluginConfig.Instance.HostPvtNW)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"CreateHostAccPort",
"(",
"portName",
",",
"globalIP",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"CreateHostAccPort",
"(",
"portName",
",",
"globalIP",
",",
"p",
".",
"PluginConfig",
".",
"Instance",
".",
"HostPvtNW",
")",
"\n",
"}"
]
| // CreateHostAccPort creates a host access port | [
"CreateHostAccPort",
"creates",
"a",
"host",
"access",
"port"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L169-L173 |
8,231 | contiv/netplugin | netplugin/plugin/netplugin.go | DeleteHostAccPort | func (p *NetPlugin) DeleteHostAccPort(portName string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteHostAccPort(portName)
} | go | func (p *NetPlugin) DeleteHostAccPort(portName string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeleteHostAccPort(portName)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"DeleteHostAccPort",
"(",
"portName",
"string",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"DeleteHostAccPort",
"(",
"portName",
")",
"\n",
"}"
]
| // DeleteHostAccPort creates a host access port | [
"DeleteHostAccPort",
"creates",
"a",
"host",
"access",
"port"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L176-L180 |
8,232 | contiv/netplugin | netplugin/plugin/netplugin.go | DeletePeerHost | func (p *NetPlugin) DeletePeerHost(node core.ServiceInfo) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeletePeerHost(node)
} | go | func (p *NetPlugin) DeletePeerHost(node core.ServiceInfo) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DeletePeerHost(node)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"DeletePeerHost",
"(",
"node",
"core",
".",
"ServiceInfo",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"DeletePeerHost",
"(",
"node",
")",
"\n",
"}"
]
| // DeletePeerHost removes a peer host. | [
"DeletePeerHost",
"removes",
"a",
"peer",
"host",
"."
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L195-L199 |
8,233 | contiv/netplugin | netplugin/plugin/netplugin.go | AddServiceLB | func (p *NetPlugin) AddServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddSvcSpec(servicename, spec)
} | go | func (p *NetPlugin) AddServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddSvcSpec(servicename, spec)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"AddServiceLB",
"(",
"servicename",
"string",
",",
"spec",
"*",
"core",
".",
"ServiceSpec",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"AddSvcSpec",
"(",
"servicename",
",",
"spec",
")",
"\n",
"}"
]
| //AddServiceLB adds service | [
"AddServiceLB",
"adds",
"service"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L230-L234 |
8,234 | contiv/netplugin | netplugin/plugin/netplugin.go | DeleteServiceLB | func (p *NetPlugin) DeleteServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DelSvcSpec(servicename, spec)
} | go | func (p *NetPlugin) DeleteServiceLB(servicename string, spec *core.ServiceSpec) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.DelSvcSpec(servicename, spec)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"DeleteServiceLB",
"(",
"servicename",
"string",
",",
"spec",
"*",
"core",
".",
"ServiceSpec",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"DelSvcSpec",
"(",
"servicename",
",",
"spec",
")",
"\n",
"}"
]
| //DeleteServiceLB deletes service | [
"DeleteServiceLB",
"deletes",
"service"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L237-L241 |
8,235 | contiv/netplugin | netplugin/plugin/netplugin.go | GetEndpointStats | func (p *NetPlugin) GetEndpointStats() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GetEndpointStats()
} | go | func (p *NetPlugin) GetEndpointStats() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GetEndpointStats()
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"GetEndpointStats",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"GetEndpointStats",
"(",
")",
"\n",
"}"
]
| // GetEndpointStats returns all endpoint stats | [
"GetEndpointStats",
"returns",
"all",
"endpoint",
"stats"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L251-L255 |
8,236 | contiv/netplugin | netplugin/plugin/netplugin.go | InspectState | func (p *NetPlugin) InspectState() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectState()
} | go | func (p *NetPlugin) InspectState() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectState()
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"InspectState",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"InspectState",
"(",
")",
"\n",
"}"
]
| // InspectState returns current state of the plugin | [
"InspectState",
"returns",
"current",
"state",
"of",
"the",
"plugin"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L258-L262 |
8,237 | contiv/netplugin | netplugin/plugin/netplugin.go | InspectBgp | func (p *NetPlugin) InspectBgp() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectBgp()
} | go | func (p *NetPlugin) InspectBgp() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectBgp()
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"InspectBgp",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"InspectBgp",
"(",
")",
"\n",
"}"
]
| // InspectBgp returns current state of the plugin | [
"InspectBgp",
"returns",
"current",
"state",
"of",
"the",
"plugin"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L265-L269 |
8,238 | contiv/netplugin | netplugin/plugin/netplugin.go | InspectNameserver | func (p *NetPlugin) InspectNameserver() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectNameserver()
} | go | func (p *NetPlugin) InspectNameserver() ([]byte, error) {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.InspectNameserver()
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"InspectNameserver",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"InspectNameserver",
"(",
")",
"\n",
"}"
]
| // InspectNameserver returns current state of the nameserver | [
"InspectNameserver",
"returns",
"current",
"state",
"of",
"the",
"nameserver"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L272-L276 |
8,239 | contiv/netplugin | netplugin/plugin/netplugin.go | GlobalConfigUpdate | func (p *NetPlugin) GlobalConfigUpdate(cfg Config) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GlobalConfigUpdate(cfg.Instance)
} | go | func (p *NetPlugin) GlobalConfigUpdate(cfg Config) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.GlobalConfigUpdate(cfg.Instance)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"GlobalConfigUpdate",
"(",
"cfg",
"Config",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"GlobalConfigUpdate",
"(",
"cfg",
".",
"Instance",
")",
"\n",
"}"
]
| //GlobalConfigUpdate update global config | [
"GlobalConfigUpdate",
"update",
"global",
"config"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L279-L283 |
8,240 | contiv/netplugin | netplugin/plugin/netplugin.go | Reinit | 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 | 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()
}
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"Reinit",
"(",
"cfg",
"Config",
")",
"{",
"var",
"err",
"error",
"\n\n",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"if",
"p",
".",
"NetworkDriver",
"!=",
"nil",
"{",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"p",
".",
"NetworkDriver",
".",
"Deinit",
"(",
")",
"\n",
"p",
".",
"NetworkDriver",
"=",
"nil",
"\n",
"}",
"\n\n",
"cfg",
".",
"Instance",
".",
"StateDriver",
",",
"_",
"=",
"utils",
".",
"GetStateDriver",
"(",
")",
"\n",
"p",
".",
"NetworkDriver",
",",
"err",
"=",
"utils",
".",
"NewNetworkDriver",
"(",
"cfg",
".",
"Drivers",
".",
"Network",
",",
"&",
"cfg",
".",
"Instance",
")",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"p",
".",
"NetworkDriver",
".",
"Deinit",
"(",
")",
"\n",
"}",
"\n",
"}"
]
| //Reinit reinitialize the network driver | [
"Reinit",
"reinitialize",
"the",
"network",
"driver"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L286-L305 |
8,241 | contiv/netplugin | netplugin/plugin/netplugin.go | DelSvcSpec | func (p *NetPlugin) DelSvcSpec(svcName string, spec *core.ServiceSpec) {
p.Lock()
defer p.Unlock()
p.NetworkDriver.DelSvcSpec(svcName, spec)
} | go | func (p *NetPlugin) DelSvcSpec(svcName string, spec *core.ServiceSpec) {
p.Lock()
defer p.Unlock()
p.NetworkDriver.DelSvcSpec(svcName, spec)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"DelSvcSpec",
"(",
"svcName",
"string",
",",
"spec",
"*",
"core",
".",
"ServiceSpec",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"NetworkDriver",
".",
"DelSvcSpec",
"(",
"svcName",
",",
"spec",
")",
"\n",
"}"
]
| //DelSvcSpec deletes k8 service spec | [
"DelSvcSpec",
"deletes",
"k8",
"service",
"spec"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L371-L375 |
8,242 | contiv/netplugin | netplugin/plugin/netplugin.go | AddPolicyRule | func (p *NetPlugin) AddPolicyRule(id string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddPolicyRule(id)
} | go | func (p *NetPlugin) AddPolicyRule(id string) error {
p.Lock()
defer p.Unlock()
return p.NetworkDriver.AddPolicyRule(id)
} | [
"func",
"(",
"p",
"*",
"NetPlugin",
")",
"AddPolicyRule",
"(",
"id",
"string",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"NetworkDriver",
".",
"AddPolicyRule",
"(",
"id",
")",
"\n",
"}"
]
| // AddPolicyRule creates a policy rule | [
"AddPolicyRule",
"creates",
"a",
"policy",
"rule"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netplugin/plugin/netplugin.go#L378-L382 |
8,243 | contiv/netplugin | netmaster/k8snetwork/networkpolicy.go | InitK8SServiceWatch | 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 | 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
} | [
"func",
"InitK8SServiceWatch",
"(",
"listenAddr",
"string",
",",
"isLeader",
"func",
"(",
")",
"bool",
")",
"error",
"{",
"npLog",
"=",
"log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"npLog",
".",
"Infof",
"(",
"\"",
"\"",
",",
"listenAddr",
")",
"\n",
"contivClient",
",",
"err",
":=",
"client",
".",
"NewContivClient",
"(",
"\"",
"\"",
"+",
"listenAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"npLog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"k8sClientSet",
",",
"err",
":=",
"k8sutils",
".",
"SetUpK8SClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"npLog",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"kubeNet",
":=",
"k8sContext",
"{",
"contivClient",
":",
"contivClient",
",",
"k8sClientSet",
":",
"k8sClientSet",
",",
"isLeader",
":",
"isLeader",
"}",
"\n\n",
"go",
"kubeNet",
".",
"handleK8sEvents",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // InitK8SServiceWatch monitor k8s services | [
"InitK8SServiceWatch",
"monitor",
"k8s",
"services"
]
| 965773066d2b8ebed3514979949061a03d46fd20 | https://github.com/contiv/netplugin/blob/965773066d2b8ebed3514979949061a03d46fd20/netmaster/k8snetwork/networkpolicy.go#L376-L395 |
8,244 | kellydunn/golang-geo | point.go | MarshalBinary | 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 | 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
} | [
"func",
"(",
"p",
"*",
"Point",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"err",
":=",
"binary",
".",
"Write",
"(",
"&",
"buf",
",",
"binary",
".",
"LittleEndian",
",",
"p",
".",
"lat",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"lat",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"binary",
".",
"Write",
"(",
"&",
"buf",
",",
"binary",
".",
"LittleEndian",
",",
"p",
".",
"lng",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"lng",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
]
| // MarshalBinary renders the current point to a byte slice.
// Implements the encoding.BinaryMarshaler Interface. | [
"MarshalBinary",
"renders",
"the",
"current",
"point",
"to",
"a",
"byte",
"slice",
".",
"Implements",
"the",
"encoding",
".",
"BinaryMarshaler",
"Interface",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/point.go#L130-L142 |
8,245 | kellydunn/golang-geo | point.go | MarshalJSON | func (p *Point) MarshalJSON() ([]byte, error) {
res := fmt.Sprintf(`{"lat":%v, "lng":%v}`, p.lat, p.lng)
return []byte(res), nil
} | go | func (p *Point) MarshalJSON() ([]byte, error) {
res := fmt.Sprintf(`{"lat":%v, "lng":%v}`, p.lat, p.lng)
return []byte(res), nil
} | [
"func",
"(",
"p",
"*",
"Point",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"res",
":=",
"fmt",
".",
"Sprintf",
"(",
"`{\"lat\":%v, \"lng\":%v}`",
",",
"p",
".",
"lat",
",",
"p",
".",
"lng",
")",
"\n",
"return",
"[",
"]",
"byte",
"(",
"res",
")",
",",
"nil",
"\n",
"}"
]
| // MarshalJSON renders the current Point to valid JSON.
// Implements the json.Marshaller Interface. | [
"MarshalJSON",
"renders",
"the",
"current",
"Point",
"to",
"valid",
"JSON",
".",
"Implements",
"the",
"json",
".",
"Marshaller",
"Interface",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/point.go#L166-L169 |
8,246 | kellydunn/golang-geo | point.go | UnmarshalJSON | 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 | 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
} | [
"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",
")",
")",
"\n",
"var",
"values",
"map",
"[",
"string",
"]",
"float64",
"\n",
"err",
":=",
"dec",
".",
"Decode",
"(",
"&",
"values",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"*",
"p",
"=",
"*",
"NewPoint",
"(",
"values",
"[",
"\"",
"\"",
"]",
",",
"values",
"[",
"\"",
"\"",
"]",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // UnmarshalJSON decodes the current Point from a JSON body.
// Throws an error if the body of the point cannot be interpreted by the JSON body | [
"UnmarshalJSON",
"decodes",
"the",
"current",
"Point",
"from",
"a",
"JSON",
"body",
".",
"Throws",
"an",
"error",
"if",
"the",
"body",
"of",
"the",
"point",
"cannot",
"be",
"interpreted",
"by",
"the",
"JSON",
"body"
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/point.go#L173-L187 |
8,247 | kellydunn/golang-geo | geo.go | HandleWithSQL | 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 | 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
} | [
"func",
"HandleWithSQL",
"(",
")",
"(",
"*",
"SQLMapper",
",",
"error",
")",
"{",
"sqlConf",
",",
"sqlConfErr",
":=",
"GetSQLConf",
"(",
")",
"\n",
"if",
"sqlConfErr",
"==",
"nil",
"{",
"s",
":=",
"&",
"SQLMapper",
"{",
"conf",
":",
"sqlConf",
"}",
"\n\n",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"s",
".",
"conf",
".",
"driver",
",",
"s",
".",
"conf",
".",
"openStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"s",
".",
"sqlConn",
"=",
"db",
"\n",
"return",
"s",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"sqlConfErr",
"\n",
"}"
]
| // HandleWithSQL retrieves the SQL configuration specified in config.yml
// that resides at the root level of the project.
// Returns a pointer to a SQLMapper if successful, or an error
// if there is an issue opening a database connection. | [
"HandleWithSQL",
"retrieves",
"the",
"SQL",
"configuration",
"specified",
"in",
"config",
".",
"yml",
"that",
"resides",
"at",
"the",
"root",
"level",
"of",
"the",
"project",
".",
"Returns",
"a",
"pointer",
"to",
"a",
"SQLMapper",
"if",
"successful",
"or",
"an",
"error",
"if",
"there",
"is",
"an",
"issue",
"opening",
"a",
"database",
"connection",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/geo.go#L14-L29 |
8,248 | kellydunn/golang-geo | opencage_geocoder.go | Geocode | 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 | 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
} | [
"func",
"(",
"g",
"*",
"OpenCageGeocoder",
")",
"Geocode",
"(",
"address",
"string",
")",
"(",
"*",
"Point",
",",
"error",
")",
"{",
"queryStr",
",",
"err",
":=",
"opencageGeocodeQueryStr",
"(",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"data",
",",
"err",
":=",
"g",
".",
"Request",
"(",
"queryStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"opencageGeocodeResponse",
"{",
"}",
"\n",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"res",
")",
"\n\n",
"if",
"len",
"(",
"res",
".",
"Results",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"opencageZeroResultsError",
"\n",
"}",
"\n\n",
"lat",
":=",
"res",
".",
"Results",
"[",
"0",
"]",
".",
"Geometry",
".",
"Lat",
"\n",
"lng",
":=",
"res",
".",
"Results",
"[",
"0",
"]",
".",
"Geometry",
".",
"Lng",
"\n\n",
"point",
":=",
"&",
"Point",
"{",
"lat",
":",
"lat",
",",
"lng",
":",
"lng",
",",
"}",
"\n\n",
"return",
"point",
",",
"nil",
"\n",
"}"
]
| // Geocode returns the first point returned by OpenCage's geocoding service or an error
// if one occurs during the geocoding request. | [
"Geocode",
"returns",
"the",
"first",
"point",
"returned",
"by",
"OpenCage",
"s",
"geocoding",
"service",
"or",
"an",
"error",
"if",
"one",
"occurs",
"during",
"the",
"geocoding",
"request",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/opencage_geocoder.go#L84-L112 |
8,249 | kellydunn/golang-geo | mapquest_geocoder.go | Geocode | 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 | 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
} | [
"func",
"(",
"g",
"*",
"MapQuestGeocoder",
")",
"Geocode",
"(",
"address",
"string",
")",
"(",
"*",
"Point",
",",
"error",
")",
"{",
"queryStr",
",",
"err",
":=",
"mapquestGeocodeQueryStr",
"(",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"data",
",",
"err",
":=",
"g",
".",
"Request",
"(",
"queryStr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"[",
"]",
"*",
"mapQuestGeocodeResponse",
"{",
"}",
"\n",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"res",
")",
"\n\n",
"if",
"len",
"(",
"res",
")",
"==",
"0",
"{",
"return",
"&",
"Point",
"{",
"}",
",",
"mapquestZeroResultsError",
"\n",
"}",
"\n\n",
"lat",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"res",
"[",
"0",
"]",
".",
"Lat",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"lng",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"res",
"[",
"0",
"]",
".",
"Lng",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"p",
":=",
"&",
"Point",
"{",
"lat",
":",
"lat",
",",
"lng",
":",
"lng",
",",
"}",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
]
| // Geocode returns the first point returned by MapQuest's geocoding service or an error
// if one occurs during the geocoding request. | [
"Geocode",
"returns",
"the",
"first",
"point",
"returned",
"by",
"MapQuest",
"s",
"geocoding",
"service",
"or",
"an",
"error",
"if",
"one",
"occurs",
"during",
"the",
"geocoding",
"request",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/mapquest_geocoder.go#L84-L119 |
8,250 | kellydunn/golang-geo | sql_conf.go | confFromYamlFile | 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 | 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
} | [
"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",
"(",
"\"",
"\"",
",",
"goEnv",
")",
")",
"\n",
"if",
"driveError",
"!=",
"nil",
"{",
"return",
"nil",
",",
"driveError",
"\n",
"}",
"\n\n",
"// Get openStr",
"openStr",
",",
"openStrError",
":=",
"config",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"goEnv",
")",
")",
"\n",
"if",
"openStrError",
"!=",
"nil",
"{",
"return",
"nil",
",",
"openStrError",
"\n",
"}",
"\n\n",
"// Get table",
"table",
",",
"tableError",
":=",
"config",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"goEnv",
")",
")",
"\n",
"if",
"tableError",
"!=",
"nil",
"{",
"return",
"nil",
",",
"tableError",
"\n",
"}",
"\n\n",
"// Get latCol",
"latCol",
",",
"latColError",
":=",
"config",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"goEnv",
")",
")",
"\n",
"if",
"latColError",
"!=",
"nil",
"{",
"return",
"nil",
",",
"latColError",
"\n",
"}",
"\n\n",
"// Get lngCol",
"lngCol",
",",
"lngColError",
":=",
"config",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"goEnv",
")",
")",
"\n",
"if",
"lngColError",
"!=",
"nil",
"{",
"return",
"nil",
",",
"lngColError",
"\n",
"}",
"\n\n",
"sqlConf",
":=",
"&",
"SQLConf",
"{",
"driver",
":",
"driver",
",",
"openStr",
":",
"openStr",
",",
"table",
":",
"table",
",",
"latCol",
":",
"latCol",
",",
"lngCol",
":",
"lngCol",
"}",
"\n",
"return",
"sqlConf",
",",
"nil",
"\n\n",
"}"
]
| // Creates a new SQLConf and returns a pointer to it.
// If it encounters an error during parsing the file,
// it will return an error instead. | [
"Creates",
"a",
"new",
"SQLConf",
"and",
"returns",
"a",
"pointer",
"to",
"it",
".",
"If",
"it",
"encounters",
"an",
"error",
"during",
"parsing",
"the",
"file",
"it",
"will",
"return",
"an",
"error",
"instead",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/sql_conf.go#L84-L121 |
8,251 | kellydunn/golang-geo | polygon.go | Contains | 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 | 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
} | [
"func",
"(",
"p",
"*",
"Polygon",
")",
"Contains",
"(",
"point",
"*",
"Point",
")",
"bool",
"{",
"if",
"!",
"p",
".",
"IsClosed",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"start",
":=",
"len",
"(",
"p",
".",
"points",
")",
"-",
"1",
"\n",
"end",
":=",
"0",
"\n\n",
"contains",
":=",
"p",
".",
"intersectsWithRaycast",
"(",
"point",
",",
"p",
".",
"points",
"[",
"start",
"]",
",",
"p",
".",
"points",
"[",
"end",
"]",
")",
"\n\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"len",
"(",
"p",
".",
"points",
")",
";",
"i",
"++",
"{",
"if",
"p",
".",
"intersectsWithRaycast",
"(",
"point",
",",
"p",
".",
"points",
"[",
"i",
"-",
"1",
"]",
",",
"p",
".",
"points",
"[",
"i",
"]",
")",
"{",
"contains",
"=",
"!",
"contains",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"contains",
"\n",
"}"
]
| // Contains returns whether or not the current Polygon contains the passed in Point. | [
"Contains",
"returns",
"whether",
"or",
"not",
"the",
"current",
"Polygon",
"contains",
"the",
"passed",
"in",
"Point",
"."
]
| 2c6d5d781da2b42e60f1d7507c1055ef625d8652 | https://github.com/kellydunn/golang-geo/blob/2c6d5d781da2b42e60f1d7507c1055ef625d8652/polygon.go#L46-L63 |
8,252 | remeh/sizedwaitgroup | sizedwaitgroup.go | New | 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 | 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{},
}
} | [
"func",
"New",
"(",
"limit",
"int",
")",
"SizedWaitGroup",
"{",
"size",
":=",
"math",
".",
"MaxInt32",
"// 2^32 - 1",
"\n",
"if",
"limit",
">",
"0",
"{",
"size",
"=",
"limit",
"\n",
"}",
"\n",
"return",
"SizedWaitGroup",
"{",
"Size",
":",
"size",
",",
"current",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"size",
")",
",",
"wg",
":",
"sync",
".",
"WaitGroup",
"{",
"}",
",",
"}",
"\n",
"}"
]
| // New creates a SizedWaitGroup.
// The limit parameter is the maximum amount of
// goroutines which can be started concurrently. | [
"New",
"creates",
"a",
"SizedWaitGroup",
".",
"The",
"limit",
"parameter",
"is",
"the",
"maximum",
"amount",
"of",
"goroutines",
"which",
"can",
"be",
"started",
"concurrently",
"."
]
| 5e7302b12ccef91dce9fde2f5bda6d5c7ea5d2eb | https://github.com/remeh/sizedwaitgroup/blob/5e7302b12ccef91dce9fde2f5bda6d5c7ea5d2eb/sizedwaitgroup.go#L31-L42 |
8,253 | remeh/sizedwaitgroup | sizedwaitgroup.go | AddWithContext | 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 | 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
} | [
"func",
"(",
"s",
"*",
"SizedWaitGroup",
")",
"AddWithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"ctx",
".",
"Err",
"(",
")",
"\n",
"case",
"s",
".",
"current",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"break",
"\n",
"}",
"\n",
"s",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // AddWithContext increments the internal WaitGroup counter.
// It can be blocking if the limit of spawned goroutines
// has been reached. It will stop blocking when Done is
// been called, or when the context is canceled. Returns nil on
// success or an error if the context is canceled before the lock
// is acquired.
//
// See sync.WaitGroup documentation for more information. | [
"AddWithContext",
"increments",
"the",
"internal",
"WaitGroup",
"counter",
".",
"It",
"can",
"be",
"blocking",
"if",
"the",
"limit",
"of",
"spawned",
"goroutines",
"has",
"been",
"reached",
".",
"It",
"will",
"stop",
"blocking",
"when",
"Done",
"is",
"been",
"called",
"or",
"when",
"the",
"context",
"is",
"canceled",
".",
"Returns",
"nil",
"on",
"success",
"or",
"an",
"error",
"if",
"the",
"context",
"is",
"canceled",
"before",
"the",
"lock",
"is",
"acquired",
".",
"See",
"sync",
".",
"WaitGroup",
"documentation",
"for",
"more",
"information",
"."
]
| 5e7302b12ccef91dce9fde2f5bda6d5c7ea5d2eb | https://github.com/remeh/sizedwaitgroup/blob/5e7302b12ccef91dce9fde2f5bda6d5c7ea5d2eb/sizedwaitgroup.go#L62-L71 |
8,254 | tidwall/pretty | pretty.go | PrettyOptions | 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 | 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
} | [
"func",
"PrettyOptions",
"(",
"json",
"[",
"]",
"byte",
",",
"opts",
"*",
"Options",
")",
"[",
"]",
"byte",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"DefaultOptions",
"\n",
"}",
"\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"json",
")",
")",
"\n",
"if",
"len",
"(",
"opts",
".",
"Prefix",
")",
"!=",
"0",
"{",
"buf",
"=",
"append",
"(",
"buf",
",",
"opts",
".",
"Prefix",
"...",
")",
"\n",
"}",
"\n",
"buf",
",",
"_",
",",
"_",
",",
"_",
"=",
"appendPrettyAny",
"(",
"buf",
",",
"json",
",",
"0",
",",
"true",
",",
"opts",
".",
"Width",
",",
"opts",
".",
"Prefix",
",",
"opts",
".",
"Indent",
",",
"opts",
".",
"SortKeys",
",",
"0",
",",
"0",
",",
"-",
"1",
")",
"\n",
"if",
"len",
"(",
"buf",
")",
">",
"0",
"{",
"buf",
"=",
"append",
"(",
"buf",
",",
"'\\n'",
")",
"\n",
"}",
"\n",
"return",
"buf",
"\n",
"}"
]
| // PrettyOptions is like Pretty but with customized options. | [
"PrettyOptions",
"is",
"like",
"Pretty",
"but",
"with",
"customized",
"options",
"."
]
| 1166b9ac2b65e46a43d8618d30d1554f4652d49b | https://github.com/tidwall/pretty/blob/1166b9ac2b65e46a43d8618d30d1554f4652d49b/pretty.go#L31-L46 |
8,255 | tidwall/pretty | pretty.go | Ugly | func Ugly(json []byte) []byte {
buf := make([]byte, 0, len(json))
return ugly(buf, json)
} | go | func Ugly(json []byte) []byte {
buf := make([]byte, 0, len(json))
return ugly(buf, json)
} | [
"func",
"Ugly",
"(",
"json",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"json",
")",
")",
"\n",
"return",
"ugly",
"(",
"buf",
",",
"json",
")",
"\n",
"}"
]
| // Ugly removes insignificant space characters from the input json byte slice
// and returns the compacted result. | [
"Ugly",
"removes",
"insignificant",
"space",
"characters",
"from",
"the",
"input",
"json",
"byte",
"slice",
"and",
"returns",
"the",
"compacted",
"result",
"."
]
| 1166b9ac2b65e46a43d8618d30d1554f4652d49b | https://github.com/tidwall/pretty/blob/1166b9ac2b65e46a43d8618d30d1554f4652d49b/pretty.go#L50-L53 |
8,256 | klauspost/compress | flate/deflate.go | writeBlockSkip | 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 | 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
} | [
"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",
"]",
"\n",
"// 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",
")",
"\n",
"}",
"else",
"{",
"// Write a dynamic huffman block.",
"d",
".",
"w",
".",
"writeBlockDynamic",
"(",
"tok",
".",
"tokens",
"[",
":",
"tok",
".",
"n",
"]",
",",
"eof",
",",
"window",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"d",
".",
"w",
".",
"writeBlock",
"(",
"tok",
".",
"tokens",
"[",
":",
"tok",
".",
"n",
"]",
",",
"eof",
",",
"nil",
")",
"\n",
"}",
"\n",
"d",
".",
"blockStart",
"=",
"index",
"\n",
"return",
"d",
".",
"w",
".",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // writeBlockSkip writes the current block and uses the number of tokens
// to determine if the block should be stored on no matches, or
// only huffman encoded. | [
"writeBlockSkip",
"writes",
"the",
"current",
"block",
"and",
"uses",
"the",
"number",
"of",
"tokens",
"to",
"determine",
"if",
"the",
"block",
"should",
"be",
"stored",
"on",
"no",
"matches",
"or",
"only",
"huffman",
"encoded",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L178-L197 |
8,257 | klauspost/compress | flate/deflate.go | findMatch | 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 | 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
} | [
"func",
"(",
"d",
"*",
"compressor",
")",
"findMatch",
"(",
"pos",
"int",
",",
"prevHead",
"int",
",",
"prevLength",
"int",
",",
"lookahead",
"int",
")",
"(",
"length",
",",
"offset",
"int",
",",
"ok",
"bool",
")",
"{",
"minMatchLook",
":=",
"maxMatchLength",
"\n",
"if",
"lookahead",
"<",
"minMatchLook",
"{",
"minMatchLook",
"=",
"lookahead",
"\n",
"}",
"\n\n",
"win",
":=",
"d",
".",
"window",
"[",
"0",
":",
"pos",
"+",
"minMatchLook",
"]",
"\n\n",
"// We quit when we get a match that's at least nice long",
"nice",
":=",
"len",
"(",
"win",
")",
"-",
"pos",
"\n",
"if",
"d",
".",
"nice",
"<",
"nice",
"{",
"nice",
"=",
"d",
".",
"nice",
"\n",
"}",
"\n\n",
"// If we've got a match that's good enough, only look in 1/4 the chain.",
"tries",
":=",
"d",
".",
"chain",
"\n",
"length",
"=",
"prevLength",
"\n",
"if",
"length",
">=",
"d",
".",
"good",
"{",
"tries",
">>=",
"2",
"\n",
"}",
"\n\n",
"wEnd",
":=",
"win",
"[",
"pos",
"+",
"length",
"]",
"\n",
"wPos",
":=",
"win",
"[",
"pos",
":",
"]",
"\n",
"minIndex",
":=",
"pos",
"-",
"windowSize",
"\n\n",
"for",
"i",
":=",
"prevHead",
";",
"tries",
">",
"0",
";",
"tries",
"--",
"{",
"if",
"wEnd",
"==",
"win",
"[",
"i",
"+",
"length",
"]",
"{",
"n",
":=",
"matchLen",
"(",
"win",
"[",
"i",
":",
"]",
",",
"wPos",
",",
"minMatchLook",
")",
"\n\n",
"if",
"n",
">",
"length",
"&&",
"(",
"n",
">",
"minMatchLength",
"||",
"pos",
"-",
"i",
"<=",
"4096",
")",
"{",
"length",
"=",
"n",
"\n",
"offset",
"=",
"pos",
"-",
"i",
"\n",
"ok",
"=",
"true",
"\n",
"if",
"n",
">=",
"nice",
"{",
"// The match is good enough that we don't try to find a better one.",
"break",
"\n",
"}",
"\n",
"wEnd",
"=",
"win",
"[",
"pos",
"+",
"n",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"i",
"==",
"minIndex",
"{",
"// hashPrev[i & windowMask] has already been overwritten, so stop now.",
"break",
"\n",
"}",
"\n",
"i",
"=",
"int",
"(",
"d",
".",
"hashPrev",
"[",
"i",
"&",
"windowMask",
"]",
")",
"-",
"d",
".",
"hashOffset",
"\n",
"if",
"i",
"<",
"minIndex",
"||",
"i",
"<",
"0",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
]
| // Try to find a match starting at index whose length is greater than prevSize.
// We only look at chainCount possibilities before giving up.
// pos = d.index, prevHead = d.chainHead-d.hashOffset, prevLength=minMatchLength-1, lookahead | [
"Try",
"to",
"find",
"a",
"match",
"starting",
"at",
"index",
"whose",
"length",
"is",
"greater",
"than",
"prevSize",
".",
"We",
"only",
"look",
"at",
"chainCount",
"possibilities",
"before",
"giving",
"up",
".",
"pos",
"=",
"d",
".",
"index",
"prevHead",
"=",
"d",
".",
"chainHead",
"-",
"d",
".",
"hashOffset",
"prevLength",
"=",
"minMatchLength",
"-",
"1",
"lookahead"
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L254-L304 |
8,258 | klauspost/compress | flate/deflate.go | bulkHash4 | 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 | 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)
}
} | [
"func",
"bulkHash4",
"(",
"b",
"[",
"]",
"byte",
",",
"dst",
"[",
"]",
"uint32",
")",
"{",
"if",
"len",
"(",
"b",
")",
"<",
"minMatchLength",
"{",
"return",
"\n",
"}",
"\n",
"hb",
":=",
"uint32",
"(",
"b",
"[",
"3",
"]",
")",
"|",
"uint32",
"(",
"b",
"[",
"2",
"]",
")",
"<<",
"8",
"|",
"uint32",
"(",
"b",
"[",
"1",
"]",
")",
"<<",
"16",
"|",
"uint32",
"(",
"b",
"[",
"0",
"]",
")",
"<<",
"24",
"\n",
"dst",
"[",
"0",
"]",
"=",
"(",
"hb",
"*",
"hashmul",
")",
">>",
"(",
"32",
"-",
"hashBits",
")",
"\n",
"end",
":=",
"len",
"(",
"b",
")",
"-",
"minMatchLength",
"+",
"1",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"end",
";",
"i",
"++",
"{",
"hb",
"=",
"(",
"hb",
"<<",
"8",
")",
"|",
"uint32",
"(",
"b",
"[",
"i",
"+",
"3",
"]",
")",
"\n",
"dst",
"[",
"i",
"]",
"=",
"(",
"hb",
"*",
"hashmul",
")",
">>",
"(",
"32",
"-",
"hashBits",
")",
"\n",
"}",
"\n",
"}"
]
| // bulkHash4 will compute hashes using the same
// algorithm as hash4 | [
"bulkHash4",
"will",
"compute",
"hashes",
"using",
"the",
"same",
"algorithm",
"as",
"hash4"
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L380-L391 |
8,259 | klauspost/compress | flate/deflate.go | matchLen | 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 | 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
} | [
"func",
"matchLen",
"(",
"a",
",",
"b",
"[",
"]",
"byte",
",",
"max",
"int",
")",
"int",
"{",
"a",
"=",
"a",
"[",
":",
"max",
"]",
"\n",
"b",
"=",
"b",
"[",
":",
"len",
"(",
"a",
")",
"]",
"\n",
"for",
"i",
",",
"av",
":=",
"range",
"a",
"{",
"if",
"b",
"[",
"i",
"]",
"!=",
"av",
"{",
"return",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"max",
"\n",
"}"
]
| // matchLen returns the number of matching bytes in a and b
// up to length 'max'. Both slices must be at least 'max'
// bytes in size. | [
"matchLen",
"returns",
"the",
"number",
"of",
"matching",
"bytes",
"in",
"a",
"and",
"b",
"up",
"to",
"length",
"max",
".",
"Both",
"slices",
"must",
"be",
"at",
"least",
"max",
"bytes",
"in",
"size",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L396-L405 |
8,260 | klauspost/compress | flate/deflate.go | fillBlock | func (d *compressor) fillBlock(b []byte) int {
n := copy(d.window[d.windowEnd:], b)
d.windowEnd += n
return n
} | go | func (d *compressor) fillBlock(b []byte) int {
n := copy(d.window[d.windowEnd:], b)
d.windowEnd += n
return n
} | [
"func",
"(",
"d",
"*",
"compressor",
")",
"fillBlock",
"(",
"b",
"[",
"]",
"byte",
")",
"int",
"{",
"n",
":=",
"copy",
"(",
"d",
".",
"window",
"[",
"d",
".",
"windowEnd",
":",
"]",
",",
"b",
")",
"\n",
"d",
".",
"windowEnd",
"+=",
"n",
"\n",
"return",
"n",
"\n",
"}"
]
| // fillWindow will fill the buffer with data for huffman-only compression.
// The number of bytes copied is returned. | [
"fillWindow",
"will",
"fill",
"the",
"buffer",
"with",
"data",
"for",
"huffman",
"-",
"only",
"compression",
".",
"The",
"number",
"of",
"bytes",
"copied",
"is",
"returned",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1062-L1066 |
8,261 | klauspost/compress | flate/deflate.go | write | 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 | 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
} | [
"func",
"(",
"d",
"*",
"compressor",
")",
"write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"d",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"d",
".",
"err",
"\n",
"}",
"\n",
"n",
"=",
"len",
"(",
"b",
")",
"\n",
"for",
"len",
"(",
"b",
")",
">",
"0",
"{",
"d",
".",
"step",
"(",
"d",
")",
"\n",
"b",
"=",
"b",
"[",
"d",
".",
"fill",
"(",
"d",
",",
"b",
")",
":",
"]",
"\n",
"if",
"d",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"d",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"n",
",",
"d",
".",
"err",
"\n",
"}"
]
| // write will add input byte to the stream.
// Unless an error occurs all bytes will be consumed. | [
"write",
"will",
"add",
"input",
"byte",
"to",
"the",
"stream",
".",
"Unless",
"an",
"error",
"occurs",
"all",
"bytes",
"will",
"be",
"consumed",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1127-L1140 |
8,262 | klauspost/compress | flate/deflate.go | reset | 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 | 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
}
} | [
"func",
"(",
"d",
"*",
"compressor",
")",
"reset",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"d",
".",
"w",
".",
"reset",
"(",
"w",
")",
"\n",
"d",
".",
"sync",
"=",
"false",
"\n",
"d",
".",
"err",
"=",
"nil",
"\n",
"// We only need to reset a few things for Snappy.",
"if",
"d",
".",
"snap",
"!=",
"nil",
"{",
"d",
".",
"snap",
".",
"Reset",
"(",
")",
"\n",
"d",
".",
"windowEnd",
"=",
"0",
"\n",
"d",
".",
"tokens",
".",
"n",
"=",
"0",
"\n",
"return",
"\n",
"}",
"\n",
"switch",
"d",
".",
"compressionLevel",
".",
"chain",
"{",
"case",
"0",
":",
"// level was NoCompression or ConstantCompresssion.",
"d",
".",
"windowEnd",
"=",
"0",
"\n",
"default",
":",
"d",
".",
"chainHead",
"=",
"-",
"1",
"\n",
"for",
"i",
":=",
"range",
"d",
".",
"hashHead",
"{",
"d",
".",
"hashHead",
"[",
"i",
"]",
"=",
"0",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"d",
".",
"hashPrev",
"{",
"d",
".",
"hashPrev",
"[",
"i",
"]",
"=",
"0",
"\n",
"}",
"\n",
"d",
".",
"hashOffset",
"=",
"1",
"\n",
"d",
".",
"index",
",",
"d",
".",
"windowEnd",
"=",
"0",
",",
"0",
"\n",
"d",
".",
"blockStart",
",",
"d",
".",
"byteAvailable",
"=",
"0",
",",
"false",
"\n",
"d",
".",
"tokens",
".",
"n",
"=",
"0",
"\n",
"d",
".",
"length",
"=",
"minMatchLength",
"-",
"1",
"\n",
"d",
".",
"offset",
"=",
"0",
"\n",
"d",
".",
"hash",
"=",
"0",
"\n",
"d",
".",
"ii",
"=",
"0",
"\n",
"d",
".",
"maxInsertIndex",
"=",
"0",
"\n",
"}",
"\n",
"}"
]
| // reset the state of the compressor. | [
"reset",
"the",
"state",
"of",
"the",
"compressor",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1202-L1235 |
8,263 | klauspost/compress | flate/deflate.go | NewWriterDict | 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 | 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
} | [
"func",
"NewWriterDict",
"(",
"w",
"io",
".",
"Writer",
",",
"level",
"int",
",",
"dict",
"[",
"]",
"byte",
")",
"(",
"*",
"Writer",
",",
"error",
")",
"{",
"dw",
":=",
"&",
"dictWriter",
"{",
"w",
"}",
"\n",
"zw",
",",
"err",
":=",
"NewWriter",
"(",
"dw",
",",
"level",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"zw",
".",
"d",
".",
"fillWindow",
"(",
"dict",
")",
"\n",
"zw",
".",
"dict",
"=",
"append",
"(",
"zw",
".",
"dict",
",",
"dict",
"...",
")",
"// duplicate dictionary for Reset method.",
"\n",
"return",
"zw",
",",
"err",
"\n",
"}"
]
| // NewWriterDict is like NewWriter but initializes the new
// Writer with a preset dictionary. The returned Writer behaves
// as if the dictionary had been written to it without producing
// any compressed output. The compressed data written to w
// can only be decompressed by a Reader initialized with the
// same dictionary. | [
"NewWriterDict",
"is",
"like",
"NewWriter",
"but",
"initializes",
"the",
"new",
"Writer",
"with",
"a",
"preset",
"dictionary",
".",
"The",
"returned",
"Writer",
"behaves",
"as",
"if",
"the",
"dictionary",
"had",
"been",
"written",
"to",
"it",
"without",
"producing",
"any",
"compressed",
"output",
".",
"The",
"compressed",
"data",
"written",
"to",
"w",
"can",
"only",
"be",
"decompressed",
"by",
"a",
"Reader",
"initialized",
"with",
"the",
"same",
"dictionary",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1279-L1288 |
8,264 | klauspost/compress | flate/deflate.go | Write | func (w *Writer) Write(data []byte) (n int, err error) {
return w.d.write(data)
} | go | func (w *Writer) Write(data []byte) (n int, err error) {
return w.d.write(data)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Write",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"w",
".",
"d",
".",
"write",
"(",
"data",
")",
"\n",
"}"
]
| // Write writes data to w, which will eventually write the
// compressed form of data to its underlying writer. | [
"Write",
"writes",
"data",
"to",
"w",
"which",
"will",
"eventually",
"write",
"the",
"compressed",
"form",
"of",
"data",
"to",
"its",
"underlying",
"writer",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1307-L1309 |
8,265 | klauspost/compress | flate/deflate.go | Reset | 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 | 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)
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Reset",
"(",
"dst",
"io",
".",
"Writer",
")",
"{",
"if",
"dw",
",",
"ok",
":=",
"w",
".",
"d",
".",
"w",
".",
"writer",
".",
"(",
"*",
"dictWriter",
")",
";",
"ok",
"{",
"// w was created with NewWriterDict",
"dw",
".",
"w",
"=",
"dst",
"\n",
"w",
".",
"d",
".",
"reset",
"(",
"dw",
")",
"\n",
"w",
".",
"d",
".",
"fillWindow",
"(",
"w",
".",
"dict",
")",
"\n",
"}",
"else",
"{",
"// w was created with NewWriter",
"w",
".",
"d",
".",
"reset",
"(",
"dst",
")",
"\n",
"}",
"\n",
"}"
]
| // Reset discards the writer's state and makes it equivalent to
// the result of NewWriter or NewWriterDict called with dst
// and w's level and dictionary. | [
"Reset",
"discards",
"the",
"writer",
"s",
"state",
"and",
"makes",
"it",
"equivalent",
"to",
"the",
"result",
"of",
"NewWriter",
"or",
"NewWriterDict",
"called",
"with",
"dst",
"and",
"w",
"s",
"level",
"and",
"dictionary",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1334-L1344 |
8,266 | klauspost/compress | flate/deflate.go | ResetDict | func (w *Writer) ResetDict(dst io.Writer, dict []byte) {
w.dict = dict
w.d.reset(dst)
w.d.fillWindow(w.dict)
} | go | func (w *Writer) ResetDict(dst io.Writer, dict []byte) {
w.dict = dict
w.d.reset(dst)
w.d.fillWindow(w.dict)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"ResetDict",
"(",
"dst",
"io",
".",
"Writer",
",",
"dict",
"[",
"]",
"byte",
")",
"{",
"w",
".",
"dict",
"=",
"dict",
"\n",
"w",
".",
"d",
".",
"reset",
"(",
"dst",
")",
"\n",
"w",
".",
"d",
".",
"fillWindow",
"(",
"w",
".",
"dict",
")",
"\n",
"}"
]
| // ResetDict discards the writer's state and makes it equivalent to
// the result of NewWriter or NewWriterDict called with dst
// and w's level, but sets a specific dictionary. | [
"ResetDict",
"discards",
"the",
"writer",
"s",
"state",
"and",
"makes",
"it",
"equivalent",
"to",
"the",
"result",
"of",
"NewWriter",
"or",
"NewWriterDict",
"called",
"with",
"dst",
"and",
"w",
"s",
"level",
"but",
"sets",
"a",
"specific",
"dictionary",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/flate/deflate.go#L1349-L1353 |
8,267 | klauspost/compress | gzip/gunzip.go | noEOF | func noEOF(err error) error {
if err == io.EOF {
return io.ErrUnexpectedEOF
}
return err
} | go | func noEOF(err error) error {
if err == io.EOF {
return io.ErrUnexpectedEOF
}
return err
} | [
"func",
"noEOF",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
]
| // noEOF converts io.EOF to io.ErrUnexpectedEOF. | [
"noEOF",
"converts",
"io",
".",
"EOF",
"to",
"io",
".",
"ErrUnexpectedEOF",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gunzip.go#L41-L46 |
8,268 | klauspost/compress | gzip/gunzip.go | NewReader | func NewReader(r io.Reader) (*Reader, error) {
z := new(Reader)
if err := z.Reset(r); err != nil {
return nil, err
}
return z, nil
} | go | func NewReader(r io.Reader) (*Reader, error) {
z := new(Reader)
if err := z.Reset(r); err != nil {
return nil, err
}
return z, nil
} | [
"func",
"NewReader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"z",
":=",
"new",
"(",
"Reader",
")",
"\n",
"if",
"err",
":=",
"z",
".",
"Reset",
"(",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"z",
",",
"nil",
"\n",
"}"
]
| // NewReader creates a new Reader reading the given reader.
// If r does not also implement io.ByteReader,
// the decompressor may read more data than necessary from r.
//
// It is the caller's responsibility to call Close on the Reader when done.
//
// The Reader.Header fields will be valid in the Reader returned. | [
"NewReader",
"creates",
"a",
"new",
"Reader",
"reading",
"the",
"given",
"reader",
".",
"If",
"r",
"does",
"not",
"also",
"implement",
"io",
".",
"ByteReader",
"the",
"decompressor",
"may",
"read",
"more",
"data",
"than",
"necessary",
"from",
"r",
".",
"It",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"call",
"Close",
"on",
"the",
"Reader",
"when",
"done",
".",
"The",
"Reader",
".",
"Header",
"fields",
"will",
"be",
"valid",
"in",
"the",
"Reader",
"returned",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gunzip.go#L93-L99 |
8,269 | klauspost/compress | gzip/gunzip.go | Reset | 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 | 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
} | [
"func",
"(",
"z",
"*",
"Reader",
")",
"Reset",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"*",
"z",
"=",
"Reader",
"{",
"decompressor",
":",
"z",
".",
"decompressor",
",",
"multistream",
":",
"true",
",",
"}",
"\n",
"if",
"rr",
",",
"ok",
":=",
"r",
".",
"(",
"flate",
".",
"Reader",
")",
";",
"ok",
"{",
"z",
".",
"r",
"=",
"rr",
"\n",
"}",
"else",
"{",
"z",
".",
"r",
"=",
"bufio",
".",
"NewReader",
"(",
"r",
")",
"\n",
"}",
"\n",
"z",
".",
"Header",
",",
"z",
".",
"err",
"=",
"z",
".",
"readHeader",
"(",
")",
"\n",
"return",
"z",
".",
"err",
"\n",
"}"
]
| // Reset discards the Reader z's state and makes it equivalent to the
// result of its original state from NewReader, but reading from r instead.
// This permits reusing a Reader rather than allocating a new one. | [
"Reset",
"discards",
"the",
"Reader",
"z",
"s",
"state",
"and",
"makes",
"it",
"equivalent",
"to",
"the",
"result",
"of",
"its",
"original",
"state",
"from",
"NewReader",
"but",
"reading",
"from",
"r",
"instead",
".",
"This",
"permits",
"reusing",
"a",
"Reader",
"rather",
"than",
"allocating",
"a",
"new",
"one",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gunzip.go#L104-L116 |
8,270 | klauspost/compress | gzip/gunzip.go | readHeader | 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 | 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
} | [
"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:",
"//\tA 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",
"\n",
"}",
"\n",
"if",
"z",
".",
"buf",
"[",
"0",
"]",
"!=",
"gzipID1",
"||",
"z",
".",
"buf",
"[",
"1",
"]",
"!=",
"gzipID2",
"||",
"z",
".",
"buf",
"[",
"2",
"]",
"!=",
"gzipDeflate",
"{",
"return",
"hdr",
",",
"ErrHeader",
"\n",
"}",
"\n",
"flg",
":=",
"z",
".",
"buf",
"[",
"3",
"]",
"\n",
"hdr",
".",
"ModTime",
"=",
"time",
".",
"Unix",
"(",
"int64",
"(",
"le",
".",
"Uint32",
"(",
"z",
".",
"buf",
"[",
"4",
":",
"8",
"]",
")",
")",
",",
"0",
")",
"\n",
"// z.buf[8] is XFL and is currently ignored.",
"hdr",
".",
"OS",
"=",
"z",
".",
"buf",
"[",
"9",
"]",
"\n",
"z",
".",
"digest",
"=",
"crc32",
".",
"ChecksumIEEE",
"(",
"z",
".",
"buf",
"[",
":",
"10",
"]",
")",
"\n\n",
"if",
"flg",
"&",
"flagExtra",
"!=",
"0",
"{",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"z",
".",
"r",
",",
"z",
".",
"buf",
"[",
":",
"2",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hdr",
",",
"noEOF",
"(",
"err",
")",
"\n",
"}",
"\n",
"z",
".",
"digest",
"=",
"crc32",
".",
"Update",
"(",
"z",
".",
"digest",
",",
"crc32",
".",
"IEEETable",
",",
"z",
".",
"buf",
"[",
":",
"2",
"]",
")",
"\n",
"data",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"le",
".",
"Uint16",
"(",
"z",
".",
"buf",
"[",
":",
"2",
"]",
")",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"z",
".",
"r",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hdr",
",",
"noEOF",
"(",
"err",
")",
"\n",
"}",
"\n",
"z",
".",
"digest",
"=",
"crc32",
".",
"Update",
"(",
"z",
".",
"digest",
",",
"crc32",
".",
"IEEETable",
",",
"data",
")",
"\n",
"hdr",
".",
"Extra",
"=",
"data",
"\n",
"}",
"\n\n",
"var",
"s",
"string",
"\n",
"if",
"flg",
"&",
"flagName",
"!=",
"0",
"{",
"if",
"s",
",",
"err",
"=",
"z",
".",
"readString",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hdr",
",",
"err",
"\n",
"}",
"\n",
"hdr",
".",
"Name",
"=",
"s",
"\n",
"}",
"\n\n",
"if",
"flg",
"&",
"flagComment",
"!=",
"0",
"{",
"if",
"s",
",",
"err",
"=",
"z",
".",
"readString",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hdr",
",",
"err",
"\n",
"}",
"\n",
"hdr",
".",
"Comment",
"=",
"s",
"\n",
"}",
"\n\n",
"if",
"flg",
"&",
"flagHdrCrc",
"!=",
"0",
"{",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"z",
".",
"r",
",",
"z",
".",
"buf",
"[",
":",
"2",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"hdr",
",",
"noEOF",
"(",
"err",
")",
"\n",
"}",
"\n",
"digest",
":=",
"le",
".",
"Uint16",
"(",
"z",
".",
"buf",
"[",
":",
"2",
"]",
")",
"\n",
"if",
"digest",
"!=",
"uint16",
"(",
"z",
".",
"digest",
")",
"{",
"return",
"hdr",
",",
"ErrHeader",
"\n",
"}",
"\n",
"}",
"\n\n",
"z",
".",
"digest",
"=",
"0",
"\n",
"if",
"z",
".",
"decompressor",
"==",
"nil",
"{",
"z",
".",
"decompressor",
"=",
"flate",
".",
"NewReader",
"(",
"z",
".",
"r",
")",
"\n",
"}",
"else",
"{",
"z",
".",
"decompressor",
".",
"(",
"flate",
".",
"Resetter",
")",
".",
"Reset",
"(",
"z",
".",
"r",
",",
"nil",
")",
"\n",
"}",
"\n",
"return",
"hdr",
",",
"nil",
"\n",
"}"
]
| // readHeader reads the GZIP header according to section 2.3.1.
// This method does not set z.err. | [
"readHeader",
"reads",
"the",
"GZIP",
"header",
"according",
"to",
"section",
"2",
".",
"3",
".",
"1",
".",
"This",
"method",
"does",
"not",
"set",
"z",
".",
"err",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gunzip.go#L175-L240 |
8,271 | klauspost/compress | gzip/gunzip.go | Read | 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 | 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)
} | [
"func",
"(",
"z",
"*",
"Reader",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"z",
".",
"err",
"\n",
"}",
"\n\n",
"n",
",",
"z",
".",
"err",
"=",
"z",
".",
"decompressor",
".",
"Read",
"(",
"p",
")",
"\n",
"z",
".",
"digest",
"=",
"crc32",
".",
"Update",
"(",
"z",
".",
"digest",
",",
"crc32",
".",
"IEEETable",
",",
"p",
"[",
":",
"n",
"]",
")",
"\n",
"z",
".",
"size",
"+=",
"uint32",
"(",
"n",
")",
"\n",
"if",
"z",
".",
"err",
"!=",
"io",
".",
"EOF",
"{",
"// In the normal case we return here.",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n\n",
"// Finished file; check checksum and size.",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"z",
".",
"r",
",",
"z",
".",
"buf",
"[",
":",
"8",
"]",
")",
";",
"err",
"!=",
"nil",
"{",
"z",
".",
"err",
"=",
"noEOF",
"(",
"err",
")",
"\n",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"digest",
":=",
"le",
".",
"Uint32",
"(",
"z",
".",
"buf",
"[",
":",
"4",
"]",
")",
"\n",
"size",
":=",
"le",
".",
"Uint32",
"(",
"z",
".",
"buf",
"[",
"4",
":",
"8",
"]",
")",
"\n",
"if",
"digest",
"!=",
"z",
".",
"digest",
"||",
"size",
"!=",
"z",
".",
"size",
"{",
"z",
".",
"err",
"=",
"ErrChecksum",
"\n",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"z",
".",
"digest",
",",
"z",
".",
"size",
"=",
"0",
",",
"0",
"\n\n",
"// File is ok; check if there is another.",
"if",
"!",
"z",
".",
"multistream",
"{",
"return",
"n",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"z",
".",
"err",
"=",
"nil",
"// Remove io.EOF",
"\n\n",
"if",
"_",
",",
"z",
".",
"err",
"=",
"z",
".",
"readHeader",
"(",
")",
";",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n\n",
"// Read from next file, if necessary.",
"if",
"n",
">",
"0",
"{",
"return",
"n",
",",
"nil",
"\n",
"}",
"\n",
"return",
"z",
".",
"Read",
"(",
"p",
")",
"\n",
"}"
]
| // Read implements io.Reader, reading uncompressed bytes from its underlying Reader. | [
"Read",
"implements",
"io",
".",
"Reader",
"reading",
"uncompressed",
"bytes",
"from",
"its",
"underlying",
"Reader",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gunzip.go#L243-L284 |
8,272 | klauspost/compress | huff0/bitwriter.go | addBits16NC | func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
b.nBits += bits
} | go | func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
b.nBits += bits
} | [
"func",
"(",
"b",
"*",
"bitWriter",
")",
"addBits16NC",
"(",
"value",
"uint16",
",",
"bits",
"uint8",
")",
"{",
"b",
".",
"bitContainer",
"|=",
"uint64",
"(",
"value",
"&",
"bitMask16",
"[",
"bits",
"&",
"31",
"]",
")",
"<<",
"(",
"b",
".",
"nBits",
"&",
"63",
")",
"\n",
"b",
".",
"nBits",
"+=",
"bits",
"\n",
"}"
]
| // addBits16NC will add up to 16 bits.
// It will not check if there is space for them,
// so the caller must ensure that it has flushed recently. | [
"addBits16NC",
"will",
"add",
"up",
"to",
"16",
"bits",
".",
"It",
"will",
"not",
"check",
"if",
"there",
"is",
"space",
"for",
"them",
"so",
"the",
"caller",
"must",
"ensure",
"that",
"it",
"has",
"flushed",
"recently",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/bitwriter.go#L29-L32 |
8,273 | klauspost/compress | huff0/bitwriter.go | addBits16ZeroNC | 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 | 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
} | [
"func",
"(",
"b",
"*",
"bitWriter",
")",
"addBits16ZeroNC",
"(",
"value",
"uint16",
",",
"bits",
"uint8",
")",
"{",
"if",
"bits",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"value",
"<<=",
"(",
"16",
"-",
"bits",
")",
"&",
"15",
"\n",
"value",
">>=",
"(",
"16",
"-",
"bits",
")",
"&",
"15",
"\n",
"b",
".",
"bitContainer",
"|=",
"uint64",
"(",
"value",
")",
"<<",
"(",
"b",
".",
"nBits",
"&",
"63",
")",
"\n",
"b",
".",
"nBits",
"+=",
"bits",
"\n",
"}"
]
| // addBits16ZeroNC will add up to 16 bits.
// It will not check if there is space for them,
// so the caller must ensure that it has flushed recently.
// This is fastest if bits can be zero. | [
"addBits16ZeroNC",
"will",
"add",
"up",
"to",
"16",
"bits",
".",
"It",
"will",
"not",
"check",
"if",
"there",
"is",
"space",
"for",
"them",
"so",
"the",
"caller",
"must",
"ensure",
"that",
"it",
"has",
"flushed",
"recently",
".",
"This",
"is",
"fastest",
"if",
"bits",
"can",
"be",
"zero",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/bitwriter.go#L53-L61 |
8,274 | klauspost/compress | huff0/bitwriter.go | flush32 | 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 | 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
} | [
"func",
"(",
"b",
"*",
"bitWriter",
")",
"flush32",
"(",
")",
"{",
"if",
"b",
".",
"nBits",
"<",
"32",
"{",
"return",
"\n",
"}",
"\n",
"b",
".",
"out",
"=",
"append",
"(",
"b",
".",
"out",
",",
"byte",
"(",
"b",
".",
"bitContainer",
")",
",",
"byte",
"(",
"b",
".",
"bitContainer",
">>",
"8",
")",
",",
"byte",
"(",
"b",
".",
"bitContainer",
">>",
"16",
")",
",",
"byte",
"(",
"b",
".",
"bitContainer",
">>",
"24",
")",
")",
"\n",
"b",
".",
"nBits",
"-=",
"32",
"\n",
"b",
".",
"bitContainer",
">>=",
"32",
"\n",
"}"
]
| // flush32 will flush out, so there are at least 32 bits available for writing. | [
"flush32",
"will",
"flush",
"out",
"so",
"there",
"are",
"at",
"least",
"32",
"bits",
"available",
"for",
"writing",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/bitwriter.go#L148-L159 |
8,275 | klauspost/compress | huff0/bitwriter.go | flushAlign | 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 | 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
} | [
"func",
"(",
"b",
"*",
"bitWriter",
")",
"flushAlign",
"(",
")",
"{",
"nbBytes",
":=",
"(",
"b",
".",
"nBits",
"+",
"7",
")",
">>",
"3",
"\n",
"for",
"i",
":=",
"uint8",
"(",
"0",
")",
";",
"i",
"<",
"nbBytes",
";",
"i",
"++",
"{",
"b",
".",
"out",
"=",
"append",
"(",
"b",
".",
"out",
",",
"byte",
"(",
"b",
".",
"bitContainer",
">>",
"(",
"i",
"*",
"8",
")",
")",
")",
"\n",
"}",
"\n",
"b",
".",
"nBits",
"=",
"0",
"\n",
"b",
".",
"bitContainer",
"=",
"0",
"\n",
"}"
]
| // flushAlign will flush remaining full bytes and align to next byte boundary. | [
"flushAlign",
"will",
"flush",
"remaining",
"full",
"bytes",
"and",
"align",
"to",
"next",
"byte",
"boundary",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/bitwriter.go#L162-L169 |
8,276 | klauspost/compress | huff0/bitwriter.go | reset | func (b *bitWriter) reset(out []byte) {
b.bitContainer = 0
b.nBits = 0
b.out = out
} | go | func (b *bitWriter) reset(out []byte) {
b.bitContainer = 0
b.nBits = 0
b.out = out
} | [
"func",
"(",
"b",
"*",
"bitWriter",
")",
"reset",
"(",
"out",
"[",
"]",
"byte",
")",
"{",
"b",
".",
"bitContainer",
"=",
"0",
"\n",
"b",
".",
"nBits",
"=",
"0",
"\n",
"b",
".",
"out",
"=",
"out",
"\n",
"}"
]
| // reset and continue writing by appending to out. | [
"reset",
"and",
"continue",
"writing",
"by",
"appending",
"to",
"out",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/bitwriter.go#L182-L186 |
8,277 | klauspost/compress | gzip/gzip.go | NewWriter | func NewWriter(w io.Writer) *Writer {
z, _ := NewWriterLevel(w, DefaultCompression)
return z
} | go | func NewWriter(w io.Writer) *Writer {
z, _ := NewWriterLevel(w, DefaultCompression)
return z
} | [
"func",
"NewWriter",
"(",
"w",
"io",
".",
"Writer",
")",
"*",
"Writer",
"{",
"z",
",",
"_",
":=",
"NewWriterLevel",
"(",
"w",
",",
"DefaultCompression",
")",
"\n",
"return",
"z",
"\n",
"}"
]
| // NewWriter returns a new Writer.
// Writes to the returned writer are compressed and written to w.
//
// It is the caller's responsibility to call Close on the WriteCloser when done.
// Writes may be buffered and not flushed until Close.
//
// Callers that wish to set the fields in Writer.Header must do so before
// the first call to Write, Flush, or Close. | [
"NewWriter",
"returns",
"a",
"new",
"Writer",
".",
"Writes",
"to",
"the",
"returned",
"writer",
"are",
"compressed",
"and",
"written",
"to",
"w",
".",
"It",
"is",
"the",
"caller",
"s",
"responsibility",
"to",
"call",
"Close",
"on",
"the",
"WriteCloser",
"when",
"done",
".",
"Writes",
"may",
"be",
"buffered",
"and",
"not",
"flushed",
"until",
"Close",
".",
"Callers",
"that",
"wish",
"to",
"set",
"the",
"fields",
"in",
"Writer",
".",
"Header",
"must",
"do",
"so",
"before",
"the",
"first",
"call",
"to",
"Write",
"Flush",
"or",
"Close",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gzip.go#L50-L53 |
8,278 | klauspost/compress | gzip/gzip.go | NewWriterLevel | 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 | 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
} | [
"func",
"NewWriterLevel",
"(",
"w",
"io",
".",
"Writer",
",",
"level",
"int",
")",
"(",
"*",
"Writer",
",",
"error",
")",
"{",
"if",
"level",
"<",
"HuffmanOnly",
"||",
"level",
">",
"BestCompression",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"level",
")",
"\n",
"}",
"\n",
"z",
":=",
"new",
"(",
"Writer",
")",
"\n",
"z",
".",
"init",
"(",
"w",
",",
"level",
")",
"\n",
"return",
"z",
",",
"nil",
"\n",
"}"
]
| // NewWriterLevel is like NewWriter but specifies the compression level instead
// of assuming DefaultCompression.
//
// The compression level can be DefaultCompression, NoCompression, or any
// integer value between BestSpeed and BestCompression inclusive. The error
// returned will be nil if the level is valid. | [
"NewWriterLevel",
"is",
"like",
"NewWriter",
"but",
"specifies",
"the",
"compression",
"level",
"instead",
"of",
"assuming",
"DefaultCompression",
".",
"The",
"compression",
"level",
"can",
"be",
"DefaultCompression",
"NoCompression",
"or",
"any",
"integer",
"value",
"between",
"BestSpeed",
"and",
"BestCompression",
"inclusive",
".",
"The",
"error",
"returned",
"will",
"be",
"nil",
"if",
"the",
"level",
"is",
"valid",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gzip.go#L61-L68 |
8,279 | klauspost/compress | gzip/gzip.go | Reset | func (z *Writer) Reset(w io.Writer) {
z.init(w, z.level)
} | go | func (z *Writer) Reset(w io.Writer) {
z.init(w, z.level)
} | [
"func",
"(",
"z",
"*",
"Writer",
")",
"Reset",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"z",
".",
"init",
"(",
"w",
",",
"z",
".",
"level",
")",
"\n",
"}"
]
| // Reset discards the Writer z's state and makes it equivalent to the
// result of its original state from NewWriter or NewWriterLevel, but
// writing to w instead. This permits reusing a Writer rather than
// allocating a new one. | [
"Reset",
"discards",
"the",
"Writer",
"z",
"s",
"state",
"and",
"makes",
"it",
"equivalent",
"to",
"the",
"result",
"of",
"its",
"original",
"state",
"from",
"NewWriter",
"or",
"NewWriterLevel",
"but",
"writing",
"to",
"w",
"instead",
".",
"This",
"permits",
"reusing",
"a",
"Writer",
"rather",
"than",
"allocating",
"a",
"new",
"one",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gzip.go#L89-L91 |
8,280 | klauspost/compress | gzip/gzip.go | writeBytes | 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 | 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
} | [
"func",
"(",
"z",
"*",
"Writer",
")",
"writeBytes",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"b",
")",
">",
"0xffff",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"le",
".",
"PutUint16",
"(",
"z",
".",
"buf",
"[",
":",
"2",
"]",
",",
"uint16",
"(",
"len",
"(",
"b",
")",
")",
")",
"\n",
"_",
",",
"err",
":=",
"z",
".",
"w",
".",
"Write",
"(",
"z",
".",
"buf",
"[",
":",
"2",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"z",
".",
"w",
".",
"Write",
"(",
"b",
")",
"\n",
"return",
"err",
"\n",
"}"
]
| // writeBytes writes a length-prefixed byte slice to z.w. | [
"writeBytes",
"writes",
"a",
"length",
"-",
"prefixed",
"byte",
"slice",
"to",
"z",
".",
"w",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gzip.go#L94-L105 |
8,281 | klauspost/compress | gzip/gzip.go | Write | 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 | 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
} | [
"func",
"(",
"z",
"*",
"Writer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"var",
"n",
"int",
"\n",
"// Write the GZIP header lazily.",
"if",
"!",
"z",
".",
"wroteHeader",
"{",
"z",
".",
"wroteHeader",
"=",
"true",
"\n",
"z",
".",
"buf",
"[",
"0",
"]",
"=",
"gzipID1",
"\n",
"z",
".",
"buf",
"[",
"1",
"]",
"=",
"gzipID2",
"\n",
"z",
".",
"buf",
"[",
"2",
"]",
"=",
"gzipDeflate",
"\n",
"z",
".",
"buf",
"[",
"3",
"]",
"=",
"0",
"\n",
"if",
"z",
".",
"Extra",
"!=",
"nil",
"{",
"z",
".",
"buf",
"[",
"3",
"]",
"|=",
"0x04",
"\n",
"}",
"\n",
"if",
"z",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"z",
".",
"buf",
"[",
"3",
"]",
"|=",
"0x08",
"\n",
"}",
"\n",
"if",
"z",
".",
"Comment",
"!=",
"\"",
"\"",
"{",
"z",
".",
"buf",
"[",
"3",
"]",
"|=",
"0x10",
"\n",
"}",
"\n",
"le",
".",
"PutUint32",
"(",
"z",
".",
"buf",
"[",
"4",
":",
"8",
"]",
",",
"uint32",
"(",
"z",
".",
"ModTime",
".",
"Unix",
"(",
")",
")",
")",
"\n",
"if",
"z",
".",
"level",
"==",
"BestCompression",
"{",
"z",
".",
"buf",
"[",
"8",
"]",
"=",
"2",
"\n",
"}",
"else",
"if",
"z",
".",
"level",
"==",
"BestSpeed",
"{",
"z",
".",
"buf",
"[",
"8",
"]",
"=",
"4",
"\n",
"}",
"else",
"{",
"z",
".",
"buf",
"[",
"8",
"]",
"=",
"0",
"\n",
"}",
"\n",
"z",
".",
"buf",
"[",
"9",
"]",
"=",
"z",
".",
"OS",
"\n",
"n",
",",
"z",
".",
"err",
"=",
"z",
".",
"w",
".",
"Write",
"(",
"z",
".",
"buf",
"[",
":",
"10",
"]",
")",
"\n",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"if",
"z",
".",
"Extra",
"!=",
"nil",
"{",
"z",
".",
"err",
"=",
"z",
".",
"writeBytes",
"(",
"z",
".",
"Extra",
")",
"\n",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"z",
".",
"Name",
"!=",
"\"",
"\"",
"{",
"z",
".",
"err",
"=",
"z",
".",
"writeString",
"(",
"z",
".",
"Name",
")",
"\n",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"z",
".",
"Comment",
"!=",
"\"",
"\"",
"{",
"z",
".",
"err",
"=",
"z",
".",
"writeString",
"(",
"z",
".",
"Comment",
")",
"\n",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"z",
".",
"compressor",
"==",
"nil",
"{",
"z",
".",
"compressor",
",",
"_",
"=",
"flate",
".",
"NewWriter",
"(",
"z",
".",
"w",
",",
"z",
".",
"level",
")",
"\n",
"}",
"\n",
"}",
"\n",
"z",
".",
"size",
"+=",
"uint32",
"(",
"len",
"(",
"p",
")",
")",
"\n",
"z",
".",
"digest",
"=",
"crc32",
".",
"Update",
"(",
"z",
".",
"digest",
",",
"crc32",
".",
"IEEETable",
",",
"p",
")",
"\n",
"n",
",",
"z",
".",
"err",
"=",
"z",
".",
"compressor",
".",
"Write",
"(",
"p",
")",
"\n",
"return",
"n",
",",
"z",
".",
"err",
"\n",
"}"
]
| // Write writes a compressed form of p to the underlying io.Writer. The
// compressed bytes are not necessarily flushed until the Writer is closed. | [
"Write",
"writes",
"a",
"compressed",
"form",
"of",
"p",
"to",
"the",
"underlying",
"io",
".",
"Writer",
".",
"The",
"compressed",
"bytes",
"are",
"not",
"necessarily",
"flushed",
"until",
"the",
"Writer",
"is",
"closed",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gzip.go#L140-L200 |
8,282 | klauspost/compress | gzip/gzip.go | Flush | 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 | 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
} | [
"func",
"(",
"z",
"*",
"Writer",
")",
"Flush",
"(",
")",
"error",
"{",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"z",
".",
"err",
"\n",
"}",
"\n",
"if",
"z",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"z",
".",
"wroteHeader",
"{",
"z",
".",
"Write",
"(",
"nil",
")",
"\n",
"if",
"z",
".",
"err",
"!=",
"nil",
"{",
"return",
"z",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"z",
".",
"err",
"=",
"z",
".",
"compressor",
".",
"Flush",
"(",
")",
"\n",
"return",
"z",
".",
"err",
"\n",
"}"
]
| // Flush flushes any pending compressed data to the underlying writer.
//
// It is useful mainly in compressed network protocols, to ensure that
// a remote reader has enough data to reconstruct a packet. Flush does
// not return until the data has been written. If the underlying
// writer returns an error, Flush returns that error.
//
// In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH. | [
"Flush",
"flushes",
"any",
"pending",
"compressed",
"data",
"to",
"the",
"underlying",
"writer",
".",
"It",
"is",
"useful",
"mainly",
"in",
"compressed",
"network",
"protocols",
"to",
"ensure",
"that",
"a",
"remote",
"reader",
"has",
"enough",
"data",
"to",
"reconstruct",
"a",
"packet",
".",
"Flush",
"does",
"not",
"return",
"until",
"the",
"data",
"has",
"been",
"written",
".",
"If",
"the",
"underlying",
"writer",
"returns",
"an",
"error",
"Flush",
"returns",
"that",
"error",
".",
"In",
"the",
"terminology",
"of",
"the",
"zlib",
"library",
"Flush",
"is",
"equivalent",
"to",
"Z_SYNC_FLUSH",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/gzip/gzip.go#L210-L225 |
8,283 | klauspost/compress | zstd/blockdec.go | reset | 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 | 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
} | [
"func",
"(",
"b",
"*",
"blockDec",
")",
"reset",
"(",
"br",
"byteBuffer",
",",
"windowSize",
"uint64",
")",
"error",
"{",
"b",
".",
"WindowSize",
"=",
"windowSize",
"\n",
"tmp",
":=",
"br",
".",
"readSmall",
"(",
"3",
")",
"\n",
"if",
"tmp",
"==",
"nil",
"{",
"if",
"debug",
"{",
"println",
"(",
"\"",
"\"",
",",
"io",
".",
"ErrUnexpectedEOF",
")",
"\n",
"}",
"\n",
"return",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"\n",
"bh",
":=",
"uint32",
"(",
"tmp",
"[",
"0",
"]",
")",
"|",
"(",
"uint32",
"(",
"tmp",
"[",
"1",
"]",
")",
"<<",
"8",
")",
"|",
"(",
"uint32",
"(",
"tmp",
"[",
"2",
"]",
")",
"<<",
"16",
")",
"\n",
"b",
".",
"Last",
"=",
"bh",
"&",
"1",
"!=",
"0",
"\n",
"b",
".",
"Type",
"=",
"blockType",
"(",
"(",
"bh",
">>",
"1",
")",
"&",
"3",
")",
"\n",
"// find size.",
"cSize",
":=",
"int",
"(",
"bh",
">>",
"3",
")",
"\n",
"switch",
"b",
".",
"Type",
"{",
"case",
"blockTypeReserved",
":",
"return",
"ErrReservedBlockType",
"\n",
"case",
"blockTypeRLE",
":",
"b",
".",
"RLESize",
"=",
"uint32",
"(",
"cSize",
")",
"\n",
"cSize",
"=",
"1",
"\n",
"case",
"blockTypeCompressed",
":",
"if",
"debug",
"{",
"println",
"(",
"\"",
"\"",
",",
"cSize",
")",
"\n",
"}",
"\n",
"b",
".",
"RLESize",
"=",
"0",
"\n",
"if",
"cSize",
">",
"maxCompressedBlockSize",
"||",
"uint64",
"(",
"cSize",
")",
">",
"b",
".",
"WindowSize",
"{",
"if",
"debug",
"{",
"printf",
"(",
"\"",
"\\n",
"\"",
",",
"b",
")",
"\n",
"}",
"\n",
"return",
"ErrCompressedSizeTooBig",
"\n",
"}",
"\n",
"default",
":",
"b",
".",
"RLESize",
"=",
"0",
"\n",
"}",
"\n\n",
"// Read block data.",
"if",
"cap",
"(",
"b",
".",
"data",
")",
"<",
"cSize",
"{",
"if",
"b",
".",
"lowMem",
"{",
"b",
".",
"data",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"cSize",
")",
"\n",
"}",
"else",
"{",
"b",
".",
"data",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"maxBlockSize",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"cap",
"(",
"b",
".",
"dst",
")",
"<=",
"maxBlockSize",
"{",
"b",
".",
"dst",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"maxBlockSize",
"+",
"1",
")",
"\n",
"}",
"\n",
"var",
"err",
"error",
"\n",
"b",
".",
"data",
",",
"err",
"=",
"br",
".",
"readBig",
"(",
"cSize",
",",
"b",
".",
"data",
"[",
":",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"debug",
"{",
"println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // reset will reset the block.
// Input must be a start of a block and will be at the end of the block when returned. | [
"reset",
"will",
"reset",
"the",
"block",
".",
"Input",
"must",
"be",
"a",
"start",
"of",
"a",
"block",
"and",
"will",
"be",
"at",
"the",
"end",
"of",
"the",
"block",
"when",
"returned",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/blockdec.go#L111-L166 |
8,284 | klauspost/compress | zstd/blockdec.go | sendErr | func (b *blockDec) sendErr(err error) {
b.Last = true
b.Type = blockTypeReserved
b.err = err
b.input <- struct{}{}
} | go | func (b *blockDec) sendErr(err error) {
b.Last = true
b.Type = blockTypeReserved
b.err = err
b.input <- struct{}{}
} | [
"func",
"(",
"b",
"*",
"blockDec",
")",
"sendErr",
"(",
"err",
"error",
")",
"{",
"b",
".",
"Last",
"=",
"true",
"\n",
"b",
".",
"Type",
"=",
"blockTypeReserved",
"\n",
"b",
".",
"err",
"=",
"err",
"\n",
"b",
".",
"input",
"<-",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}"
]
| // sendEOF will make the decoder send EOF on this frame. | [
"sendEOF",
"will",
"make",
"the",
"decoder",
"send",
"EOF",
"on",
"this",
"frame",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/blockdec.go#L169-L174 |
8,285 | klauspost/compress | zstd/blockdec.go | Close | func (b *blockDec) Close() {
close(b.input)
close(b.history)
close(b.result)
} | go | func (b *blockDec) Close() {
close(b.input)
close(b.history)
close(b.result)
} | [
"func",
"(",
"b",
"*",
"blockDec",
")",
"Close",
"(",
")",
"{",
"close",
"(",
"b",
".",
"input",
")",
"\n",
"close",
"(",
"b",
".",
"history",
")",
"\n",
"close",
"(",
"b",
".",
"result",
")",
"\n",
"}"
]
| // Close will release resources.
// Closed blockDec cannot be reset. | [
"Close",
"will",
"release",
"resources",
".",
"Closed",
"blockDec",
"cannot",
"be",
"reset",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/blockdec.go#L178-L182 |
8,286 | klauspost/compress | zstd/blockdec.go | startDecoder | 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 | 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")
}
}
} | [
"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",
")",
"\n",
"}",
"else",
"{",
"b",
".",
"dst",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"maxBlockSize",
")",
"\n",
"}",
"\n",
"}",
"\n",
"o",
":=",
"decodeOutput",
"{",
"d",
":",
"b",
",",
"b",
":",
"b",
".",
"dst",
"[",
":",
"b",
".",
"RLESize",
"]",
",",
"err",
":",
"nil",
",",
"}",
"\n",
"v",
":=",
"b",
".",
"data",
"[",
"0",
"]",
"\n",
"for",
"i",
":=",
"range",
"o",
".",
"b",
"{",
"o",
".",
"b",
"[",
"i",
"]",
"=",
"v",
"\n",
"}",
"\n",
"hist",
":=",
"<-",
"b",
".",
"history",
"\n",
"hist",
".",
"append",
"(",
"o",
".",
"b",
")",
"\n",
"b",
".",
"result",
"<-",
"o",
"\n",
"case",
"blockTypeRaw",
":",
"o",
":=",
"decodeOutput",
"{",
"d",
":",
"b",
",",
"b",
":",
"b",
".",
"data",
",",
"err",
":",
"nil",
",",
"}",
"\n",
"hist",
":=",
"<-",
"b",
".",
"history",
"\n",
"hist",
".",
"append",
"(",
"o",
".",
"b",
")",
"\n",
"b",
".",
"result",
"<-",
"o",
"\n",
"case",
"blockTypeCompressed",
":",
"b",
".",
"dst",
"=",
"b",
".",
"dst",
"[",
":",
"0",
"]",
"\n",
"err",
":=",
"b",
".",
"decodeCompressed",
"(",
"nil",
")",
"\n",
"o",
":=",
"decodeOutput",
"{",
"d",
":",
"b",
",",
"b",
":",
"b",
".",
"dst",
",",
"err",
":",
"err",
",",
"}",
"\n",
"if",
"debug",
"{",
"println",
"(",
"\"",
"\"",
",",
"len",
"(",
"b",
".",
"dst",
")",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"b",
".",
"result",
"<-",
"o",
"\n",
"case",
"blockTypeReserved",
":",
"// Used for returning errors.",
"<-",
"b",
".",
"history",
"\n",
"b",
".",
"result",
"<-",
"decodeOutput",
"{",
"d",
":",
"b",
",",
"b",
":",
"nil",
",",
"err",
":",
"b",
".",
"err",
",",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"debug",
"{",
"println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
]
| // decodeAsync will prepare decoding the block when it receives input.
// This will separate output and history. | [
"decodeAsync",
"will",
"prepare",
"decoding",
"the",
"block",
"when",
"it",
"receives",
"input",
".",
"This",
"will",
"separate",
"output",
"and",
"history",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/blockdec.go#L186-L246 |
8,287 | klauspost/compress | zstd/blockdec.go | decodeBuf | 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 | 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")
}
} | [
"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",
")",
"\n",
"}",
"else",
"{",
"b",
".",
"dst",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"maxBlockSize",
")",
"\n",
"}",
"\n",
"}",
"\n",
"b",
".",
"dst",
"=",
"b",
".",
"dst",
"[",
":",
"b",
".",
"RLESize",
"]",
"\n",
"v",
":=",
"b",
".",
"data",
"[",
"0",
"]",
"\n",
"for",
"i",
":=",
"range",
"b",
".",
"dst",
"{",
"b",
".",
"dst",
"[",
"i",
"]",
"=",
"v",
"\n",
"}",
"\n",
"hist",
".",
"appendKeep",
"(",
"b",
".",
"dst",
")",
"\n",
"return",
"nil",
"\n",
"case",
"blockTypeRaw",
":",
"hist",
".",
"appendKeep",
"(",
"b",
".",
"data",
")",
"\n",
"return",
"nil",
"\n",
"case",
"blockTypeCompressed",
":",
"saved",
":=",
"b",
".",
"dst",
"\n",
"b",
".",
"dst",
"=",
"hist",
".",
"b",
"\n",
"hist",
".",
"b",
"=",
"nil",
"\n",
"err",
":=",
"b",
".",
"decodeCompressed",
"(",
"hist",
")",
"\n",
"if",
"debug",
"{",
"println",
"(",
"\"",
"\"",
",",
"len",
"(",
"b",
".",
"dst",
")",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"hist",
".",
"b",
"=",
"b",
".",
"dst",
"\n",
"b",
".",
"dst",
"=",
"saved",
"\n",
"return",
"err",
"\n",
"case",
"blockTypeReserved",
":",
"// Used for returning errors.",
"return",
"b",
".",
"err",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
]
| // decodeAsync will prepare decoding the block when it receives the history.
// If history is provided, it will not fetch it from the channel. | [
"decodeAsync",
"will",
"prepare",
"decoding",
"the",
"block",
"when",
"it",
"receives",
"the",
"history",
".",
"If",
"history",
"is",
"provided",
"it",
"will",
"not",
"fetch",
"it",
"from",
"the",
"channel",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/blockdec.go#L250-L287 |
8,288 | klauspost/compress | zstd/bitreader.go | init | 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 | 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
} | [
"func",
"(",
"b",
"*",
"bitReader",
")",
"init",
"(",
"in",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"in",
")",
"<",
"1",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"b",
".",
"in",
"=",
"in",
"\n",
"b",
".",
"off",
"=",
"uint",
"(",
"len",
"(",
"in",
")",
")",
"\n",
"// The highest bit of the last byte indicates where to start",
"v",
":=",
"in",
"[",
"len",
"(",
"in",
")",
"-",
"1",
"]",
"\n",
"if",
"v",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"b",
".",
"bitsRead",
"=",
"64",
"\n",
"b",
".",
"value",
"=",
"0",
"\n",
"b",
".",
"fill",
"(",
")",
"\n",
"b",
".",
"fill",
"(",
")",
"\n",
"b",
".",
"bitsRead",
"+=",
"8",
"-",
"uint8",
"(",
"highBits",
"(",
"uint32",
"(",
"v",
")",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // init initializes and resets the bit reader. | [
"init",
"initializes",
"and",
"resets",
"the",
"bit",
"reader",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/bitreader.go#L24-L41 |
8,289 | klauspost/compress | zstd/bitreader.go | close | func (b *bitReader) close() error {
// Release reference.
b.in = nil
if b.bitsRead > 64 {
return io.ErrUnexpectedEOF
}
return nil
} | go | func (b *bitReader) close() error {
// Release reference.
b.in = nil
if b.bitsRead > 64 {
return io.ErrUnexpectedEOF
}
return nil
} | [
"func",
"(",
"b",
"*",
"bitReader",
")",
"close",
"(",
")",
"error",
"{",
"// Release reference.",
"b",
".",
"in",
"=",
"nil",
"\n",
"if",
"b",
".",
"bitsRead",
">",
"64",
"{",
"return",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // close the bitstream and returns an error if out-of-buffer reads occurred. | [
"close",
"the",
"bitstream",
"and",
"returns",
"an",
"error",
"if",
"out",
"-",
"of",
"-",
"buffer",
"reads",
"occurred",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/bitreader.go#L110-L117 |
8,290 | klauspost/compress | zip/register.go | RegisterDecompressor | func RegisterDecompressor(method uint16, d Decompressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := decompressors[method]; ok {
panic("decompressor already registered")
}
decompressors[method] = d
} | go | func RegisterDecompressor(method uint16, d Decompressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := decompressors[method]; ok {
panic("decompressor already registered")
}
decompressors[method] = d
} | [
"func",
"RegisterDecompressor",
"(",
"method",
"uint16",
",",
"d",
"Decompressor",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"decompressors",
"[",
"method",
"]",
";",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"decompressors",
"[",
"method",
"]",
"=",
"d",
"\n",
"}"
]
| // RegisterDecompressor allows custom decompressors for a specified method ID. | [
"RegisterDecompressor",
"allows",
"custom",
"decompressors",
"for",
"a",
"specified",
"method",
"ID",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zip/register.go#L79-L87 |
8,291 | klauspost/compress | zip/register.go | RegisterCompressor | func RegisterCompressor(method uint16, comp Compressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := compressors[method]; ok {
panic("compressor already registered")
}
compressors[method] = comp
} | go | func RegisterCompressor(method uint16, comp Compressor) {
mu.Lock()
defer mu.Unlock()
if _, ok := compressors[method]; ok {
panic("compressor already registered")
}
compressors[method] = comp
} | [
"func",
"RegisterCompressor",
"(",
"method",
"uint16",
",",
"comp",
"Compressor",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"compressors",
"[",
"method",
"]",
";",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"compressors",
"[",
"method",
"]",
"=",
"comp",
"\n",
"}"
]
| // RegisterCompressor registers custom compressors for a specified method ID.
// The common methods Store and Deflate are built in. | [
"RegisterCompressor",
"registers",
"custom",
"compressors",
"for",
"a",
"specified",
"method",
"ID",
".",
"The",
"common",
"methods",
"Store",
"and",
"Deflate",
"are",
"built",
"in",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zip/register.go#L91-L99 |
8,292 | klauspost/compress | zstd/sequencedec.go | init | 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 | 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
} | [
"func",
"(",
"s",
"*",
"sequenceDec",
")",
"init",
"(",
"br",
"*",
"bitReader",
")",
"error",
"{",
"if",
"s",
".",
"fse",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"s",
".",
"state",
".",
"init",
"(",
"br",
",",
"s",
".",
"fse",
".",
"actualTableLog",
",",
"s",
".",
"fse",
".",
"dt",
"[",
":",
"1",
"<<",
"s",
".",
"fse",
".",
"actualTableLog",
"]",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // init the state of the decoder with input from stream. | [
"init",
"the",
"state",
"of",
"the",
"decoder",
"with",
"input",
"from",
"stream",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/sequencedec.go#L36-L42 |
8,293 | klauspost/compress | zstd/sequencedec.go | initialize | 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 | 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
} | [
"func",
"(",
"s",
"*",
"sequenceDecs",
")",
"initialize",
"(",
"br",
"*",
"bitReader",
",",
"hist",
"*",
"history",
",",
"literals",
",",
"out",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"litLengths",
".",
"init",
"(",
"br",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"offsets",
".",
"init",
"(",
"br",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"matchLengths",
".",
"init",
"(",
"br",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"s",
".",
"literals",
"=",
"literals",
"\n",
"s",
".",
"hist",
"=",
"hist",
".",
"b",
"\n",
"s",
".",
"prevOffset",
"=",
"hist",
".",
"recentOffsets",
"\n",
"s",
".",
"maxBits",
"=",
"s",
".",
"litLengths",
".",
"fse",
".",
"maxBits",
"+",
"s",
".",
"offsets",
".",
"fse",
".",
"maxBits",
"+",
"s",
".",
"matchLengths",
".",
"fse",
".",
"maxBits",
"\n",
"s",
".",
"out",
"=",
"out",
"\n",
"return",
"nil",
"\n",
"}"
]
| // initialize all 3 decoders from the stream input. | [
"initialize",
"all",
"3",
"decoders",
"from",
"the",
"stream",
"input",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/sequencedec.go#L57-L73 |
8,294 | klauspost/compress | zstd/sequencedec.go | nextFast | 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 | 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
} | [
"func",
"(",
"s",
"*",
"sequenceDecs",
")",
"nextFast",
"(",
"br",
"*",
"bitReader",
")",
"(",
"ll",
",",
"mo",
",",
"ml",
"int",
")",
"{",
"// Final will not read from stream.",
"ll",
",",
"llB",
":=",
"s",
".",
"litLengths",
".",
"state",
".",
"final",
"(",
")",
"\n",
"ml",
",",
"mlB",
":=",
"s",
".",
"matchLengths",
".",
"state",
".",
"final",
"(",
")",
"\n",
"mo",
",",
"moB",
":=",
"s",
".",
"offsets",
".",
"state",
".",
"final",
"(",
")",
"\n\n",
"// extra bits are stored in reverse order.",
"br",
".",
"fillFast",
"(",
")",
"\n",
"if",
"s",
".",
"maxBits",
"<=",
"32",
"{",
"mo",
"+=",
"br",
".",
"getBits",
"(",
"moB",
")",
"\n",
"ml",
"+=",
"br",
".",
"getBits",
"(",
"mlB",
")",
"\n",
"ll",
"+=",
"br",
".",
"getBits",
"(",
"llB",
")",
"\n",
"}",
"else",
"{",
"mo",
"+=",
"br",
".",
"getBits",
"(",
"moB",
")",
"\n",
"br",
".",
"fillFast",
"(",
")",
"\n",
"// matchlength+literal length, max 32 bits",
"ml",
"+=",
"br",
".",
"getBits",
"(",
"mlB",
")",
"\n",
"ll",
"+=",
"br",
".",
"getBits",
"(",
"llB",
")",
"\n",
"}",
"\n\n",
"// mo = s.adjustOffset(mo, ll, moB)",
"// Inlined for rather big speedup",
"if",
"moB",
">",
"1",
"{",
"s",
".",
"prevOffset",
"[",
"2",
"]",
"=",
"s",
".",
"prevOffset",
"[",
"1",
"]",
"\n",
"s",
".",
"prevOffset",
"[",
"1",
"]",
"=",
"s",
".",
"prevOffset",
"[",
"0",
"]",
"\n",
"s",
".",
"prevOffset",
"[",
"0",
"]",
"=",
"mo",
"\n",
"return",
"\n",
"}",
"\n\n",
"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",
"++",
"\n",
"}",
"\n\n",
"if",
"mo",
"==",
"0",
"{",
"mo",
"=",
"s",
".",
"prevOffset",
"[",
"0",
"]",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"temp",
"int",
"\n",
"if",
"mo",
"==",
"3",
"{",
"temp",
"=",
"s",
".",
"prevOffset",
"[",
"0",
"]",
"-",
"1",
"\n",
"}",
"else",
"{",
"temp",
"=",
"s",
".",
"prevOffset",
"[",
"mo",
"]",
"\n",
"}",
"\n\n",
"if",
"temp",
"==",
"0",
"{",
"// 0 is not valid; input is corrupted; force offset to 1",
"println",
"(",
"\"",
"\"",
")",
"\n",
"temp",
"=",
"1",
"\n",
"}",
"\n\n",
"if",
"mo",
"!=",
"1",
"{",
"s",
".",
"prevOffset",
"[",
"2",
"]",
"=",
"s",
".",
"prevOffset",
"[",
"1",
"]",
"\n",
"}",
"\n",
"s",
".",
"prevOffset",
"[",
"1",
"]",
"=",
"s",
".",
"prevOffset",
"[",
"0",
"]",
"\n",
"s",
".",
"prevOffset",
"[",
"0",
"]",
"=",
"temp",
"\n",
"mo",
"=",
"temp",
"\n",
"return",
"\n",
"}"
]
| // nextFast will return new states when there are at least 4 unused bytes left on the stream when done. | [
"nextFast",
"will",
"return",
"new",
"states",
"when",
"there",
"are",
"at",
"least",
"4",
"unused",
"bytes",
"left",
"on",
"the",
"stream",
"when",
"done",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/sequencedec.go#L239-L299 |
8,295 | klauspost/compress | zstd/sequencedec.go | mergeHistory | 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 | 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
} | [
"func",
"(",
"s",
"*",
"sequenceDecs",
")",
"mergeHistory",
"(",
"hist",
"*",
"sequenceDecs",
")",
"(",
"*",
"sequenceDecs",
",",
"error",
")",
"{",
"for",
"i",
":=",
"uint",
"(",
"0",
")",
";",
"i",
"<",
"3",
";",
"i",
"++",
"{",
"var",
"sNew",
",",
"sHist",
"*",
"sequenceDec",
"\n",
"switch",
"i",
"{",
"default",
":",
"// same as \"case 0\":",
"sNew",
"=",
"&",
"s",
".",
"litLengths",
"\n",
"sHist",
"=",
"&",
"hist",
".",
"litLengths",
"\n",
"case",
"1",
":",
"sNew",
"=",
"&",
"s",
".",
"offsets",
"\n",
"sHist",
"=",
"&",
"hist",
".",
"offsets",
"\n",
"case",
"2",
":",
"sNew",
"=",
"&",
"s",
".",
"matchLengths",
"\n",
"sHist",
"=",
"&",
"hist",
".",
"matchLengths",
"\n",
"}",
"\n",
"if",
"sNew",
".",
"repeat",
"{",
"if",
"sHist",
".",
"fse",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"sNew",
".",
"fse",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
")",
"\n",
"}",
"\n",
"if",
"sHist",
".",
"fse",
"!=",
"nil",
"&&",
"!",
"sHist",
".",
"fse",
".",
"preDefined",
"{",
"fseDecoderPool",
".",
"Put",
"(",
"sHist",
".",
"fse",
")",
"\n",
"}",
"\n",
"sHist",
".",
"fse",
"=",
"sNew",
".",
"fse",
"\n",
"}",
"\n",
"return",
"hist",
",",
"nil",
"\n",
"}"
]
| // mergeHistory will merge history. | [
"mergeHistory",
"will",
"merge",
"history",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/zstd/sequencedec.go#L365-L395 |
8,296 | klauspost/compress | huff0/compress.go | Compress1X | 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 | 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)
} | [
"func",
"Compress1X",
"(",
"in",
"[",
"]",
"byte",
",",
"s",
"*",
"Scratch",
")",
"(",
"out",
"[",
"]",
"byte",
",",
"reUsed",
"bool",
",",
"err",
"error",
")",
"{",
"s",
",",
"err",
"=",
"s",
".",
"prepare",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"compress",
"(",
"in",
",",
"s",
",",
"s",
".",
"compress1X",
")",
"\n",
"}"
]
| // Compress1X will compress the input.
// The output can be decoded using Decompress1X.
// Supply a Scratch object. The scratch object contains state about re-use,
// So when sharing across independent encodes, be sure to set the re-use policy. | [
"Compress1X",
"will",
"compress",
"the",
"input",
".",
"The",
"output",
"can",
"be",
"decoded",
"using",
"Decompress1X",
".",
"Supply",
"a",
"Scratch",
"object",
".",
"The",
"scratch",
"object",
"contains",
"state",
"about",
"re",
"-",
"use",
"So",
"when",
"sharing",
"across",
"independent",
"encodes",
"be",
"sure",
"to",
"set",
"the",
"re",
"-",
"use",
"policy",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/compress.go#L13-L19 |
8,297 | klauspost/compress | huff0/compress.go | Compress4X | 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 | 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)
} | [
"func",
"Compress4X",
"(",
"in",
"[",
"]",
"byte",
",",
"s",
"*",
"Scratch",
")",
"(",
"out",
"[",
"]",
"byte",
",",
"reUsed",
"bool",
",",
"err",
"error",
")",
"{",
"s",
",",
"err",
"=",
"s",
".",
"prepare",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"err",
"\n",
"}",
"\n",
"if",
"false",
"{",
"// TODO: compress4Xp only slightly faster.",
"const",
"parallelThreshold",
"=",
"8",
"<<",
"10",
"\n",
"if",
"len",
"(",
"in",
")",
"<",
"parallelThreshold",
"||",
"runtime",
".",
"GOMAXPROCS",
"(",
"0",
")",
"==",
"1",
"{",
"return",
"compress",
"(",
"in",
",",
"s",
",",
"s",
".",
"compress4X",
")",
"\n",
"}",
"\n",
"return",
"compress",
"(",
"in",
",",
"s",
",",
"s",
".",
"compress4Xp",
")",
"\n",
"}",
"\n",
"return",
"compress",
"(",
"in",
",",
"s",
",",
"s",
".",
"compress4X",
")",
"\n",
"}"
]
| // Compress4X will compress the input. The input is split into 4 independent blocks
// and compressed similar to Compress1X.
// The output can be decoded using Decompress4X.
// Supply a Scratch object. The scratch object contains state about re-use,
// So when sharing across independent encodes, be sure to set the re-use policy. | [
"Compress4X",
"will",
"compress",
"the",
"input",
".",
"The",
"input",
"is",
"split",
"into",
"4",
"independent",
"blocks",
"and",
"compressed",
"similar",
"to",
"Compress1X",
".",
"The",
"output",
"can",
"be",
"decoded",
"using",
"Decompress4X",
".",
"Supply",
"a",
"Scratch",
"object",
".",
"The",
"scratch",
"object",
"contains",
"state",
"about",
"re",
"-",
"use",
"So",
"when",
"sharing",
"across",
"independent",
"encodes",
"be",
"sure",
"to",
"set",
"the",
"re",
"-",
"use",
"policy",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/compress.go#L26-L40 |
8,298 | klauspost/compress | huff0/compress.go | compress4Xp | 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 | 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
} | [
"func",
"(",
"s",
"*",
"Scratch",
")",
"compress4Xp",
"(",
"src",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"src",
")",
"<",
"12",
"{",
"return",
"nil",
",",
"ErrIncompressible",
"\n",
"}",
"\n",
"// Add placeholder for output length",
"s",
".",
"Out",
"=",
"s",
".",
"Out",
"[",
":",
"6",
"]",
"\n\n",
"segmentSize",
":=",
"(",
"len",
"(",
"src",
")",
"+",
"3",
")",
"/",
"4",
"\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"var",
"errs",
"[",
"4",
"]",
"error",
"\n",
"wg",
".",
"Add",
"(",
"4",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"4",
";",
"i",
"++",
"{",
"toDo",
":=",
"src",
"\n",
"if",
"len",
"(",
"toDo",
")",
">",
"segmentSize",
"{",
"toDo",
"=",
"toDo",
"[",
":",
"segmentSize",
"]",
"\n",
"}",
"\n",
"src",
"=",
"src",
"[",
"len",
"(",
"toDo",
")",
":",
"]",
"\n\n",
"// Separate goroutine for each block.",
"go",
"func",
"(",
"i",
"int",
")",
"{",
"s",
".",
"tmpOut",
"[",
"i",
"]",
",",
"errs",
"[",
"i",
"]",
"=",
"s",
".",
"compress1xDo",
"(",
"s",
".",
"tmpOut",
"[",
"i",
"]",
"[",
":",
"0",
"]",
",",
"toDo",
")",
"\n",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
"i",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"4",
";",
"i",
"++",
"{",
"if",
"errs",
"[",
"i",
"]",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errs",
"[",
"i",
"]",
"\n",
"}",
"\n",
"o",
":=",
"s",
".",
"tmpOut",
"[",
"i",
"]",
"\n",
"// Write compressed length as little endian before block.",
"if",
"i",
"<",
"3",
"{",
"// Last length is not written.",
"s",
".",
"Out",
"[",
"i",
"*",
"2",
"]",
"=",
"byte",
"(",
"len",
"(",
"o",
")",
")",
"\n",
"s",
".",
"Out",
"[",
"i",
"*",
"2",
"+",
"1",
"]",
"=",
"byte",
"(",
"len",
"(",
"o",
")",
">>",
"8",
")",
"\n",
"}",
"\n\n",
"// Write output.",
"s",
".",
"Out",
"=",
"append",
"(",
"s",
".",
"Out",
",",
"o",
"...",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"Out",
",",
"nil",
"\n",
"}"
]
| // compress4Xp will compress 4 streams using separate goroutines. | [
"compress4Xp",
"will",
"compress",
"4",
"streams",
"using",
"separate",
"goroutines",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/compress.go#L216-L257 |
8,299 | klauspost/compress | huff0/compress.go | minTableLog | 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 | 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)
} | [
"func",
"(",
"s",
"*",
"Scratch",
")",
"minTableLog",
"(",
")",
"uint8",
"{",
"minBitsSrc",
":=",
"highBit32",
"(",
"uint32",
"(",
"s",
".",
"br",
".",
"remain",
"(",
")",
"-",
"1",
")",
")",
"+",
"1",
"\n",
"minBitsSymbols",
":=",
"highBit32",
"(",
"uint32",
"(",
"s",
".",
"symbolLen",
"-",
"1",
")",
")",
"+",
"2",
"\n",
"if",
"minBitsSrc",
"<",
"minBitsSymbols",
"{",
"return",
"uint8",
"(",
"minBitsSrc",
")",
"\n",
"}",
"\n",
"return",
"uint8",
"(",
"minBitsSymbols",
")",
"\n",
"}"
]
| // minTableLog provides the minimum logSize to safely represent a distribution. | [
"minTableLog",
"provides",
"the",
"minimum",
"logSize",
"to",
"safely",
"represent",
"a",
"distribution",
"."
]
| ae52aff18558bd92cbe681549bfe9e8cbffd5903 | https://github.com/klauspost/compress/blob/ae52aff18558bd92cbe681549bfe9e8cbffd5903/huff0/compress.go#L310-L317 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.