_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q18400 | GetAlert | train | func (c *Client) GetAlert(ctx context.Context, id string) (*Alert, error) {
var alert Alert
path := fmt.Sprintf(alertInfoPath, id)
req, err := c.NewRequest("GET", path, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &alert); err != nil {
return nil, err
}
return &alert, err
} | go | {
"resource": ""
} |
q18401 | DeleteAlert | train | func (c *Client) DeleteAlert(ctx context.Context, id string) (bool, error) {
path := fmt.Sprintf(alertDeletePath, id)
req, err := c.NewRequest("DELETE", path, nil, nil)
if err != nil {
return false, err
}
if err := c.Do(ctx, req, nil); err != nil {
return false, err
}
return true, nil
} | go | {
"resource": ""
} |
q18402 | GetAccountProfile | train | func (c *Client) GetAccountProfile(ctx context.Context) (*Profile, error) {
var profile Profile
req, err := c.NewRequest("GET", profilePath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &profile); err != nil {
return nil, err
}
return &profile, err
} | go | {
"resource": ""
} |
q18403 | GetServicesForHost | train | func (c *Client) GetServicesForHost(ctx context.Context, ip string, options *HostServicesOptions) (*Host, error) {
var host Host
req, err := c.NewRequest("GET", hostPath+"/"+ip, options, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &host); err != nil {
return nil, err
}
return &host, nil
} | go | {
"resource": ""
} |
q18404 | BreakQueryIntoTokens | train | func (c *Client) BreakQueryIntoTokens(ctx context.Context, query string) (*HostQueryTokens, error) {
var tokens HostQueryTokens
options := struct {
Query string `url:"query"`
}{Query: query}
req, err := c.NewRequest("GET", hostSearchTokensPath, options, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &tokens); err != nil {
return nil, err
}
return &tokens, nil
} | go | {
"resource": ""
} |
q18405 | GetProtocols | train | func (c *Client) GetProtocols(ctx context.Context) (map[string]string, error) {
var protocols map[string]string
req, err := c.NewRequest("GET", protocolsPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &protocols); err != nil {
return nil, err
}
return protocols, err
} | go | {
"resource": ""
} |
q18406 | NewClient | train | func NewClient(client *http.Client, token string) *Client {
if client == nil {
client = http.DefaultClient
}
return &Client{
Token: token,
BaseURL: baseURL,
ExploitBaseURL: exploitBaseURL,
StreamBaseURL: streamBaseURL,
Client: client,
m: &sync.Mutex{},
}
} | go | {
"resource": ""
} |
q18407 | SetDebug | train | func (c *Client) SetDebug(debug bool) {
c.m.Lock()
defer c.m.Unlock()
c.Debug = debug
} | go | {
"resource": ""
} |
q18408 | NewExploitRequest | train | func (c *Client) NewExploitRequest(method string, path string, params interface{}, body io.Reader) (*http.Request, error) {
u, err := url.Parse(c.ExploitBaseURL + path)
if err != nil {
return nil, err
}
return c.newRequest(method, u, params, body)
} | go | {
"resource": ""
} |
q18409 | GetDNSResolve | train | func (c *Client) GetDNSResolve(ctx context.Context, hostnames []string) (map[string]*net.IP, error) {
dnsResolved := make(map[string]*net.IP)
params := struct {
Hostnames string `url:"hostnames"`
}{strings.Join(hostnames, ",")}
req, err := c.NewRequest("GET", resolvePath, params, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &dnsResolved); err != nil {
return nil, err
}
return dnsResolved, nil
} | go | {
"resource": ""
} |
q18410 | GetDNSReverse | train | func (c *Client) GetDNSReverse(ctx context.Context, ip []net.IP) (map[string]*[]string, error) {
ips := make([]string, 0)
for _, ipAddress := range ip {
ips = append(ips, ipAddress.String())
}
dnsReversed := make(map[string]*[]string)
params := struct {
IP string `url:"ips"`
}{strings.Join(ips, ",")}
req, err := c.NewRequest("GET", reversePath, params, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &dnsReversed); err != nil {
return nil, err
}
return dnsReversed, nil
} | go | {
"resource": ""
} |
q18411 | ScanInternet | train | func (c *Client) ScanInternet(ctx context.Context, port int, protocol string) (string, error) {
crawlScanInternetStatus := new(struct {
ID string `json:"id"`
})
body := neturl.Values{}
body.Add("port", strconv.Itoa(port))
body.Add("protocol", protocol)
req, err := c.NewRequest("POST", scanInternetPath, nil, strings.NewReader(body.Encode()))
if err != nil {
return "", err
}
if err := c.Do(ctx, req, crawlScanInternetStatus); err != nil {
return "", err
}
return crawlScanInternetStatus.ID, nil
} | go | {
"resource": ""
} |
q18412 | GetScanStatus | train | func (c *Client) GetScanStatus(ctx context.Context, id string) (*ScanStatus, error) {
var scanStatus ScanStatus
path := fmt.Sprintf(scanStatusPath, id)
req, err := c.NewRequest("GET", path, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &scanStatus); err != nil {
return nil, err
}
return &scanStatus, nil
} | go | {
"resource": ""
} |
q18413 | UnmarshalJSON | train | func (v *IntString) UnmarshalJSON(b []byte) error {
var s string
if err := json.Unmarshal(b, &s); err == nil {
*v = IntString(s)
return nil
}
var n int
if err := json.Unmarshal(b, &n); err != nil {
return err
}
*v = IntString(strconv.Itoa(n))
return nil
} | go | {
"resource": ""
} |
q18414 | GetAPIInfo | train | func (c *Client) GetAPIInfo(ctx context.Context) (*APIInfo, error) {
var apiInfo APIInfo
req, err := c.NewRequest("GET", infoPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &apiInfo); err != nil {
return nil, err
}
return &apiInfo, nil
} | go | {
"resource": ""
} |
q18415 | GetMyIP | train | func (c *Client) GetMyIP(ctx context.Context) (net.IP, error) {
var ip bytes.Buffer
req, err := c.NewRequest("GET", ipPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &ip); err != nil {
return nil, err
}
return net.ParseIP(strings.Trim(ip.String(), "\"")), nil
} | go | {
"resource": ""
} |
q18416 | GetHTTPHeaders | train | func (c *Client) GetHTTPHeaders(ctx context.Context) (map[string]string, error) {
var headers map[string]string
req, err := c.NewRequest("GET", headersPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &headers); err != nil {
return nil, err
}
return headers, nil
} | go | {
"resource": ""
} |
q18417 | GetServices | train | func (c *Client) GetServices(ctx context.Context) (map[string]string, error) {
var services map[string]string
req, err := c.NewRequest("GET", servicesPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &services); err != nil {
return nil, err
}
return services, err
} | go | {
"resource": ""
} |
q18418 | NewStreamingRequest | train | func (c *Client) NewStreamingRequest(path string, params interface{}) (*http.Request, error) {
u, err := url.Parse(c.StreamBaseURL + path)
if err != nil {
return nil, err
}
return c.newRequest("GET", u, params, nil)
} | go | {
"resource": ""
} |
q18419 | DoStream | train | func (c *Client) DoStream(ctx context.Context, req *http.Request) (*http.Response, error) {
resp, err := c.do(ctx, req)
if err != nil {
return nil, err
}
if resp.StatusCode != http.StatusOK {
resp.Body.Close()
return nil, getErrorFromResponse(resp)
}
return resp, nil
} | go | {
"resource": ""
} |
q18420 | startStreaming | train | func (c *Client) startStreaming(ctx context.Context, path string) (*http.Response, error) {
req, err := c.NewStreamingRequest(path, nil)
if err != nil {
return nil, err
}
resp, err := c.DoStream(ctx, req)
if err != nil {
return nil, err
}
return resp, nil
} | go | {
"resource": ""
} |
q18421 | GetBannersByASN | train | func (c *Client) GetBannersByASN(ctx context.Context, asn []string, ch chan *HostData) error {
path := fmt.Sprintf(bannersASNPath, strings.Join(asn, ","))
resp, err := c.startStreaming(ctx, path)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | go | {
"resource": ""
} |
q18422 | GetBannersByCountries | train | func (c *Client) GetBannersByCountries(ctx context.Context, countries []string, ch chan *HostData) error {
strCountries := make([]string, 0)
for _, country := range countries {
strCountries = append(strCountries, strings.ToUpper(country))
}
path := fmt.Sprintf(bannersCountryPath, strings.Join(strCountries, ","))
resp, err := c.startStreaming(ctx, path)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | go | {
"resource": ""
} |
q18423 | GetBannersByPorts | train | func (c *Client) GetBannersByPorts(ctx context.Context, ports []int, ch chan *HostData) error {
strPorts := make([]string, 0)
for _, port := range ports {
strPorts = append(strPorts, strconv.Itoa(port))
}
path := fmt.Sprintf(bannersPortsPath, strings.Join(strPorts, ","))
resp, err := c.startStreaming(ctx, path)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | go | {
"resource": ""
} |
q18424 | GetBannersByAlert | train | func (c *Client) GetBannersByAlert(ctx context.Context, id string, ch chan *HostData) error {
path := fmt.Sprintf(bannersAlertPath, id)
resp, err := c.startStreaming(ctx, path)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | go | {
"resource": ""
} |
q18425 | GetBannersByAlerts | train | func (c *Client) GetBannersByAlerts(ctx context.Context, ch chan *HostData) error {
resp, err := c.startStreaming(ctx, bannersAlertsPath)
if err != nil {
return err
}
go c.handleResponseStream(resp, ch)
return nil
} | go | {
"resource": ""
} |
q18426 | GetPorts | train | func (c *Client) GetPorts(ctx context.Context) ([]int, error) {
var ports []int
req, err := c.NewRequest("GET", portsPath, nil, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &ports); err != nil {
return nil, err
}
return ports, nil
} | go | {
"resource": ""
} |
q18427 | SearchExploits | train | func (c *Client) SearchExploits(ctx context.Context, options *ExploitSearchOptions) (*ExploitSearch, error) {
if options == nil || options.Query == "" {
return nil, ErrInvalidQuery
}
req, err := c.NewExploitRequest("GET", exploitSearchPath, options, nil)
if err != nil {
return nil, err
}
var found ExploitSearch
if err := c.Do(ctx, req, &found); err != nil {
return nil, err
}
return &found, nil
} | go | {
"resource": ""
} |
q18428 | GetQueryTags | train | func (c *Client) GetQueryTags(ctx context.Context, options *QueryTagsOptions) (*QueryTags, error) {
var queryTags QueryTags
req, err := c.NewRequest("GET", queryTagsPath, options, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &queryTags); err != nil {
return nil, err
}
return &queryTags, nil
} | go | {
"resource": ""
} |
q18429 | GetQueries | train | func (c *Client) GetQueries(ctx context.Context, options *QueryOptions) (*QuerySearch, error) {
var querySearch QuerySearch
req, err := c.NewRequest("GET", queryPath, options, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &querySearch); err != nil {
return nil, err
}
return &querySearch, nil
} | go | {
"resource": ""
} |
q18430 | SearchQueries | train | func (c *Client) SearchQueries(ctx context.Context, options *SearchQueryOptions) (*QuerySearch, error) {
if options == nil || options.Query == "" {
return nil, ErrInvalidQuery
}
var querySearch QuerySearch
req, err := c.NewRequest("GET", querySearchPath, options, nil)
if err != nil {
return nil, err
}
if err := c.Do(ctx, req, &querySearch); err != nil {
return nil, err
}
return &querySearch, nil
} | go | {
"resource": ""
} |
q18431 | NewWatcher | train | func NewWatcher() *Watcher {
w := &Watcher{
pins: make(map[uintptr]Pin),
fds: fdHeap{},
cmdChan: make(chan watcherCmd, watcherCmdChanLen),
Notification: make(chan WatcherNotification, notificationLen),
}
heap.Init(&w.fds)
go w.watch()
return w
} | go | {
"resource": ""
} |
q18432 | removePin | train | func (w *Watcher) removePin(p Pin) {
// we don't index by pin, so go looking
for fd, pin := range w.pins {
if pin.Number == p.Number {
// found pin
w.removeFd(fd)
return
}
}
} | go | {
"resource": ""
} |
q18433 | AddPin | train | func (w *Watcher) AddPin(p uint) {
w.AddPinWithEdgeAndLogic(p, EdgeBoth, ActiveHigh)
} | go | {
"resource": ""
} |
q18434 | AddPinWithEdgeAndLogic | train | func (w *Watcher) AddPinWithEdgeAndLogic(p uint, edge Edge, logicLevel LogicLevel) {
pin := NewInput(p)
setLogicLevel(pin, logicLevel)
setEdgeTrigger(pin, edge)
w.cmdChan <- watcherCmd{
pin: pin,
action: watcherAdd,
}
} | go | {
"resource": ""
} |
q18435 | RemovePin | train | func (w *Watcher) RemovePin(p uint) {
pin := Pin{
Number: p,
}
w.cmdChan <- watcherCmd{
pin: pin,
action: watcherRemove,
}
} | go | {
"resource": ""
} |
q18436 | Close | train | func (w *Watcher) Close() {
w.cmdChan <- watcherCmd{
pin: Pin{},
action: watcherClose,
}
} | go | {
"resource": ""
} |
q18437 | NewInput | train | func NewInput(p uint) Pin {
pin := Pin{
Number: p,
}
exportGPIO(pin)
time.Sleep(10 * time.Millisecond)
pin.direction = inDirection
setDirection(pin, inDirection, 0)
pin = openPin(pin, false)
return pin
} | go | {
"resource": ""
} |
q18438 | Read | train | func (p Pin) Read() (value uint, err error) {
if p.direction != inDirection {
return 0, errors.New("pin is not configured for input")
}
return readPin(p)
} | go | {
"resource": ""
} |
q18439 | High | train | func (p Pin) High() error {
if p.direction != outDirection {
return errors.New("pin is not configured for output")
}
return writePin(p, 1)
} | go | {
"resource": ""
} |
q18440 | Go | train | func Go() {
host, err := os.Hostname()
if err != nil {
host = "localhost"
}
username := "nobody"
user, err := user.Current()
if err == nil && user != nil && len(user.Username) > 0 {
username = user.Username
}
fromAddr := username + "@" + host
smtpAddr := "localhost:1025"
var recip []string
// defaults from envars if provided
if len(os.Getenv("MH_SENDMAIL_SMTP_ADDR")) > 0 {
smtpAddr = os.Getenv("MH_SENDMAIL_SMTP_ADDR")
}
if len(os.Getenv("MH_SENDMAIL_FROM")) > 0 {
fromAddr = os.Getenv("MH_SENDMAIL_FROM")
}
var verbose bool
// override defaults from cli flags
flag.StringVar(&smtpAddr, "smtp-addr", smtpAddr, "SMTP server address")
flag.StringVarP(&fromAddr, "from", "f", fromAddr, "SMTP sender")
flag.BoolP("long-i", "i", true, "Ignored. This flag exists for sendmail compatibility.")
flag.BoolP("long-o", "o", true, "Ignored. This flag exists for sendmail compatibility.")
flag.BoolP("long-t", "t", true, "Ignored. This flag exists for sendmail compatibility.")
flag.BoolVarP(&verbose, "verbose", "v", false, "Verbose mode (sends debug output to stderr)")
flag.Parse()
// allow recipient to be passed as an argument
recip = flag.Args()
if verbose {
fmt.Fprintln(os.Stderr, smtpAddr, fromAddr)
}
body, err := ioutil.ReadAll(os.Stdin)
if err != nil {
fmt.Fprintln(os.Stderr, "error reading stdin")
os.Exit(11)
}
msg, err := mail.ReadMessage(bytes.NewReader(body))
if err != nil {
fmt.Fprintln(os.Stderr, "error parsing message body")
os.Exit(11)
}
if len(recip) == 0 {
// We only need to parse the message to get a recipient if none where
// provided on the command line.
recip = append(recip, msg.Header.Get("To"))
}
err = smtp.SendMail(smtpAddr, nil, fromAddr, recip, body)
if err != nil {
fmt.Fprintln(os.Stderr, "error sending mail")
log.Fatal(err)
}
} | go | {
"resource": ""
} |
q18441 | ByCreatingContainer | train | func ByCreatingContainer(opts docker.CreateContainerOptions) (Execution, error) {
if opts.Config == nil {
return nil, errors.New("dexec: Config is nil")
}
return &createContainer{opt: opts}, nil
} | go | {
"resource": ""
} |
q18442 | Command | train | func (d Docker) Command(method Execution, name string, arg ...string) *Cmd {
return &Cmd{Method: method, Path: name, Args: arg, docker: d}
} | go | {
"resource": ""
} |
q18443 | Start | train | func (c *Cmd) Start() error {
if c.Dir != "" {
if err := c.Method.setDir(c.Dir); err != nil {
return err
}
}
if c.Env != nil {
if err := c.Method.setEnv(c.Env); err != nil {
return err
}
}
if c.started {
return errors.New("dexec: already started")
}
c.started = true
if c.Stdin == nil {
c.Stdin = empty
}
if c.Stdout == nil {
c.Stdout = ioutil.Discard
}
if c.Stderr == nil {
c.Stderr = ioutil.Discard
}
cmd := append([]string{c.Path}, c.Args...)
if err := c.Method.create(c.docker, cmd); err != nil {
return err
}
if err := c.Method.run(c.docker, c.Stdin, c.Stdout, c.Stderr); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q18444 | StdoutPipe | train | func (c *Cmd) StdoutPipe() (io.ReadCloser, error) {
if c.Stdout != nil {
return nil, errors.New("dexec: Stdout already set")
}
pr, pw := io.Pipe()
c.Stdout = pw
c.closeAfterWait = append(c.closeAfterWait, pw)
return pr, nil
} | go | {
"resource": ""
} |
q18445 | StderrPipe | train | func (c *Cmd) StderrPipe() (io.ReadCloser, error) {
if c.Stderr != nil {
return nil, errors.New("dexec: Stderr already set")
}
pr, pw := io.Pipe()
c.Stderr = pw
c.closeAfterWait = append(c.closeAfterWait, pw)
return pr, nil
} | go | {
"resource": ""
} |
q18446 | socketAddr | train | func socketAddr() (addr [4]byte, err error) {
addrs, err := net.InterfaceAddrs()
if err != nil {
return
}
for _, a := range addrs {
if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
if len(ipnet.IP.To4()) == net.IPv4len {
copy(addr[:], ipnet.IP.To4())
return
}
}
}
err = errors.New("You do not appear to be connected to the Internet")
return
} | go | {
"resource": ""
} |
q18447 | destAddr | train | func destAddr(dest string) (destAddr [4]byte, err error) {
addrs, err := net.LookupHost(dest)
if err != nil {
return
}
addr := addrs[0]
ipAddr, err := net.ResolveIPAddr("ip", addr)
if err != nil {
return
}
copy(destAddr[:], ipAddr.IP.To4())
return
} | go | {
"resource": ""
} |
q18448 | goRun | train | func goRun(src string, tags string) error {
// Create a temp folder.
tempDir, err := ioutil.TempDir("", "vfsgendev_")
if err != nil {
return err
}
defer func() {
err := os.RemoveAll(tempDir)
if err != nil {
fmt.Fprintln(os.Stderr, "warning: error removing temp dir:", err)
}
}()
// Write the source code file.
tempFile := filepath.Join(tempDir, "generate.go")
err = ioutil.WriteFile(tempFile, []byte(src), 0600)
if err != nil {
return err
}
// Compile and run the program.
cmd := exec.Command("go", "run", "-tags="+tags, tempFile)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
} | go | {
"resource": ""
} |
q18449 | Generate | train | func Generate(input http.FileSystem, opt Options) error {
opt.fillMissing()
// Use an in-memory buffer to generate the entire output.
buf := new(bytes.Buffer)
err := t.ExecuteTemplate(buf, "Header", opt)
if err != nil {
return err
}
var toc toc
err = findAndWriteFiles(buf, input, &toc)
if err != nil {
return err
}
err = t.ExecuteTemplate(buf, "DirEntries", toc.dirs)
if err != nil {
return err
}
err = t.ExecuteTemplate(buf, "Trailer", toc)
if err != nil {
return err
}
// Write output file (all at once).
fmt.Println("writing", opt.Filename)
err = ioutil.WriteFile(opt.Filename, buf.Bytes(), 0644)
return err
} | go | {
"resource": ""
} |
q18450 | findAndWriteFiles | train | func findAndWriteFiles(buf *bytes.Buffer, fs http.FileSystem, toc *toc) error {
walkFn := func(path string, fi os.FileInfo, r io.ReadSeeker, err error) error {
if err != nil {
// Consider all errors reading the input filesystem as fatal.
return err
}
switch fi.IsDir() {
case false:
file := &fileInfo{
Path: path,
Name: pathpkg.Base(path),
ModTime: fi.ModTime().UTC(),
UncompressedSize: fi.Size(),
}
marker := buf.Len()
// Write CompressedFileInfo.
err = writeCompressedFileInfo(buf, file, r)
switch err {
default:
return err
case nil:
toc.HasCompressedFile = true
// If compressed file is not smaller than original, revert and write original file.
case errCompressedNotSmaller:
_, err = r.Seek(0, io.SeekStart)
if err != nil {
return err
}
buf.Truncate(marker)
// Write FileInfo.
err = writeFileInfo(buf, file, r)
if err != nil {
return err
}
toc.HasFile = true
}
case true:
entries, err := readDirPaths(fs, path)
if err != nil {
return err
}
dir := &dirInfo{
Path: path,
Name: pathpkg.Base(path),
ModTime: fi.ModTime().UTC(),
Entries: entries,
}
toc.dirs = append(toc.dirs, dir)
// Write DirInfo.
err = t.ExecuteTemplate(buf, "DirInfo", dir)
if err != nil {
return err
}
}
return nil
}
err := vfsutil.WalkFiles(fs, "/", walkFn)
return err
} | go | {
"resource": ""
} |
q18451 | readDirPaths | train | func readDirPaths(fs http.FileSystem, dirname string) ([]string, error) {
fis, err := vfsutil.ReadDir(fs, dirname)
if err != nil {
return nil, err
}
paths := make([]string, len(fis))
for i := range fis {
paths[i] = pathpkg.Join(dirname, fis[i].Name())
}
sort.Strings(paths)
return paths, nil
} | go | {
"resource": ""
} |
q18452 | writeCompressedFileInfo | train | func writeCompressedFileInfo(w io.Writer, file *fileInfo, r io.Reader) error {
err := t.ExecuteTemplate(w, "CompressedFileInfo-Before", file)
if err != nil {
return err
}
sw := &stringWriter{Writer: w}
gw := gzip.NewWriter(sw)
_, err = io.Copy(gw, r)
if err != nil {
return err
}
err = gw.Close()
if err != nil {
return err
}
if sw.N >= file.UncompressedSize {
return errCompressedNotSmaller
}
err = t.ExecuteTemplate(w, "CompressedFileInfo-After", file)
return err
} | go | {
"resource": ""
} |
q18453 | writeFileInfo | train | func writeFileInfo(w io.Writer, file *fileInfo, r io.Reader) error {
err := t.ExecuteTemplate(w, "FileInfo-Before", file)
if err != nil {
return err
}
sw := &stringWriter{Writer: w}
_, err = io.Copy(sw, r)
if err != nil {
return err
}
err = t.ExecuteTemplate(w, "FileInfo-After", file)
return err
} | go | {
"resource": ""
} |
q18454 | stringValue | train | func stringValue(e ast.Expr) (string, error) {
lit, ok := e.(*ast.BasicLit)
if !ok {
return "", fmt.Errorf("not a string, but %T", e)
}
if lit.Kind != token.STRING {
return "", fmt.Errorf("not a string, but %v", lit.Kind)
}
return strconv.Unquote(lit.Value)
} | go | {
"resource": ""
} |
q18455 | parseTagFlag | train | func parseTagFlag(tagFlag string) (tag string, err error) {
tags := strings.Fields(tagFlag)
if len(tags) != 1 {
return "", fmt.Errorf("%q is not a valid single build tag, but %q", tagFlag, tags)
}
return tags[0], nil
} | go | {
"resource": ""
} |
q18456 | lookupNameAndComment | train | func lookupNameAndComment(bctx build.Context, importPath, variableName string) (packageName, variableComment string, err error) {
wd, err := os.Getwd()
if err != nil {
return "", "", err
}
bpkg, err := bctx.Import(importPath, wd, 0)
if err != nil {
return "", "", fmt.Errorf("can't import package %q: %v", importPath, err)
}
dpkg, err := computeDoc(bpkg)
if err != nil {
return "", "", fmt.Errorf("can't get godoc of package %q: %v", importPath, err)
}
for _, v := range dpkg.Vars {
if len(v.Names) == 1 && v.Names[0] == variableName {
variableComment = strings.TrimSuffix(v.Doc, "\n")
break
}
}
return bpkg.Name, variableComment, nil
} | go | {
"resource": ""
} |
q18457 | computeDoc | train | func computeDoc(bpkg *build.Package) (*doc.Package, error) {
fset := token.NewFileSet()
files := make(map[string]*ast.File)
for _, file := range append(bpkg.GoFiles, bpkg.CgoFiles...) {
f, err := parser.ParseFile(fset, filepath.Join(bpkg.Dir, file), nil, parser.ParseComments)
if err != nil {
return nil, err
}
files[file] = f
}
apkg := &ast.Package{
Name: bpkg.Name,
Files: files,
}
return doc.New(apkg, bpkg.ImportPath, 0), nil
} | go | {
"resource": ""
} |
q18458 | fillMissing | train | func (opt *Options) fillMissing() {
if opt.PackageName == "" {
opt.PackageName = "main"
}
if opt.VariableName == "" {
opt.VariableName = "assets"
}
if opt.Filename == "" {
opt.Filename = fmt.Sprintf("%s_vfsdata.go", strings.ToLower(opt.VariableName))
}
if opt.VariableComment == "" {
opt.VariableComment = fmt.Sprintf("%s statically implements the virtual filesystem provided to vfsgen.", opt.VariableName)
}
} | go | {
"resource": ""
} |
q18459 | Dir | train | func Dir() (string, error) {
if !DisableCache {
cacheLock.RLock()
cached := homedirCache
cacheLock.RUnlock()
if cached != "" {
return cached, nil
}
}
cacheLock.Lock()
defer cacheLock.Unlock()
var result string
var err error
if runtime.GOOS == "windows" {
result, err = dirWindows()
} else {
// Unix-like system, so just assume Unix
result, err = dirUnix()
}
if err != nil {
return "", err
}
homedirCache = result
return result, nil
} | go | {
"resource": ""
} |
q18460 | Expand | train | func Expand(path string) (string, error) {
if len(path) == 0 {
return path, nil
}
if path[0] != '~' {
return path, nil
}
if len(path) > 1 && path[1] != '/' && path[1] != '\\' {
return "", errors.New("cannot expand user-specific home dir")
}
dir, err := Dir()
if err != nil {
return "", err
}
return filepath.Join(dir, path[1:]), nil
} | go | {
"resource": ""
} |
q18461 | String | train | func (v Version) String() string {
b := make([]byte, 0, 5)
b = strconv.AppendUint(b, v.Major, 10)
b = append(b, '.')
b = strconv.AppendUint(b, v.Minor, 10)
b = append(b, '.')
b = strconv.AppendUint(b, v.Patch, 10)
if len(v.Pre) > 0 {
b = append(b, '-')
b = append(b, v.Pre[0].String()...)
for _, pre := range v.Pre[1:] {
b = append(b, '.')
b = append(b, pre.String()...)
}
}
if len(v.Build) > 0 {
b = append(b, '+')
b = append(b, v.Build[0]...)
for _, build := range v.Build[1:] {
b = append(b, '.')
b = append(b, build...)
}
}
return string(b)
} | go | {
"resource": ""
} |
q18462 | IncrementPatch | train | func (v *Version) IncrementPatch() error {
if v.Major == 0 {
return fmt.Errorf("Patch version can not be incremented for %q", v.String())
}
v.Patch += 1
return nil
} | go | {
"resource": ""
} |
q18463 | IncrementMinor | train | func (v *Version) IncrementMinor() error {
if v.Major == 0 {
return fmt.Errorf("Minor version can not be incremented for %q", v.String())
}
v.Minor += 1
v.Patch = 0
return nil
} | go | {
"resource": ""
} |
q18464 | Validate | train | func (v Version) Validate() error {
// Major, Minor, Patch already validated using uint64
for _, pre := range v.Pre {
if !pre.IsNum { //Numeric prerelease versions already uint64
if len(pre.VersionStr) == 0 {
return fmt.Errorf("Prerelease can not be empty %q", pre.VersionStr)
}
if !containsOnly(pre.VersionStr, alphanum) {
return fmt.Errorf("Invalid character(s) found in prerelease %q", pre.VersionStr)
}
}
}
for _, build := range v.Build {
if len(build) == 0 {
return fmt.Errorf("Build meta data can not be empty %q", build)
}
if !containsOnly(build, alphanum) {
return fmt.Errorf("Invalid character(s) found in build meta data %q", build)
}
}
return nil
} | go | {
"resource": ""
} |
q18465 | New | train | func New(s string) (vp *Version, err error) {
v, err := Parse(s)
vp = &v
return
} | go | {
"resource": ""
} |
q18466 | MustParse | train | func MustParse(s string) Version {
v, err := Parse(s)
if err != nil {
panic(`semver: Parse(` + s + `): ` + err.Error())
}
return v
} | go | {
"resource": ""
} |
q18467 | NewPRVersion | train | func NewPRVersion(s string) (PRVersion, error) {
if len(s) == 0 {
return PRVersion{}, errors.New("Prerelease is empty")
}
v := PRVersion{}
if containsOnly(s, numbers) {
if hasLeadingZeroes(s) {
return PRVersion{}, fmt.Errorf("Numeric PreRelease version must not contain leading zeroes %q", s)
}
num, err := strconv.ParseUint(s, 10, 64)
// Might never be hit, but just in case
if err != nil {
return PRVersion{}, err
}
v.VersionNum = num
v.IsNum = true
} else if containsOnly(s, alphanum) {
v.VersionStr = s
v.IsNum = false
} else {
return PRVersion{}, fmt.Errorf("Invalid character(s) found in prerelease %q", s)
}
return v, nil
} | go | {
"resource": ""
} |
q18468 | String | train | func (v PRVersion) String() string {
if v.IsNum {
return strconv.FormatUint(v.VersionNum, 10)
}
return v.VersionStr
} | go | {
"resource": ""
} |
q18469 | NewBuildVersion | train | func NewBuildVersion(s string) (string, error) {
if len(s) == 0 {
return "", errors.New("Buildversion is empty")
}
if !containsOnly(s, alphanum) {
return "", fmt.Errorf("Invalid character(s) found in build meta data %q", s)
}
return s, nil
} | go | {
"resource": ""
} |
q18470 | rangeFunc | train | func (vr *versionRange) rangeFunc() Range {
return Range(func(v Version) bool {
return vr.c(v, vr.v)
})
} | go | {
"resource": ""
} |
q18471 | OR | train | func (rf Range) OR(f Range) Range {
return Range(func(v Version) bool {
return rf(v) || f(v)
})
} | go | {
"resource": ""
} |
q18472 | AND | train | func (rf Range) AND(f Range) Range {
return Range(func(v Version) bool {
return rf(v) && f(v)
})
} | go | {
"resource": ""
} |
q18473 | splitORParts | train | func splitORParts(parts []string) ([][]string, error) {
var ORparts [][]string
last := 0
for i, p := range parts {
if p == "||" {
if i == 0 {
return nil, fmt.Errorf("First element in range is '||'")
}
ORparts = append(ORparts, parts[last:i])
last = i + 1
}
}
if last == len(parts) {
return nil, fmt.Errorf("Last element in range is '||'")
}
ORparts = append(ORparts, parts[last:])
return ORparts, nil
} | go | {
"resource": ""
} |
q18474 | inArray | train | func inArray(s byte, list []byte) bool {
for _, el := range list {
if el == s {
return true
}
}
return false
} | go | {
"resource": ""
} |
q18475 | splitAndTrim | train | func splitAndTrim(s string) (result []string) {
last := 0
var lastChar byte
excludeFromSplit := []byte{'>', '<', '='}
for i := 0; i < len(s); i++ {
if s[i] == ' ' && !inArray(lastChar, excludeFromSplit) {
if last < i-1 {
result = append(result, s[last:i])
}
last = i + 1
} else if s[i] != ' ' {
lastChar = s[i]
}
}
if last < len(s)-1 {
result = append(result, s[last:])
}
for i, v := range result {
result[i] = strings.Replace(v, " ", "", -1)
}
// parts := strings.Split(s, " ")
// for _, x := range parts {
// if s := strings.TrimSpace(x); len(s) != 0 {
// result = append(result, s)
// }
// }
return
} | go | {
"resource": ""
} |
q18476 | splitComparatorVersion | train | func splitComparatorVersion(s string) (string, string, error) {
i := strings.IndexFunc(s, unicode.IsDigit)
if i == -1 {
return "", "", fmt.Errorf("Could not get version from string: %q", s)
}
return strings.TrimSpace(s[0:i]), s[i:], nil
} | go | {
"resource": ""
} |
q18477 | getWildcardType | train | func getWildcardType(vStr string) wildcardType {
parts := strings.Split(vStr, ".")
nparts := len(parts)
wildcard := parts[nparts-1]
possibleWildcardType := wildcardTypefromInt(nparts)
if wildcard == "x" {
return possibleWildcardType
}
return noneWildcard
} | go | {
"resource": ""
} |
q18478 | createVersionFromWildcard | train | func createVersionFromWildcard(vStr string) string {
// handle 1.x.x
vStr2 := strings.Replace(vStr, ".x.x", ".x", 1)
vStr2 = strings.Replace(vStr2, ".x", ".0", 1)
parts := strings.Split(vStr2, ".")
// handle 1.x
if len(parts) == 2 {
return vStr2 + ".0"
}
return vStr2
} | go | {
"resource": ""
} |
q18479 | incrementMajorVersion | train | func incrementMajorVersion(vStr string) (string, error) {
parts := strings.Split(vStr, ".")
i, err := strconv.Atoi(parts[0])
if err != nil {
return "", err
}
parts[0] = strconv.Itoa(i + 1)
return strings.Join(parts, "."), nil
} | go | {
"resource": ""
} |
q18480 | MustParseRange | train | func MustParseRange(s string) Range {
r, err := ParseRange(s)
if err != nil {
panic(`semver: ParseRange(` + s + `): ` + err.Error())
}
return r
} | go | {
"resource": ""
} |
q18481 | Get | train | func (c *Cache) Get(_ context.Context, key dataloader.Key) (dataloader.Thunk, bool) {
v, ok := c.c.Get(key.String())
if ok {
return v.(dataloader.Thunk), ok
}
return nil, ok
} | go | {
"resource": ""
} |
q18482 | Set | train | func (c *Cache) Set(_ context.Context, key dataloader.Key, value dataloader.Thunk) {
c.c.Set(key.String(), value, 0)
} | go | {
"resource": ""
} |
q18483 | Delete | train | func (c *Cache) Delete(_ context.Context, key dataloader.Key) bool {
if _, found := c.c.Get(key.String()); found {
c.c.Delete(key.String())
return true
}
return false
} | go | {
"resource": ""
} |
q18484 | WithWait | train | func WithWait(d time.Duration) Option {
return func(l *Loader) {
l.wait = d
}
} | go | {
"resource": ""
} |
q18485 | WithClearCacheOnBatch | train | func WithClearCacheOnBatch() Option {
return func(l *Loader) {
l.cacheLock.Lock()
l.clearCacheOnBatch = true
l.cacheLock.Unlock()
}
} | go | {
"resource": ""
} |
q18486 | NewBatchedLoader | train | func NewBatchedLoader(batchFn BatchFunc, opts ...Option) *Loader {
loader := &Loader{
batchFn: batchFn,
inputCap: 1000,
wait: 16 * time.Millisecond,
}
// Apply options
for _, apply := range opts {
apply(loader)
}
// Set defaults
if loader.cache == nil {
loader.cache = NewCache()
}
if loader.tracer == nil {
loader.tracer = &NoopTracer{}
}
return loader
} | go | {
"resource": ""
} |
q18487 | Clear | train | func (l *Loader) Clear(ctx context.Context, key Key) Interface {
l.cacheLock.Lock()
l.cache.Delete(ctx, key)
l.cacheLock.Unlock()
return l
} | go | {
"resource": ""
} |
q18488 | ClearAll | train | func (l *Loader) ClearAll() Interface {
l.cacheLock.Lock()
l.cache.Clear()
l.cacheLock.Unlock()
return l
} | go | {
"resource": ""
} |
q18489 | Prime | train | func (l *Loader) Prime(ctx context.Context, key Key, value interface{}) Interface {
if _, ok := l.cache.Get(ctx, key); !ok {
thunk := func() (interface{}, error) {
return value, nil
}
l.cache.Set(ctx, key, thunk)
}
return l
} | go | {
"resource": ""
} |
q18490 | newBatcher | train | func (l *Loader) newBatcher(silent bool, tracer Tracer) *batcher {
return &batcher{
input: make(chan *batchRequest, l.inputCap),
batchFn: l.batchFn,
silent: silent,
tracer: tracer,
}
} | go | {
"resource": ""
} |
q18491 | end | train | func (b *batcher) end() {
if !b.finished {
close(b.input)
b.finished = true
}
} | go | {
"resource": ""
} |
q18492 | batch | train | func (b *batcher) batch(originalContext context.Context) {
var (
keys = make(Keys, 0)
reqs = make([]*batchRequest, 0)
items = make([]*Result, 0)
panicErr interface{}
)
for item := range b.input {
keys = append(keys, item.key)
reqs = append(reqs, item)
}
ctx, finish := b.tracer.TraceBatch(originalContext, keys)
defer finish(items)
func() {
defer func() {
if r := recover(); r != nil {
panicErr = r
if b.silent {
return
}
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
log.Printf("Dataloader: Panic received in batch function:: %v\n%s", panicErr, buf)
}
}()
items = b.batchFn(ctx, keys)
}()
if panicErr != nil {
for _, req := range reqs {
req.channel <- &Result{Error: fmt.Errorf("Panic received in batch function: %v", panicErr)}
close(req.channel)
}
return
}
if len(items) != len(keys) {
err := &Result{Error: fmt.Errorf(`
The batch function supplied did not return an array of responses
the same length as the array of keys.
Keys:
%v
Values:
%v
`, keys, items)}
for _, req := range reqs {
req.channel <- err
close(req.channel)
}
return
}
for i, req := range reqs {
req.channel <- items[i]
close(req.channel)
}
} | go | {
"resource": ""
} |
q18493 | sleeper | train | func (l *Loader) sleeper(b *batcher, close chan bool) {
select {
// used by batch to close early. usually triggered by max batch size
case <-close:
return
// this will move this goroutine to the back of the callstack?
case <-time.After(l.wait):
}
// reset
// this is protected by the batchLock to avoid closing the batcher input
// channel while Load is inserting a request
l.batchLock.Lock()
b.end()
// We can end here also if the batcher has already been closed and a
// new one has been created. So reset the loader state only if the batcher
// is the current one
if l.curBatcher == b {
l.reset()
}
l.batchLock.Unlock()
} | go | {
"resource": ""
} |
q18494 | Set | train | func (c *Cache) Set(_ context.Context, key dataloader.Key, value dataloader.Thunk) {
c.ARCCache.Add(key, value)
} | go | {
"resource": ""
} |
q18495 | Delete | train | func (c *Cache) Delete(_ context.Context, key dataloader.Key) bool {
if c.ARCCache.Contains(key) {
c.ARCCache.Remove(key)
return true
}
return false
} | go | {
"resource": ""
} |
q18496 | Keys | train | func (l Keys) Keys() []string {
list := make([]string, len(l))
for i := range l {
list[i] = l[i].String()
}
return list
} | go | {
"resource": ""
} |
q18497 | TraceLoad | train | func (OpenTracingTracer) TraceLoad(ctx context.Context, key Key) (context.Context, TraceLoadFinishFunc) {
span, spanCtx := opentracing.StartSpanFromContext(ctx, "Dataloader: load")
span.SetTag("dataloader.key", key.String())
return spanCtx, func(thunk Thunk) {
// TODO: is there anything we should do with the results?
span.Finish()
}
} | go | {
"resource": ""
} |
q18498 | TraceLoadMany | train | func (OpenTracingTracer) TraceLoadMany(ctx context.Context, keys Keys) (context.Context, TraceLoadManyFinishFunc) {
span, spanCtx := opentracing.StartSpanFromContext(ctx, "Dataloader: loadmany")
span.SetTag("dataloader.keys", keys.Keys())
return spanCtx, func(thunk ThunkMany) {
// TODO: is there anything we should do with the results?
span.Finish()
}
} | go | {
"resource": ""
} |
q18499 | TraceBatch | train | func (OpenTracingTracer) TraceBatch(ctx context.Context, keys Keys) (context.Context, TraceBatchFinishFunc) {
span, spanCtx := opentracing.StartSpanFromContext(ctx, "Dataloader: batch")
span.SetTag("dataloader.keys", keys.Keys())
return spanCtx, func(results []*Result) {
// TODO: is there anything we should do with the results?
span.Finish()
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.