_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24600 | RegisteredFor | train | func (r RuleSet) RegisteredFor(n ast.Node) []Rule {
if rules, found := r[reflect.TypeOf(n)]; found {
return rules
}
return []Rule{}
} | go | {
"resource": ""
} |
q24601 | MatchPatterns | train | func (s *sqlStatement) MatchPatterns(str string) bool {
for _, pattern := range s.patterns {
if !pattern.MatchString(str) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q24602 | checkObject | train | func (s *sqlStrConcat) checkObject(n *ast.Ident, c *gosec.Context) bool {
if n.Obj != nil {
return n.Obj.Kind != ast.Var && n.Obj.Kind != ast.Fun
}
// Try to resolve unresolved identifiers using other files in same package
for _, file := range c.PkgFiles {
if node, ok := file.Scope.Objects[n.String()]; ok {
... | go | {
"resource": ""
} |
q24603 | NewSQLStrConcat | train | func NewSQLStrConcat(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
return &sqlStrConcat{
sqlStatement: sqlStatement{
patterns: []*regexp.Regexp{
regexp.MustCompile(`(?)(SELECT|DELETE|INSERT|UPDATE|INTO|FROM|WHERE) `),
},
MetaData: gosec.MetaData{
ID: id,
Severity: gosec.Medi... | go | {
"resource": ""
} |
q24604 | NewSQLStrFormat | train | func NewSQLStrFormat(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
rule := &sqlStrFormat{
calls: gosec.NewCallList(),
noIssue: gosec.NewCallList(),
noIssueQuoted: gosec.NewCallList(),
sqlStatement: sqlStatement{
patterns: []*regexp.Regexp{
regexp.MustCompile("(?)(SELECT|DELETE|I... | go | {
"resource": ""
} |
q24605 | ReadFrom | train | func (c Config) ReadFrom(r io.Reader) (int64, error) {
data, err := ioutil.ReadAll(r)
if err != nil {
return int64(len(data)), err
}
if err = json.Unmarshal(data, &c); err != nil {
return int64(len(data)), err
}
return int64(len(data)), nil
} | go | {
"resource": ""
} |
q24606 | WriteTo | train | func (c Config) WriteTo(w io.Writer) (int64, error) {
data, err := json.Marshal(c)
if err != nil {
return int64(len(data)), err
}
return io.Copy(w, bytes.NewReader(data))
} | go | {
"resource": ""
} |
q24607 | Get | train | func (c Config) Get(section string) (interface{}, error) {
settings, found := c[section]
if !found {
return nil, fmt.Errorf("Section %s not in configuration", section)
}
return settings, nil
} | go | {
"resource": ""
} |
q24608 | GetGlobal | train | func (c Config) GetGlobal(option GlobalOption) (string, error) {
if globals, ok := c[Globals]; ok {
if settings, ok := globals.(map[GlobalOption]string); ok {
if value, ok := settings[option]; ok {
return value, nil
}
return "", fmt.Errorf("global setting for %s not found", option)
}
}
return "", fm... | go | {
"resource": ""
} |
q24609 | SetGlobal | train | func (c Config) SetGlobal(option GlobalOption, value string) {
if globals, ok := c[Globals]; ok {
if settings, ok := globals.(map[GlobalOption]string); ok {
settings[option] = value
}
}
} | go | {
"resource": ""
} |
q24610 | IsGlobalEnabled | train | func (c Config) IsGlobalEnabled(option GlobalOption) (bool, error) {
value, err := c.GetGlobal(option)
if err != nil {
return false, err
}
return (value == "true" || value == "enabled"), nil
} | go | {
"resource": ""
} |
q24611 | NewWeakRandCheck | train | func NewWeakRandCheck(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
return &weakRand{
funcNames: []string{"Read", "Int"},
packagePath: "math/rand",
MetaData: gosec.MetaData{
ID: id,
Severity: gosec.High,
Confidence: gosec.Medium,
What: "Use of weak random number generator... | go | {
"resource": ""
} |
q24612 | NewSSHHostKey | train | func NewSSHHostKey(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
return &sshHostKey{
pkg: "golang.org/x/crypto/ssh",
calls: []string{"InsecureIgnoreHostKey"},
MetaData: gosec.MetaData{
ID: id,
What: "Use of ssh InsecureIgnoreHostKey should be audited",
Severity: gosec.Medium... | go | {
"resource": ""
} |
q24613 | NewNoErrorCheck | train | func NewNoErrorCheck(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
// TODO(gm) Come up with sensible defaults here. Or flip it to use a
// black list instead.
whitelist := gosec.NewCallList()
whitelist.AddAll("bytes.Buffer", "Write", "WriteByte", "WriteRune", "WriteString")
whitelist.AddAll("fmt", "Prin... | go | {
"resource": ""
} |
q24614 | NewUsingBigExp | train | func NewUsingBigExp(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
return &usingBigExp{
pkg: "*math/big.Int",
calls: []string{"Exp"},
MetaData: gosec.MetaData{
ID: id,
What: "Use of math/big.Int.Exp function should be audited for modulus == 0",
Severity: gosec.Low,
Confide... | go | {
"resource": ""
} |
q24615 | Builders | train | func (rl RuleList) Builders() map[string]gosec.RuleBuilder {
builders := make(map[string]gosec.RuleBuilder)
for _, def := range rl {
builders[def.ID] = def.Create
}
return builders
} | go | {
"resource": ""
} |
q24616 | Generate | train | func Generate(filters ...RuleFilter) RuleList {
rules := []RuleDefinition{
// misc
{"G101", "Look for hardcoded credentials", NewHardcodedCredentials},
{"G102", "Bind to all interfaces", NewBindsToAllNetworkInterfaces},
{"G103", "Audit the use of unsafe block", NewUsingUnsafe},
{"G104", "Audit errors not che... | go | {
"resource": ""
} |
q24617 | NewError | train | func NewError(line, column int, err string) *Error {
return &Error{
Line: line,
Column: column,
Err: err,
}
} | go | {
"resource": ""
} |
q24618 | sortErrors | train | func sortErrors(allErrors map[string][]Error) {
for _, errors := range allErrors {
sort.Slice(errors, func(i, j int) bool {
if errors[i].Line == errors[j].Line {
return errors[i].Column <= errors[j].Column
}
return errors[i].Line < errors[j].Line
})
}
} | go | {
"resource": ""
} |
q24619 | NewBadTempFile | train | func NewBadTempFile(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
calls := gosec.NewCallList()
calls.Add("io/ioutil", "WriteFile")
calls.Add("os", "Create")
return &badTempFile{
calls: calls,
args: regexp.MustCompile(`^/tmp/.*$|^/var/tmp/.*$`),
MetaData: gosec.MetaData{
ID: id,
Sever... | go | {
"resource": ""
} |
q24620 | NewImportTracker | train | func NewImportTracker() *ImportTracker {
return &ImportTracker{
make(map[string]string),
make(map[string]string),
make(map[string]bool),
}
} | go | {
"resource": ""
} |
q24621 | TrackFile | train | func (t *ImportTracker) TrackFile(file *ast.File) {
for _, imp := range file.Imports {
path := strings.Trim(imp.Path.Value, `"`)
parts := strings.Split(path, "/")
if len(parts) > 0 {
name := parts[len(parts)-1]
t.Imported[path] = name
}
}
} | go | {
"resource": ""
} |
q24622 | TrackPackages | train | func (t *ImportTracker) TrackPackages(pkgs ...*types.Package) {
for _, pkg := range pkgs {
t.Imported[pkg.Path()] = pkg.Name()
}
} | go | {
"resource": ""
} |
q24623 | TrackImport | train | func (t *ImportTracker) TrackImport(n ast.Node) {
if imported, ok := n.(*ast.ImportSpec); ok {
path := strings.Trim(imported.Path.Value, `"`)
if imported.Name != nil {
if imported.Name.Name == "_" {
// Initialization only import
t.InitOnly[path] = true
} else {
// Aliased import
t.Aliased[pat... | go | {
"resource": ""
} |
q24624 | isJoinFunc | train | func (r *readfile) isJoinFunc(n ast.Node, c *gosec.Context) bool {
if call := r.pathJoin.ContainsCallExpr(n, c, false); call != nil {
for _, arg := range call.Args {
// edge case: check if one of the args is a BinaryExpr
if binExp, ok := arg.(*ast.BinaryExpr); ok {
// iterate and resolve all found identiti... | go | {
"resource": ""
} |
q24625 | Match | train | func (r *readfile) Match(n ast.Node, c *gosec.Context) (*gosec.Issue, error) {
if node := r.ContainsCallExpr(n, c, false); node != nil {
for _, arg := range node.Args {
// handles path joining functions in Arg
// eg. os.Open(filepath.Join("/tmp/", file))
if callExpr, ok := arg.(*ast.CallExpr); ok {
if r... | go | {
"resource": ""
} |
q24626 | NewReadFile | train | func NewReadFile(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
rule := &readfile{
pathJoin: gosec.NewCallList(),
CallList: gosec.NewCallList(),
MetaData: gosec.MetaData{
ID: id,
What: "Potential file inclusion via variable",
Severity: gosec.Medium,
Confidence: gosec.High,
... | go | {
"resource": ""
} |
q24627 | ResolveVar | train | func (r *ssrf) ResolveVar(n *ast.CallExpr, c *gosec.Context) bool {
if len(n.Args) > 0 {
arg := n.Args[0]
if ident, ok := arg.(*ast.Ident); ok {
obj := c.Info.ObjectOf(ident)
if _, ok := obj.(*types.Var); ok && !gosec.TryResolve(ident, c) {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q24628 | NewSSRFCheck | train | func NewSSRFCheck(id string, conf gosec.Config) (gosec.Rule, []ast.Node) {
rule := &ssrf{
CallList: gosec.NewCallList(),
MetaData: gosec.MetaData{
ID: id,
What: "Potential HTTP request made with variable url",
Severity: gosec.Medium,
Confidence: gosec.Medium,
},
}
rule.AddAll("net/h... | go | {
"resource": ""
} |
q24629 | TryResolve | train | func TryResolve(n ast.Node, c *Context) bool {
switch node := n.(type) {
case *ast.BasicLit:
return true
case *ast.CompositeLit:
return resolveCompLit(node, c)
case *ast.Ident:
return resolveIdent(node, c)
case *ast.AssignStmt:
return resolveAssign(node, c)
case *ast.CallExpr:
return resolveCallExpr... | go | {
"resource": ""
} |
q24630 | NewIssue | train | func NewIssue(ctx *Context, node ast.Node, ruleID, desc string, severity Score, confidence Score) *Issue {
var code string
fobj := ctx.FileSet.File(node.Pos())
name := fobj.Name()
start, end := fobj.Line(node.Pos()), fobj.Line(node.End())
line := strconv.Itoa(start)
if start != end {
line = fmt.Sprintf("%d-%d"... | go | {
"resource": ""
} |
q24631 | NewAnalyzer | train | func NewAnalyzer(conf Config, tests bool, logger *log.Logger) *Analyzer {
ignoreNoSec := false
if enabled, err := conf.IsGlobalEnabled(Nosec); err == nil {
ignoreNoSec = enabled
}
if logger == nil {
logger = log.New(os.Stderr, "[gosec]", log.LstdFlags)
}
return &Analyzer{
ignoreNosec: ignoreNoSec,
ruleset... | go | {
"resource": ""
} |
q24632 | LoadRules | train | func (gosec *Analyzer) LoadRules(ruleDefinitions map[string]RuleBuilder) {
for id, def := range ruleDefinitions {
r, nodes := def(id, gosec.config)
gosec.ruleset.Register(r, nodes...)
}
} | go | {
"resource": ""
} |
q24633 | Process | train | func (gosec *Analyzer) Process(buildTags []string, packagePaths ...string) error {
config := gosec.pkgConfig(buildTags)
for _, pkgPath := range packagePaths {
pkgs, err := gosec.load(pkgPath, config)
if err != nil {
gosec.AppendError(pkgPath, err)
}
for _, pkg := range pkgs {
if pkg.Name != "" {
err... | go | {
"resource": ""
} |
q24634 | ParseErrors | train | func (gosec *Analyzer) ParseErrors(pkg *packages.Package) error {
if len(pkg.Errors) == 0 {
return nil
}
for _, pkgErr := range pkg.Errors {
parts := strings.Split(pkgErr.Pos, ":")
file := parts[0]
var err error
var line int
if len(parts) > 1 {
if line, err = strconv.Atoi(parts[1]); err != nil {
r... | go | {
"resource": ""
} |
q24635 | AppendError | train | func (gosec *Analyzer) AppendError(file string, err error) {
// Do not report the error for empty packages (e.g. files excluded from build with a tag)
r := regexp.MustCompile(`no buildable Go source files in`)
if r.MatchString(err.Error()) {
return
}
errors := []Error{}
if ferrs, ok := gosec.errors[file]; ok {
... | go | {
"resource": ""
} |
q24636 | Visit | train | func (gosec *Analyzer) Visit(n ast.Node) ast.Visitor {
// If we've reached the end of this branch, pop off the ignores stack.
if n == nil {
if len(gosec.context.Ignores) > 0 {
gosec.context.Ignores = gosec.context.Ignores[1:]
}
return gosec
}
// Get any new rule exclusions.
ignoredRules, ignoreAll := gos... | go | {
"resource": ""
} |
q24637 | Report | train | func (gosec *Analyzer) Report() ([]*Issue, *Metrics, map[string][]Error) {
return gosec.issues, gosec.stats, gosec.errors
} | go | {
"resource": ""
} |
q24638 | Reset | train | func (gosec *Analyzer) Reset() {
gosec.context = &Context{}
gosec.issues = make([]*Issue, 0, 16)
gosec.stats = &Metrics{}
} | go | {
"resource": ""
} |
q24639 | Proxies | train | func (client *Client) Proxies() (map[string]*Proxy, error) {
resp, err := http.Get(client.endpoint + "/proxies")
if err != nil {
return nil, err
}
err = checkError(resp, http.StatusOK, "Proxies")
if err != nil {
return nil, err
}
proxies := make(map[string]*Proxy)
err = json.NewDecoder(resp.Body).Decode(&... | go | {
"resource": ""
} |
q24640 | Proxy | train | func (client *Client) Proxy(name string) (*Proxy, error) {
// TODO url encode
resp, err := http.Get(client.endpoint + "/proxies/" + name)
if err != nil {
return nil, err
}
err = checkError(resp, http.StatusOK, "Proxy")
if err != nil {
return nil, err
}
proxy := new(Proxy)
err = json.NewDecoder(resp.Body)... | go | {
"resource": ""
} |
q24641 | Populate | train | func (client *Client) Populate(config []Proxy) ([]*Proxy, error) {
proxies := struct {
Proxies []*Proxy `json:"proxies"`
}{}
request, err := json.Marshal(config)
if err != nil {
return nil, err
}
resp, err := http.Post(client.endpoint+"/populate", "application/json", bytes.NewReader(request))
if err != nil ... | go | {
"resource": ""
} |
q24642 | Save | train | func (proxy *Proxy) Save() error {
request, err := json.Marshal(proxy)
if err != nil {
return err
}
var resp *http.Response
if proxy.created {
resp, err = http.Post(proxy.client.endpoint+"/proxies/"+proxy.Name, "text/plain", bytes.NewReader(request))
} else {
resp, err = http.Post(proxy.client.endpoint+"/p... | go | {
"resource": ""
} |
q24643 | Toxics | train | func (proxy *Proxy) Toxics() (Toxics, error) {
resp, err := http.Get(proxy.client.endpoint + "/proxies/" + proxy.Name + "/toxics")
if err != nil {
return nil, err
}
err = checkError(resp, http.StatusOK, "Toxics")
if err != nil {
return nil, err
}
toxics := make(Toxics, 0)
err = json.NewDecoder(resp.Body).... | go | {
"resource": ""
} |
q24644 | ResetState | train | func (client *Client) ResetState() error {
resp, err := http.Post(client.endpoint+"/reset", "text/plain", bytes.NewReader([]byte{}))
if err != nil {
return err
}
return checkError(resp, http.StatusNoContent, "ResetState")
} | go | {
"resource": ""
} |
q24645 | Start | train | func (link *ToxicLink) Start(name string, source io.Reader, dest io.WriteCloser) {
go func() {
bytes, err := io.Copy(link.input, source)
if err != nil {
logrus.WithFields(logrus.Fields{
"name": link.proxy.Name,
"bytes": bytes,
"err": err,
}).Warn("Source terminated")
}
link.input.Close()
... | go | {
"resource": ""
} |
q24646 | AddToxic | train | func (link *ToxicLink) AddToxic(toxic *toxics.ToxicWrapper) {
i := len(link.stubs)
newin := make(chan *stream.StreamChunk, toxic.BufferSize)
link.stubs = append(link.stubs, toxics.NewToxicStub(newin, link.stubs[i-1].Output))
// Interrupt the last toxic so that we don't have a race when moving channels
if link.st... | go | {
"resource": ""
} |
q24647 | UpdateToxic | train | func (link *ToxicLink) UpdateToxic(toxic *toxics.ToxicWrapper) {
if link.stubs[toxic.Index].InterruptToxic() {
go link.stubs[toxic.Index].Run(toxic)
}
} | go | {
"resource": ""
} |
q24648 | RemoveToxic | train | func (link *ToxicLink) RemoveToxic(toxic *toxics.ToxicWrapper) {
i := toxic.Index
if link.stubs[i].InterruptToxic() {
cleanup, ok := toxic.Toxic.(toxics.CleanupToxic)
if ok {
cleanup.Cleanup(link.stubs[i])
// Cleanup could have closed the stub.
if link.stubs[i].Closed() {
return
}
}
stop := ... | go | {
"resource": ""
} |
q24649 | Run | train | func (s *ToxicStub) Run(toxic *ToxicWrapper) {
s.running = make(chan struct{})
defer close(s.running)
if rand.Float32() < toxic.Toxicity {
toxic.Pipe(s)
} else {
new(NoopToxic).Pipe(s)
}
} | go | {
"resource": ""
} |
q24650 | InterruptToxic | train | func (s *ToxicStub) InterruptToxic() bool {
select {
case <-s.closed:
return false
case s.Interrupt <- struct{}{}:
<-s.running // Wait for the running toxic to exit
return true
}
} | go | {
"resource": ""
} |
q24651 | findToxicByName | train | func (c *ToxicCollection) findToxicByName(name string) *toxics.ToxicWrapper {
for dir := range c.chain {
for i, toxic := range c.chain[dir] {
if i == 0 {
// Skip the first noop toxic, it has no name
continue
}
if toxic.Name == name {
return toxic
}
}
}
return nil
} | go | {
"resource": ""
} |
q24652 | server | train | func (proxy *Proxy) server() {
ln, err := net.Listen("tcp", proxy.Listen)
if err != nil {
proxy.started <- err
return
}
proxy.Listen = ln.Addr().String()
proxy.started <- nil
logrus.WithFields(logrus.Fields{
"name": proxy.Name,
"proxy": proxy.Listen,
"upstream": proxy.Upstream,
}).Info("Starte... | go | {
"resource": ""
} |
q24653 | start | train | func start(proxy *Proxy) error {
if proxy.Enabled {
return ErrProxyAlreadyStarted
}
proxy.tomb = tomb.Tomb{} // Reset tomb, from previous starts/stops
go proxy.server()
err := <-proxy.started
// Only enable the proxy if it successfully started
proxy.Enabled = err == nil
return err
} | go | {
"resource": ""
} |
q24654 | stop | train | func stop(proxy *Proxy) {
if !proxy.Enabled {
return
}
proxy.Enabled = false
proxy.tomb.Killf("Shutting down from stop()")
proxy.tomb.Wait() // Wait until we stop accepting new connections
proxy.connections.Lock()
defer proxy.connections.Unlock()
for _, conn := range proxy.connections.list {
conn.Close()
... | go | {
"resource": ""
} |
q24655 | Parse | train | func (p *Parser) Parse(srcPath string, files []models.Path) (*Result, error) {
b, err := p.readFile(srcPath)
if err != nil {
return nil, err
}
fset := token.NewFileSet()
f, err := p.parseFile(fset, srcPath)
if err != nil {
return nil, err
}
fs, err := p.parseFiles(fset, f, files)
if err != nil {
return n... | go | {
"resource": ""
} |
q24656 | goCode | train | func goCode(b []byte, f *ast.File) []byte {
furthestPos := f.Name.End()
for _, node := range f.Imports {
if pos := node.End(); pos > furthestPos {
furthestPos = pos
}
}
if furthestPos < token.Pos(len(b)) {
furthestPos++
// Avoid wrong output on windows-encoded files
if b[furthestPos-2] == '\r' && b[fu... | go | {
"resource": ""
} |
q24657 | Files | train | func Files(srcPath string) ([]models.Path, error) {
srcPath, err := filepath.Abs(srcPath)
if err != nil {
return nil, fmt.Errorf("filepath.Abs: %v\n", err)
}
var fi os.FileInfo
if fi, err = os.Stat(srcPath); err != nil {
return nil, fmt.Errorf("os.Stat: %v\n", err)
}
if fi.IsDir() {
return dirFiles(srcPath... | go | {
"resource": ""
} |
q24658 | LoadCustomTemplates | train | func LoadCustomTemplates(dir string) error {
initEmptyTmpls()
files, err := ioutil.ReadDir(dir)
if err != nil {
return fmt.Errorf("ioutil.ReadDir: %v", err)
}
templateFiles := []string{}
for _, f := range files {
templateFiles = append(templateFiles, path.Join(dir, f.Name()))
}
tmpls, err = tmpls.ParseFil... | go | {
"resource": ""
} |
q24659 | FSByte | train | func FSByte(useLocal bool, name string) ([]byte, error) {
if useLocal {
f, err := _escLocal.Open(name)
if err != nil {
return nil, err
}
b, err := ioutil.ReadAll(f)
_ = f.Close()
return b, err
}
f, err := _escStatic.prepare(name)
if err != nil {
return nil, err
}
return f.data, nil
} | go | {
"resource": ""
} |
q24660 | FSMustByte | train | func FSMustByte(useLocal bool, name string) []byte {
b, err := FSByte(useLocal, name)
if err != nil {
panic(err)
}
return b
} | go | {
"resource": ""
} |
q24661 | FSString | train | func FSString(useLocal bool, name string) (string, error) {
b, err := FSByte(useLocal, name)
return string(b), err
} | go | {
"resource": ""
} |
q24662 | FSMustString | train | func FSMustString(useLocal bool, name string) string {
return string(FSMustByte(useLocal, name))
} | go | {
"resource": ""
} |
q24663 | NewParsedV4EventReader | train | func NewParsedV4EventReader(
reader EventReader,
parsers V4EventParserMap) EventReader {
return &parsedV4EventReader{
reader: reader,
eventParsers: parsers,
}
} | go | {
"resource": ""
} |
q24664 | NewWriterToReaderAdapter | train | func NewWriterToReaderAdapter(toBeAdapted func(io.Reader) (io.Reader, error),
output io.Writer,
shouldCloseDownstream bool) io.WriteCloser {
retval := privateReaderAdapter{
Writer: WriterToReaderAdapter{
workChan: make(chan *[]byte),
doneWorkChan: make(chan *[]byte),
errChan: make(chan error, 3),... | go | {
"resource": ""
} |
q24665 | Read | train | func (rself *privateReaderAdapter) Read(data []byte) (int, error) {
lenToCopy := len(rself.bufferToBeRead)
if lenToCopy == 0 {
rself.workReceipt = <-rself.Writer.workChan
if rself.workReceipt == nil {
// no more data to consume
rself.closeReceived = true
return 0, io.EOF
}
rself.bufferToBeRead = *rse... | go | {
"resource": ""
} |
q24666 | copyDataToOutput | train | func copyDataToOutput(inputFactory func(io.Reader) (io.Reader, error),
adaptedInput *privateReaderAdapter,
output io.Writer,
shouldCloseDownstream bool) {
input, err := inputFactory(adaptedInput)
if err != nil {
adaptedInput.Writer.errChan <- err
} else {
_, err = io.Copy(output, input)
if err != nil {
... | go | {
"resource": ""
} |
q24667 | NewGenericStorage | train | func NewGenericStorage(name string, options GenericStorageOptions) Storage {
return &GenericStorage{
name: name,
get: options.GetFunc,
getMulti: options.GetMultiFunc,
set: options.SetFunc,
setMulti: options.SetMultiFunc,
del: options.DelFunc,
delMulti: optio... | go | {
"resource": ""
} |
q24668 | Union | train | func Union(s1 Set, s2 Set) Set {
if s1 == nil {
if s2 == nil {
return nil
}
return s2.Copy()
}
s3 := s1.Copy()
s3.Union(s2)
return s3
} | go | {
"resource": ""
} |
q24669 | Intersect | train | func Intersect(s1 Set, s2 Set) Set {
if s1 == nil {
if s2 == nil {
return nil
}
return s2.New()
}
s3 := s1.Copy()
s3.Intersect(s2)
return s3
} | go | {
"resource": ""
} |
q24670 | Subtract | train | func Subtract(s1 Set, s2 Set) Set {
if s1 == nil {
if s2 == nil {
return nil
}
return s2.New()
}
s3 := s1.Copy()
s3.Subtract(s2)
return s3
} | go | {
"resource": ""
} |
q24671 | equal | train | func equal(s Set, s2 Set) bool {
if s.Len() != s2.Len() {
return false
}
return s.IsSubset(s2)
} | go | {
"resource": ""
} |
q24672 | NewRawBinaryClient | train | func NewRawBinaryClient(shard int, channel io.ReadWriter) ClientShard {
return &RawBinaryClient{
shard: shard,
channel: channel,
validState: true,
maxValueLength: defaultMaxValueLength,
}
} | go | {
"resource": ""
} |
q24673 | NewLargeRawBinaryClient | train | func NewLargeRawBinaryClient(shard int, channel io.ReadWriter) ClientShard {
return &RawBinaryClient{
shard: shard,
channel: channel,
validState: true,
maxValueLength: largeMaxValueLength,
}
} | go | {
"resource": ""
} |
q24674 | mutate | train | func (c *RawBinaryClient) mutate(code opCode, item *Item) MutateResponse {
if item == nil {
return NewMutateErrorResponse("", errors.New("item is nil"))
}
c.mutex.Lock()
defer c.mutex.Unlock()
if resp := c.sendMutateRequest(code, item, true); resp != nil {
return resp
}
return c.receiveMutateResponse(code... | go | {
"resource": ""
} |
q24675 | MaxQuota | train | func (l *rateLimiterImpl) MaxQuota() float64 {
l.mutex.Lock()
defer l.mutex.Unlock()
return l.maxQuota
} | go | {
"resource": ""
} |
q24676 | SetMaxQuota | train | func (l *rateLimiterImpl) SetMaxQuota(q float64) error {
if q < 0 {
return errors.Newf("Max quota must be non-negative: %f", q)
}
l.mutex.Lock()
defer l.mutex.Unlock()
l.maxQuota = q
if l.quota > q {
l.quota = q
}
if l.maxQuota == 0 {
l.cond.Broadcast()
}
return nil
} | go | {
"resource": ""
} |
q24677 | QuotaPerSec | train | func (l *rateLimiterImpl) QuotaPerSec() float64 {
l.mutex.Lock()
defer l.mutex.Unlock()
return l.quotaPerSec
} | go | {
"resource": ""
} |
q24678 | SetQuotaPerSec | train | func (l *rateLimiterImpl) SetQuotaPerSec(r float64) error {
if r < 0 {
return errors.Newf("Quota per second must be non-negative: %f", r)
}
l.mutex.Lock()
defer l.mutex.Unlock()
l.quotaPerSec = r
return nil
} | go | {
"resource": ""
} |
q24679 | Quota | train | func (l *rateLimiterImpl) Quota() float64 {
l.mutex.Lock()
defer l.mutex.Unlock()
return l.quota
} | go | {
"resource": ""
} |
q24680 | setQuota | train | func (l *rateLimiterImpl) setQuota(q float64) {
l.mutex.Lock()
defer l.mutex.Unlock()
l.quota = q
} | go | {
"resource": ""
} |
q24681 | Stop | train | func (l *rateLimiterImpl) Stop() {
l.mutex.Lock()
defer l.mutex.Unlock()
if l.stopped {
return
}
l.stopped = true
close(l.stopChan)
l.ticker.Stop()
l.cond.Broadcast()
} | go | {
"resource": ""
} |
q24682 | Write | train | func (sbself *splitBufferedWriter) Write(data []byte) (int, error) {
toCopy := len(sbself.userBuffer) - sbself.userBufferCount
if toCopy > len(data) {
toCopy = len(data)
}
copy(sbself.userBuffer[sbself.userBufferCount:sbself.userBufferCount+toCopy], data[:toCopy])
sbself.userBufferCount += toCopy
if toCopy < le... | go | {
"resource": ""
} |
q24683 | RemoveUserBuffer | train | func (sbself *splitBufferedWriter) RemoveUserBuffer() (amountReturned int, err error) {
if len(sbself.userBuffer) > sbself.userBufferCount {
if len(sbself.remainder.Bytes()) != 0 {
err = errors.New("remainder must be clear if userBuffer isn't full")
panic(err)
}
}
amountReturned = sbself.userBufferCount
s... | go | {
"resource": ""
} |
q24684 | InstallNewUserBufferAndResetRemainder | train | func (sbself *splitBufferedWriter) InstallNewUserBufferAndResetRemainder(
data []byte) {
sbself.remainder.Reset()
sbself.userBuffer = data
sbself.userBufferCount = 0
} | go | {
"resource": ""
} |
q24685 | Read | train | func (rwaself *ReaderToWriterAdapter) Read(data []byte) (int, error) {
lenToCopy := len(rwaself.writeBuffer.Bytes()) - rwaself.offset
if lenToCopy > 0 {
// if we have leftover data from a previous call, we can return that only
if lenToCopy > len(data) {
lenToCopy = len(data)
}
copy(data[:lenToCopy],
rwa... | go | {
"resource": ""
} |
q24686 | Close | train | func (rwaself *ReaderToWriterAdapter) Close() error {
var wCloseErr error
var rCloseErr error
if writeCloser, ok := rwaself.writer.(io.WriteCloser); ok {
if !rwaself.closedWriter {
wCloseErr = writeCloser.Close()
}
}
if readCloser, ok := rwaself.upstream.(io.ReadCloser); ok {
rCloseErr = readCloser.Close(... | go | {
"resource": ""
} |
q24687 | NewGzipResponseWriter | train | func NewGzipResponseWriter(writer http.ResponseWriter, compressionLevel int) gzipResponseWriter {
gzWriter, _ := gzip.NewWriterLevel(writer, compressionLevel)
return gzipResponseWriter{ResponseWriter: writer, gzWriter: gzWriter}
} | go | {
"resource": ""
} |
q24688 | TryRLock | train | func (f *FileLock) TryRLock() error {
return f.performLock(syscall.LOCK_SH | syscall.LOCK_NB)
} | go | {
"resource": ""
} |
q24689 | TryLock | train | func (f *FileLock) TryLock() error {
return f.performLock(syscall.LOCK_EX | syscall.LOCK_NB)
} | go | {
"resource": ""
} |
q24690 | DateTimeColumn | train | func DateTimeColumn(name string, nullable NullableColumn) NonAliasColumn {
if !validIdentifierName(name) {
panic("Invalid column name in datetime column")
}
dc := &dateTimeColumn{}
dc.name = name
dc.nullable = nullable
return dc
} | go | {
"resource": ""
} |
q24691 | IntColumn | train | func IntColumn(name string, nullable NullableColumn) NonAliasColumn {
if !validIdentifierName(name) {
panic("Invalid column name in int column")
}
ic := &integerColumn{}
ic.name = name
ic.nullable = nullable
return ic
} | go | {
"resource": ""
} |
q24692 | DoubleColumn | train | func DoubleColumn(name string, nullable NullableColumn) NonAliasColumn {
if !validIdentifierName(name) {
panic("Invalid column name in int column")
}
ic := &doubleColumn{}
ic.name = name
ic.nullable = nullable
return ic
} | go | {
"resource": ""
} |
q24693 | BoolColumn | train | func BoolColumn(name string, nullable NullableColumn) NonAliasColumn {
if !validIdentifierName(name) {
panic("Invalid column name in bool column")
}
bc := &booleanColumn{}
bc.name = name
bc.nullable = nullable
return bc
} | go | {
"resource": ""
} |
q24694 | NewManagedHandle | train | func NewManagedHandle(
resourceLocation string,
handle interface{},
pool ResourcePool,
options Options) ManagedHandle {
h := &managedHandleImpl{
location: resourceLocation,
handle: handle,
pool: pool,
options: options,
}
atomic.StoreInt32(&h.isActive, 1)
return h
} | go | {
"resource": ""
} |
q24695 | NewStaticShardManager | train | func NewStaticShardManager(
serverAddrs []string,
shardFunc func(key string, numShard int) (shard int),
options net2.ConnectionOptions) ShardManager {
manager := &StaticShardManager{}
manager.Init(
shardFunc,
func(err error) { log.Print(err) },
log.Print,
options)
shardStates := make([]ShardState, len(s... | go | {
"resource": ""
} |
q24696 | NewLookAheadBuffer | train | func NewLookAheadBuffer(src io.Reader, bufferSize int) *LookAheadBuffer {
return NewLookAheadBufferUsing(src, make([]byte, bufferSize, bufferSize))
} | go | {
"resource": ""
} |
q24697 | NewLookAheadBufferUsing | train | func NewLookAheadBufferUsing(src io.Reader, rawBuffer []byte) *LookAheadBuffer {
return &LookAheadBuffer{
src: src,
buffer: rawBuffer,
bytesBuffered: 0,
}
} | go | {
"resource": ""
} |
q24698 | ConsumeAll | train | func (b *LookAheadBuffer) ConsumeAll() {
err := b.Consume(b.bytesBuffered)
if err != nil { // This should never happen
panic(err)
}
} | go | {
"resource": ""
} |
q24699 | IsModeEnabled | train | func (e *QueryEvent) IsModeEnabled(mode mysql_proto.SqlMode_BitPosition) bool {
if e.sqlMode == nil {
return false
}
return (*e.sqlMode & (uint64(1) << uint(mode))) != 0
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.