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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
14,500 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsIgnoreFlushesDuringBoot
|
func (g *Generator) SetWindowsIgnoreFlushesDuringBoot(ignore bool) {
g.initConfigWindows()
g.Config.Windows.IgnoreFlushesDuringBoot = ignore
}
|
go
|
func (g *Generator) SetWindowsIgnoreFlushesDuringBoot(ignore bool) {
g.initConfigWindows()
g.Config.Windows.IgnoreFlushesDuringBoot = ignore
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsIgnoreFlushesDuringBoot",
"(",
"ignore",
"bool",
")",
"{",
"g",
".",
"initConfigWindows",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"IgnoreFlushesDuringBoot",
"=",
"ignore",
"\n",
"}"
] |
// SetWindowsIgnoreFlushesDuringBoot sets g.Config.Windows.IgnoreFlushesDuringBoot.
|
[
"SetWindowsIgnoreFlushesDuringBoot",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"IgnoreFlushesDuringBoot",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1760-L1763
|
14,501 |
opencontainers/runtime-tools
|
generate/generate.go
|
AddWindowsLayerFolders
|
func (g *Generator) AddWindowsLayerFolders(folder string) {
g.initConfigWindows()
g.Config.Windows.LayerFolders = append(g.Config.Windows.LayerFolders, folder)
}
|
go
|
func (g *Generator) AddWindowsLayerFolders(folder string) {
g.initConfigWindows()
g.Config.Windows.LayerFolders = append(g.Config.Windows.LayerFolders, folder)
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"AddWindowsLayerFolders",
"(",
"folder",
"string",
")",
"{",
"g",
".",
"initConfigWindows",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"LayerFolders",
"=",
"append",
"(",
"g",
".",
"Config",
".",
"Windows",
".",
"LayerFolders",
",",
"folder",
")",
"\n",
"}"
] |
// AddWindowsLayerFolders adds layer folders into g.Config.Windows.LayerFolders.
|
[
"AddWindowsLayerFolders",
"adds",
"layer",
"folders",
"into",
"g",
".",
"Config",
".",
"Windows",
".",
"LayerFolders",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1766-L1769
|
14,502 |
opencontainers/runtime-tools
|
generate/generate.go
|
AddWindowsDevices
|
func (g *Generator) AddWindowsDevices(id, idType string) error {
if idType != "class" {
return fmt.Errorf("Invalid idType value: %s. Windows only supports a value of class", idType)
}
device := rspec.WindowsDevice{
ID: id,
IDType: idType,
}
g.initConfigWindows()
for i, device := range g.Config.Windows.Devices {
if device.ID == id {
g.Config.Windows.Devices[i].IDType = idType
return nil
}
}
g.Config.Windows.Devices = append(g.Config.Windows.Devices, device)
return nil
}
|
go
|
func (g *Generator) AddWindowsDevices(id, idType string) error {
if idType != "class" {
return fmt.Errorf("Invalid idType value: %s. Windows only supports a value of class", idType)
}
device := rspec.WindowsDevice{
ID: id,
IDType: idType,
}
g.initConfigWindows()
for i, device := range g.Config.Windows.Devices {
if device.ID == id {
g.Config.Windows.Devices[i].IDType = idType
return nil
}
}
g.Config.Windows.Devices = append(g.Config.Windows.Devices, device)
return nil
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"AddWindowsDevices",
"(",
"id",
",",
"idType",
"string",
")",
"error",
"{",
"if",
"idType",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"idType",
")",
"\n",
"}",
"\n",
"device",
":=",
"rspec",
".",
"WindowsDevice",
"{",
"ID",
":",
"id",
",",
"IDType",
":",
"idType",
",",
"}",
"\n\n",
"g",
".",
"initConfigWindows",
"(",
")",
"\n",
"for",
"i",
",",
"device",
":=",
"range",
"g",
".",
"Config",
".",
"Windows",
".",
"Devices",
"{",
"if",
"device",
".",
"ID",
"==",
"id",
"{",
"g",
".",
"Config",
".",
"Windows",
".",
"Devices",
"[",
"i",
"]",
".",
"IDType",
"=",
"idType",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Devices",
"=",
"append",
"(",
"g",
".",
"Config",
".",
"Windows",
".",
"Devices",
",",
"device",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// AddWindowsDevices adds or sets g.Config.Windwos.Devices
|
[
"AddWindowsDevices",
"adds",
"or",
"sets",
"g",
".",
"Config",
".",
"Windwos",
".",
"Devices"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1772-L1790
|
14,503 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsNetwork
|
func (g *Generator) SetWindowsNetwork(network rspec.WindowsNetwork) {
g.initConfigWindows()
g.Config.Windows.Network = &network
}
|
go
|
func (g *Generator) SetWindowsNetwork(network rspec.WindowsNetwork) {
g.initConfigWindows()
g.Config.Windows.Network = &network
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsNetwork",
"(",
"network",
"rspec",
".",
"WindowsNetwork",
")",
"{",
"g",
".",
"initConfigWindows",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Network",
"=",
"&",
"network",
"\n",
"}"
] |
// SetWindowsNetwork sets g.Config.Windows.Network.
|
[
"SetWindowsNetwork",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Network",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1793-L1796
|
14,504 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsNetworkAllowUnqualifiedDNSQuery
|
func (g *Generator) SetWindowsNetworkAllowUnqualifiedDNSQuery(setting bool) {
g.initConfigWindowsNetwork()
g.Config.Windows.Network.AllowUnqualifiedDNSQuery = setting
}
|
go
|
func (g *Generator) SetWindowsNetworkAllowUnqualifiedDNSQuery(setting bool) {
g.initConfigWindowsNetwork()
g.Config.Windows.Network.AllowUnqualifiedDNSQuery = setting
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsNetworkAllowUnqualifiedDNSQuery",
"(",
"setting",
"bool",
")",
"{",
"g",
".",
"initConfigWindowsNetwork",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Network",
".",
"AllowUnqualifiedDNSQuery",
"=",
"setting",
"\n",
"}"
] |
// SetWindowsNetworkAllowUnqualifiedDNSQuery sets g.Config.Windows.Network.AllowUnqualifiedDNSQuery
|
[
"SetWindowsNetworkAllowUnqualifiedDNSQuery",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Network",
".",
"AllowUnqualifiedDNSQuery"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1799-L1802
|
14,505 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsNetworkNamespace
|
func (g *Generator) SetWindowsNetworkNamespace(path string) {
g.initConfigWindowsNetwork()
g.Config.Windows.Network.NetworkNamespace = path
}
|
go
|
func (g *Generator) SetWindowsNetworkNamespace(path string) {
g.initConfigWindowsNetwork()
g.Config.Windows.Network.NetworkNamespace = path
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsNetworkNamespace",
"(",
"path",
"string",
")",
"{",
"g",
".",
"initConfigWindowsNetwork",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Network",
".",
"NetworkNamespace",
"=",
"path",
"\n",
"}"
] |
// SetWindowsNetworkNamespace sets g.Config.Windows.Network.NetworkNamespace
|
[
"SetWindowsNetworkNamespace",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Network",
".",
"NetworkNamespace"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1805-L1808
|
14,506 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsResourcesCPU
|
func (g *Generator) SetWindowsResourcesCPU(cpu rspec.WindowsCPUResources) {
g.initConfigWindowsResources()
g.Config.Windows.Resources.CPU = &cpu
}
|
go
|
func (g *Generator) SetWindowsResourcesCPU(cpu rspec.WindowsCPUResources) {
g.initConfigWindowsResources()
g.Config.Windows.Resources.CPU = &cpu
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsResourcesCPU",
"(",
"cpu",
"rspec",
".",
"WindowsCPUResources",
")",
"{",
"g",
".",
"initConfigWindowsResources",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Resources",
".",
"CPU",
"=",
"&",
"cpu",
"\n",
"}"
] |
// SetWindowsResourcesCPU sets g.Config.Windows.Resources.CPU.
|
[
"SetWindowsResourcesCPU",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Resources",
".",
"CPU",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1811-L1814
|
14,507 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsResourcesMemoryLimit
|
func (g *Generator) SetWindowsResourcesMemoryLimit(limit uint64) {
g.initConfigWindowsResourcesMemory()
g.Config.Windows.Resources.Memory.Limit = &limit
}
|
go
|
func (g *Generator) SetWindowsResourcesMemoryLimit(limit uint64) {
g.initConfigWindowsResourcesMemory()
g.Config.Windows.Resources.Memory.Limit = &limit
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsResourcesMemoryLimit",
"(",
"limit",
"uint64",
")",
"{",
"g",
".",
"initConfigWindowsResourcesMemory",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Resources",
".",
"Memory",
".",
"Limit",
"=",
"&",
"limit",
"\n",
"}"
] |
// SetWindowsResourcesMemoryLimit sets g.Config.Windows.Resources.Memory.Limit.
|
[
"SetWindowsResourcesMemoryLimit",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Resources",
".",
"Memory",
".",
"Limit",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1817-L1820
|
14,508 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsResourcesStorage
|
func (g *Generator) SetWindowsResourcesStorage(storage rspec.WindowsStorageResources) {
g.initConfigWindowsResources()
g.Config.Windows.Resources.Storage = &storage
}
|
go
|
func (g *Generator) SetWindowsResourcesStorage(storage rspec.WindowsStorageResources) {
g.initConfigWindowsResources()
g.Config.Windows.Resources.Storage = &storage
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsResourcesStorage",
"(",
"storage",
"rspec",
".",
"WindowsStorageResources",
")",
"{",
"g",
".",
"initConfigWindowsResources",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Resources",
".",
"Storage",
"=",
"&",
"storage",
"\n",
"}"
] |
// SetWindowsResourcesStorage sets g.Config.Windows.Resources.Storage.
|
[
"SetWindowsResourcesStorage",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Resources",
".",
"Storage",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1823-L1826
|
14,509 |
opencontainers/runtime-tools
|
generate/generate.go
|
SetWindowsServicing
|
func (g *Generator) SetWindowsServicing(servicing bool) {
g.initConfigWindows()
g.Config.Windows.Servicing = servicing
}
|
go
|
func (g *Generator) SetWindowsServicing(servicing bool) {
g.initConfigWindows()
g.Config.Windows.Servicing = servicing
}
|
[
"func",
"(",
"g",
"*",
"Generator",
")",
"SetWindowsServicing",
"(",
"servicing",
"bool",
")",
"{",
"g",
".",
"initConfigWindows",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Windows",
".",
"Servicing",
"=",
"servicing",
"\n",
"}"
] |
// SetWindowsServicing sets g.Config.Windows.Servicing.
|
[
"SetWindowsServicing",
"sets",
"g",
".",
"Config",
".",
"Windows",
".",
"Servicing",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L1829-L1832
|
14,510 |
opencontainers/runtime-tools
|
validation/util/linux_resources_devices.go
|
ValidateLinuxResourcesDevices
|
func ValidateLinuxResourcesDevices(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find devices")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lnd, err := cg.GetDevicesData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get devices data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
for i, device := range config.Linux.Resources.Devices {
if device.Allow == true {
found := false
if lnd[i-1].Type == device.Type && *lnd[i-1].Major == *device.Major && *lnd[i-1].Minor == *device.Minor && lnd[i-1].Access == device.Access {
found = true
}
t.Ok(found, fmt.Sprintf("devices %s %d:%d %s is set correctly", device.Type, *device.Major, *device.Minor, device.Access))
t.Diagnosticf("expect: %s %d:%d %s, actual: %s %d:%d %s",
device.Type, *device.Major, *device.Minor, device.Access, lnd[i-1].Type, *lnd[i-1].Major, *lnd[i-1].Minor, lnd[i-1].Access)
if !found {
err := specerror.NewError(specerror.DevicesApplyInOrder, fmt.Errorf("The runtime MUST apply entries in the listed order"), rspec.Version)
t.Diagnostic(err.Error())
return nil
}
}
}
return nil
}
|
go
|
func ValidateLinuxResourcesDevices(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find devices")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lnd, err := cg.GetDevicesData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get devices data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
for i, device := range config.Linux.Resources.Devices {
if device.Allow == true {
found := false
if lnd[i-1].Type == device.Type && *lnd[i-1].Major == *device.Major && *lnd[i-1].Minor == *device.Minor && lnd[i-1].Access == device.Access {
found = true
}
t.Ok(found, fmt.Sprintf("devices %s %d:%d %s is set correctly", device.Type, *device.Major, *device.Minor, device.Access))
t.Diagnosticf("expect: %s %d:%d %s, actual: %s %d:%d %s",
device.Type, *device.Major, *device.Minor, device.Access, lnd[i-1].Type, *lnd[i-1].Major, *lnd[i-1].Minor, lnd[i-1].Access)
if !found {
err := specerror.NewError(specerror.DevicesApplyInOrder, fmt.Errorf("The runtime MUST apply entries in the listed order"), rspec.Version)
t.Diagnostic(err.Error())
return nil
}
}
}
return nil
}
|
[
"func",
"ValidateLinuxResourcesDevices",
"(",
"config",
"*",
"rspec",
".",
"Spec",
",",
"t",
"*",
"tap",
".",
"T",
",",
"state",
"*",
"rspec",
".",
"State",
")",
"error",
"{",
"cg",
",",
"err",
":=",
"cgroups",
".",
"FindCgroup",
"(",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"lnd",
",",
"err",
":=",
"cg",
".",
"GetDevicesData",
"(",
"state",
".",
"Pid",
",",
"config",
".",
"Linux",
".",
"CgroupsPath",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"device",
":=",
"range",
"config",
".",
"Linux",
".",
"Resources",
".",
"Devices",
"{",
"if",
"device",
".",
"Allow",
"==",
"true",
"{",
"found",
":=",
"false",
"\n",
"if",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Type",
"==",
"device",
".",
"Type",
"&&",
"*",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Major",
"==",
"*",
"device",
".",
"Major",
"&&",
"*",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Minor",
"==",
"*",
"device",
".",
"Minor",
"&&",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Access",
"==",
"device",
".",
"Access",
"{",
"found",
"=",
"true",
"\n",
"}",
"\n",
"t",
".",
"Ok",
"(",
"found",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"device",
".",
"Type",
",",
"*",
"device",
".",
"Major",
",",
"*",
"device",
".",
"Minor",
",",
"device",
".",
"Access",
")",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"device",
".",
"Type",
",",
"*",
"device",
".",
"Major",
",",
"*",
"device",
".",
"Minor",
",",
"device",
".",
"Access",
",",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Type",
",",
"*",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Major",
",",
"*",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Minor",
",",
"lnd",
"[",
"i",
"-",
"1",
"]",
".",
"Access",
")",
"\n",
"if",
"!",
"found",
"{",
"err",
":=",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"DevicesApplyInOrder",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
",",
"rspec",
".",
"Version",
")",
"\n",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ValidateLinuxResourcesDevices validates linux.resources.devices.
|
[
"ValidateLinuxResourcesDevices",
"validates",
"linux",
".",
"resources",
".",
"devices",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/linux_resources_devices.go#L13-L46
|
14,511 |
opencontainers/runtime-tools
|
filepath/ancestor.go
|
IsAncestor
|
func IsAncestor(os, pathA, pathB, cwd string) (_ bool, err error) {
if pathA == pathB {
return false, nil
}
pathA, err = Abs(os, pathA, cwd)
if err != nil {
return false, err
}
pathB, err = Abs(os, pathB, cwd)
if err != nil {
return false, err
}
sep := Separator(os)
if !strings.HasSuffix(pathA, string(sep)) {
pathA = fmt.Sprintf("%s%c", pathA, sep)
}
if pathA == pathB {
return false, nil
}
return strings.HasPrefix(pathB, pathA), nil
}
|
go
|
func IsAncestor(os, pathA, pathB, cwd string) (_ bool, err error) {
if pathA == pathB {
return false, nil
}
pathA, err = Abs(os, pathA, cwd)
if err != nil {
return false, err
}
pathB, err = Abs(os, pathB, cwd)
if err != nil {
return false, err
}
sep := Separator(os)
if !strings.HasSuffix(pathA, string(sep)) {
pathA = fmt.Sprintf("%s%c", pathA, sep)
}
if pathA == pathB {
return false, nil
}
return strings.HasPrefix(pathB, pathA), nil
}
|
[
"func",
"IsAncestor",
"(",
"os",
",",
"pathA",
",",
"pathB",
",",
"cwd",
"string",
")",
"(",
"_",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"pathA",
"==",
"pathB",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"pathA",
",",
"err",
"=",
"Abs",
"(",
"os",
",",
"pathA",
",",
"cwd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"pathB",
",",
"err",
"=",
"Abs",
"(",
"os",
",",
"pathB",
",",
"cwd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"sep",
":=",
"Separator",
"(",
"os",
")",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"pathA",
",",
"string",
"(",
"sep",
")",
")",
"{",
"pathA",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pathA",
",",
"sep",
")",
"\n",
"}",
"\n",
"if",
"pathA",
"==",
"pathB",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"strings",
".",
"HasPrefix",
"(",
"pathB",
",",
"pathA",
")",
",",
"nil",
"\n",
"}"
] |
// IsAncestor returns true when pathB is an strict ancestor of pathA,
// and false where the paths are equal or pathB is outside of pathA.
// Paths that are not absolute will be made absolute with Abs.
|
[
"IsAncestor",
"returns",
"true",
"when",
"pathB",
"is",
"an",
"strict",
"ancestor",
"of",
"pathA",
"and",
"false",
"where",
"the",
"paths",
"are",
"equal",
"or",
"pathB",
"is",
"outside",
"of",
"pathA",
".",
"Paths",
"that",
"are",
"not",
"absolute",
"will",
"be",
"made",
"absolute",
"with",
"Abs",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/filepath/ancestor.go#L11-L32
|
14,512 |
opencontainers/runtime-tools
|
validation/util/linux_resources_network.go
|
ValidateLinuxResourcesNetwork
|
func ValidateLinuxResourcesNetwork(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find network cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lnd, err := cg.GetNetworkData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get network cgroup data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
t.Ok(*lnd.ClassID == *config.Linux.Resources.Network.ClassID, "network ID set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Network.ClassID, *lnd.ClassID)
for _, priority := range config.Linux.Resources.Network.Priorities {
found := false
for _, lip := range lnd.Priorities {
if lip.Name == priority.Name {
found = true
t.Ok(lip.Priority == priority.Priority, fmt.Sprintf("network priority for %s is set correctly", priority.Name))
t.Diagnosticf("expect: %d, actual: %d", priority.Priority, lip.Priority)
}
}
t.Ok(found, fmt.Sprintf("network priority for %s found", priority.Name))
}
return nil
}
|
go
|
func ValidateLinuxResourcesNetwork(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find network cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lnd, err := cg.GetNetworkData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get network cgroup data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
t.Ok(*lnd.ClassID == *config.Linux.Resources.Network.ClassID, "network ID set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Network.ClassID, *lnd.ClassID)
for _, priority := range config.Linux.Resources.Network.Priorities {
found := false
for _, lip := range lnd.Priorities {
if lip.Name == priority.Name {
found = true
t.Ok(lip.Priority == priority.Priority, fmt.Sprintf("network priority for %s is set correctly", priority.Name))
t.Diagnosticf("expect: %d, actual: %d", priority.Priority, lip.Priority)
}
}
t.Ok(found, fmt.Sprintf("network priority for %s found", priority.Name))
}
return nil
}
|
[
"func",
"ValidateLinuxResourcesNetwork",
"(",
"config",
"*",
"rspec",
".",
"Spec",
",",
"t",
"*",
"tap",
".",
"T",
",",
"state",
"*",
"rspec",
".",
"State",
")",
"error",
"{",
"cg",
",",
"err",
":=",
"cgroups",
".",
"FindCgroup",
"(",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"lnd",
",",
"err",
":=",
"cg",
".",
"GetNetworkData",
"(",
"state",
".",
"Pid",
",",
"config",
".",
"Linux",
".",
"CgroupsPath",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lnd",
".",
"ClassID",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Network",
".",
"ClassID",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Network",
".",
"ClassID",
",",
"*",
"lnd",
".",
"ClassID",
")",
"\n\n",
"for",
"_",
",",
"priority",
":=",
"range",
"config",
".",
"Linux",
".",
"Resources",
".",
"Network",
".",
"Priorities",
"{",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"lip",
":=",
"range",
"lnd",
".",
"Priorities",
"{",
"if",
"lip",
".",
"Name",
"==",
"priority",
".",
"Name",
"{",
"found",
"=",
"true",
"\n",
"t",
".",
"Ok",
"(",
"lip",
".",
"Priority",
"==",
"priority",
".",
"Priority",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"priority",
".",
"Name",
")",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"priority",
".",
"Priority",
",",
"lip",
".",
"Priority",
")",
"\n",
"}",
"\n",
"}",
"\n",
"t",
".",
"Ok",
"(",
"found",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"priority",
".",
"Name",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ValidateLinuxResourcesNetwork validates linux.resources.network.
|
[
"ValidateLinuxResourcesNetwork",
"validates",
"linux",
".",
"resources",
".",
"network",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/linux_resources_network.go#L12-L43
|
14,513 |
opencontainers/runtime-tools
|
validation/util/linux_resources_memory.go
|
ValidateLinuxResourcesMemory
|
func ValidateLinuxResourcesMemory(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find memory cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lm, err := cg.GetMemoryData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get memory cgroup data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
t.Ok(*lm.Limit == *config.Linux.Resources.Memory.Limit, "memory limit is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Limit, *lm.Limit)
t.Ok(*lm.Reservation == *config.Linux.Resources.Memory.Reservation, "memory reservation is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Reservation, *lm.Reservation)
t.Ok(*lm.Swap == *config.Linux.Resources.Memory.Swap, "memory swap is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Swap, *lm.Reservation)
t.Ok(*lm.Kernel == *config.Linux.Resources.Memory.Kernel, "memory kernel is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Kernel, *lm.Kernel)
t.Ok(*lm.KernelTCP == *config.Linux.Resources.Memory.KernelTCP, "memory kernelTCP is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.KernelTCP, *lm.Kernel)
t.Ok(*lm.Swappiness == *config.Linux.Resources.Memory.Swappiness, "memory swappiness is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Swappiness, *lm.Swappiness)
t.Ok(*lm.DisableOOMKiller == *config.Linux.Resources.Memory.DisableOOMKiller, "memory oom is set correctly")
t.Diagnosticf("expect: %t, actual: %t", *config.Linux.Resources.Memory.DisableOOMKiller, *lm.DisableOOMKiller)
return nil
}
|
go
|
func ValidateLinuxResourcesMemory(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find memory cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lm, err := cg.GetMemoryData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get memory cgroup data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
t.Ok(*lm.Limit == *config.Linux.Resources.Memory.Limit, "memory limit is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Limit, *lm.Limit)
t.Ok(*lm.Reservation == *config.Linux.Resources.Memory.Reservation, "memory reservation is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Reservation, *lm.Reservation)
t.Ok(*lm.Swap == *config.Linux.Resources.Memory.Swap, "memory swap is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Swap, *lm.Reservation)
t.Ok(*lm.Kernel == *config.Linux.Resources.Memory.Kernel, "memory kernel is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Kernel, *lm.Kernel)
t.Ok(*lm.KernelTCP == *config.Linux.Resources.Memory.KernelTCP, "memory kernelTCP is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.KernelTCP, *lm.Kernel)
t.Ok(*lm.Swappiness == *config.Linux.Resources.Memory.Swappiness, "memory swappiness is set correctly")
t.Diagnosticf("expect: %d, actual: %d", *config.Linux.Resources.Memory.Swappiness, *lm.Swappiness)
t.Ok(*lm.DisableOOMKiller == *config.Linux.Resources.Memory.DisableOOMKiller, "memory oom is set correctly")
t.Diagnosticf("expect: %t, actual: %t", *config.Linux.Resources.Memory.DisableOOMKiller, *lm.DisableOOMKiller)
return nil
}
|
[
"func",
"ValidateLinuxResourcesMemory",
"(",
"config",
"*",
"rspec",
".",
"Spec",
",",
"t",
"*",
"tap",
".",
"T",
",",
"state",
"*",
"rspec",
".",
"State",
")",
"error",
"{",
"cg",
",",
"err",
":=",
"cgroups",
".",
"FindCgroup",
"(",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"lm",
",",
"err",
":=",
"cg",
".",
"GetMemoryData",
"(",
"state",
".",
"Pid",
",",
"config",
".",
"Linux",
".",
"CgroupsPath",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"Limit",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Limit",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Limit",
",",
"*",
"lm",
".",
"Limit",
")",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"Reservation",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Reservation",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Reservation",
",",
"*",
"lm",
".",
"Reservation",
")",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"Swap",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Swap",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Swap",
",",
"*",
"lm",
".",
"Reservation",
")",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"Kernel",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Kernel",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Kernel",
",",
"*",
"lm",
".",
"Kernel",
")",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"KernelTCP",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"KernelTCP",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"KernelTCP",
",",
"*",
"lm",
".",
"Kernel",
")",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"Swappiness",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Swappiness",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"Swappiness",
",",
"*",
"lm",
".",
"Swappiness",
")",
"\n\n",
"t",
".",
"Ok",
"(",
"*",
"lm",
".",
"DisableOOMKiller",
"==",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"DisableOOMKiller",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"*",
"config",
".",
"Linux",
".",
"Resources",
".",
"Memory",
".",
"DisableOOMKiller",
",",
"*",
"lm",
".",
"DisableOOMKiller",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ValidateLinuxResourcesMemory validates linux.resources.memory.
|
[
"ValidateLinuxResourcesMemory",
"validates",
"linux",
".",
"resources",
".",
"memory",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/linux_resources_memory.go#L10-L47
|
14,514 |
opencontainers/runtime-tools
|
error/error.go
|
ParseLevel
|
func ParseLevel(level string) (Level, error) {
switch strings.ToUpper(level) {
case "MAY":
fallthrough
case "OPTIONAL":
return May, nil
case "SHOULD":
fallthrough
case "SHOULDNOT":
fallthrough
case "RECOMMENDED":
fallthrough
case "NOTRECOMMENDED":
return Should, nil
case "MUST":
fallthrough
case "MUSTNOT":
fallthrough
case "SHALL":
fallthrough
case "SHALLNOT":
fallthrough
case "REQUIRED":
return Must, nil
}
var l Level
return l, fmt.Errorf("%q is not a valid compliance level", level)
}
|
go
|
func ParseLevel(level string) (Level, error) {
switch strings.ToUpper(level) {
case "MAY":
fallthrough
case "OPTIONAL":
return May, nil
case "SHOULD":
fallthrough
case "SHOULDNOT":
fallthrough
case "RECOMMENDED":
fallthrough
case "NOTRECOMMENDED":
return Should, nil
case "MUST":
fallthrough
case "MUSTNOT":
fallthrough
case "SHALL":
fallthrough
case "SHALLNOT":
fallthrough
case "REQUIRED":
return Must, nil
}
var l Level
return l, fmt.Errorf("%q is not a valid compliance level", level)
}
|
[
"func",
"ParseLevel",
"(",
"level",
"string",
")",
"(",
"Level",
",",
"error",
")",
"{",
"switch",
"strings",
".",
"ToUpper",
"(",
"level",
")",
"{",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"return",
"May",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"return",
"Should",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"return",
"Must",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"l",
"Level",
"\n",
"return",
"l",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"level",
")",
"\n",
"}"
] |
// ParseLevel takes a string level and returns the RFC 2119 compliance level constant.
|
[
"ParseLevel",
"takes",
"a",
"string",
"level",
"and",
"returns",
"the",
"RFC",
"2119",
"compliance",
"level",
"constant",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/error/error.go#L59-L87
|
14,515 |
opencontainers/runtime-tools
|
error/error.go
|
String
|
func (level Level) String() string {
switch level {
case May:
return "MAY"
case Optional:
return "OPTIONAL"
case Should:
return "SHOULD"
case ShouldNot:
return "SHOULD NOT"
case Recommended:
return "RECOMMENDED"
case NotRecommended:
return "NOT RECOMMENDED"
case Must:
return "MUST"
case MustNot:
return "MUST NOT"
case Shall:
return "SHALL"
case ShallNot:
return "SHALL NOT"
case Required:
return "REQUIRED"
}
panic(fmt.Sprintf("%d is not a valid compliance level", level))
}
|
go
|
func (level Level) String() string {
switch level {
case May:
return "MAY"
case Optional:
return "OPTIONAL"
case Should:
return "SHOULD"
case ShouldNot:
return "SHOULD NOT"
case Recommended:
return "RECOMMENDED"
case NotRecommended:
return "NOT RECOMMENDED"
case Must:
return "MUST"
case MustNot:
return "MUST NOT"
case Shall:
return "SHALL"
case ShallNot:
return "SHALL NOT"
case Required:
return "REQUIRED"
}
panic(fmt.Sprintf("%d is not a valid compliance level", level))
}
|
[
"func",
"(",
"level",
"Level",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"level",
"{",
"case",
"May",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Optional",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Should",
":",
"return",
"\"",
"\"",
"\n",
"case",
"ShouldNot",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Recommended",
":",
"return",
"\"",
"\"",
"\n",
"case",
"NotRecommended",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Must",
":",
"return",
"\"",
"\"",
"\n",
"case",
"MustNot",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Shall",
":",
"return",
"\"",
"\"",
"\n",
"case",
"ShallNot",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Required",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"level",
")",
")",
"\n",
"}"
] |
// String takes a RFC 2119 compliance level constant and returns a string representation.
|
[
"String",
"takes",
"a",
"RFC",
"2119",
"compliance",
"level",
"constant",
"and",
"returns",
"a",
"string",
"representation",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/error/error.go#L90-L117
|
14,516 |
opencontainers/runtime-tools
|
error/error.go
|
Error
|
func (err *Error) Error() string {
return fmt.Sprintf("%s\nRefer to: %s", err.Err.Error(), err.Reference)
}
|
go
|
func (err *Error) Error() string {
return fmt.Sprintf("%s\nRefer to: %s", err.Err.Error(), err.Reference)
}
|
[
"func",
"(",
"err",
"*",
"Error",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
".",
"Err",
".",
"Error",
"(",
")",
",",
"err",
".",
"Reference",
")",
"\n",
"}"
] |
// Error returns the error message with specification reference.
|
[
"Error",
"returns",
"the",
"error",
"message",
"with",
"specification",
"reference",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/error/error.go#L120-L122
|
14,517 |
opencontainers/runtime-tools
|
validation/util/container.go
|
NewRuntime
|
func NewRuntime(runtimeCommand string, bundleDir string) (Runtime, error) {
var r Runtime
var err error
r.RuntimeCommand, err = exec.LookPath(runtimeCommand)
if err != nil {
return Runtime{}, err
}
r.BundleDir = bundleDir
return r, err
}
|
go
|
func NewRuntime(runtimeCommand string, bundleDir string) (Runtime, error) {
var r Runtime
var err error
r.RuntimeCommand, err = exec.LookPath(runtimeCommand)
if err != nil {
return Runtime{}, err
}
r.BundleDir = bundleDir
return r, err
}
|
[
"func",
"NewRuntime",
"(",
"runtimeCommand",
"string",
",",
"bundleDir",
"string",
")",
"(",
"Runtime",
",",
"error",
")",
"{",
"var",
"r",
"Runtime",
"\n",
"var",
"err",
"error",
"\n",
"r",
".",
"RuntimeCommand",
",",
"err",
"=",
"exec",
".",
"LookPath",
"(",
"runtimeCommand",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Runtime",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"r",
".",
"BundleDir",
"=",
"bundleDir",
"\n",
"return",
"r",
",",
"err",
"\n",
"}"
] |
// NewRuntime create a runtime by command and the bundle directory
|
[
"NewRuntime",
"create",
"a",
"runtime",
"by",
"command",
"and",
"the",
"bundle",
"directory"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L34-L44
|
14,518 |
opencontainers/runtime-tools
|
validation/util/container.go
|
SetConfig
|
func (r *Runtime) SetConfig(g *generate.Generator) error {
if g == nil {
return errors.New("cannot set a nil config")
}
return g.SaveToFile(filepath.Join(r.bundleDir(), "config.json"), generate.ExportOptions{})
}
|
go
|
func (r *Runtime) SetConfig(g *generate.Generator) error {
if g == nil {
return errors.New("cannot set a nil config")
}
return g.SaveToFile(filepath.Join(r.bundleDir(), "config.json"), generate.ExportOptions{})
}
|
[
"func",
"(",
"r",
"*",
"Runtime",
")",
"SetConfig",
"(",
"g",
"*",
"generate",
".",
"Generator",
")",
"error",
"{",
"if",
"g",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"g",
".",
"SaveToFile",
"(",
"filepath",
".",
"Join",
"(",
"r",
".",
"bundleDir",
"(",
")",
",",
"\"",
"\"",
")",
",",
"generate",
".",
"ExportOptions",
"{",
"}",
")",
"\n",
"}"
] |
// SetConfig creates a 'config.json' by the generator
|
[
"SetConfig",
"creates",
"a",
"config",
".",
"json",
"by",
"the",
"generator"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L57-L62
|
14,519 |
opencontainers/runtime-tools
|
validation/util/container.go
|
ReadStandardStreams
|
func (r *Runtime) ReadStandardStreams() (stdout []byte, stderr []byte, err error) {
_, err = r.stdout.Seek(0, io.SeekStart)
stdout, err2 := ioutil.ReadAll(r.stdout)
if err == nil && err2 != nil {
err = err2
}
_, err = r.stderr.Seek(0, io.SeekStart)
stderr, err2 = ioutil.ReadAll(r.stderr)
if err == nil && err2 != nil {
err = err2
}
return stdout, stderr, err
}
|
go
|
func (r *Runtime) ReadStandardStreams() (stdout []byte, stderr []byte, err error) {
_, err = r.stdout.Seek(0, io.SeekStart)
stdout, err2 := ioutil.ReadAll(r.stdout)
if err == nil && err2 != nil {
err = err2
}
_, err = r.stderr.Seek(0, io.SeekStart)
stderr, err2 = ioutil.ReadAll(r.stderr)
if err == nil && err2 != nil {
err = err2
}
return stdout, stderr, err
}
|
[
"func",
"(",
"r",
"*",
"Runtime",
")",
"ReadStandardStreams",
"(",
")",
"(",
"stdout",
"[",
"]",
"byte",
",",
"stderr",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"_",
",",
"err",
"=",
"r",
".",
"stdout",
".",
"Seek",
"(",
"0",
",",
"io",
".",
"SeekStart",
")",
"\n",
"stdout",
",",
"err2",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"stdout",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"err2",
"!=",
"nil",
"{",
"err",
"=",
"err2",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"r",
".",
"stderr",
".",
"Seek",
"(",
"0",
",",
"io",
".",
"SeekStart",
")",
"\n",
"stderr",
",",
"err2",
"=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"stderr",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"err2",
"!=",
"nil",
"{",
"err",
"=",
"err2",
"\n",
"}",
"\n",
"return",
"stdout",
",",
"stderr",
",",
"err",
"\n",
"}"
] |
// ReadStandardStreams collects content from the stdout and stderr buffers.
|
[
"ReadStandardStreams",
"collects",
"content",
"from",
"the",
"stdout",
"and",
"stderr",
"buffers",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L112-L124
|
14,520 |
opencontainers/runtime-tools
|
validation/util/container.go
|
State
|
func (r *Runtime) State() (rspecs.State, error) {
var args []string
args = append(args, "state")
if r.ID != "" {
args = append(args, r.ID)
}
out, err := exec.Command(r.RuntimeCommand, args...).Output()
if err != nil {
if e, ok := err.(*exec.ExitError); ok {
if len(e.Stderr) == 0 {
e.Stderr = out
return rspecs.State{}, e
}
}
return rspecs.State{}, err
}
var state rspecs.State
err = json.Unmarshal(out, &state)
if err != nil {
return rspecs.State{}, specerror.NewError(specerror.DefaultStateJSONPattern, fmt.Errorf("when serialized in JSON, the format MUST adhere to the default pattern"), rspecs.Version)
}
return state, err
}
|
go
|
func (r *Runtime) State() (rspecs.State, error) {
var args []string
args = append(args, "state")
if r.ID != "" {
args = append(args, r.ID)
}
out, err := exec.Command(r.RuntimeCommand, args...).Output()
if err != nil {
if e, ok := err.(*exec.ExitError); ok {
if len(e.Stderr) == 0 {
e.Stderr = out
return rspecs.State{}, e
}
}
return rspecs.State{}, err
}
var state rspecs.State
err = json.Unmarshal(out, &state)
if err != nil {
return rspecs.State{}, specerror.NewError(specerror.DefaultStateJSONPattern, fmt.Errorf("when serialized in JSON, the format MUST adhere to the default pattern"), rspecs.Version)
}
return state, err
}
|
[
"func",
"(",
"r",
"*",
"Runtime",
")",
"State",
"(",
")",
"(",
"rspecs",
".",
"State",
",",
"error",
")",
"{",
"var",
"args",
"[",
"]",
"string",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"if",
"r",
".",
"ID",
"!=",
"\"",
"\"",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"r",
".",
"ID",
")",
"\n",
"}",
"\n\n",
"out",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"r",
".",
"RuntimeCommand",
",",
"args",
"...",
")",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"exec",
".",
"ExitError",
")",
";",
"ok",
"{",
"if",
"len",
"(",
"e",
".",
"Stderr",
")",
"==",
"0",
"{",
"e",
".",
"Stderr",
"=",
"out",
"\n",
"return",
"rspecs",
".",
"State",
"{",
"}",
",",
"e",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"rspecs",
".",
"State",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"state",
"rspecs",
".",
"State",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"out",
",",
"&",
"state",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"rspecs",
".",
"State",
"{",
"}",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"DefaultStateJSONPattern",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
",",
"rspecs",
".",
"Version",
")",
"\n",
"}",
"\n",
"return",
"state",
",",
"err",
"\n",
"}"
] |
// State a container information
|
[
"State",
"a",
"container",
"information"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L139-L163
|
14,521 |
opencontainers/runtime-tools
|
validation/util/container.go
|
Kill
|
func (r *Runtime) Kill(sig string) (err error) {
var args []string
args = append(args, "kill")
if r.ID != "" {
args = append(args, r.ID)
}
if sig != "" {
// TODO: runc does not support this
// args = append(args, "--signal", sig)
args = append(args, sig)
} else {
args = append(args, DefaultSignal)
}
cmd := exec.Command(r.RuntimeCommand, args...)
return execWithStderrFallbackToStdout(cmd)
}
|
go
|
func (r *Runtime) Kill(sig string) (err error) {
var args []string
args = append(args, "kill")
if r.ID != "" {
args = append(args, r.ID)
}
if sig != "" {
// TODO: runc does not support this
// args = append(args, "--signal", sig)
args = append(args, sig)
} else {
args = append(args, DefaultSignal)
}
cmd := exec.Command(r.RuntimeCommand, args...)
return execWithStderrFallbackToStdout(cmd)
}
|
[
"func",
"(",
"r",
"*",
"Runtime",
")",
"Kill",
"(",
"sig",
"string",
")",
"(",
"err",
"error",
")",
"{",
"var",
"args",
"[",
"]",
"string",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"if",
"r",
".",
"ID",
"!=",
"\"",
"\"",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"r",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"sig",
"!=",
"\"",
"\"",
"{",
"// TODO: runc does not support this",
"//\targs = append(args, \"--signal\", sig)",
"args",
"=",
"append",
"(",
"args",
",",
"sig",
")",
"\n",
"}",
"else",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"DefaultSignal",
")",
"\n",
"}",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"r",
".",
"RuntimeCommand",
",",
"args",
"...",
")",
"\n",
"return",
"execWithStderrFallbackToStdout",
"(",
"cmd",
")",
"\n",
"}"
] |
// Kill a container
|
[
"Kill",
"a",
"container"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L166-L182
|
14,522 |
opencontainers/runtime-tools
|
validation/util/container.go
|
Delete
|
func (r *Runtime) Delete() (err error) {
var args []string
args = append(args, "delete")
if r.ID != "" {
args = append(args, r.ID)
}
cmd := exec.Command(r.RuntimeCommand, args...)
return execWithStderrFallbackToStdout(cmd)
}
|
go
|
func (r *Runtime) Delete() (err error) {
var args []string
args = append(args, "delete")
if r.ID != "" {
args = append(args, r.ID)
}
cmd := exec.Command(r.RuntimeCommand, args...)
return execWithStderrFallbackToStdout(cmd)
}
|
[
"func",
"(",
"r",
"*",
"Runtime",
")",
"Delete",
"(",
")",
"(",
"err",
"error",
")",
"{",
"var",
"args",
"[",
"]",
"string",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"if",
"r",
".",
"ID",
"!=",
"\"",
"\"",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"r",
".",
"ID",
")",
"\n",
"}",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"r",
".",
"RuntimeCommand",
",",
"args",
"...",
")",
"\n",
"return",
"execWithStderrFallbackToStdout",
"(",
"cmd",
")",
"\n",
"}"
] |
// Delete a container
|
[
"Delete",
"a",
"container"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L185-L194
|
14,523 |
opencontainers/runtime-tools
|
validation/util/container.go
|
Clean
|
func (r *Runtime) Clean(removeBundle bool, forceRemoveBundle bool) error {
r.Kill("KILL")
WaitingForStatus(*r, LifecycleStatusStopped, time.Second*10, time.Second/10)
err := r.Delete()
if removeBundle && (err == nil || forceRemoveBundle) {
err2 := os.RemoveAll(r.bundleDir())
if err2 != nil && err == nil {
err = err2
}
}
return err
}
|
go
|
func (r *Runtime) Clean(removeBundle bool, forceRemoveBundle bool) error {
r.Kill("KILL")
WaitingForStatus(*r, LifecycleStatusStopped, time.Second*10, time.Second/10)
err := r.Delete()
if removeBundle && (err == nil || forceRemoveBundle) {
err2 := os.RemoveAll(r.bundleDir())
if err2 != nil && err == nil {
err = err2
}
}
return err
}
|
[
"func",
"(",
"r",
"*",
"Runtime",
")",
"Clean",
"(",
"removeBundle",
"bool",
",",
"forceRemoveBundle",
"bool",
")",
"error",
"{",
"r",
".",
"Kill",
"(",
"\"",
"\"",
")",
"\n",
"WaitingForStatus",
"(",
"*",
"r",
",",
"LifecycleStatusStopped",
",",
"time",
".",
"Second",
"*",
"10",
",",
"time",
".",
"Second",
"/",
"10",
")",
"\n\n",
"err",
":=",
"r",
".",
"Delete",
"(",
")",
"\n\n",
"if",
"removeBundle",
"&&",
"(",
"err",
"==",
"nil",
"||",
"forceRemoveBundle",
")",
"{",
"err2",
":=",
"os",
".",
"RemoveAll",
"(",
"r",
".",
"bundleDir",
"(",
")",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"err",
"=",
"err2",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}"
] |
// Clean deletes the container. If removeBundle is set, the bundle
// directory is removed after the container is deleted successfully or, if
// forceRemoveBundle is true, after the deletion attempt regardless of
// whether it was successful or not.
|
[
"Clean",
"deletes",
"the",
"container",
".",
"If",
"removeBundle",
"is",
"set",
"the",
"bundle",
"directory",
"is",
"removed",
"after",
"the",
"container",
"is",
"deleted",
"successfully",
"or",
"if",
"forceRemoveBundle",
"is",
"true",
"after",
"the",
"deletion",
"attempt",
"regardless",
"of",
"whether",
"it",
"was",
"successful",
"or",
"not",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/container.go#L200-L214
|
14,524 |
opencontainers/runtime-tools
|
specerror/error.go
|
NewRFCErrorOrPanic
|
func NewRFCErrorOrPanic(code Code, err error, version string) *rfc2119.Error {
rfcError, err2 := NewRFCError(code, err, version)
if err2 != nil {
panic(err2.Error())
}
return rfcError
}
|
go
|
func NewRFCErrorOrPanic(code Code, err error, version string) *rfc2119.Error {
rfcError, err2 := NewRFCError(code, err, version)
if err2 != nil {
panic(err2.Error())
}
return rfcError
}
|
[
"func",
"NewRFCErrorOrPanic",
"(",
"code",
"Code",
",",
"err",
"error",
",",
"version",
"string",
")",
"*",
"rfc2119",
".",
"Error",
"{",
"rfcError",
",",
"err2",
":=",
"NewRFCError",
"(",
"code",
",",
"err",
",",
"version",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"panic",
"(",
"err2",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"rfcError",
"\n",
"}"
] |
// NewRFCErrorOrPanic creates an rfc2119.Error referencing a spec
// violation and panics on failure. This is handy for situations
// where you can't be bothered to check NewRFCError for failure.
|
[
"NewRFCErrorOrPanic",
"creates",
"an",
"rfc2119",
".",
"Error",
"referencing",
"a",
"spec",
"violation",
"and",
"panics",
"on",
"failure",
".",
"This",
"is",
"handy",
"for",
"situations",
"where",
"you",
"can",
"t",
"be",
"bothered",
"to",
"check",
"NewRFCError",
"for",
"failure",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/specerror/error.go#L84-L90
|
14,525 |
opencontainers/runtime-tools
|
specerror/error.go
|
SplitLevel
|
func SplitLevel(errIn error, level rfc2119.Level) (levelErrors LevelErrors, errOut error) {
merr, ok := errIn.(*multierror.Error)
if !ok {
return levelErrors, errIn
}
for _, err := range merr.Errors {
e, ok := err.(*Error)
if ok && e.Err.Level < level {
fmt.Println(e)
levelErrors.Warnings = append(levelErrors.Warnings, e)
continue
}
levelErrors.Error = multierror.Append(levelErrors.Error, err)
}
return levelErrors, nil
}
|
go
|
func SplitLevel(errIn error, level rfc2119.Level) (levelErrors LevelErrors, errOut error) {
merr, ok := errIn.(*multierror.Error)
if !ok {
return levelErrors, errIn
}
for _, err := range merr.Errors {
e, ok := err.(*Error)
if ok && e.Err.Level < level {
fmt.Println(e)
levelErrors.Warnings = append(levelErrors.Warnings, e)
continue
}
levelErrors.Error = multierror.Append(levelErrors.Error, err)
}
return levelErrors, nil
}
|
[
"func",
"SplitLevel",
"(",
"errIn",
"error",
",",
"level",
"rfc2119",
".",
"Level",
")",
"(",
"levelErrors",
"LevelErrors",
",",
"errOut",
"error",
")",
"{",
"merr",
",",
"ok",
":=",
"errIn",
".",
"(",
"*",
"multierror",
".",
"Error",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"levelErrors",
",",
"errIn",
"\n",
"}",
"\n",
"for",
"_",
",",
"err",
":=",
"range",
"merr",
".",
"Errors",
"{",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"Error",
")",
"\n",
"if",
"ok",
"&&",
"e",
".",
"Err",
".",
"Level",
"<",
"level",
"{",
"fmt",
".",
"Println",
"(",
"e",
")",
"\n",
"levelErrors",
".",
"Warnings",
"=",
"append",
"(",
"levelErrors",
".",
"Warnings",
",",
"e",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"levelErrors",
".",
"Error",
"=",
"multierror",
".",
"Append",
"(",
"levelErrors",
".",
"Error",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"levelErrors",
",",
"nil",
"\n",
"}"
] |
// SplitLevel removes RFC 2119 errors with a level less than 'level'
// from the source error. If the source error is not a multierror, it
// is returned unchanged.
|
[
"SplitLevel",
"removes",
"RFC",
"2119",
"errors",
"with",
"a",
"level",
"less",
"than",
"level",
"from",
"the",
"source",
"error",
".",
"If",
"the",
"source",
"error",
"is",
"not",
"a",
"multierror",
"it",
"is",
"returned",
"unchanged",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/specerror/error.go#L137-L152
|
14,526 |
opencontainers/runtime-tools
|
generate/seccomp/parse_action.go
|
ParseSyscallFlag
|
func ParseSyscallFlag(args SyscallOpts, config *rspec.LinuxSeccomp) error {
var arguments []string
if args.Index != "" && args.Value != "" && args.ValueTwo != "" && args.Operator != "" {
arguments = []string{args.Action, args.Syscall, args.Index, args.Value,
args.ValueTwo, args.Operator}
} else {
arguments = []string{args.Action, args.Syscall}
}
action, _ := parseAction(arguments[0])
if action == config.DefaultAction && args.argsAreEmpty() {
// default already set, no need to make changes
return nil
}
var newSyscall rspec.LinuxSyscall
numOfArgs := len(arguments)
if numOfArgs == 6 || numOfArgs == 2 {
argStruct, err := parseArguments(arguments[1:])
if err != nil {
return err
}
newSyscall = newSyscallStruct(arguments[1], action, argStruct)
} else {
return fmt.Errorf("incorrect number of arguments to ParseSyscall: %d", numOfArgs)
}
descison, err := decideCourseOfAction(&newSyscall, config.Syscalls)
if err != nil {
return err
}
delimDescison := strings.Split(descison, ":")
if delimDescison[0] == seccompAppend {
config.Syscalls = append(config.Syscalls, newSyscall)
}
if delimDescison[0] == seccompOverwrite {
indexForOverwrite, err := strconv.ParseInt(delimDescison[1], 10, 32)
if err != nil {
return err
}
config.Syscalls[indexForOverwrite] = newSyscall
}
return nil
}
|
go
|
func ParseSyscallFlag(args SyscallOpts, config *rspec.LinuxSeccomp) error {
var arguments []string
if args.Index != "" && args.Value != "" && args.ValueTwo != "" && args.Operator != "" {
arguments = []string{args.Action, args.Syscall, args.Index, args.Value,
args.ValueTwo, args.Operator}
} else {
arguments = []string{args.Action, args.Syscall}
}
action, _ := parseAction(arguments[0])
if action == config.DefaultAction && args.argsAreEmpty() {
// default already set, no need to make changes
return nil
}
var newSyscall rspec.LinuxSyscall
numOfArgs := len(arguments)
if numOfArgs == 6 || numOfArgs == 2 {
argStruct, err := parseArguments(arguments[1:])
if err != nil {
return err
}
newSyscall = newSyscallStruct(arguments[1], action, argStruct)
} else {
return fmt.Errorf("incorrect number of arguments to ParseSyscall: %d", numOfArgs)
}
descison, err := decideCourseOfAction(&newSyscall, config.Syscalls)
if err != nil {
return err
}
delimDescison := strings.Split(descison, ":")
if delimDescison[0] == seccompAppend {
config.Syscalls = append(config.Syscalls, newSyscall)
}
if delimDescison[0] == seccompOverwrite {
indexForOverwrite, err := strconv.ParseInt(delimDescison[1], 10, 32)
if err != nil {
return err
}
config.Syscalls[indexForOverwrite] = newSyscall
}
return nil
}
|
[
"func",
"ParseSyscallFlag",
"(",
"args",
"SyscallOpts",
",",
"config",
"*",
"rspec",
".",
"LinuxSeccomp",
")",
"error",
"{",
"var",
"arguments",
"[",
"]",
"string",
"\n",
"if",
"args",
".",
"Index",
"!=",
"\"",
"\"",
"&&",
"args",
".",
"Value",
"!=",
"\"",
"\"",
"&&",
"args",
".",
"ValueTwo",
"!=",
"\"",
"\"",
"&&",
"args",
".",
"Operator",
"!=",
"\"",
"\"",
"{",
"arguments",
"=",
"[",
"]",
"string",
"{",
"args",
".",
"Action",
",",
"args",
".",
"Syscall",
",",
"args",
".",
"Index",
",",
"args",
".",
"Value",
",",
"args",
".",
"ValueTwo",
",",
"args",
".",
"Operator",
"}",
"\n",
"}",
"else",
"{",
"arguments",
"=",
"[",
"]",
"string",
"{",
"args",
".",
"Action",
",",
"args",
".",
"Syscall",
"}",
"\n",
"}",
"\n\n",
"action",
",",
"_",
":=",
"parseAction",
"(",
"arguments",
"[",
"0",
"]",
")",
"\n",
"if",
"action",
"==",
"config",
".",
"DefaultAction",
"&&",
"args",
".",
"argsAreEmpty",
"(",
")",
"{",
"// default already set, no need to make changes",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"newSyscall",
"rspec",
".",
"LinuxSyscall",
"\n",
"numOfArgs",
":=",
"len",
"(",
"arguments",
")",
"\n",
"if",
"numOfArgs",
"==",
"6",
"||",
"numOfArgs",
"==",
"2",
"{",
"argStruct",
",",
"err",
":=",
"parseArguments",
"(",
"arguments",
"[",
"1",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"newSyscall",
"=",
"newSyscallStruct",
"(",
"arguments",
"[",
"1",
"]",
",",
"action",
",",
"argStruct",
")",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"numOfArgs",
")",
"\n",
"}",
"\n\n",
"descison",
",",
"err",
":=",
"decideCourseOfAction",
"(",
"&",
"newSyscall",
",",
"config",
".",
"Syscalls",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"delimDescison",
":=",
"strings",
".",
"Split",
"(",
"descison",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"delimDescison",
"[",
"0",
"]",
"==",
"seccompAppend",
"{",
"config",
".",
"Syscalls",
"=",
"append",
"(",
"config",
".",
"Syscalls",
",",
"newSyscall",
")",
"\n",
"}",
"\n\n",
"if",
"delimDescison",
"[",
"0",
"]",
"==",
"seccompOverwrite",
"{",
"indexForOverwrite",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"delimDescison",
"[",
"1",
"]",
",",
"10",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"config",
".",
"Syscalls",
"[",
"indexForOverwrite",
"]",
"=",
"newSyscall",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ParseSyscallFlag takes a SyscallOpts struct and the seccomp configuration
// and sets the new syscall rule accordingly
|
[
"ParseSyscallFlag",
"takes",
"a",
"SyscallOpts",
"struct",
"and",
"the",
"seccomp",
"configuration",
"and",
"sets",
"the",
"new",
"syscall",
"rule",
"accordingly"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/seccomp/parse_action.go#L23-L69
|
14,527 |
opencontainers/runtime-tools
|
generate/seccomp/parse_action.go
|
ParseDefaultAction
|
func ParseDefaultAction(action string, config *rspec.LinuxSeccomp) error {
if action == "" {
return nil
}
defaultAction, err := parseAction(action)
if err != nil {
return err
}
config.DefaultAction = defaultAction
err = RemoveAllMatchingRules(config, defaultAction)
if err != nil {
return err
}
return nil
}
|
go
|
func ParseDefaultAction(action string, config *rspec.LinuxSeccomp) error {
if action == "" {
return nil
}
defaultAction, err := parseAction(action)
if err != nil {
return err
}
config.DefaultAction = defaultAction
err = RemoveAllMatchingRules(config, defaultAction)
if err != nil {
return err
}
return nil
}
|
[
"func",
"ParseDefaultAction",
"(",
"action",
"string",
",",
"config",
"*",
"rspec",
".",
"LinuxSeccomp",
")",
"error",
"{",
"if",
"action",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"defaultAction",
",",
"err",
":=",
"parseAction",
"(",
"action",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"config",
".",
"DefaultAction",
"=",
"defaultAction",
"\n",
"err",
"=",
"RemoveAllMatchingRules",
"(",
"config",
",",
"defaultAction",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ParseDefaultAction sets the default action of the seccomp configuration
// and then removes any rules that were already specified with this action
|
[
"ParseDefaultAction",
"sets",
"the",
"default",
"action",
"of",
"the",
"seccomp",
"configuration",
"and",
"then",
"removes",
"any",
"rules",
"that",
"were",
"already",
"specified",
"with",
"this",
"action"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/seccomp/parse_action.go#L90-L105
|
14,528 |
opencontainers/runtime-tools
|
generate/seccomp/parse_action.go
|
ParseDefaultActionForce
|
func ParseDefaultActionForce(action string, config *rspec.LinuxSeccomp) error {
if action == "" {
return nil
}
defaultAction, err := parseAction(action)
if err != nil {
return err
}
config.DefaultAction = defaultAction
return nil
}
|
go
|
func ParseDefaultActionForce(action string, config *rspec.LinuxSeccomp) error {
if action == "" {
return nil
}
defaultAction, err := parseAction(action)
if err != nil {
return err
}
config.DefaultAction = defaultAction
return nil
}
|
[
"func",
"ParseDefaultActionForce",
"(",
"action",
"string",
",",
"config",
"*",
"rspec",
".",
"LinuxSeccomp",
")",
"error",
"{",
"if",
"action",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"defaultAction",
",",
"err",
":=",
"parseAction",
"(",
"action",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"config",
".",
"DefaultAction",
"=",
"defaultAction",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ParseDefaultActionForce simply sets the default action of the seccomp configuration
|
[
"ParseDefaultActionForce",
"simply",
"sets",
"the",
"default",
"action",
"of",
"the",
"seccomp",
"configuration"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/seccomp/parse_action.go#L108-L119
|
14,529 |
opencontainers/runtime-tools
|
validate/validate.go
|
NewValidator
|
func NewValidator(spec *rspec.Spec, bundlePath string, hostSpecific bool, platform string) (Validator, error) {
if hostSpecific && platform != runtime.GOOS {
return Validator{}, fmt.Errorf("When hostSpecific is set, platform must be same as the host platform")
}
return Validator{
spec: spec,
bundlePath: bundlePath,
HostSpecific: hostSpecific,
platform: platform,
}, nil
}
|
go
|
func NewValidator(spec *rspec.Spec, bundlePath string, hostSpecific bool, platform string) (Validator, error) {
if hostSpecific && platform != runtime.GOOS {
return Validator{}, fmt.Errorf("When hostSpecific is set, platform must be same as the host platform")
}
return Validator{
spec: spec,
bundlePath: bundlePath,
HostSpecific: hostSpecific,
platform: platform,
}, nil
}
|
[
"func",
"NewValidator",
"(",
"spec",
"*",
"rspec",
".",
"Spec",
",",
"bundlePath",
"string",
",",
"hostSpecific",
"bool",
",",
"platform",
"string",
")",
"(",
"Validator",
",",
"error",
")",
"{",
"if",
"hostSpecific",
"&&",
"platform",
"!=",
"runtime",
".",
"GOOS",
"{",
"return",
"Validator",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"Validator",
"{",
"spec",
":",
"spec",
",",
"bundlePath",
":",
"bundlePath",
",",
"HostSpecific",
":",
"hostSpecific",
",",
"platform",
":",
"platform",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewValidator creates a Validator
|
[
"NewValidator",
"creates",
"a",
"Validator"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L68-L78
|
14,530 |
opencontainers/runtime-tools
|
validate/validate.go
|
NewValidatorFromPath
|
func NewValidatorFromPath(bundlePath string, hostSpecific bool, platform string) (Validator, error) {
if bundlePath == "" {
return Validator{}, fmt.Errorf("bundle path shouldn't be empty")
}
if _, err := os.Stat(bundlePath); err != nil {
return Validator{}, err
}
configPath := filepath.Join(bundlePath, specConfig)
content, err := ioutil.ReadFile(configPath)
if err != nil {
return Validator{}, specerror.NewError(specerror.ConfigInRootBundleDir, err, rspec.Version)
}
if !utf8.Valid(content) {
return Validator{}, fmt.Errorf("%q is not encoded in UTF-8", configPath)
}
var spec rspec.Spec
if err = json.Unmarshal(content, &spec); err != nil {
return Validator{}, err
}
return NewValidator(&spec, bundlePath, hostSpecific, platform)
}
|
go
|
func NewValidatorFromPath(bundlePath string, hostSpecific bool, platform string) (Validator, error) {
if bundlePath == "" {
return Validator{}, fmt.Errorf("bundle path shouldn't be empty")
}
if _, err := os.Stat(bundlePath); err != nil {
return Validator{}, err
}
configPath := filepath.Join(bundlePath, specConfig)
content, err := ioutil.ReadFile(configPath)
if err != nil {
return Validator{}, specerror.NewError(specerror.ConfigInRootBundleDir, err, rspec.Version)
}
if !utf8.Valid(content) {
return Validator{}, fmt.Errorf("%q is not encoded in UTF-8", configPath)
}
var spec rspec.Spec
if err = json.Unmarshal(content, &spec); err != nil {
return Validator{}, err
}
return NewValidator(&spec, bundlePath, hostSpecific, platform)
}
|
[
"func",
"NewValidatorFromPath",
"(",
"bundlePath",
"string",
",",
"hostSpecific",
"bool",
",",
"platform",
"string",
")",
"(",
"Validator",
",",
"error",
")",
"{",
"if",
"bundlePath",
"==",
"\"",
"\"",
"{",
"return",
"Validator",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"bundlePath",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Validator",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"configPath",
":=",
"filepath",
".",
"Join",
"(",
"bundlePath",
",",
"specConfig",
")",
"\n",
"content",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"configPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Validator",
"{",
"}",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"ConfigInRootBundleDir",
",",
"err",
",",
"rspec",
".",
"Version",
")",
"\n",
"}",
"\n",
"if",
"!",
"utf8",
".",
"Valid",
"(",
"content",
")",
"{",
"return",
"Validator",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"configPath",
")",
"\n",
"}",
"\n",
"var",
"spec",
"rspec",
".",
"Spec",
"\n",
"if",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"content",
",",
"&",
"spec",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Validator",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewValidator",
"(",
"&",
"spec",
",",
"bundlePath",
",",
"hostSpecific",
",",
"platform",
")",
"\n",
"}"
] |
// NewValidatorFromPath creates a Validator with specified bundle path
|
[
"NewValidatorFromPath",
"creates",
"a",
"Validator",
"with",
"specified",
"bundle",
"path"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L81-L104
|
14,531 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckAll
|
func (v *Validator) CheckAll() error {
var errs *multierror.Error
errs = multierror.Append(errs, v.CheckJSONSchema())
errs = multierror.Append(errs, v.CheckPlatform())
errs = multierror.Append(errs, v.CheckRoot())
errs = multierror.Append(errs, v.CheckMandatoryFields())
errs = multierror.Append(errs, v.CheckSemVer())
errs = multierror.Append(errs, v.CheckMounts())
errs = multierror.Append(errs, v.CheckProcess())
errs = multierror.Append(errs, v.CheckLinux())
errs = multierror.Append(errs, v.CheckAnnotations())
if v.platform == "linux" || v.platform == "solaris" {
errs = multierror.Append(errs, v.CheckHooks())
}
return errs.ErrorOrNil()
}
|
go
|
func (v *Validator) CheckAll() error {
var errs *multierror.Error
errs = multierror.Append(errs, v.CheckJSONSchema())
errs = multierror.Append(errs, v.CheckPlatform())
errs = multierror.Append(errs, v.CheckRoot())
errs = multierror.Append(errs, v.CheckMandatoryFields())
errs = multierror.Append(errs, v.CheckSemVer())
errs = multierror.Append(errs, v.CheckMounts())
errs = multierror.Append(errs, v.CheckProcess())
errs = multierror.Append(errs, v.CheckLinux())
errs = multierror.Append(errs, v.CheckAnnotations())
if v.platform == "linux" || v.platform == "solaris" {
errs = multierror.Append(errs, v.CheckHooks())
}
return errs.ErrorOrNil()
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckAll",
"(",
")",
"error",
"{",
"var",
"errs",
"*",
"multierror",
".",
"Error",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckJSONSchema",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckPlatform",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckRoot",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckMandatoryFields",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckSemVer",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckMounts",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckProcess",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckLinux",
"(",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckAnnotations",
"(",
")",
")",
"\n",
"if",
"v",
".",
"platform",
"==",
"\"",
"\"",
"||",
"v",
".",
"platform",
"==",
"\"",
"\"",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckHooks",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"errs",
".",
"ErrorOrNil",
"(",
")",
"\n",
"}"
] |
// CheckAll checks all parts of runtime bundle
|
[
"CheckAll",
"checks",
"all",
"parts",
"of",
"runtime",
"bundle"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L107-L123
|
14,532 |
opencontainers/runtime-tools
|
validate/validate.go
|
JSONSchemaURL
|
func JSONSchemaURL(version string) (url string, err error) {
ver, err := semver.Parse(version)
if err != nil {
return "", specerror.NewError(specerror.SpecVersionInSemVer, err, rspec.Version)
}
configRenamedToConfigSchemaVersion, err := semver.Parse("1.0.0-rc2") // config.json became config-schema.json in 1.0.0-rc2
if ver.Compare(configRenamedToConfigSchemaVersion) == -1 {
return "", fmt.Errorf("unsupported configuration version (older than %s)", configRenamedToConfigSchemaVersion)
}
return fmt.Sprintf(configSchemaTemplate, version), nil
}
|
go
|
func JSONSchemaURL(version string) (url string, err error) {
ver, err := semver.Parse(version)
if err != nil {
return "", specerror.NewError(specerror.SpecVersionInSemVer, err, rspec.Version)
}
configRenamedToConfigSchemaVersion, err := semver.Parse("1.0.0-rc2") // config.json became config-schema.json in 1.0.0-rc2
if ver.Compare(configRenamedToConfigSchemaVersion) == -1 {
return "", fmt.Errorf("unsupported configuration version (older than %s)", configRenamedToConfigSchemaVersion)
}
return fmt.Sprintf(configSchemaTemplate, version), nil
}
|
[
"func",
"JSONSchemaURL",
"(",
"version",
"string",
")",
"(",
"url",
"string",
",",
"err",
"error",
")",
"{",
"ver",
",",
"err",
":=",
"semver",
".",
"Parse",
"(",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"SpecVersionInSemVer",
",",
"err",
",",
"rspec",
".",
"Version",
")",
"\n",
"}",
"\n",
"configRenamedToConfigSchemaVersion",
",",
"err",
":=",
"semver",
".",
"Parse",
"(",
"\"",
"\"",
")",
"// config.json became config-schema.json in 1.0.0-rc2",
"\n",
"if",
"ver",
".",
"Compare",
"(",
"configRenamedToConfigSchemaVersion",
")",
"==",
"-",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"configRenamedToConfigSchemaVersion",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"configSchemaTemplate",
",",
"version",
")",
",",
"nil",
"\n",
"}"
] |
// JSONSchemaURL returns the URL for the JSON Schema specifying the
// configuration format. It consumes configSchemaTemplate, but we
// provide it as a function to isolate consumers from inconsistent
// naming as runtime-spec evolves.
|
[
"JSONSchemaURL",
"returns",
"the",
"URL",
"for",
"the",
"JSON",
"Schema",
"specifying",
"the",
"configuration",
"format",
".",
"It",
"consumes",
"configSchemaTemplate",
"but",
"we",
"provide",
"it",
"as",
"a",
"function",
"to",
"isolate",
"consumers",
"from",
"inconsistent",
"naming",
"as",
"runtime",
"-",
"spec",
"evolves",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L129-L139
|
14,533 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckJSONSchema
|
func (v *Validator) CheckJSONSchema() (errs error) {
logrus.Debugf("check JSON schema")
url, err := JSONSchemaURL(v.spec.Version)
if err != nil {
errs = multierror.Append(errs, err)
return errs
}
schemaLoader := gojsonschema.NewReferenceLoader(url)
documentLoader := gojsonschema.NewGoLoader(v.spec)
result, err := gojsonschema.Validate(schemaLoader, documentLoader)
if err != nil {
errs = multierror.Append(errs, err)
return errs
}
if !result.Valid() {
for _, resultError := range result.Errors() {
errs = multierror.Append(errs, errors.New(resultError.String()))
}
}
return errs
}
|
go
|
func (v *Validator) CheckJSONSchema() (errs error) {
logrus.Debugf("check JSON schema")
url, err := JSONSchemaURL(v.spec.Version)
if err != nil {
errs = multierror.Append(errs, err)
return errs
}
schemaLoader := gojsonschema.NewReferenceLoader(url)
documentLoader := gojsonschema.NewGoLoader(v.spec)
result, err := gojsonschema.Validate(schemaLoader, documentLoader)
if err != nil {
errs = multierror.Append(errs, err)
return errs
}
if !result.Valid() {
for _, resultError := range result.Errors() {
errs = multierror.Append(errs, errors.New(resultError.String()))
}
}
return errs
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckJSONSchema",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"url",
",",
"err",
":=",
"JSONSchemaURL",
"(",
"v",
".",
"spec",
".",
"Version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"return",
"errs",
"\n",
"}",
"\n\n",
"schemaLoader",
":=",
"gojsonschema",
".",
"NewReferenceLoader",
"(",
"url",
")",
"\n",
"documentLoader",
":=",
"gojsonschema",
".",
"NewGoLoader",
"(",
"v",
".",
"spec",
")",
"\n",
"result",
",",
"err",
":=",
"gojsonschema",
".",
"Validate",
"(",
"schemaLoader",
",",
"documentLoader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"return",
"errs",
"\n",
"}",
"\n\n",
"if",
"!",
"result",
".",
"Valid",
"(",
")",
"{",
"for",
"_",
",",
"resultError",
":=",
"range",
"result",
".",
"Errors",
"(",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"errors",
".",
"New",
"(",
"resultError",
".",
"String",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"errs",
"\n",
"}"
] |
// CheckJSONSchema validates the configuration against the
// runtime-spec JSON Schema, using the version of the schema that
// matches the configuration's declared version.
|
[
"CheckJSONSchema",
"validates",
"the",
"configuration",
"against",
"the",
"runtime",
"-",
"spec",
"JSON",
"Schema",
"using",
"the",
"version",
"of",
"the",
"schema",
"that",
"matches",
"the",
"configuration",
"s",
"declared",
"version",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L144-L168
|
14,534 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckSemVer
|
func (v *Validator) CheckSemVer() (errs error) {
logrus.Debugf("check semver")
version := v.spec.Version
_, err := semver.Parse(version)
if err != nil {
errs = multierror.Append(errs,
specerror.NewError(specerror.SpecVersionInSemVer, fmt.Errorf("%q is not valid SemVer: %s", version, err.Error()), rspec.Version))
}
if version != rspec.Version {
errs = multierror.Append(errs, fmt.Errorf("validate currently only handles version %s, but the supplied configuration targets %s", rspec.Version, version))
}
return
}
|
go
|
func (v *Validator) CheckSemVer() (errs error) {
logrus.Debugf("check semver")
version := v.spec.Version
_, err := semver.Parse(version)
if err != nil {
errs = multierror.Append(errs,
specerror.NewError(specerror.SpecVersionInSemVer, fmt.Errorf("%q is not valid SemVer: %s", version, err.Error()), rspec.Version))
}
if version != rspec.Version {
errs = multierror.Append(errs, fmt.Errorf("validate currently only handles version %s, but the supplied configuration targets %s", rspec.Version, version))
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckSemVer",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"version",
":=",
"v",
".",
"spec",
".",
"Version",
"\n",
"_",
",",
"err",
":=",
"semver",
".",
"Parse",
"(",
"version",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"SpecVersionInSemVer",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"version",
",",
"err",
".",
"Error",
"(",
")",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"if",
"version",
"!=",
"rspec",
".",
"Version",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rspec",
".",
"Version",
",",
"version",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckSemVer checks v.spec.Version
|
[
"CheckSemVer",
"checks",
"v",
".",
"spec",
".",
"Version"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L253-L267
|
14,535 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckHooks
|
func (v *Validator) CheckHooks() (errs error) {
logrus.Debugf("check hooks")
if v.platform != "linux" && v.platform != "solaris" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support hooks", v.platform))
return
}
if v.spec.Hooks != nil {
errs = multierror.Append(errs, v.checkEventHooks("prestart", v.spec.Hooks.Prestart, v.HostSpecific))
errs = multierror.Append(errs, v.checkEventHooks("poststart", v.spec.Hooks.Poststart, v.HostSpecific))
errs = multierror.Append(errs, v.checkEventHooks("poststop", v.spec.Hooks.Poststop, v.HostSpecific))
}
return
}
|
go
|
func (v *Validator) CheckHooks() (errs error) {
logrus.Debugf("check hooks")
if v.platform != "linux" && v.platform != "solaris" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support hooks", v.platform))
return
}
if v.spec.Hooks != nil {
errs = multierror.Append(errs, v.checkEventHooks("prestart", v.spec.Hooks.Prestart, v.HostSpecific))
errs = multierror.Append(errs, v.checkEventHooks("poststart", v.spec.Hooks.Poststart, v.HostSpecific))
errs = multierror.Append(errs, v.checkEventHooks("poststop", v.spec.Hooks.Poststop, v.HostSpecific))
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckHooks",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"&&",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
".",
"platform",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"v",
".",
"spec",
".",
"Hooks",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"checkEventHooks",
"(",
"\"",
"\"",
",",
"v",
".",
"spec",
".",
"Hooks",
".",
"Prestart",
",",
"v",
".",
"HostSpecific",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"checkEventHooks",
"(",
"\"",
"\"",
",",
"v",
".",
"spec",
".",
"Hooks",
".",
"Poststart",
",",
"v",
".",
"HostSpecific",
")",
")",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"checkEventHooks",
"(",
"\"",
"\"",
",",
"v",
".",
"spec",
".",
"Hooks",
".",
"Poststop",
",",
"v",
".",
"HostSpecific",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckHooks check v.spec.Hooks
|
[
"CheckHooks",
"check",
"v",
".",
"spec",
".",
"Hooks"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L270-L285
|
14,536 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckProcess
|
func (v *Validator) CheckProcess() (errs error) {
logrus.Debugf("check process")
if v.spec.Process == nil {
return
}
process := v.spec.Process
if !osFilepath.IsAbs(v.platform, process.Cwd) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.ProcCwdAbs,
fmt.Errorf("cwd %q is not an absolute path", process.Cwd),
rspec.Version))
}
for _, env := range process.Env {
if !envValid(env) {
errs = multierror.Append(errs, fmt.Errorf("env %q should be in the form of 'key=value'. The left hand side must consist solely of letters, digits, and underscores '_'", env))
}
}
if len(process.Args) == 0 {
errs = multierror.Append(errs,
specerror.NewError(
specerror.ProcArgsOneEntryRequired,
fmt.Errorf("args must not be empty"),
rspec.Version))
} else {
if filepath.IsAbs(process.Args[0]) && v.spec.Root != nil {
var rootfsPath string
if filepath.IsAbs(v.spec.Root.Path) {
rootfsPath = v.spec.Root.Path
} else {
rootfsPath = filepath.Join(v.bundlePath, v.spec.Root.Path)
}
absPath := filepath.Join(rootfsPath, process.Args[0])
fileinfo, err := os.Stat(absPath)
if os.IsNotExist(err) {
logrus.Warnf("executable %q is not available in rootfs currently", process.Args[0])
} else if err != nil {
errs = multierror.Append(errs, err)
} else {
m := fileinfo.Mode()
if m.IsDir() || m&0111 == 0 {
errs = multierror.Append(errs, fmt.Errorf("arg %q is not executable", process.Args[0]))
}
}
}
}
if v.platform == "linux" || v.platform == "solaris" {
errs = multierror.Append(errs, v.CheckRlimits())
}
if v.platform == "linux" {
if v.spec.Process.Capabilities != nil {
errs = multierror.Append(errs, v.CheckCapabilities())
}
if len(process.ApparmorProfile) > 0 {
profilePath := filepath.Join(v.bundlePath, v.spec.Root.Path, "/etc/apparmor.d", process.ApparmorProfile)
_, err := os.Stat(profilePath)
if err != nil {
errs = multierror.Append(errs, err)
}
}
}
return
}
|
go
|
func (v *Validator) CheckProcess() (errs error) {
logrus.Debugf("check process")
if v.spec.Process == nil {
return
}
process := v.spec.Process
if !osFilepath.IsAbs(v.platform, process.Cwd) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.ProcCwdAbs,
fmt.Errorf("cwd %q is not an absolute path", process.Cwd),
rspec.Version))
}
for _, env := range process.Env {
if !envValid(env) {
errs = multierror.Append(errs, fmt.Errorf("env %q should be in the form of 'key=value'. The left hand side must consist solely of letters, digits, and underscores '_'", env))
}
}
if len(process.Args) == 0 {
errs = multierror.Append(errs,
specerror.NewError(
specerror.ProcArgsOneEntryRequired,
fmt.Errorf("args must not be empty"),
rspec.Version))
} else {
if filepath.IsAbs(process.Args[0]) && v.spec.Root != nil {
var rootfsPath string
if filepath.IsAbs(v.spec.Root.Path) {
rootfsPath = v.spec.Root.Path
} else {
rootfsPath = filepath.Join(v.bundlePath, v.spec.Root.Path)
}
absPath := filepath.Join(rootfsPath, process.Args[0])
fileinfo, err := os.Stat(absPath)
if os.IsNotExist(err) {
logrus.Warnf("executable %q is not available in rootfs currently", process.Args[0])
} else if err != nil {
errs = multierror.Append(errs, err)
} else {
m := fileinfo.Mode()
if m.IsDir() || m&0111 == 0 {
errs = multierror.Append(errs, fmt.Errorf("arg %q is not executable", process.Args[0]))
}
}
}
}
if v.platform == "linux" || v.platform == "solaris" {
errs = multierror.Append(errs, v.CheckRlimits())
}
if v.platform == "linux" {
if v.spec.Process.Capabilities != nil {
errs = multierror.Append(errs, v.CheckCapabilities())
}
if len(process.ApparmorProfile) > 0 {
profilePath := filepath.Join(v.bundlePath, v.spec.Root.Path, "/etc/apparmor.d", process.ApparmorProfile)
_, err := os.Stat(profilePath)
if err != nil {
errs = multierror.Append(errs, err)
}
}
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckProcess",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"v",
".",
"spec",
".",
"Process",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"process",
":=",
"v",
".",
"spec",
".",
"Process",
"\n",
"if",
"!",
"osFilepath",
".",
"IsAbs",
"(",
"v",
".",
"platform",
",",
"process",
".",
"Cwd",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"ProcCwdAbs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"process",
".",
"Cwd",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"env",
":=",
"range",
"process",
".",
"Env",
"{",
"if",
"!",
"envValid",
"(",
"env",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"env",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"process",
".",
"Args",
")",
"==",
"0",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"ProcArgsOneEntryRequired",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"else",
"{",
"if",
"filepath",
".",
"IsAbs",
"(",
"process",
".",
"Args",
"[",
"0",
"]",
")",
"&&",
"v",
".",
"spec",
".",
"Root",
"!=",
"nil",
"{",
"var",
"rootfsPath",
"string",
"\n",
"if",
"filepath",
".",
"IsAbs",
"(",
"v",
".",
"spec",
".",
"Root",
".",
"Path",
")",
"{",
"rootfsPath",
"=",
"v",
".",
"spec",
".",
"Root",
".",
"Path",
"\n",
"}",
"else",
"{",
"rootfsPath",
"=",
"filepath",
".",
"Join",
"(",
"v",
".",
"bundlePath",
",",
"v",
".",
"spec",
".",
"Root",
".",
"Path",
")",
"\n",
"}",
"\n",
"absPath",
":=",
"filepath",
".",
"Join",
"(",
"rootfsPath",
",",
"process",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"fileinfo",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"absPath",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"process",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"m",
":=",
"fileinfo",
".",
"Mode",
"(",
")",
"\n",
"if",
"m",
".",
"IsDir",
"(",
")",
"||",
"m",
"&",
"0111",
"==",
"0",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"process",
".",
"Args",
"[",
"0",
"]",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"v",
".",
"platform",
"==",
"\"",
"\"",
"||",
"v",
".",
"platform",
"==",
"\"",
"\"",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckRlimits",
"(",
")",
")",
"\n",
"}",
"\n\n",
"if",
"v",
".",
"platform",
"==",
"\"",
"\"",
"{",
"if",
"v",
".",
"spec",
".",
"Process",
".",
"Capabilities",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"CheckCapabilities",
"(",
")",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"process",
".",
"ApparmorProfile",
")",
">",
"0",
"{",
"profilePath",
":=",
"filepath",
".",
"Join",
"(",
"v",
".",
"bundlePath",
",",
"v",
".",
"spec",
".",
"Root",
".",
"Path",
",",
"\"",
"\"",
",",
"process",
".",
"ApparmorProfile",
")",
"\n",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"profilePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckProcess checks v.spec.Process
|
[
"CheckProcess",
"checks",
"v",
".",
"spec",
".",
"Process"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L319-L389
|
14,537 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckCapabilities
|
func (v *Validator) CheckCapabilities() (errs error) {
if v.platform != "linux" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support process.capabilities", v.platform))
return
}
process := v.spec.Process
var effective, permitted, inheritable, ambient bool
caps := make(map[string][]string)
for _, cap := range process.Capabilities.Bounding {
caps[cap] = append(caps[cap], "bounding")
}
for _, cap := range process.Capabilities.Effective {
caps[cap] = append(caps[cap], "effective")
}
for _, cap := range process.Capabilities.Inheritable {
caps[cap] = append(caps[cap], "inheritable")
}
for _, cap := range process.Capabilities.Permitted {
caps[cap] = append(caps[cap], "permitted")
}
for _, cap := range process.Capabilities.Ambient {
caps[cap] = append(caps[cap], "ambient")
}
for capability, owns := range caps {
if err := CapValid(capability, v.HostSpecific); err != nil {
errs = multierror.Append(errs, fmt.Errorf("capability %q is not valid, man capabilities(7)", capability))
}
effective, permitted, ambient, inheritable = false, false, false, false
for _, set := range owns {
if set == "effective" {
effective = true
continue
}
if set == "inheritable" {
inheritable = true
continue
}
if set == "permitted" {
permitted = true
continue
}
if set == "ambient" {
ambient = true
continue
}
}
if effective && !permitted {
errs = multierror.Append(errs, fmt.Errorf("effective capability %q is not allowed, as it's not permitted", capability))
}
if ambient && !(permitted && inheritable) {
errs = multierror.Append(errs, fmt.Errorf("ambient capability %q is not allowed, as it's not permitted and inheribate", capability))
}
}
return
}
|
go
|
func (v *Validator) CheckCapabilities() (errs error) {
if v.platform != "linux" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support process.capabilities", v.platform))
return
}
process := v.spec.Process
var effective, permitted, inheritable, ambient bool
caps := make(map[string][]string)
for _, cap := range process.Capabilities.Bounding {
caps[cap] = append(caps[cap], "bounding")
}
for _, cap := range process.Capabilities.Effective {
caps[cap] = append(caps[cap], "effective")
}
for _, cap := range process.Capabilities.Inheritable {
caps[cap] = append(caps[cap], "inheritable")
}
for _, cap := range process.Capabilities.Permitted {
caps[cap] = append(caps[cap], "permitted")
}
for _, cap := range process.Capabilities.Ambient {
caps[cap] = append(caps[cap], "ambient")
}
for capability, owns := range caps {
if err := CapValid(capability, v.HostSpecific); err != nil {
errs = multierror.Append(errs, fmt.Errorf("capability %q is not valid, man capabilities(7)", capability))
}
effective, permitted, ambient, inheritable = false, false, false, false
for _, set := range owns {
if set == "effective" {
effective = true
continue
}
if set == "inheritable" {
inheritable = true
continue
}
if set == "permitted" {
permitted = true
continue
}
if set == "ambient" {
ambient = true
continue
}
}
if effective && !permitted {
errs = multierror.Append(errs, fmt.Errorf("effective capability %q is not allowed, as it's not permitted", capability))
}
if ambient && !(permitted && inheritable) {
errs = multierror.Append(errs, fmt.Errorf("ambient capability %q is not allowed, as it's not permitted and inheribate", capability))
}
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckCapabilities",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"if",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
".",
"platform",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"process",
":=",
"v",
".",
"spec",
".",
"Process",
"\n",
"var",
"effective",
",",
"permitted",
",",
"inheritable",
",",
"ambient",
"bool",
"\n",
"caps",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n\n",
"for",
"_",
",",
"cap",
":=",
"range",
"process",
".",
"Capabilities",
".",
"Bounding",
"{",
"caps",
"[",
"cap",
"]",
"=",
"append",
"(",
"caps",
"[",
"cap",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"cap",
":=",
"range",
"process",
".",
"Capabilities",
".",
"Effective",
"{",
"caps",
"[",
"cap",
"]",
"=",
"append",
"(",
"caps",
"[",
"cap",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"cap",
":=",
"range",
"process",
".",
"Capabilities",
".",
"Inheritable",
"{",
"caps",
"[",
"cap",
"]",
"=",
"append",
"(",
"caps",
"[",
"cap",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"cap",
":=",
"range",
"process",
".",
"Capabilities",
".",
"Permitted",
"{",
"caps",
"[",
"cap",
"]",
"=",
"append",
"(",
"caps",
"[",
"cap",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"cap",
":=",
"range",
"process",
".",
"Capabilities",
".",
"Ambient",
"{",
"caps",
"[",
"cap",
"]",
"=",
"append",
"(",
"caps",
"[",
"cap",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"capability",
",",
"owns",
":=",
"range",
"caps",
"{",
"if",
"err",
":=",
"CapValid",
"(",
"capability",
",",
"v",
".",
"HostSpecific",
")",
";",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"capability",
")",
")",
"\n",
"}",
"\n\n",
"effective",
",",
"permitted",
",",
"ambient",
",",
"inheritable",
"=",
"false",
",",
"false",
",",
"false",
",",
"false",
"\n",
"for",
"_",
",",
"set",
":=",
"range",
"owns",
"{",
"if",
"set",
"==",
"\"",
"\"",
"{",
"effective",
"=",
"true",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"set",
"==",
"\"",
"\"",
"{",
"inheritable",
"=",
"true",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"set",
"==",
"\"",
"\"",
"{",
"permitted",
"=",
"true",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"set",
"==",
"\"",
"\"",
"{",
"ambient",
"=",
"true",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"effective",
"&&",
"!",
"permitted",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"capability",
")",
")",
"\n",
"}",
"\n",
"if",
"ambient",
"&&",
"!",
"(",
"permitted",
"&&",
"inheritable",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"capability",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckCapabilities checks v.spec.Process.Capabilities
|
[
"CheckCapabilities",
"checks",
"v",
".",
"spec",
".",
"Process",
".",
"Capabilities"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L392-L451
|
14,538 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckRlimits
|
func (v *Validator) CheckRlimits() (errs error) {
if v.platform != "linux" && v.platform != "solaris" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support process.rlimits", v.platform))
return
}
process := v.spec.Process
for index, rlimit := range process.Rlimits {
for i := index + 1; i < len(process.Rlimits); i++ {
if process.Rlimits[index].Type == process.Rlimits[i].Type {
errs = multierror.Append(errs,
specerror.NewError(
specerror.PosixProcRlimitsErrorOnDup,
fmt.Errorf("rlimit can not contain the same type %q",
process.Rlimits[index].Type),
rspec.Version))
}
}
errs = multierror.Append(errs, v.rlimitValid(rlimit))
}
return
}
|
go
|
func (v *Validator) CheckRlimits() (errs error) {
if v.platform != "linux" && v.platform != "solaris" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support process.rlimits", v.platform))
return
}
process := v.spec.Process
for index, rlimit := range process.Rlimits {
for i := index + 1; i < len(process.Rlimits); i++ {
if process.Rlimits[index].Type == process.Rlimits[i].Type {
errs = multierror.Append(errs,
specerror.NewError(
specerror.PosixProcRlimitsErrorOnDup,
fmt.Errorf("rlimit can not contain the same type %q",
process.Rlimits[index].Type),
rspec.Version))
}
}
errs = multierror.Append(errs, v.rlimitValid(rlimit))
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckRlimits",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"if",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"&&",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
".",
"platform",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"process",
":=",
"v",
".",
"spec",
".",
"Process",
"\n",
"for",
"index",
",",
"rlimit",
":=",
"range",
"process",
".",
"Rlimits",
"{",
"for",
"i",
":=",
"index",
"+",
"1",
";",
"i",
"<",
"len",
"(",
"process",
".",
"Rlimits",
")",
";",
"i",
"++",
"{",
"if",
"process",
".",
"Rlimits",
"[",
"index",
"]",
".",
"Type",
"==",
"process",
".",
"Rlimits",
"[",
"i",
"]",
".",
"Type",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"PosixProcRlimitsErrorOnDup",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"process",
".",
"Rlimits",
"[",
"index",
"]",
".",
"Type",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"v",
".",
"rlimitValid",
"(",
"rlimit",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckRlimits checks v.spec.Process.Rlimits
|
[
"CheckRlimits",
"checks",
"v",
".",
"spec",
".",
"Process",
".",
"Rlimits"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L454-L476
|
14,539 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckMounts
|
func (v *Validator) CheckMounts() (errs error) {
logrus.Debugf("check mounts")
supportedTypes, err := supportedMountTypes(v.platform, v.HostSpecific)
if err != nil {
errs = multierror.Append(errs, err)
return
}
for i, mountA := range v.spec.Mounts {
if supportedTypes != nil && !supportedTypes[mountA.Type] {
errs = multierror.Append(errs, fmt.Errorf("unsupported mount type %q", mountA.Type))
}
if !osFilepath.IsAbs(v.platform, mountA.Destination) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.MountsDestAbs,
fmt.Errorf("mounts[%d].destination %q is not absolute",
i,
mountA.Destination),
rspec.Version))
}
for j, mountB := range v.spec.Mounts {
if i == j {
continue
}
// whether B.Desination is nested within A.Destination
nested, err := osFilepath.IsAncestor(v.platform, mountA.Destination, mountB.Destination, ".")
if err != nil {
errs = multierror.Append(errs, err)
continue
}
if nested {
if v.platform == "windows" && i < j {
errs = multierror.Append(errs,
specerror.NewError(
specerror.MountsDestOnWindowsNotNested,
fmt.Errorf("on Windows, %v nested within %v is forbidden",
mountB.Destination, mountA.Destination),
rspec.Version))
}
if i > j {
logrus.Warnf("%v will be covered by %v", mountB.Destination, mountA.Destination)
}
}
}
}
return
}
|
go
|
func (v *Validator) CheckMounts() (errs error) {
logrus.Debugf("check mounts")
supportedTypes, err := supportedMountTypes(v.platform, v.HostSpecific)
if err != nil {
errs = multierror.Append(errs, err)
return
}
for i, mountA := range v.spec.Mounts {
if supportedTypes != nil && !supportedTypes[mountA.Type] {
errs = multierror.Append(errs, fmt.Errorf("unsupported mount type %q", mountA.Type))
}
if !osFilepath.IsAbs(v.platform, mountA.Destination) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.MountsDestAbs,
fmt.Errorf("mounts[%d].destination %q is not absolute",
i,
mountA.Destination),
rspec.Version))
}
for j, mountB := range v.spec.Mounts {
if i == j {
continue
}
// whether B.Desination is nested within A.Destination
nested, err := osFilepath.IsAncestor(v.platform, mountA.Destination, mountB.Destination, ".")
if err != nil {
errs = multierror.Append(errs, err)
continue
}
if nested {
if v.platform == "windows" && i < j {
errs = multierror.Append(errs,
specerror.NewError(
specerror.MountsDestOnWindowsNotNested,
fmt.Errorf("on Windows, %v nested within %v is forbidden",
mountB.Destination, mountA.Destination),
rspec.Version))
}
if i > j {
logrus.Warnf("%v will be covered by %v", mountB.Destination, mountA.Destination)
}
}
}
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckMounts",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"supportedTypes",
",",
"err",
":=",
"supportedMountTypes",
"(",
"v",
".",
"platform",
",",
"v",
".",
"HostSpecific",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"mountA",
":=",
"range",
"v",
".",
"spec",
".",
"Mounts",
"{",
"if",
"supportedTypes",
"!=",
"nil",
"&&",
"!",
"supportedTypes",
"[",
"mountA",
".",
"Type",
"]",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"mountA",
".",
"Type",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"osFilepath",
".",
"IsAbs",
"(",
"v",
".",
"platform",
",",
"mountA",
".",
"Destination",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"MountsDestAbs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
",",
"mountA",
".",
"Destination",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"for",
"j",
",",
"mountB",
":=",
"range",
"v",
".",
"spec",
".",
"Mounts",
"{",
"if",
"i",
"==",
"j",
"{",
"continue",
"\n",
"}",
"\n",
"// whether B.Desination is nested within A.Destination",
"nested",
",",
"err",
":=",
"osFilepath",
".",
"IsAncestor",
"(",
"v",
".",
"platform",
",",
"mountA",
".",
"Destination",
",",
"mountB",
".",
"Destination",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"nested",
"{",
"if",
"v",
".",
"platform",
"==",
"\"",
"\"",
"&&",
"i",
"<",
"j",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"MountsDestOnWindowsNotNested",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"mountB",
".",
"Destination",
",",
"mountA",
".",
"Destination",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"if",
"i",
">",
"j",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"mountB",
".",
"Destination",
",",
"mountA",
".",
"Destination",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckMounts checks v.spec.Mounts
|
[
"CheckMounts",
"checks",
"v",
".",
"spec",
".",
"Mounts"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L520-L569
|
14,540 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckPlatform
|
func (v *Validator) CheckPlatform() (errs error) {
logrus.Debugf("check platform")
if v.platform != "linux" && v.platform != "solaris" && v.platform != "windows" {
errs = multierror.Append(errs, fmt.Errorf("platform %q is not supported", v.platform))
return
}
if v.HostSpecific && v.platform != runtime.GOOS {
errs = multierror.Append(errs, fmt.Errorf("platform %q differs from the host %q, skipping host-specific checks", v.platform, runtime.GOOS))
v.HostSpecific = false
}
if v.platform == "windows" {
if v.spec.Windows == nil {
errs = multierror.Append(errs,
specerror.NewError(
specerror.PlatformSpecConfOnWindowsSet,
fmt.Errorf("'windows' MUST be set when platform is `windows`"),
rspec.Version))
}
}
return
}
|
go
|
func (v *Validator) CheckPlatform() (errs error) {
logrus.Debugf("check platform")
if v.platform != "linux" && v.platform != "solaris" && v.platform != "windows" {
errs = multierror.Append(errs, fmt.Errorf("platform %q is not supported", v.platform))
return
}
if v.HostSpecific && v.platform != runtime.GOOS {
errs = multierror.Append(errs, fmt.Errorf("platform %q differs from the host %q, skipping host-specific checks", v.platform, runtime.GOOS))
v.HostSpecific = false
}
if v.platform == "windows" {
if v.spec.Windows == nil {
errs = multierror.Append(errs,
specerror.NewError(
specerror.PlatformSpecConfOnWindowsSet,
fmt.Errorf("'windows' MUST be set when platform is `windows`"),
rspec.Version))
}
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckPlatform",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"&&",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"&&",
"v",
".",
"platform",
"!=",
"\"",
"\"",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
".",
"platform",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"v",
".",
"HostSpecific",
"&&",
"v",
".",
"platform",
"!=",
"runtime",
".",
"GOOS",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
".",
"platform",
",",
"runtime",
".",
"GOOS",
")",
")",
"\n",
"v",
".",
"HostSpecific",
"=",
"false",
"\n",
"}",
"\n\n",
"if",
"v",
".",
"platform",
"==",
"\"",
"\"",
"{",
"if",
"v",
".",
"spec",
".",
"Windows",
"==",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"PlatformSpecConfOnWindowsSet",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckPlatform checks v.platform
|
[
"CheckPlatform",
"checks",
"v",
".",
"platform"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L572-L596
|
14,541 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckLinuxResources
|
func (v *Validator) CheckLinuxResources() (errs error) {
logrus.Debugf("check linux resources")
r := v.spec.Linux.Resources
if r.Memory != nil {
if r.Memory.Limit != nil && r.Memory.Swap != nil && uint64(*r.Memory.Limit) > uint64(*r.Memory.Swap) {
errs = multierror.Append(errs, fmt.Errorf("minimum memoryswap should be larger than memory limit"))
}
if r.Memory.Limit != nil && r.Memory.Reservation != nil && uint64(*r.Memory.Reservation) > uint64(*r.Memory.Limit) {
errs = multierror.Append(errs, fmt.Errorf("minimum memory limit should be larger than memory reservation"))
}
}
if r.Network != nil && v.HostSpecific {
var exist bool
interfaces, err := net.Interfaces()
if err != nil {
errs = multierror.Append(errs, err)
return
}
for _, prio := range r.Network.Priorities {
exist = false
for _, ni := range interfaces {
if prio.Name == ni.Name {
exist = true
break
}
}
if !exist {
errs = multierror.Append(errs, fmt.Errorf("interface %s does not exist currently", prio.Name))
}
}
}
for index := 0; index < len(r.Devices); index++ {
switch r.Devices[index].Type {
case "a", "b", "c", "":
default:
errs = multierror.Append(errs, fmt.Errorf("type of devices %s is invalid", r.Devices[index].Type))
}
access := []byte(r.Devices[index].Access)
for i := 0; i < len(access); i++ {
switch access[i] {
case 'r', 'w', 'm':
default:
errs = multierror.Append(errs, fmt.Errorf("access %s is invalid", r.Devices[index].Access))
return
}
}
}
if r.BlockIO != nil && r.BlockIO.WeightDevice != nil {
for i, weightDevice := range r.BlockIO.WeightDevice {
if weightDevice.Weight == nil && weightDevice.LeafWeight == nil {
errs = multierror.Append(errs,
specerror.NewError(
specerror.BlkIOWeightOrLeafWeightExist,
fmt.Errorf("linux.resources.blockIO.weightDevice[%d] specifies neither weight nor leafWeight", i),
rspec.Version))
}
}
}
return
}
|
go
|
func (v *Validator) CheckLinuxResources() (errs error) {
logrus.Debugf("check linux resources")
r := v.spec.Linux.Resources
if r.Memory != nil {
if r.Memory.Limit != nil && r.Memory.Swap != nil && uint64(*r.Memory.Limit) > uint64(*r.Memory.Swap) {
errs = multierror.Append(errs, fmt.Errorf("minimum memoryswap should be larger than memory limit"))
}
if r.Memory.Limit != nil && r.Memory.Reservation != nil && uint64(*r.Memory.Reservation) > uint64(*r.Memory.Limit) {
errs = multierror.Append(errs, fmt.Errorf("minimum memory limit should be larger than memory reservation"))
}
}
if r.Network != nil && v.HostSpecific {
var exist bool
interfaces, err := net.Interfaces()
if err != nil {
errs = multierror.Append(errs, err)
return
}
for _, prio := range r.Network.Priorities {
exist = false
for _, ni := range interfaces {
if prio.Name == ni.Name {
exist = true
break
}
}
if !exist {
errs = multierror.Append(errs, fmt.Errorf("interface %s does not exist currently", prio.Name))
}
}
}
for index := 0; index < len(r.Devices); index++ {
switch r.Devices[index].Type {
case "a", "b", "c", "":
default:
errs = multierror.Append(errs, fmt.Errorf("type of devices %s is invalid", r.Devices[index].Type))
}
access := []byte(r.Devices[index].Access)
for i := 0; i < len(access); i++ {
switch access[i] {
case 'r', 'w', 'm':
default:
errs = multierror.Append(errs, fmt.Errorf("access %s is invalid", r.Devices[index].Access))
return
}
}
}
if r.BlockIO != nil && r.BlockIO.WeightDevice != nil {
for i, weightDevice := range r.BlockIO.WeightDevice {
if weightDevice.Weight == nil && weightDevice.LeafWeight == nil {
errs = multierror.Append(errs,
specerror.NewError(
specerror.BlkIOWeightOrLeafWeightExist,
fmt.Errorf("linux.resources.blockIO.weightDevice[%d] specifies neither weight nor leafWeight", i),
rspec.Version))
}
}
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckLinuxResources",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"r",
":=",
"v",
".",
"spec",
".",
"Linux",
".",
"Resources",
"\n",
"if",
"r",
".",
"Memory",
"!=",
"nil",
"{",
"if",
"r",
".",
"Memory",
".",
"Limit",
"!=",
"nil",
"&&",
"r",
".",
"Memory",
".",
"Swap",
"!=",
"nil",
"&&",
"uint64",
"(",
"*",
"r",
".",
"Memory",
".",
"Limit",
")",
">",
"uint64",
"(",
"*",
"r",
".",
"Memory",
".",
"Swap",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Memory",
".",
"Limit",
"!=",
"nil",
"&&",
"r",
".",
"Memory",
".",
"Reservation",
"!=",
"nil",
"&&",
"uint64",
"(",
"*",
"r",
".",
"Memory",
".",
"Reservation",
")",
">",
"uint64",
"(",
"*",
"r",
".",
"Memory",
".",
"Limit",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"r",
".",
"Network",
"!=",
"nil",
"&&",
"v",
".",
"HostSpecific",
"{",
"var",
"exist",
"bool",
"\n",
"interfaces",
",",
"err",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"for",
"_",
",",
"prio",
":=",
"range",
"r",
".",
"Network",
".",
"Priorities",
"{",
"exist",
"=",
"false",
"\n",
"for",
"_",
",",
"ni",
":=",
"range",
"interfaces",
"{",
"if",
"prio",
".",
"Name",
"==",
"ni",
".",
"Name",
"{",
"exist",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"exist",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"prio",
".",
"Name",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"index",
":=",
"0",
";",
"index",
"<",
"len",
"(",
"r",
".",
"Devices",
")",
";",
"index",
"++",
"{",
"switch",
"r",
".",
"Devices",
"[",
"index",
"]",
".",
"Type",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"default",
":",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"Devices",
"[",
"index",
"]",
".",
"Type",
")",
")",
"\n",
"}",
"\n\n",
"access",
":=",
"[",
"]",
"byte",
"(",
"r",
".",
"Devices",
"[",
"index",
"]",
".",
"Access",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"access",
")",
";",
"i",
"++",
"{",
"switch",
"access",
"[",
"i",
"]",
"{",
"case",
"'r'",
",",
"'w'",
",",
"'m'",
":",
"default",
":",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"Devices",
"[",
"index",
"]",
".",
"Access",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"BlockIO",
"!=",
"nil",
"&&",
"r",
".",
"BlockIO",
".",
"WeightDevice",
"!=",
"nil",
"{",
"for",
"i",
",",
"weightDevice",
":=",
"range",
"r",
".",
"BlockIO",
".",
"WeightDevice",
"{",
"if",
"weightDevice",
".",
"Weight",
"==",
"nil",
"&&",
"weightDevice",
".",
"LeafWeight",
"==",
"nil",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"BlkIOWeightOrLeafWeightExist",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckLinuxResources checks v.spec.Linux.Resources
|
[
"CheckLinuxResources",
"checks",
"v",
".",
"spec",
".",
"Linux",
".",
"Resources"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L599-L662
|
14,542 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckAnnotations
|
func (v *Validator) CheckAnnotations() (errs error) {
logrus.Debugf("check annotations")
reversedDomain := regexp.MustCompile(`^[A-Za-z]{2,6}(\.[A-Za-z0-9-]{1,63})+$`)
for key := range v.spec.Annotations {
if strings.HasPrefix(key, "org.opencontainers") {
errs = multierror.Append(errs,
specerror.NewError(
specerror.AnnotationsKeyReservedNS,
fmt.Errorf("key %q is reserved", key),
rspec.Version))
}
if !reversedDomain.MatchString(key) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.AnnotationsKeyReversedDomain,
fmt.Errorf("key %q SHOULD be named using a reverse domain notation", key),
rspec.Version))
}
}
return
}
|
go
|
func (v *Validator) CheckAnnotations() (errs error) {
logrus.Debugf("check annotations")
reversedDomain := regexp.MustCompile(`^[A-Za-z]{2,6}(\.[A-Za-z0-9-]{1,63})+$`)
for key := range v.spec.Annotations {
if strings.HasPrefix(key, "org.opencontainers") {
errs = multierror.Append(errs,
specerror.NewError(
specerror.AnnotationsKeyReservedNS,
fmt.Errorf("key %q is reserved", key),
rspec.Version))
}
if !reversedDomain.MatchString(key) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.AnnotationsKeyReversedDomain,
fmt.Errorf("key %q SHOULD be named using a reverse domain notation", key),
rspec.Version))
}
}
return
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckAnnotations",
"(",
")",
"(",
"errs",
"error",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"reversedDomain",
":=",
"regexp",
".",
"MustCompile",
"(",
"`^[A-Za-z]{2,6}(\\.[A-Za-z0-9-]{1,63})+$`",
")",
"\n",
"for",
"key",
":=",
"range",
"v",
".",
"spec",
".",
"Annotations",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"AnnotationsKeyReservedNS",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"reversedDomain",
".",
"MatchString",
"(",
"key",
")",
"{",
"errs",
"=",
"multierror",
".",
"Append",
"(",
"errs",
",",
"specerror",
".",
"NewError",
"(",
"specerror",
".",
"AnnotationsKeyReversedDomain",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
")",
",",
"rspec",
".",
"Version",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// CheckAnnotations checks v.spec.Annotations
|
[
"CheckAnnotations",
"checks",
"v",
".",
"spec",
".",
"Annotations"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L665-L688
|
14,543 |
opencontainers/runtime-tools
|
validate/validate.go
|
CapValid
|
func CapValid(c string, hostSpecific bool) error {
isValid := false
if !strings.HasPrefix(c, "CAP_") {
return fmt.Errorf("capability %s must start with CAP_", c)
}
for _, cap := range capability.List() {
if c == fmt.Sprintf("CAP_%s", strings.ToUpper(cap.String())) {
if hostSpecific && cap > LastCap() {
return fmt.Errorf("%s is not supported on the current host", c)
}
isValid = true
break
}
}
if !isValid {
return fmt.Errorf("invalid capability: %s", c)
}
return nil
}
|
go
|
func CapValid(c string, hostSpecific bool) error {
isValid := false
if !strings.HasPrefix(c, "CAP_") {
return fmt.Errorf("capability %s must start with CAP_", c)
}
for _, cap := range capability.List() {
if c == fmt.Sprintf("CAP_%s", strings.ToUpper(cap.String())) {
if hostSpecific && cap > LastCap() {
return fmt.Errorf("%s is not supported on the current host", c)
}
isValid = true
break
}
}
if !isValid {
return fmt.Errorf("invalid capability: %s", c)
}
return nil
}
|
[
"func",
"CapValid",
"(",
"c",
"string",
",",
"hostSpecific",
"bool",
")",
"error",
"{",
"isValid",
":=",
"false",
"\n\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"c",
",",
"\"",
"\"",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"cap",
":=",
"range",
"capability",
".",
"List",
"(",
")",
"{",
"if",
"c",
"==",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strings",
".",
"ToUpper",
"(",
"cap",
".",
"String",
"(",
")",
")",
")",
"{",
"if",
"hostSpecific",
"&&",
"cap",
">",
"LastCap",
"(",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"\n",
"isValid",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"isValid",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CapValid checks whether a capability is valid
|
[
"CapValid",
"checks",
"whether",
"a",
"capability",
"is",
"valid"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L691-L711
|
14,544 |
opencontainers/runtime-tools
|
validate/validate.go
|
CheckMandatoryFields
|
func (v *Validator) CheckMandatoryFields() error {
logrus.Debugf("check mandatory fields")
if v.spec == nil {
return fmt.Errorf("Spec can't be nil")
}
return checkMandatory(v.spec)
}
|
go
|
func (v *Validator) CheckMandatoryFields() error {
logrus.Debugf("check mandatory fields")
if v.spec == nil {
return fmt.Errorf("Spec can't be nil")
}
return checkMandatory(v.spec)
}
|
[
"func",
"(",
"v",
"*",
"Validator",
")",
"CheckMandatoryFields",
"(",
")",
"error",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"v",
".",
"spec",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"checkMandatory",
"(",
"v",
".",
"spec",
")",
"\n",
"}"
] |
// CheckMandatoryFields checks mandatory field of container's config file
|
[
"CheckMandatoryFields",
"checks",
"mandatory",
"field",
"of",
"container",
"s",
"config",
"file"
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate.go#L830-L838
|
14,545 |
opencontainers/runtime-tools
|
validation/util/linux_resources_pids.go
|
ValidateLinuxResourcesPids
|
func ValidateLinuxResourcesPids(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find pids cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lpd, err := cg.GetPidsData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get pids cgroup data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
t.Ok(lpd.Limit == config.Linux.Resources.Pids.Limit, "pids limit is set correctly")
t.Diagnosticf("expect: %d, actual: %d", config.Linux.Resources.Pids.Limit, lpd.Limit)
return nil
}
|
go
|
func ValidateLinuxResourcesPids(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find pids cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lpd, err := cg.GetPidsData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get pids cgroup data")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
t.Ok(lpd.Limit == config.Linux.Resources.Pids.Limit, "pids limit is set correctly")
t.Diagnosticf("expect: %d, actual: %d", config.Linux.Resources.Pids.Limit, lpd.Limit)
return nil
}
|
[
"func",
"ValidateLinuxResourcesPids",
"(",
"config",
"*",
"rspec",
".",
"Spec",
",",
"t",
"*",
"tap",
".",
"T",
",",
"state",
"*",
"rspec",
".",
"State",
")",
"error",
"{",
"cg",
",",
"err",
":=",
"cgroups",
".",
"FindCgroup",
"(",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"lpd",
",",
"err",
":=",
"cg",
".",
"GetPidsData",
"(",
"state",
".",
"Pid",
",",
"config",
".",
"Linux",
".",
"CgroupsPath",
")",
"\n",
"t",
".",
"Ok",
"(",
"(",
"err",
"==",
"nil",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"Diagnostic",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"t",
".",
"Ok",
"(",
"lpd",
".",
"Limit",
"==",
"config",
".",
"Linux",
".",
"Resources",
".",
"Pids",
".",
"Limit",
",",
"\"",
"\"",
")",
"\n",
"t",
".",
"Diagnosticf",
"(",
"\"",
"\"",
",",
"config",
".",
"Linux",
".",
"Resources",
".",
"Pids",
".",
"Limit",
",",
"lpd",
".",
"Limit",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ValidateLinuxResourcesPids validates linux.resources.pids.
|
[
"ValidateLinuxResourcesPids",
"validates",
"linux",
".",
"resources",
".",
"pids",
"."
] |
095789df6c2bc53a9dd4464cda8c22616d66e0d6
|
https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validation/util/linux_resources_pids.go#L10-L29
|
14,546 |
doug-martin/goqu
|
adapters.go
|
removeAdapter
|
func removeAdapter(dialect string) {
if HasAdapter(dialect) {
dialect = strings.ToLower(dialect)
delete(ds_adapters, dialect)
}
}
|
go
|
func removeAdapter(dialect string) {
if HasAdapter(dialect) {
dialect = strings.ToLower(dialect)
delete(ds_adapters, dialect)
}
}
|
[
"func",
"removeAdapter",
"(",
"dialect",
"string",
")",
"{",
"if",
"HasAdapter",
"(",
"dialect",
")",
"{",
"dialect",
"=",
"strings",
".",
"ToLower",
"(",
"dialect",
")",
"\n",
"delete",
"(",
"ds_adapters",
",",
"dialect",
")",
"\n",
"}",
"\n",
"}"
] |
//Clears the current adapter map, used internally for tests
|
[
"Clears",
"the",
"current",
"adapter",
"map",
"used",
"internally",
"for",
"tests"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/adapters.go#L251-L256
|
14,547 |
doug-martin/goqu
|
default_adapter.go
|
Literal
|
func (me *DefaultAdapter) Literal(buf *SqlBuilder, val interface{}) error {
return me.dataset.Literal(buf, val)
}
|
go
|
func (me *DefaultAdapter) Literal(buf *SqlBuilder, val interface{}) error {
return me.dataset.Literal(buf, val)
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"Literal",
"(",
"buf",
"*",
"SqlBuilder",
",",
"val",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"me",
".",
"dataset",
".",
"Literal",
"(",
"buf",
",",
"val",
")",
"\n",
"}"
] |
//This is a proxy to Dataset.Literal. Used internally to ensure the correct method is called on any subclasses and to prevent duplication of code
|
[
"This",
"is",
"a",
"proxy",
"to",
"Dataset",
".",
"Literal",
".",
"Used",
"internally",
"to",
"ensure",
"the",
"correct",
"method",
"is",
"called",
"on",
"any",
"subclasses",
"and",
"to",
"prevent",
"duplication",
"of",
"code"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L332-L334
|
14,548 |
doug-martin/goqu
|
default_adapter.go
|
UpdateBeginSql
|
func (me *DefaultAdapter) UpdateBeginSql(buf *SqlBuilder) error {
buf.Write(me.UpdateClause)
return nil
}
|
go
|
func (me *DefaultAdapter) UpdateBeginSql(buf *SqlBuilder) error {
buf.Write(me.UpdateClause)
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"UpdateBeginSql",
"(",
"buf",
"*",
"SqlBuilder",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"UpdateClause",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the correct fragment to being an UPDATE statement
|
[
"Adds",
"the",
"correct",
"fragment",
"to",
"being",
"an",
"UPDATE",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L347-L350
|
14,549 |
doug-martin/goqu
|
default_adapter.go
|
InsertBeginSql
|
func (me *DefaultAdapter) InsertBeginSql(buf *SqlBuilder, o ConflictExpression) error {
if me.SupportsInsertIgnoreSyntax() && o != nil {
buf.Write(me.InsertIgnoreClause)
} else {
buf.Write(me.InsertClause)
}
return nil
}
|
go
|
func (me *DefaultAdapter) InsertBeginSql(buf *SqlBuilder, o ConflictExpression) error {
if me.SupportsInsertIgnoreSyntax() && o != nil {
buf.Write(me.InsertIgnoreClause)
} else {
buf.Write(me.InsertClause)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"InsertBeginSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"o",
"ConflictExpression",
")",
"error",
"{",
"if",
"me",
".",
"SupportsInsertIgnoreSyntax",
"(",
")",
"&&",
"o",
"!=",
"nil",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"InsertIgnoreClause",
")",
"\n",
"}",
"else",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"InsertClause",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the correct fragment to being an INSERT statement
|
[
"Adds",
"the",
"correct",
"fragment",
"to",
"being",
"an",
"INSERT",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L353-L360
|
14,550 |
doug-martin/goqu
|
default_adapter.go
|
DeleteBeginSql
|
func (me *DefaultAdapter) DeleteBeginSql(buf *SqlBuilder) error {
buf.Write(me.DeleteClause)
return nil
}
|
go
|
func (me *DefaultAdapter) DeleteBeginSql(buf *SqlBuilder) error {
buf.Write(me.DeleteClause)
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"DeleteBeginSql",
"(",
"buf",
"*",
"SqlBuilder",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"DeleteClause",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the correct fragment to being an DELETE statement
|
[
"Adds",
"the",
"correct",
"fragment",
"to",
"being",
"an",
"DELETE",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L363-L366
|
14,551 |
doug-martin/goqu
|
default_adapter.go
|
TruncateSql
|
func (me *DefaultAdapter) TruncateSql(buf *SqlBuilder, from ColumnList, opts TruncateOptions) error {
buf.Write(me.TruncateClause)
if err := me.SourcesSql(buf, from); err != nil {
return err
}
if opts.Identity != empty_string {
buf.WriteRune(space_rune)
buf.WriteString(strings.ToUpper(opts.Identity))
buf.Write(me.IdentityFragment)
}
if opts.Cascade {
buf.Write(me.CascadeFragment)
} else if opts.Restrict {
buf.Write(me.RestrictFragment)
}
return nil
}
|
go
|
func (me *DefaultAdapter) TruncateSql(buf *SqlBuilder, from ColumnList, opts TruncateOptions) error {
buf.Write(me.TruncateClause)
if err := me.SourcesSql(buf, from); err != nil {
return err
}
if opts.Identity != empty_string {
buf.WriteRune(space_rune)
buf.WriteString(strings.ToUpper(opts.Identity))
buf.Write(me.IdentityFragment)
}
if opts.Cascade {
buf.Write(me.CascadeFragment)
} else if opts.Restrict {
buf.Write(me.RestrictFragment)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"TruncateSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"from",
"ColumnList",
",",
"opts",
"TruncateOptions",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"TruncateClause",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"SourcesSql",
"(",
"buf",
",",
"from",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"opts",
".",
"Identity",
"!=",
"empty_string",
"{",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"strings",
".",
"ToUpper",
"(",
"opts",
".",
"Identity",
")",
")",
"\n",
"buf",
".",
"Write",
"(",
"me",
".",
"IdentityFragment",
")",
"\n",
"}",
"\n",
"if",
"opts",
".",
"Cascade",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"CascadeFragment",
")",
"\n",
"}",
"else",
"if",
"opts",
".",
"Restrict",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"RestrictFragment",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates a TRUNCATE statement
|
[
"Generates",
"a",
"TRUNCATE",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L369-L385
|
14,552 |
doug-martin/goqu
|
default_adapter.go
|
InsertColumnsSql
|
func (me *DefaultAdapter) InsertColumnsSql(buf *SqlBuilder, cols ColumnList) error {
buf.WriteRune(space_rune)
buf.WriteRune(left_paren_rune)
if err := me.Literal(buf, cols); err != nil {
return err
}
buf.WriteRune(right_paren_rune)
return nil
}
|
go
|
func (me *DefaultAdapter) InsertColumnsSql(buf *SqlBuilder, cols ColumnList) error {
buf.WriteRune(space_rune)
buf.WriteRune(left_paren_rune)
if err := me.Literal(buf, cols); err != nil {
return err
}
buf.WriteRune(right_paren_rune)
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"InsertColumnsSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"cols",
"ColumnList",
")",
"error",
"{",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"buf",
".",
"WriteRune",
"(",
"left_paren_rune",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"cols",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"right_paren_rune",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the columns list to an insert statement
|
[
"Adds",
"the",
"columns",
"list",
"to",
"an",
"insert",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L394-L402
|
14,553 |
doug-martin/goqu
|
default_adapter.go
|
InsertValuesSql
|
func (me *DefaultAdapter) InsertValuesSql(buf *SqlBuilder, values [][]interface{}) error {
buf.Write(me.ValuesFragment)
rowLen := len(values[0])
valueLen := len(values)
for i, row := range values {
if len(row) != rowLen {
return fmt.Errorf("Rows with different value length expected %d got %d", rowLen, len(row))
}
if err := me.Literal(buf, row); err != nil {
return err
}
if i < valueLen-1 {
buf.WriteRune(comma_rune)
buf.WriteRune(space_rune)
}
}
return nil
}
|
go
|
func (me *DefaultAdapter) InsertValuesSql(buf *SqlBuilder, values [][]interface{}) error {
buf.Write(me.ValuesFragment)
rowLen := len(values[0])
valueLen := len(values)
for i, row := range values {
if len(row) != rowLen {
return fmt.Errorf("Rows with different value length expected %d got %d", rowLen, len(row))
}
if err := me.Literal(buf, row); err != nil {
return err
}
if i < valueLen-1 {
buf.WriteRune(comma_rune)
buf.WriteRune(space_rune)
}
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"InsertValuesSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"values",
"[",
"]",
"[",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"ValuesFragment",
")",
"\n",
"rowLen",
":=",
"len",
"(",
"values",
"[",
"0",
"]",
")",
"\n",
"valueLen",
":=",
"len",
"(",
"values",
")",
"\n",
"for",
"i",
",",
"row",
":=",
"range",
"values",
"{",
"if",
"len",
"(",
"row",
")",
"!=",
"rowLen",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"rowLen",
",",
"len",
"(",
"row",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"row",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"i",
"<",
"valueLen",
"-",
"1",
"{",
"buf",
".",
"WriteRune",
"(",
"comma_rune",
")",
"\n",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the values clause to an SQL statement
|
[
"Adds",
"the",
"values",
"clause",
"to",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L405-L422
|
14,554 |
doug-martin/goqu
|
default_adapter.go
|
SelectSql
|
func (me *DefaultAdapter) SelectSql(buf *SqlBuilder, cols ColumnList) error {
buf.Write(me.SelectClause)
buf.WriteRune(space_rune)
if len(cols.Columns()) == 0 {
buf.WriteRune(star_rune)
} else {
return me.Literal(buf, cols)
}
return nil
}
|
go
|
func (me *DefaultAdapter) SelectSql(buf *SqlBuilder, cols ColumnList) error {
buf.Write(me.SelectClause)
buf.WriteRune(space_rune)
if len(cols.Columns()) == 0 {
buf.WriteRune(star_rune)
} else {
return me.Literal(buf, cols)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"SelectSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"cols",
"ColumnList",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"SelectClause",
")",
"\n",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"if",
"len",
"(",
"cols",
".",
"Columns",
"(",
")",
")",
"==",
"0",
"{",
"buf",
".",
"WriteRune",
"(",
"star_rune",
")",
"\n",
"}",
"else",
"{",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"cols",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the SELECT clause and columns to a sql statement
|
[
"Adds",
"the",
"SELECT",
"clause",
"and",
"columns",
"to",
"a",
"sql",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L497-L506
|
14,555 |
doug-martin/goqu
|
default_adapter.go
|
SelectDistinctSql
|
func (me *DefaultAdapter) SelectDistinctSql(buf *SqlBuilder, cols ColumnList) error {
buf.Write(me.SelectClause)
buf.Write(me.DistinctFragment)
return me.Literal(buf, cols)
}
|
go
|
func (me *DefaultAdapter) SelectDistinctSql(buf *SqlBuilder, cols ColumnList) error {
buf.Write(me.SelectClause)
buf.Write(me.DistinctFragment)
return me.Literal(buf, cols)
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"SelectDistinctSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"cols",
"ColumnList",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"SelectClause",
")",
"\n",
"buf",
".",
"Write",
"(",
"me",
".",
"DistinctFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"cols",
")",
"\n",
"}"
] |
//Adds the SELECT DISTINCT clause and columns to a sql statement
|
[
"Adds",
"the",
"SELECT",
"DISTINCT",
"clause",
"and",
"columns",
"to",
"a",
"sql",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L509-L513
|
14,556 |
doug-martin/goqu
|
default_adapter.go
|
FromSql
|
func (me *DefaultAdapter) FromSql(buf *SqlBuilder, from ColumnList) error {
if from != nil && len(from.Columns()) > 0 {
buf.Write(me.FromFragment)
return me.SourcesSql(buf, from)
}
return nil
}
|
go
|
func (me *DefaultAdapter) FromSql(buf *SqlBuilder, from ColumnList) error {
if from != nil && len(from.Columns()) > 0 {
buf.Write(me.FromFragment)
return me.SourcesSql(buf, from)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"FromSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"from",
"ColumnList",
")",
"error",
"{",
"if",
"from",
"!=",
"nil",
"&&",
"len",
"(",
"from",
".",
"Columns",
"(",
")",
")",
">",
"0",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"FromFragment",
")",
"\n",
"return",
"me",
".",
"SourcesSql",
"(",
"buf",
",",
"from",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Adds the FROM clause and tables to an sql statement
|
[
"Adds",
"the",
"FROM",
"clause",
"and",
"tables",
"to",
"an",
"sql",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L524-L530
|
14,557 |
doug-martin/goqu
|
default_adapter.go
|
SourcesSql
|
func (me *DefaultAdapter) SourcesSql(buf *SqlBuilder, from ColumnList) error {
buf.WriteRune(space_rune)
return me.Literal(buf, from)
}
|
go
|
func (me *DefaultAdapter) SourcesSql(buf *SqlBuilder, from ColumnList) error {
buf.WriteRune(space_rune)
return me.Literal(buf, from)
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"SourcesSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"from",
"ColumnList",
")",
"error",
"{",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"from",
")",
"\n",
"}"
] |
//Adds the generates the SQL for a column list
|
[
"Adds",
"the",
"generates",
"the",
"SQL",
"for",
"a",
"column",
"list"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L533-L536
|
14,558 |
doug-martin/goqu
|
default_adapter.go
|
JoinSql
|
func (me *DefaultAdapter) JoinSql(buf *SqlBuilder, joins JoiningClauses) error {
if len(joins) > 0 {
for _, j := range joins {
joinType := me.JoinTypeLookup[j.JoinType]
buf.Write(joinType)
if err := me.Literal(buf, j.Table); err != nil {
return err
}
if j.IsConditioned {
buf.WriteRune(space_rune)
if j.Condition == nil {
return NewGoquError("Join condition required for conditioned join %s", string(joinType))
}
condition := j.Condition
if condition.JoinCondition() == USING_COND {
buf.WriteString("USING ")
} else {
buf.WriteString("ON ")
}
switch condition.(type) {
case JoinOnExpression:
if err := me.Literal(buf, condition.(JoinOnExpression).On()); err != nil {
return err
}
case JoinUsingExpression:
buf.WriteRune(left_paren_rune)
if err := me.Literal(buf, condition.(JoinUsingExpression).Using()); err != nil {
return err
}
buf.WriteRune(right_paren_rune)
}
}
}
}
return nil
}
|
go
|
func (me *DefaultAdapter) JoinSql(buf *SqlBuilder, joins JoiningClauses) error {
if len(joins) > 0 {
for _, j := range joins {
joinType := me.JoinTypeLookup[j.JoinType]
buf.Write(joinType)
if err := me.Literal(buf, j.Table); err != nil {
return err
}
if j.IsConditioned {
buf.WriteRune(space_rune)
if j.Condition == nil {
return NewGoquError("Join condition required for conditioned join %s", string(joinType))
}
condition := j.Condition
if condition.JoinCondition() == USING_COND {
buf.WriteString("USING ")
} else {
buf.WriteString("ON ")
}
switch condition.(type) {
case JoinOnExpression:
if err := me.Literal(buf, condition.(JoinOnExpression).On()); err != nil {
return err
}
case JoinUsingExpression:
buf.WriteRune(left_paren_rune)
if err := me.Literal(buf, condition.(JoinUsingExpression).Using()); err != nil {
return err
}
buf.WriteRune(right_paren_rune)
}
}
}
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"JoinSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"joins",
"JoiningClauses",
")",
"error",
"{",
"if",
"len",
"(",
"joins",
")",
">",
"0",
"{",
"for",
"_",
",",
"j",
":=",
"range",
"joins",
"{",
"joinType",
":=",
"me",
".",
"JoinTypeLookup",
"[",
"j",
".",
"JoinType",
"]",
"\n",
"buf",
".",
"Write",
"(",
"joinType",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"j",
".",
"Table",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"j",
".",
"IsConditioned",
"{",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"if",
"j",
".",
"Condition",
"==",
"nil",
"{",
"return",
"NewGoquError",
"(",
"\"",
"\"",
",",
"string",
"(",
"joinType",
")",
")",
"\n",
"}",
"\n",
"condition",
":=",
"j",
".",
"Condition",
"\n",
"if",
"condition",
".",
"JoinCondition",
"(",
")",
"==",
"USING_COND",
"{",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"switch",
"condition",
".",
"(",
"type",
")",
"{",
"case",
"JoinOnExpression",
":",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"condition",
".",
"(",
"JoinOnExpression",
")",
".",
"On",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"case",
"JoinUsingExpression",
":",
"buf",
".",
"WriteRune",
"(",
"left_paren_rune",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"condition",
".",
"(",
"JoinUsingExpression",
")",
".",
"Using",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"right_paren_rune",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the JOIN clauses for an SQL statement
|
[
"Generates",
"the",
"JOIN",
"clauses",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L539-L574
|
14,559 |
doug-martin/goqu
|
default_adapter.go
|
WhereSql
|
func (me *DefaultAdapter) WhereSql(buf *SqlBuilder, where ExpressionList) error {
if where != nil && len(where.Expressions()) > 0 {
buf.Write(me.WhereFragment)
return me.Literal(buf, where)
}
return nil
}
|
go
|
func (me *DefaultAdapter) WhereSql(buf *SqlBuilder, where ExpressionList) error {
if where != nil && len(where.Expressions()) > 0 {
buf.Write(me.WhereFragment)
return me.Literal(buf, where)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"WhereSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"where",
"ExpressionList",
")",
"error",
"{",
"if",
"where",
"!=",
"nil",
"&&",
"len",
"(",
"where",
".",
"Expressions",
"(",
")",
")",
">",
"0",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"WhereFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"where",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the WHERE clause for an SQL statement
|
[
"Generates",
"the",
"WHERE",
"clause",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L577-L583
|
14,560 |
doug-martin/goqu
|
default_adapter.go
|
GroupBySql
|
func (me *DefaultAdapter) GroupBySql(buf *SqlBuilder, groupBy ColumnList) error {
if groupBy != nil && len(groupBy.Columns()) > 0 {
buf.Write(me.GroupByFragment)
return me.Literal(buf, groupBy)
}
return nil
}
|
go
|
func (me *DefaultAdapter) GroupBySql(buf *SqlBuilder, groupBy ColumnList) error {
if groupBy != nil && len(groupBy.Columns()) > 0 {
buf.Write(me.GroupByFragment)
return me.Literal(buf, groupBy)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"GroupBySql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"groupBy",
"ColumnList",
")",
"error",
"{",
"if",
"groupBy",
"!=",
"nil",
"&&",
"len",
"(",
"groupBy",
".",
"Columns",
"(",
")",
")",
">",
"0",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"GroupByFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"groupBy",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the GROUP BY clause for an SQL statement
|
[
"Generates",
"the",
"GROUP",
"BY",
"clause",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L586-L592
|
14,561 |
doug-martin/goqu
|
default_adapter.go
|
HavingSql
|
func (me *DefaultAdapter) HavingSql(buf *SqlBuilder, having ExpressionList) error {
if having != nil && len(having.Expressions()) > 0 {
buf.Write(me.HavingFragment)
return me.Literal(buf, having)
}
return nil
}
|
go
|
func (me *DefaultAdapter) HavingSql(buf *SqlBuilder, having ExpressionList) error {
if having != nil && len(having.Expressions()) > 0 {
buf.Write(me.HavingFragment)
return me.Literal(buf, having)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"HavingSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"having",
"ExpressionList",
")",
"error",
"{",
"if",
"having",
"!=",
"nil",
"&&",
"len",
"(",
"having",
".",
"Expressions",
"(",
")",
")",
">",
"0",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"HavingFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"having",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the HAVING clause for an SQL statement
|
[
"Generates",
"the",
"HAVING",
"clause",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L595-L601
|
14,562 |
doug-martin/goqu
|
default_adapter.go
|
OrderSql
|
func (me *DefaultAdapter) OrderSql(buf *SqlBuilder, order ColumnList) error {
if order != nil && len(order.Columns()) > 0 {
buf.Write(me.OrderByFragment)
return me.Literal(buf, order)
}
return nil
}
|
go
|
func (me *DefaultAdapter) OrderSql(buf *SqlBuilder, order ColumnList) error {
if order != nil && len(order.Columns()) > 0 {
buf.Write(me.OrderByFragment)
return me.Literal(buf, order)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"OrderSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"order",
"ColumnList",
")",
"error",
"{",
"if",
"order",
"!=",
"nil",
"&&",
"len",
"(",
"order",
".",
"Columns",
"(",
")",
")",
">",
"0",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"OrderByFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"order",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the ORDER BY clause for an SQL statement
|
[
"Generates",
"the",
"ORDER",
"BY",
"clause",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L645-L651
|
14,563 |
doug-martin/goqu
|
default_adapter.go
|
LimitSql
|
func (me *DefaultAdapter) LimitSql(buf *SqlBuilder, limit interface{}) error {
if limit != nil {
buf.Write(me.LimitFragment)
return me.Literal(buf, limit)
}
return nil
}
|
go
|
func (me *DefaultAdapter) LimitSql(buf *SqlBuilder, limit interface{}) error {
if limit != nil {
buf.Write(me.LimitFragment)
return me.Literal(buf, limit)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LimitSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"limit",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"limit",
"!=",
"nil",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"LimitFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"limit",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the LIMIT clause for an SQL statement
|
[
"Generates",
"the",
"LIMIT",
"clause",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L654-L660
|
14,564 |
doug-martin/goqu
|
default_adapter.go
|
OffsetSql
|
func (me *DefaultAdapter) OffsetSql(buf *SqlBuilder, offset uint) error {
if offset > 0 {
buf.Write(me.OffsetFragment)
return me.Literal(buf, offset)
}
return nil
}
|
go
|
func (me *DefaultAdapter) OffsetSql(buf *SqlBuilder, offset uint) error {
if offset > 0 {
buf.Write(me.OffsetFragment)
return me.Literal(buf, offset)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"OffsetSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"offset",
"uint",
")",
"error",
"{",
"if",
"offset",
">",
"0",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"OffsetFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"offset",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates the OFFSET clause for an SQL statement
|
[
"Generates",
"the",
"OFFSET",
"clause",
"for",
"an",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L663-L669
|
14,565 |
doug-martin/goqu
|
default_adapter.go
|
DatasetSql
|
func (me *DefaultAdapter) DatasetSql(buf *SqlBuilder, dataset Dataset) error {
buf.WriteRune(left_paren_rune)
if buf.IsPrepared {
if err := dataset.selectSqlWriteTo(buf); err != nil {
return err
}
} else {
sql, _, err := dataset.Prepared(false).ToSql()
if err != nil {
return err
}
buf.WriteString(sql)
}
buf.WriteRune(right_paren_rune)
alias := dataset.GetClauses().Alias
if alias != nil {
buf.Write(me.AsFragment)
return me.Literal(buf, alias)
}
return nil
}
|
go
|
func (me *DefaultAdapter) DatasetSql(buf *SqlBuilder, dataset Dataset) error {
buf.WriteRune(left_paren_rune)
if buf.IsPrepared {
if err := dataset.selectSqlWriteTo(buf); err != nil {
return err
}
} else {
sql, _, err := dataset.Prepared(false).ToSql()
if err != nil {
return err
}
buf.WriteString(sql)
}
buf.WriteRune(right_paren_rune)
alias := dataset.GetClauses().Alias
if alias != nil {
buf.Write(me.AsFragment)
return me.Literal(buf, alias)
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"DatasetSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"dataset",
"Dataset",
")",
"error",
"{",
"buf",
".",
"WriteRune",
"(",
"left_paren_rune",
")",
"\n",
"if",
"buf",
".",
"IsPrepared",
"{",
"if",
"err",
":=",
"dataset",
".",
"selectSqlWriteTo",
"(",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"sql",
",",
"_",
",",
"err",
":=",
"dataset",
".",
"Prepared",
"(",
"false",
")",
".",
"ToSql",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"buf",
".",
"WriteString",
"(",
"sql",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"right_paren_rune",
")",
"\n",
"alias",
":=",
"dataset",
".",
"GetClauses",
"(",
")",
".",
"Alias",
"\n",
"if",
"alias",
"!=",
"nil",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"AsFragment",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"alias",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates creates the sql for a sub select on a Dataset
|
[
"Generates",
"creates",
"the",
"sql",
"for",
"a",
"sub",
"select",
"on",
"a",
"Dataset"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L672-L692
|
14,566 |
doug-martin/goqu
|
default_adapter.go
|
LiteralNil
|
func (me *DefaultAdapter) LiteralNil(buf *SqlBuilder) error {
buf.Write(me.Null)
return nil
}
|
go
|
func (me *DefaultAdapter) LiteralNil(buf *SqlBuilder) error {
buf.Write(me.Null)
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LiteralNil",
"(",
"buf",
"*",
"SqlBuilder",
")",
"error",
"{",
"buf",
".",
"Write",
"(",
"me",
".",
"Null",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates SQL NULL value
|
[
"Generates",
"SQL",
"NULL",
"value"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L731-L734
|
14,567 |
doug-martin/goqu
|
default_adapter.go
|
LiteralTime
|
func (me *DefaultAdapter) LiteralTime(buf *SqlBuilder, t time.Time) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, t)
}
return me.Literal(buf, t.UTC().Format(me.TimeFormat))
}
|
go
|
func (me *DefaultAdapter) LiteralTime(buf *SqlBuilder, t time.Time) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, t)
}
return me.Literal(buf, t.UTC().Format(me.TimeFormat))
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LiteralTime",
"(",
"buf",
"*",
"SqlBuilder",
",",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"if",
"buf",
".",
"IsPrepared",
"{",
"return",
"me",
".",
"PlaceHolderSql",
"(",
"buf",
",",
"t",
")",
"\n",
"}",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"t",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"me",
".",
"TimeFormat",
")",
")",
"\n",
"}"
] |
//Generates SQL for a time.Time value
|
[
"Generates",
"SQL",
"for",
"a",
"time",
".",
"Time",
"value"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L750-L755
|
14,568 |
doug-martin/goqu
|
default_adapter.go
|
LiteralFloat
|
func (me *DefaultAdapter) LiteralFloat(buf *SqlBuilder, f float64) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, f)
}
buf.WriteString(strconv.FormatFloat(f, 'f', -1, 64))
return nil
}
|
go
|
func (me *DefaultAdapter) LiteralFloat(buf *SqlBuilder, f float64) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, f)
}
buf.WriteString(strconv.FormatFloat(f, 'f', -1, 64))
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LiteralFloat",
"(",
"buf",
"*",
"SqlBuilder",
",",
"f",
"float64",
")",
"error",
"{",
"if",
"buf",
".",
"IsPrepared",
"{",
"return",
"me",
".",
"PlaceHolderSql",
"(",
"buf",
",",
"f",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteString",
"(",
"strconv",
".",
"FormatFloat",
"(",
"f",
",",
"'f'",
",",
"-",
"1",
",",
"64",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates SQL for a Float Value
|
[
"Generates",
"SQL",
"for",
"a",
"Float",
"Value"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L758-L764
|
14,569 |
doug-martin/goqu
|
default_adapter.go
|
LiteralInt
|
func (me *DefaultAdapter) LiteralInt(buf *SqlBuilder, i int64) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, i)
}
buf.WriteString(strconv.FormatInt(i, 10))
return nil
}
|
go
|
func (me *DefaultAdapter) LiteralInt(buf *SqlBuilder, i int64) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, i)
}
buf.WriteString(strconv.FormatInt(i, 10))
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LiteralInt",
"(",
"buf",
"*",
"SqlBuilder",
",",
"i",
"int64",
")",
"error",
"{",
"if",
"buf",
".",
"IsPrepared",
"{",
"return",
"me",
".",
"PlaceHolderSql",
"(",
"buf",
",",
"i",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteString",
"(",
"strconv",
".",
"FormatInt",
"(",
"i",
",",
"10",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates SQL for an int value
|
[
"Generates",
"SQL",
"for",
"an",
"int",
"value"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L767-L773
|
14,570 |
doug-martin/goqu
|
default_adapter.go
|
LiteralString
|
func (me *DefaultAdapter) LiteralString(buf *SqlBuilder, s string) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, s)
}
buf.WriteRune(me.StringQuote)
for _, char := range s {
if e, ok := me.EscapedRunes[char]; ok {
buf.Write(e)
} else {
buf.WriteRune(char)
}
}
buf.WriteRune(me.StringQuote)
return nil
}
|
go
|
func (me *DefaultAdapter) LiteralString(buf *SqlBuilder, s string) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, s)
}
buf.WriteRune(me.StringQuote)
for _, char := range s {
if e, ok := me.EscapedRunes[char]; ok {
buf.Write(e)
} else {
buf.WriteRune(char)
}
}
buf.WriteRune(me.StringQuote)
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LiteralString",
"(",
"buf",
"*",
"SqlBuilder",
",",
"s",
"string",
")",
"error",
"{",
"if",
"buf",
".",
"IsPrepared",
"{",
"return",
"me",
".",
"PlaceHolderSql",
"(",
"buf",
",",
"s",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"me",
".",
"StringQuote",
")",
"\n",
"for",
"_",
",",
"char",
":=",
"range",
"s",
"{",
"if",
"e",
",",
"ok",
":=",
"me",
".",
"EscapedRunes",
"[",
"char",
"]",
";",
"ok",
"{",
"buf",
".",
"Write",
"(",
"e",
")",
"\n",
"}",
"else",
"{",
"buf",
".",
"WriteRune",
"(",
"char",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteRune",
"(",
"me",
".",
"StringQuote",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates SQL for a string
|
[
"Generates",
"SQL",
"for",
"a",
"string"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L776-L791
|
14,571 |
doug-martin/goqu
|
default_adapter.go
|
LiteralBytes
|
func (me *DefaultAdapter) LiteralBytes(buf *SqlBuilder, bs []byte) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, bs)
}
buf.WriteRune(me.StringQuote)
i := 0
for len(bs) > 0 {
char, l := utf8.DecodeRune(bs)
if e, ok := me.EscapedRunes[char]; ok {
buf.Write(e)
} else {
buf.WriteRune(char)
}
i++
bs = bs[l:]
}
buf.WriteRune(me.StringQuote)
return nil
}
|
go
|
func (me *DefaultAdapter) LiteralBytes(buf *SqlBuilder, bs []byte) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, bs)
}
buf.WriteRune(me.StringQuote)
i := 0
for len(bs) > 0 {
char, l := utf8.DecodeRune(bs)
if e, ok := me.EscapedRunes[char]; ok {
buf.Write(e)
} else {
buf.WriteRune(char)
}
i++
bs = bs[l:]
}
buf.WriteRune(me.StringQuote)
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"LiteralBytes",
"(",
"buf",
"*",
"SqlBuilder",
",",
"bs",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"buf",
".",
"IsPrepared",
"{",
"return",
"me",
".",
"PlaceHolderSql",
"(",
"buf",
",",
"bs",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"me",
".",
"StringQuote",
")",
"\n",
"i",
":=",
"0",
"\n",
"for",
"len",
"(",
"bs",
")",
">",
"0",
"{",
"char",
",",
"l",
":=",
"utf8",
".",
"DecodeRune",
"(",
"bs",
")",
"\n",
"if",
"e",
",",
"ok",
":=",
"me",
".",
"EscapedRunes",
"[",
"char",
"]",
";",
"ok",
"{",
"buf",
".",
"Write",
"(",
"e",
")",
"\n",
"}",
"else",
"{",
"buf",
".",
"WriteRune",
"(",
"char",
")",
"\n",
"}",
"\n",
"i",
"++",
"\n",
"bs",
"=",
"bs",
"[",
"l",
":",
"]",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"me",
".",
"StringQuote",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Generates SQL for a slice of bytes
|
[
"Generates",
"SQL",
"for",
"a",
"slice",
"of",
"bytes"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L794-L812
|
14,572 |
doug-martin/goqu
|
default_adapter.go
|
ColumnListSql
|
func (me *DefaultAdapter) ColumnListSql(buf *SqlBuilder, columnList ColumnList) error {
cols := columnList.Columns()
colLen := len(cols)
for i, col := range cols {
if err := me.Literal(buf, col); err != nil {
return err
}
if i < colLen-1 {
buf.WriteRune(comma_rune)
buf.WriteRune(space_rune)
}
}
return nil
}
|
go
|
func (me *DefaultAdapter) ColumnListSql(buf *SqlBuilder, columnList ColumnList) error {
cols := columnList.Columns()
colLen := len(cols)
for i, col := range cols {
if err := me.Literal(buf, col); err != nil {
return err
}
if i < colLen-1 {
buf.WriteRune(comma_rune)
buf.WriteRune(space_rune)
}
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"ColumnListSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"columnList",
"ColumnList",
")",
"error",
"{",
"cols",
":=",
"columnList",
".",
"Columns",
"(",
")",
"\n",
"colLen",
":=",
"len",
"(",
"cols",
")",
"\n",
"for",
"i",
",",
"col",
":=",
"range",
"cols",
"{",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"col",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"i",
"<",
"colLen",
"-",
"1",
"{",
"buf",
".",
"WriteRune",
"(",
"comma_rune",
")",
"\n",
"buf",
".",
"WriteRune",
"(",
"space_rune",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates SQL for a ColumnList
|
[
"Generates",
"SQL",
"for",
"a",
"ColumnList"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L950-L963
|
14,573 |
doug-martin/goqu
|
default_adapter.go
|
UpdateExpressionSql
|
func (me *DefaultAdapter) UpdateExpressionSql(buf *SqlBuilder, update UpdateExpression) error {
if err := me.Literal(buf, update.Col()); err != nil {
return err
}
buf.WriteRune(me.SetOperatorRune)
return me.Literal(buf, update.Val())
}
|
go
|
func (me *DefaultAdapter) UpdateExpressionSql(buf *SqlBuilder, update UpdateExpression) error {
if err := me.Literal(buf, update.Col()); err != nil {
return err
}
buf.WriteRune(me.SetOperatorRune)
return me.Literal(buf, update.Val())
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"UpdateExpressionSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"update",
"UpdateExpression",
")",
"error",
"{",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"update",
".",
"Col",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"buf",
".",
"WriteRune",
"(",
"me",
".",
"SetOperatorRune",
")",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"update",
".",
"Val",
"(",
")",
")",
"\n",
"}"
] |
//Generates SQL for an UpdateEpxresion
|
[
"Generates",
"SQL",
"for",
"an",
"UpdateEpxresion"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L966-L972
|
14,574 |
doug-martin/goqu
|
default_adapter.go
|
CommonTableExpressionSql
|
func (me *DefaultAdapter) CommonTableExpressionSql(buf *SqlBuilder, cte CommonTableExpression) error {
if err := me.Literal(buf, cte.Name()); err != nil {
return err
}
buf.Write(me.AsFragment)
if err := me.Literal(buf, cte.SubQuery()); err != nil {
return err
}
return nil
}
|
go
|
func (me *DefaultAdapter) CommonTableExpressionSql(buf *SqlBuilder, cte CommonTableExpression) error {
if err := me.Literal(buf, cte.Name()); err != nil {
return err
}
buf.Write(me.AsFragment)
if err := me.Literal(buf, cte.SubQuery()); err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"CommonTableExpressionSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"cte",
"CommonTableExpression",
")",
"error",
"{",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"cte",
".",
"Name",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"buf",
".",
"Write",
"(",
"me",
".",
"AsFragment",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"Literal",
"(",
"buf",
",",
"cte",
".",
"SubQuery",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
//Generates SQL for a CommonTableExpression
|
[
"Generates",
"SQL",
"for",
"a",
"CommonTableExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L1023-L1032
|
14,575 |
doug-martin/goqu
|
default_adapter.go
|
CompoundExpressionSql
|
func (me *DefaultAdapter) CompoundExpressionSql(buf *SqlBuilder, compound CompoundExpression) error {
switch compound.Type() {
case UNION:
buf.Write(me.UnionFragment)
case UNION_ALL:
buf.Write(me.UnionAllFragment)
case INTERSECT:
buf.Write(me.IntersectFragment)
case INTERSECT_ALL:
buf.Write(me.IntersectAllFragment)
}
return me.Literal(buf, compound.Rhs())
}
|
go
|
func (me *DefaultAdapter) CompoundExpressionSql(buf *SqlBuilder, compound CompoundExpression) error {
switch compound.Type() {
case UNION:
buf.Write(me.UnionFragment)
case UNION_ALL:
buf.Write(me.UnionAllFragment)
case INTERSECT:
buf.Write(me.IntersectFragment)
case INTERSECT_ALL:
buf.Write(me.IntersectAllFragment)
}
return me.Literal(buf, compound.Rhs())
}
|
[
"func",
"(",
"me",
"*",
"DefaultAdapter",
")",
"CompoundExpressionSql",
"(",
"buf",
"*",
"SqlBuilder",
",",
"compound",
"CompoundExpression",
")",
"error",
"{",
"switch",
"compound",
".",
"Type",
"(",
")",
"{",
"case",
"UNION",
":",
"buf",
".",
"Write",
"(",
"me",
".",
"UnionFragment",
")",
"\n",
"case",
"UNION_ALL",
":",
"buf",
".",
"Write",
"(",
"me",
".",
"UnionAllFragment",
")",
"\n",
"case",
"INTERSECT",
":",
"buf",
".",
"Write",
"(",
"me",
".",
"IntersectFragment",
")",
"\n",
"case",
"INTERSECT_ALL",
":",
"buf",
".",
"Write",
"(",
"me",
".",
"IntersectAllFragment",
")",
"\n",
"}",
"\n",
"return",
"me",
".",
"Literal",
"(",
"buf",
",",
"compound",
".",
"Rhs",
"(",
")",
")",
"\n",
"}"
] |
//Generates SQL for a CompoundExpression
|
[
"Generates",
"SQL",
"for",
"a",
"CompoundExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/default_adapter.go#L1035-L1047
|
14,576 |
doug-martin/goqu
|
dataset.go
|
withDatabase
|
func withDatabase(db database) *Dataset {
ret := new(Dataset)
ret.database = db
ret.clauses = clauses{
Select: cols(Star()),
}
ret.adapter = db.queryAdapter(ret)
return ret
}
|
go
|
func withDatabase(db database) *Dataset {
ret := new(Dataset)
ret.database = db
ret.clauses = clauses{
Select: cols(Star()),
}
ret.adapter = db.queryAdapter(ret)
return ret
}
|
[
"func",
"withDatabase",
"(",
"db",
"database",
")",
"*",
"Dataset",
"{",
"ret",
":=",
"new",
"(",
"Dataset",
")",
"\n",
"ret",
".",
"database",
"=",
"db",
"\n",
"ret",
".",
"clauses",
"=",
"clauses",
"{",
"Select",
":",
"cols",
"(",
"Star",
"(",
")",
")",
",",
"}",
"\n",
"ret",
".",
"adapter",
"=",
"db",
".",
"queryAdapter",
"(",
"ret",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
//used internally by database to create a database with a specific adapter
|
[
"used",
"internally",
"by",
"database",
"to",
"create",
"a",
"database",
"with",
"a",
"specific",
"adapter"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset.go#L142-L150
|
14,577 |
doug-martin/goqu
|
dataset.go
|
SetAdapter
|
func (me *Dataset) SetAdapter(adapter Adapter) *Dataset {
me.adapter = adapter
return me
}
|
go
|
func (me *Dataset) SetAdapter(adapter Adapter) *Dataset {
me.adapter = adapter
return me
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"SetAdapter",
"(",
"adapter",
"Adapter",
")",
"*",
"Dataset",
"{",
"me",
".",
"adapter",
"=",
"adapter",
"\n",
"return",
"me",
"\n",
"}"
] |
//Sets the adapter used to serialize values and create the SQL statement
|
[
"Sets",
"the",
"adapter",
"used",
"to",
"serialize",
"values",
"and",
"create",
"the",
"SQL",
"statement"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset.go#L153-L156
|
14,578 |
doug-martin/goqu
|
dataset.go
|
hasSources
|
func (me *Dataset) hasSources() bool {
return me.clauses.From != nil && len(me.clauses.From.Columns()) > 0
}
|
go
|
func (me *Dataset) hasSources() bool {
return me.clauses.From != nil && len(me.clauses.From.Columns()) > 0
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"hasSources",
"(",
")",
"bool",
"{",
"return",
"me",
".",
"clauses",
".",
"From",
"!=",
"nil",
"&&",
"len",
"(",
"me",
".",
"clauses",
".",
"From",
".",
"Columns",
"(",
")",
")",
">",
"0",
"\n",
"}"
] |
//Returns true if the dataset has a FROM clause
|
[
"Returns",
"true",
"if",
"the",
"dataset",
"has",
"a",
"FROM",
"clause"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset.go#L192-L194
|
14,579 |
doug-martin/goqu
|
sql_builder.go
|
WriteArg
|
func (me *SqlBuilder) WriteArg(i interface{}) {
me.CurrentArgPosition++
me.args = append(me.args, i)
}
|
go
|
func (me *SqlBuilder) WriteArg(i interface{}) {
me.CurrentArgPosition++
me.args = append(me.args, i)
}
|
[
"func",
"(",
"me",
"*",
"SqlBuilder",
")",
"WriteArg",
"(",
"i",
"interface",
"{",
"}",
")",
"{",
"me",
".",
"CurrentArgPosition",
"++",
"\n",
"me",
".",
"args",
"=",
"append",
"(",
"me",
".",
"args",
",",
"i",
")",
"\n",
"}"
] |
//Adds an argument to the builder, used when IsPrepared is false
|
[
"Adds",
"an",
"argument",
"to",
"the",
"builder",
"used",
"when",
"IsPrepared",
"is",
"false"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/sql_builder.go#L20-L23
|
14,580 |
doug-martin/goqu
|
database.go
|
Begin
|
func (me *Database) Begin() (*TxDatabase, error) {
tx, err := me.Db.Begin()
if err != nil {
return nil, err
}
return &TxDatabase{Dialect: me.Dialect, Tx: tx, logger: me.logger}, nil
}
|
go
|
func (me *Database) Begin() (*TxDatabase, error) {
tx, err := me.Db.Begin()
if err != nil {
return nil, err
}
return &TxDatabase{Dialect: me.Dialect, Tx: tx, logger: me.logger}, nil
}
|
[
"func",
"(",
"me",
"*",
"Database",
")",
"Begin",
"(",
")",
"(",
"*",
"TxDatabase",
",",
"error",
")",
"{",
"tx",
",",
"err",
":=",
"me",
".",
"Db",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"TxDatabase",
"{",
"Dialect",
":",
"me",
".",
"Dialect",
",",
"Tx",
":",
"tx",
",",
"logger",
":",
"me",
".",
"logger",
"}",
",",
"nil",
"\n",
"}"
] |
//Starts a new Transaction.
|
[
"Starts",
"a",
"new",
"Transaction",
"."
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/database.go#L69-L75
|
14,581 |
doug-martin/goqu
|
database.go
|
queryAdapter
|
func (me *Database) queryAdapter(dataset *Dataset) Adapter {
return NewAdapter(me.Dialect, dataset)
}
|
go
|
func (me *Database) queryAdapter(dataset *Dataset) Adapter {
return NewAdapter(me.Dialect, dataset)
}
|
[
"func",
"(",
"me",
"*",
"Database",
")",
"queryAdapter",
"(",
"dataset",
"*",
"Dataset",
")",
"Adapter",
"{",
"return",
"NewAdapter",
"(",
"me",
".",
"Dialect",
",",
"dataset",
")",
"\n",
"}"
] |
//used internally to create a new Adapter for a dataset
|
[
"used",
"internally",
"to",
"create",
"a",
"new",
"Adapter",
"for",
"a",
"dataset"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/database.go#L78-L80
|
14,582 |
doug-martin/goqu
|
database.go
|
Trace
|
func (me *Database) Trace(op, sql string, args ...interface{}) {
if me.logger != nil {
if sql != "" {
if len(args) != 0 {
me.logger.Printf("[goqu] %s [query:=`%s` args:=%+v]", op, sql, args)
} else {
me.logger.Printf("[goqu] %s [query:=`%s`]", op, sql)
}
} else {
me.logger.Printf("[goqu] %s", op)
}
}
}
|
go
|
func (me *Database) Trace(op, sql string, args ...interface{}) {
if me.logger != nil {
if sql != "" {
if len(args) != 0 {
me.logger.Printf("[goqu] %s [query:=`%s` args:=%+v]", op, sql, args)
} else {
me.logger.Printf("[goqu] %s [query:=`%s`]", op, sql)
}
} else {
me.logger.Printf("[goqu] %s", op)
}
}
}
|
[
"func",
"(",
"me",
"*",
"Database",
")",
"Trace",
"(",
"op",
",",
"sql",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"me",
".",
"logger",
"!=",
"nil",
"{",
"if",
"sql",
"!=",
"\"",
"\"",
"{",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
"{",
"me",
".",
"logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"op",
",",
"sql",
",",
"args",
")",
"\n",
"}",
"else",
"{",
"me",
".",
"logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"op",
",",
"sql",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"me",
".",
"logger",
".",
"Printf",
"(",
"\"",
"\"",
",",
"op",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
//Logs a given operation with the specified sql and arguments
|
[
"Logs",
"a",
"given",
"operation",
"with",
"the",
"specified",
"sql",
"and",
"arguments"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/database.go#L100-L112
|
14,583 |
doug-martin/goqu
|
database.go
|
queryAdapter
|
func (me *TxDatabase) queryAdapter(dataset *Dataset) Adapter {
return NewAdapter(me.Dialect, dataset)
}
|
go
|
func (me *TxDatabase) queryAdapter(dataset *Dataset) Adapter {
return NewAdapter(me.Dialect, dataset)
}
|
[
"func",
"(",
"me",
"*",
"TxDatabase",
")",
"queryAdapter",
"(",
"dataset",
"*",
"Dataset",
")",
"Adapter",
"{",
"return",
"NewAdapter",
"(",
"me",
".",
"Dialect",
",",
"dataset",
")",
"\n",
"}"
] |
//used internally to create a new query adapter for a Dataset
|
[
"used",
"internally",
"to",
"create",
"a",
"new",
"query",
"adapter",
"for",
"a",
"Dataset"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/database.go#L394-L396
|
14,584 |
doug-martin/goqu
|
dataset_insert.go
|
getInsertColsAndVals
|
func (me *Dataset) getInsertColsAndVals(rows ...interface{}) (columns ColumnList, vals [][]interface{}, err error) {
var mapKeys valueSlice
rowValue := reflect.Indirect(reflect.ValueOf(rows[0]))
rowType := rowValue.Type()
rowKind := rowValue.Kind()
vals = make([][]interface{}, len(rows))
for i, row := range rows {
if rowType != reflect.Indirect(reflect.ValueOf(row)).Type() {
return nil, nil, NewGoquError("Rows must be all the same type expected %+v got %+v", rowType, reflect.Indirect(reflect.ValueOf(row)).Type())
}
newRowValue := reflect.Indirect(reflect.ValueOf(row))
switch rowKind {
case reflect.Map:
if columns == nil {
mapKeys = valueSlice(newRowValue.MapKeys())
sort.Sort(mapKeys)
colKeys := make([]interface{}, len(mapKeys))
for j, key := range mapKeys {
colKeys[j] = key.Interface()
}
columns = cols(colKeys...)
}
newMapKeys := valueSlice(newRowValue.MapKeys())
if len(newMapKeys) != len(mapKeys) {
return nil, nil, NewGoquError("Rows with different value length expected %d got %d", len(mapKeys), len(newMapKeys))
}
if !mapKeys.Equal(newMapKeys) {
return nil, nil, NewGoquError("Rows with different keys expected %s got %s", mapKeys.String(), newMapKeys.String())
}
rowVals := make([]interface{}, len(mapKeys))
for j, key := range mapKeys {
rowVals[j] = newRowValue.MapIndex(key).Interface()
}
vals[i] = rowVals
case reflect.Struct:
var (
rowCols []interface{}
rowVals []interface{}
)
rowCols, rowVals = me.getFieldsValues(newRowValue)
if columns == nil {
columns = cols(rowCols...)
}
vals[i] = rowVals
default:
return nil, nil, NewGoquError("Unsupported insert must be map, goqu.Record, or struct type got: %T", row)
}
}
return columns, vals, nil
}
|
go
|
func (me *Dataset) getInsertColsAndVals(rows ...interface{}) (columns ColumnList, vals [][]interface{}, err error) {
var mapKeys valueSlice
rowValue := reflect.Indirect(reflect.ValueOf(rows[0]))
rowType := rowValue.Type()
rowKind := rowValue.Kind()
vals = make([][]interface{}, len(rows))
for i, row := range rows {
if rowType != reflect.Indirect(reflect.ValueOf(row)).Type() {
return nil, nil, NewGoquError("Rows must be all the same type expected %+v got %+v", rowType, reflect.Indirect(reflect.ValueOf(row)).Type())
}
newRowValue := reflect.Indirect(reflect.ValueOf(row))
switch rowKind {
case reflect.Map:
if columns == nil {
mapKeys = valueSlice(newRowValue.MapKeys())
sort.Sort(mapKeys)
colKeys := make([]interface{}, len(mapKeys))
for j, key := range mapKeys {
colKeys[j] = key.Interface()
}
columns = cols(colKeys...)
}
newMapKeys := valueSlice(newRowValue.MapKeys())
if len(newMapKeys) != len(mapKeys) {
return nil, nil, NewGoquError("Rows with different value length expected %d got %d", len(mapKeys), len(newMapKeys))
}
if !mapKeys.Equal(newMapKeys) {
return nil, nil, NewGoquError("Rows with different keys expected %s got %s", mapKeys.String(), newMapKeys.String())
}
rowVals := make([]interface{}, len(mapKeys))
for j, key := range mapKeys {
rowVals[j] = newRowValue.MapIndex(key).Interface()
}
vals[i] = rowVals
case reflect.Struct:
var (
rowCols []interface{}
rowVals []interface{}
)
rowCols, rowVals = me.getFieldsValues(newRowValue)
if columns == nil {
columns = cols(rowCols...)
}
vals[i] = rowVals
default:
return nil, nil, NewGoquError("Unsupported insert must be map, goqu.Record, or struct type got: %T", row)
}
}
return columns, vals, nil
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"getInsertColsAndVals",
"(",
"rows",
"...",
"interface",
"{",
"}",
")",
"(",
"columns",
"ColumnList",
",",
"vals",
"[",
"]",
"[",
"]",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"var",
"mapKeys",
"valueSlice",
"\n",
"rowValue",
":=",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"rows",
"[",
"0",
"]",
")",
")",
"\n",
"rowType",
":=",
"rowValue",
".",
"Type",
"(",
")",
"\n",
"rowKind",
":=",
"rowValue",
".",
"Kind",
"(",
")",
"\n",
"vals",
"=",
"make",
"(",
"[",
"]",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"rows",
")",
")",
"\n",
"for",
"i",
",",
"row",
":=",
"range",
"rows",
"{",
"if",
"rowType",
"!=",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"row",
")",
")",
".",
"Type",
"(",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"NewGoquError",
"(",
"\"",
"\"",
",",
"rowType",
",",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"row",
")",
")",
".",
"Type",
"(",
")",
")",
"\n",
"}",
"\n",
"newRowValue",
":=",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"row",
")",
")",
"\n",
"switch",
"rowKind",
"{",
"case",
"reflect",
".",
"Map",
":",
"if",
"columns",
"==",
"nil",
"{",
"mapKeys",
"=",
"valueSlice",
"(",
"newRowValue",
".",
"MapKeys",
"(",
")",
")",
"\n",
"sort",
".",
"Sort",
"(",
"mapKeys",
")",
"\n",
"colKeys",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"mapKeys",
")",
")",
"\n",
"for",
"j",
",",
"key",
":=",
"range",
"mapKeys",
"{",
"colKeys",
"[",
"j",
"]",
"=",
"key",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n",
"columns",
"=",
"cols",
"(",
"colKeys",
"...",
")",
"\n",
"}",
"\n",
"newMapKeys",
":=",
"valueSlice",
"(",
"newRowValue",
".",
"MapKeys",
"(",
")",
")",
"\n",
"if",
"len",
"(",
"newMapKeys",
")",
"!=",
"len",
"(",
"mapKeys",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"NewGoquError",
"(",
"\"",
"\"",
",",
"len",
"(",
"mapKeys",
")",
",",
"len",
"(",
"newMapKeys",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"mapKeys",
".",
"Equal",
"(",
"newMapKeys",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"NewGoquError",
"(",
"\"",
"\"",
",",
"mapKeys",
".",
"String",
"(",
")",
",",
"newMapKeys",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"rowVals",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"mapKeys",
")",
")",
"\n",
"for",
"j",
",",
"key",
":=",
"range",
"mapKeys",
"{",
"rowVals",
"[",
"j",
"]",
"=",
"newRowValue",
".",
"MapIndex",
"(",
"key",
")",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n",
"vals",
"[",
"i",
"]",
"=",
"rowVals",
"\n",
"case",
"reflect",
".",
"Struct",
":",
"var",
"(",
"rowCols",
"[",
"]",
"interface",
"{",
"}",
"\n",
"rowVals",
"[",
"]",
"interface",
"{",
"}",
"\n",
")",
"\n",
"rowCols",
",",
"rowVals",
"=",
"me",
".",
"getFieldsValues",
"(",
"newRowValue",
")",
"\n",
"if",
"columns",
"==",
"nil",
"{",
"columns",
"=",
"cols",
"(",
"rowCols",
"...",
")",
"\n",
"}",
"\n",
"vals",
"[",
"i",
"]",
"=",
"rowVals",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
",",
"NewGoquError",
"(",
"\"",
"\"",
",",
"row",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"columns",
",",
"vals",
",",
"nil",
"\n",
"}"
] |
//parses the rows gathering and sorting unique columns and values for each record
|
[
"parses",
"the",
"rows",
"gathering",
"and",
"sorting",
"unique",
"columns",
"and",
"values",
"for",
"each",
"record"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_insert.go#L92-L141
|
14,585 |
doug-martin/goqu
|
dataset_insert.go
|
insertSql
|
func (me *Dataset) insertSql(cols ColumnList, values [][]interface{}, prepared bool, c ConflictExpression) (string, []interface{}, error) {
buf := NewSqlBuilder(prepared)
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return "", nil, err
}
if err := me.adapter.InsertBeginSql(buf, c); err != nil {
return "", nil, err
}
if err := me.adapter.SourcesSql(buf, me.clauses.From); err != nil {
return "", nil, NewGoquError(err.Error())
}
if cols == nil {
if err := me.adapter.DefaultValuesSql(buf); err != nil {
return "", nil, NewGoquError(err.Error())
}
} else {
if err := me.adapter.InsertColumnsSql(buf, cols); err != nil {
return "", nil, NewGoquError(err.Error())
}
if err := me.adapter.InsertValuesSql(buf, values); err != nil {
return "", nil, NewGoquError(err.Error())
}
}
if err := me.adapter.OnConflictSql(buf, c); err != nil {
return "", nil, err
}
if me.adapter.SupportsReturn() {
if err := me.adapter.ReturningSql(buf, me.clauses.Returning); err != nil {
return "", nil, err
}
} else if me.clauses.Returning != nil {
return "", nil, NewGoquError("Adapter does not support RETURNING clause")
}
sql, args := buf.ToSql()
return sql, args, nil
}
|
go
|
func (me *Dataset) insertSql(cols ColumnList, values [][]interface{}, prepared bool, c ConflictExpression) (string, []interface{}, error) {
buf := NewSqlBuilder(prepared)
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return "", nil, err
}
if err := me.adapter.InsertBeginSql(buf, c); err != nil {
return "", nil, err
}
if err := me.adapter.SourcesSql(buf, me.clauses.From); err != nil {
return "", nil, NewGoquError(err.Error())
}
if cols == nil {
if err := me.adapter.DefaultValuesSql(buf); err != nil {
return "", nil, NewGoquError(err.Error())
}
} else {
if err := me.adapter.InsertColumnsSql(buf, cols); err != nil {
return "", nil, NewGoquError(err.Error())
}
if err := me.adapter.InsertValuesSql(buf, values); err != nil {
return "", nil, NewGoquError(err.Error())
}
}
if err := me.adapter.OnConflictSql(buf, c); err != nil {
return "", nil, err
}
if me.adapter.SupportsReturn() {
if err := me.adapter.ReturningSql(buf, me.clauses.Returning); err != nil {
return "", nil, err
}
} else if me.clauses.Returning != nil {
return "", nil, NewGoquError("Adapter does not support RETURNING clause")
}
sql, args := buf.ToSql()
return sql, args, nil
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"insertSql",
"(",
"cols",
"ColumnList",
",",
"values",
"[",
"]",
"[",
"]",
"interface",
"{",
"}",
",",
"prepared",
"bool",
",",
"c",
"ConflictExpression",
")",
"(",
"string",
",",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"buf",
":=",
"NewSqlBuilder",
"(",
"prepared",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"CommonTablesSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"CommonTables",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"InsertBeginSql",
"(",
"buf",
",",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"SourcesSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"From",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"cols",
"==",
"nil",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"DefaultValuesSql",
"(",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"InsertColumnsSql",
"(",
"buf",
",",
"cols",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"InsertValuesSql",
"(",
"buf",
",",
"values",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"OnConflictSql",
"(",
"buf",
",",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"me",
".",
"adapter",
".",
"SupportsReturn",
"(",
")",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"ReturningSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Returning",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"if",
"me",
".",
"clauses",
".",
"Returning",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sql",
",",
"args",
":=",
"buf",
".",
"ToSql",
"(",
")",
"\n",
"return",
"sql",
",",
"args",
",",
"nil",
"\n",
"}"
] |
//Creates an INSERT statement with the columns and values passed in
|
[
"Creates",
"an",
"INSERT",
"statement",
"with",
"the",
"columns",
"and",
"values",
"passed",
"in"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_insert.go#L166-L202
|
14,586 |
doug-martin/goqu
|
dataset_insert.go
|
insertFromSql
|
func (me *Dataset) insertFromSql(other Dataset, prepared bool, c ConflictExpression) (string, []interface{}, error) {
buf := NewSqlBuilder(prepared)
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return "", nil, err
}
if err := me.adapter.InsertBeginSql(buf, nil); err != nil {
return "", nil, err
}
if err := me.adapter.SourcesSql(buf, me.clauses.From); err != nil {
return "", nil, NewGoquError(err.Error())
}
buf.WriteString(" ")
if err := other.selectSqlWriteTo(buf); err != nil {
return "", nil, err
}
if err := me.adapter.OnConflictSql(buf, c); err != nil {
return "", nil, err
}
if me.adapter.SupportsReturn() {
if err := me.adapter.ReturningSql(buf, me.clauses.Returning); err != nil {
return "", nil, err
}
} else if me.clauses.Returning != nil {
return "", nil, NewGoquError("Adapter does not support RETURNING clause")
}
sql, args := buf.ToSql()
return sql, args, nil
}
|
go
|
func (me *Dataset) insertFromSql(other Dataset, prepared bool, c ConflictExpression) (string, []interface{}, error) {
buf := NewSqlBuilder(prepared)
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return "", nil, err
}
if err := me.adapter.InsertBeginSql(buf, nil); err != nil {
return "", nil, err
}
if err := me.adapter.SourcesSql(buf, me.clauses.From); err != nil {
return "", nil, NewGoquError(err.Error())
}
buf.WriteString(" ")
if err := other.selectSqlWriteTo(buf); err != nil {
return "", nil, err
}
if err := me.adapter.OnConflictSql(buf, c); err != nil {
return "", nil, err
}
if me.adapter.SupportsReturn() {
if err := me.adapter.ReturningSql(buf, me.clauses.Returning); err != nil {
return "", nil, err
}
} else if me.clauses.Returning != nil {
return "", nil, NewGoquError("Adapter does not support RETURNING clause")
}
sql, args := buf.ToSql()
return sql, args, nil
}
|
[
"func",
"(",
"me",
"*",
"Dataset",
")",
"insertFromSql",
"(",
"other",
"Dataset",
",",
"prepared",
"bool",
",",
"c",
"ConflictExpression",
")",
"(",
"string",
",",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"buf",
":=",
"NewSqlBuilder",
"(",
"prepared",
")",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"CommonTablesSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"CommonTables",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"InsertBeginSql",
"(",
"buf",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"SourcesSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"From",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"buf",
".",
"WriteString",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"other",
".",
"selectSqlWriteTo",
"(",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"OnConflictSql",
"(",
"buf",
",",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"me",
".",
"adapter",
".",
"SupportsReturn",
"(",
")",
"{",
"if",
"err",
":=",
"me",
".",
"adapter",
".",
"ReturningSql",
"(",
"buf",
",",
"me",
".",
"clauses",
".",
"Returning",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"if",
"me",
".",
"clauses",
".",
"Returning",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"NewGoquError",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"sql",
",",
"args",
":=",
"buf",
".",
"ToSql",
"(",
")",
"\n",
"return",
"sql",
",",
"args",
",",
"nil",
"\n",
"}"
] |
//Creates an insert statement with values coming from another dataset
|
[
"Creates",
"an",
"insert",
"statement",
"with",
"values",
"coming",
"from",
"another",
"dataset"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/dataset_insert.go#L205-L232
|
14,587 |
doug-martin/goqu
|
expressions.go
|
eq
|
func eq(lhs Expression, rhs interface{}) BooleanExpression {
return checkBoolExpType(EQ_OP, lhs, rhs, false)
}
|
go
|
func eq(lhs Expression, rhs interface{}) BooleanExpression {
return checkBoolExpType(EQ_OP, lhs, rhs, false)
}
|
[
"func",
"eq",
"(",
"lhs",
"Expression",
",",
"rhs",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkBoolExpType",
"(",
"EQ_OP",
",",
"lhs",
",",
"rhs",
",",
"false",
")",
"\n",
"}"
] |
//used internally to create an equality BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"equality",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L914-L916
|
14,588 |
doug-martin/goqu
|
expressions.go
|
neq
|
func neq(lhs Expression, rhs interface{}) BooleanExpression {
return checkBoolExpType(EQ_OP, lhs, rhs, true)
}
|
go
|
func neq(lhs Expression, rhs interface{}) BooleanExpression {
return checkBoolExpType(EQ_OP, lhs, rhs, true)
}
|
[
"func",
"neq",
"(",
"lhs",
"Expression",
",",
"rhs",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkBoolExpType",
"(",
"EQ_OP",
",",
"lhs",
",",
"rhs",
",",
"true",
")",
"\n",
"}"
] |
//used internally to create an in-equality BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"in",
"-",
"equality",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L919-L921
|
14,589 |
doug-martin/goqu
|
expressions.go
|
gt
|
func gt(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: GT_OP, lhs: lhs, rhs: rhs}
}
|
go
|
func gt(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: GT_OP, lhs: lhs, rhs: rhs}
}
|
[
"func",
"gt",
"(",
"lhs",
"Expression",
",",
"rhs",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"boolean",
"{",
"op",
":",
"GT_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//used internally to create an gt comparison BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"gt",
"comparison",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L924-L926
|
14,590 |
doug-martin/goqu
|
expressions.go
|
gte
|
func gte(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: GTE_OP, lhs: lhs, rhs: rhs}
}
|
go
|
func gte(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: GTE_OP, lhs: lhs, rhs: rhs}
}
|
[
"func",
"gte",
"(",
"lhs",
"Expression",
",",
"rhs",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"boolean",
"{",
"op",
":",
"GTE_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//used internally to create an gte comparison BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"gte",
"comparison",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L929-L931
|
14,591 |
doug-martin/goqu
|
expressions.go
|
lt
|
func lt(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: LT_OP, lhs: lhs, rhs: rhs}
}
|
go
|
func lt(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: LT_OP, lhs: lhs, rhs: rhs}
}
|
[
"func",
"lt",
"(",
"lhs",
"Expression",
",",
"rhs",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"boolean",
"{",
"op",
":",
"LT_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//used internally to create an lt comparison BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"lt",
"comparison",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L934-L936
|
14,592 |
doug-martin/goqu
|
expressions.go
|
lte
|
func lte(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: LTE_OP, lhs: lhs, rhs: rhs}
}
|
go
|
func lte(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: LTE_OP, lhs: lhs, rhs: rhs}
}
|
[
"func",
"lte",
"(",
"lhs",
"Expression",
",",
"rhs",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"boolean",
"{",
"op",
":",
"LTE_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"rhs",
"}",
"\n",
"}"
] |
//used internally to create an lte comparison BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"lte",
"comparison",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L939-L941
|
14,593 |
doug-martin/goqu
|
expressions.go
|
in
|
func in(lhs Expression, vals ...interface{}) BooleanExpression {
if len(vals) == 1 && reflect.Indirect(reflect.ValueOf(vals[0])).Kind() == reflect.Slice {
return boolean{op: IN_OP, lhs: lhs, rhs: vals[0]}
}
return boolean{op: IN_OP, lhs: lhs, rhs: vals}
}
|
go
|
func in(lhs Expression, vals ...interface{}) BooleanExpression {
if len(vals) == 1 && reflect.Indirect(reflect.ValueOf(vals[0])).Kind() == reflect.Slice {
return boolean{op: IN_OP, lhs: lhs, rhs: vals[0]}
}
return boolean{op: IN_OP, lhs: lhs, rhs: vals}
}
|
[
"func",
"in",
"(",
"lhs",
"Expression",
",",
"vals",
"...",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"if",
"len",
"(",
"vals",
")",
"==",
"1",
"&&",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"vals",
"[",
"0",
"]",
")",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Slice",
"{",
"return",
"boolean",
"{",
"op",
":",
"IN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"vals",
"[",
"0",
"]",
"}",
"\n",
"}",
"\n",
"return",
"boolean",
"{",
"op",
":",
"IN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"vals",
"}",
"\n",
"}"
] |
//used internally to create an IN BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"IN",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L944-L949
|
14,594 |
doug-martin/goqu
|
expressions.go
|
notIn
|
func notIn(lhs Expression, vals ...interface{}) BooleanExpression {
if len(vals) == 1 && reflect.Indirect(reflect.ValueOf(vals[0])).Kind() == reflect.Slice {
return boolean{op: NOT_IN_OP, lhs: lhs, rhs: vals[0]}
}
return boolean{op: NOT_IN_OP, lhs: lhs, rhs: vals}
}
|
go
|
func notIn(lhs Expression, vals ...interface{}) BooleanExpression {
if len(vals) == 1 && reflect.Indirect(reflect.ValueOf(vals[0])).Kind() == reflect.Slice {
return boolean{op: NOT_IN_OP, lhs: lhs, rhs: vals[0]}
}
return boolean{op: NOT_IN_OP, lhs: lhs, rhs: vals}
}
|
[
"func",
"notIn",
"(",
"lhs",
"Expression",
",",
"vals",
"...",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"if",
"len",
"(",
"vals",
")",
"==",
"1",
"&&",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"vals",
"[",
"0",
"]",
")",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Slice",
"{",
"return",
"boolean",
"{",
"op",
":",
"NOT_IN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"vals",
"[",
"0",
"]",
"}",
"\n",
"}",
"\n",
"return",
"boolean",
"{",
"op",
":",
"NOT_IN_OP",
",",
"lhs",
":",
"lhs",
",",
"rhs",
":",
"vals",
"}",
"\n",
"}"
] |
//used internally to create a NOT IN BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"a",
"NOT",
"IN",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L952-L957
|
14,595 |
doug-martin/goqu
|
expressions.go
|
is
|
func is(lhs Expression, val interface{}) BooleanExpression {
return checkBoolExpType(IS_OP, lhs, val, false)
}
|
go
|
func is(lhs Expression, val interface{}) BooleanExpression {
return checkBoolExpType(IS_OP, lhs, val, false)
}
|
[
"func",
"is",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkBoolExpType",
"(",
"IS_OP",
",",
"lhs",
",",
"val",
",",
"false",
")",
"\n",
"}"
] |
//used internally to create an IS BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"IS",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L960-L962
|
14,596 |
doug-martin/goqu
|
expressions.go
|
isNot
|
func isNot(lhs Expression, val interface{}) BooleanExpression {
return checkBoolExpType(IS_OP, lhs, val, true)
}
|
go
|
func isNot(lhs Expression, val interface{}) BooleanExpression {
return checkBoolExpType(IS_OP, lhs, val, true)
}
|
[
"func",
"isNot",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkBoolExpType",
"(",
"IS_OP",
",",
"lhs",
",",
"val",
",",
"true",
")",
"\n",
"}"
] |
//used internally to create an IS NOT BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"IS",
"NOT",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L965-L967
|
14,597 |
doug-martin/goqu
|
expressions.go
|
like
|
func like(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(LIKE_OP, lhs, val, false)
}
|
go
|
func like(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(LIKE_OP, lhs, val, false)
}
|
[
"func",
"like",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkLikeExp",
"(",
"LIKE_OP",
",",
"lhs",
",",
"val",
",",
"false",
")",
"\n",
"}"
] |
//used internally to create a LIKE BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"a",
"LIKE",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L970-L972
|
14,598 |
doug-martin/goqu
|
expressions.go
|
iLike
|
func iLike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, false)
}
|
go
|
func iLike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, false)
}
|
[
"func",
"iLike",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkLikeExp",
"(",
"I_LIKE_OP",
",",
"lhs",
",",
"val",
",",
"false",
")",
"\n",
"}"
] |
//used internally to create an ILIKE BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"an",
"ILIKE",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L975-L977
|
14,599 |
doug-martin/goqu
|
expressions.go
|
notLike
|
func notLike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(LIKE_OP, lhs, val, true)
}
|
go
|
func notLike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(LIKE_OP, lhs, val, true)
}
|
[
"func",
"notLike",
"(",
"lhs",
"Expression",
",",
"val",
"interface",
"{",
"}",
")",
"BooleanExpression",
"{",
"return",
"checkLikeExp",
"(",
"LIKE_OP",
",",
"lhs",
",",
"val",
",",
"true",
")",
"\n",
"}"
] |
//used internally to create a NOT LIKE BooleanExpression
|
[
"used",
"internally",
"to",
"create",
"a",
"NOT",
"LIKE",
"BooleanExpression"
] |
6803bc2ea3462276f0e87814761a787d5537c4eb
|
https://github.com/doug-martin/goqu/blob/6803bc2ea3462276f0e87814761a787d5537c4eb/expressions.go#L980-L982
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.