_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q31800 | MustGetBlobRef | train | func MustGetBlobRef(req *http.Request, param string) blob.Ref {
br, ok := blob.Parse(MustGet(req, param))
if !ok {
panic(InvalidParameterError(param))
}
return br
} | go | {
"resource": ""
} |
q31801 | OptionalInt | train | func OptionalInt(req *http.Request, param string) int {
v := req.FormValue(param)
if v == "" {
return 0
}
i, err := strconv.Atoi(v)
if err != nil {
panic(InvalidParameterError(param))
}
return i
} | go | {
"resource": ""
} |
q31802 | fileInfoPacked | train | func fileInfoPacked(ctx context.Context, sh *search.Handler, src blob.Fetcher, r *http.Request, file blob.Ref) (packFileInfo fileInfo, ok bool) {
if sh == nil {
return fileInfo{whyNot: "no search"}, false
}
wf, ok := src.(blobserver.WholeRefFetcher)
if !ok {
return fileInfo{whyNot: "fetcher type"}, false
}
if... | go | {
"resource": ""
} |
q31803 | isText | train | func isText(rs io.ReadSeeker) (ok bool, err error) {
defer func() {
if _, seekErr := rs.Seek(0, io.SeekStart); seekErr != nil {
if err == nil {
err = seekErr
}
}
}()
var buf bytes.Buffer
if _, err := io.CopyN(&buf, rs, 1e6); err != nil {
if err != io.EOF {
return false, err
}
}
return utf8.Va... | go | {
"resource": ""
} |
q31804 | statFiles | train | func (dh *DownloadHandler) statFiles(refs []blob.Ref) error {
statter, ok := dh.Fetcher.(blobserver.BlobStatter)
if !ok {
return fmt.Errorf("DownloadHandler.Fetcher %T is not a BlobStatter", dh.Fetcher)
}
statted := make(map[blob.Ref]bool)
err := statter.StatBlobs(context.TODO(), refs, func(sb blob.SizedRef) er... | go | {
"resource": ""
} |
q31805 | serveZip | train | func (dh *DownloadHandler) serveZip(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if r.Method != "POST" {
http.Error(w, "Invalid download method", http.StatusBadRequest)
return
}
filesValue := r.FormValue("files")
if filesValue == "" {
http.Error(w, "No file blobRefs specified", http.StatusBa... | go | {
"resource": ""
} |
q31806 | SimpleEnumerateBlobs | train | func (c *Client) SimpleEnumerateBlobs(ctx context.Context, ch chan<- blob.SizedRef) error {
return c.EnumerateBlobsOpts(ctx, ch, EnumerateOpts{})
} | go | {
"resource": ""
} |
q31807 | EnumerateBlobsOpts | train | func (c *Client) EnumerateBlobsOpts(ctx context.Context, ch chan<- blob.SizedRef, opts EnumerateOpts) error {
defer close(ch)
if opts.After != "" && opts.MaxWait != 0 {
return errors.New("client error: it's invalid to use enumerate After and MaxWaitSec together")
}
pfx, err := c.prefix()
if err != nil {
return... | go | {
"resource": ""
} |
q31808 | RegisterCommand | train | func RegisterCommand(mode string, makeCmd func(Flags *flag.FlagSet) CommandRunner) {
RegisterMode(mode, makeCmd)
asNewCommand[mode] = true
} | go | {
"resource": ""
} |
q31809 | runAsNewCommand | train | func runAsNewCommand(cmd CommandRunner, mode string) {
execCmd, ok := cmd.(ExecRunner)
if !ok {
panic(fmt.Sprintf("%v does not implement ExecRunner", mode))
}
cmdPath, err := execCmd.LookPath()
if err != nil {
Errorf("Error: %v\n", err)
Exit(2)
}
allArgs := shiftFlags(mode)
if err := runExec(cmdPath, allA... | go | {
"resource": ""
} |
q31810 | Printf | train | func Printf(format string, args ...interface{}) {
if *FlagVerbose {
fmt.Fprintf(Stderr, format, args...)
}
} | go | {
"resource": ""
} |
q31811 | maybeSetupGoogleCloudLogging | train | func maybeSetupGoogleCloudLogging() io.Closer {
if flagGCEProjectID == "" && flagGCELogName == "" && flagGCEJWTFile == "" {
return types.NopCloser
}
if flagGCEProjectID == "" || flagGCELogName == "" || flagGCEJWTFile == "" {
exitf("All of --gce_project_id, --gce_log_name, and --gce_jwt_file must be specified for... | go | {
"resource": ""
} |
q31812 | setupLogging | train | func setupLogging() io.Closer {
if *flagSyslog && runtime.GOOS == "windows" {
exitf("-syslog not available on windows")
}
if fn := setupLoggingSyslog; fn != nil {
if flusher := fn(); flusher != nil {
return flusher
}
}
if env.OnGCE() {
lw, err := gce.LogWriter()
if err != nil {
log.Fatalf("Error se... | go | {
"resource": ""
} |
q31813 | writePump | train | func (c *wsConn) writePump() {
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
c.ws.Close()
}()
for {
select {
case message, ok := <-c.send:
if !ok {
c.write(websocket.CloseMessage, []byte{})
return
}
if err := c.write(websocket.TextMessage, message); err != nil {
retu... | go | {
"resource": ""
} |
q31814 | Get | train | func (s *DriveService) Get(ctx context.Context, title string) (*client.File, error) {
// TODO: use field selectors
query := fmt.Sprintf("'%s' in parents and title = '%s'", s.parentID, title)
req := s.apiservice.Files.List().Context(ctx).Q(query)
files, err := req.Do()
if err != nil {
return nil, err
}
if len(f... | go | {
"resource": ""
} |
q31815 | List | train | func (s *DriveService) List(pageToken string, limit int) (files []*client.File, next string, err error) {
req := s.apiservice.Files.List()
req.Q(fmt.Sprintf("'%s' in parents and mimeType != '%s'", s.parentID, MimeTypeDriveFolder))
if pageToken != "" {
req.PageToken(pageToken)
}
if limit > 0 {
req.MaxResults(... | go | {
"resource": ""
} |
q31816 | Upsert | train | func (s *DriveService) Upsert(ctx context.Context, title string, data io.Reader) (file *client.File, err error) {
if file, err = s.Get(ctx, title); err != nil {
if !os.IsNotExist(err) {
return
}
}
if file == nil {
file = &client.File{Title: title}
file.Parents = []*client.ParentReference{
{Id: s.parent... | go | {
"resource": ""
} |
q31817 | Fetch | train | func (s *DriveService) Fetch(ctx context.Context, title string) (body io.ReadCloser, size uint32, err error) {
file, err := s.Get(ctx, title)
if err != nil {
return
}
// TODO: maybe in the case of no download link, remove the file.
// The file should have malformed or converted to a Docs file
// unwantedly.
//... | go | {
"resource": ""
} |
q31818 | Stat | train | func (s *DriveService) Stat(ctx context.Context, title string) (int64, error) {
file, err := s.Get(ctx, title)
if err != nil || file == nil {
return 0, err
}
return file.FileSize, err
} | go | {
"resource": ""
} |
q31819 | Trash | train | func (s *DriveService) Trash(ctx context.Context, title string) error {
file, err := s.Get(ctx, title)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
_, err = s.apiservice.Files.Trash(file.Id).Context(ctx).Do()
return err
} | go | {
"resource": ""
} |
q31820 | Send | train | func (q *Query) Send() {
if q.pending {
q.Cleanup()
return
}
q.pending = true
go func() {
resp, err := q.send()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
}
q.Callback(string(resp))
}()
} | go | {
"resource": ""
} |
q31821 | punchHoleLinux | train | func punchHoleLinux(file *os.File, offset int64, size int64) error {
err := syscall.Fallocate(int(file.Fd()),
falloc_fl_punch_hole|falloc_fl_keep_size,
offset, size)
if err == syscall.ENOSYS || err == syscall.EOPNOTSUPP {
return errNoPunch
}
return err
} | go | {
"resource": ""
} |
q31822 | NewFileReader | train | func NewFileReader(ctx context.Context, fetcher blob.Fetcher, fileBlobRef blob.Ref) (*FileReader, error) {
// TODO(bradfitz): rename this into bytes reader? but for now it's still
// named FileReader, but can also read a "bytes" schema.
if !fileBlobRef.Valid() {
return nil, errors.New("schema/filer... | go | {
"resource": ""
} |
q31823 | NewFileReader | train | func (ss *superset) NewFileReader(fetcher blob.Fetcher) (*FileReader, error) {
if ss.Type != "file" && ss.Type != "bytes" {
return nil, fmt.Errorf("schema/filereader: Superset not of type \"file\" or \"bytes\"")
}
size := int64(ss.SumPartsSize())
fr := &FileReader{
fetcher: fetcher,
ss: ss,
size: si... | go | {
"resource": ""
} |
q31824 | UnixMtime | train | func (fr *FileReader) UnixMtime() time.Time {
t, err := time.Parse(time.RFC3339, fr.ss.UnixMtime)
if err != nil {
return time.Time{}
}
return t
} | go | {
"resource": ""
} |
q31825 | ForeachChunk | train | func (fr *FileReader) ForeachChunk(ctx context.Context, fn func(schemaPath []blob.Ref, p BytesPart) error) error {
return fr.foreachChunk(ctx, fn, nil)
} | go | {
"resource": ""
} |
q31826 | HasID3v1Tag | train | func HasID3v1Tag(r readerutil.SizeReaderAt) (bool, error) {
if r.Size() < ID3v1TagLength {
return false, nil
}
buf := make([]byte, len(id3v1Magic))
if _, err := r.ReadAt(buf, r.Size()-ID3v1TagLength); err != nil {
return false, fmt.Errorf("Failed to read ID3v1 data: %v", err)
}
if bytes.Equal(buf, id3v1Magic... | go | {
"resource": ""
} |
q31827 | renderFile | train | func renderFile() {
var err error
theFic, err = newFileItemContainer(fileThumbnailHeight)
if err != nil {
fmt.Printf("error creating file container: %v\n", err)
return
}
if err := theFic.populate(); err != nil {
fmt.Printf("Error initializing file container: %v", err)
return
}
if err := theFic.render(); ... | go | {
"resource": ""
} |
q31828 | GenDepsWithPath | train | func GenDepsWithPath(pathPrefix string, root http.FileSystem) ([]byte, error) {
d, err := root.Open("/")
if err != nil {
return nil, fmt.Errorf("Failed to open root of %v: %v", root, err)
}
fi, err := d.Stat()
if err != nil {
return nil, err
}
if !fi.IsDir() {
return nil, fmt.Errorf("root of %v is not a di... | go | {
"resource": ""
} |
q31829 | ParseDeps | train | func ParseDeps(r io.Reader) (providedBy map[string]string, requires map[string][]string, err error) {
providedBy = make(map[string]string)
requires = make(map[string][]string)
scanner := bufio.NewScanner(r)
for scanner.Scan() {
l := scanner.Text()
if strings.HasPrefix(l, "//") {
continue
}
if l == "" {
... | go | {
"resource": ""
} |
q31830 | DeepParseDeps | train | func DeepParseDeps(r io.Reader) (map[string][]string, error) {
providedBy, requires, err := ParseDeps(r)
if err != nil {
return nil, err
}
filesDeps := make(map[string][]string)
var deeperDeps func(namespace string) []string
deeperDeps = func(namespace string) []string {
if jsdeps, ok := filesDeps[namespace];... | go | {
"resource": ""
} |
q31831 | Alias | train | func (conf *Config) Alias(server string) string {
longestMatch := ""
serverAlias := ""
for alias, serverConf := range conf.Servers {
if strings.HasPrefix(server, serverConf.Server) {
if len(serverConf.Server) > len(longestMatch) {
longestMatch = serverConf.Server
serverAlias = alias
}
}
}
return ... | go | {
"resource": ""
} |
q31832 | StatBlobs | train | func (sto *replicaStorage) StatBlobs(ctx context.Context, blobs []blob.Ref, fn func(blob.SizedRef) error) error {
var (
mu sync.Mutex // serializes calls to fn, guards need
need = make(map[blob.Ref]bool)
failed bool
)
for _, br := range blobs {
need[br] = true
}
group, ctx := errgroup.WithContext(ct... | go | {
"resource": ""
} |
q31833 | CallbackURLParameters | train | func (im imp) CallbackURLParameters(acctRef blob.Ref) url.Values {
return url.Values{}
} | go | {
"resource": ""
} |
q31834 | decodeToken | train | func decodeToken(encoded string) *oauth2.Token {
t := new(oauth2.Token)
f := strings.Fields(encoded)
if len(f) > 0 {
t.AccessToken = f[0]
}
if len(f) > 1 {
t.RefreshToken = f[1]
}
if len(f) > 2 && f[2] != "0" {
sec, err := strconv.ParseInt(f[2], 10, 64)
if err == nil {
t.Expiry = time.Unix(sec, 0)
}... | go | {
"resource": ""
} |
q31835 | encryptBlob | train | func (s *storage) encryptBlob(ciphertext, plaintext []byte) []byte {
if s.key == [32]byte{} {
// Safety check, we really don't want this to happen.
panic("no passphrase set")
}
var nonce [24]byte
s.randNonce(&nonce)
ciphertext = append(ciphertext, version)
ciphertext = append(ciphertext, nonce[:]...)
return ... | go | {
"resource": ""
} |
q31836 | decryptBlob | train | func (s *storage) decryptBlob(plaintext, ciphertext []byte) ([]byte, error) {
if len(ciphertext) < overhead {
return nil, errors.New("blob too short to be encrypted")
}
if ciphertext[0] != version {
return nil, errors.New("unknown encrypted blob version")
}
var nonce [24]byte
copy(nonce[:], ciphertext[1:])
p... | go | {
"resource": ""
} |
q31837 | InitDB | train | func InitDB(path string) error {
db, err := sql.Open("sqlite3", path)
if err != nil {
return err
}
defer db.Close()
for _, tableSQL := range SQLCreateTables() {
if _, err := db.Exec(tableSQL); err != nil {
return err
}
}
// Use Write Ahead Logging which improves SQLite concurrency.
// Requires SQLite ... | go | {
"resource": ""
} |
q31838 | hookGofmt | train | func (c *hookCmd) hookGofmt() error {
if os.Getenv("GIT_GOFMT_HOOK") == "off" {
printf("gofmt disabled by $GIT_GOFMT_HOOK=off\n")
return nil
}
files, err := c.runGofmt()
if err != nil {
printf("gofmt hook reported errors:\n\t%v\n", strings.Replace(strings.TrimSpace(err.Error()), "\n", "\n\t", -1))
return e... | go | {
"resource": ""
} |
q31839 | runGofmt | train | func (c *hookCmd) runGofmt() (files []string, err error) {
repo, err := repoRoot()
if err != nil {
return nil, err
}
if !strings.HasSuffix(repo, string(filepath.Separator)) {
repo += string(filepath.Separator)
}
out, err := cmdOutputDirErr(".", "git", "diff-index", "--name-only", "--diff-filter=ACM", "--cach... | go | {
"resource": ""
} |
q31840 | nonBlankLines | train | func nonBlankLines(text string) []string {
var out []string
for _, s := range lines(text) {
if strings.TrimSpace(s) != "" {
out = append(out, s)
}
}
return out
} | go | {
"resource": ""
} |
q31841 | filter | train | func filter(f func(string) bool, list []string) []string {
var out []string
for _, x := range list {
if f(x) {
out = append(out, x)
}
}
return out
} | go | {
"resource": ""
} |
q31842 | DirExists | train | func DirExists(dir string) bool {
fi, err := os.Stat(dir)
return err == nil && fi.IsDir()
} | go | {
"resource": ""
} |
q31843 | Err | train | func Err(key string) error {
v, ok := camErrors[key]
if !ok {
panic(fmt.Sprintf("unknown/unregistered error key %v", key))
}
return v
} | go | {
"resource": ""
} |
q31844 | IsDir | train | func IsDir(dir string) (bool, error) {
_, err := os.Stat(filepath.Join(dir, defaultIndexFile))
if os.IsNotExist(err) {
return false, nil
}
return err == nil, err
} | go | {
"resource": ""
} |
q31845 | New | train | func New(dir string) (blobserver.Storage, error) {
var maxSize int64
if ok, _ := IsDir(dir); ok {
// TODO: detect existing max size from size of files, if obvious,
// and set maxSize to that?
}
return newStorage(dir, maxSize, nil)
} | go | {
"resource": ""
} |
q31846 | newIndex | train | func newIndex(root string, indexConf jsonconfig.Obj) (sorted.KeyValue, error) {
if len(indexConf) > 0 {
return sorted.NewKeyValueMaybeWipe(indexConf)
}
return sorted.NewKeyValueMaybeWipe(jsonconfig.Obj{
"type": defaultIndexType,
"file": filepath.Join(root, defaultIndexFile),
})
} | go | {
"resource": ""
} |
q31847 | openForRead | train | func (s *storage) openForRead(n int) error {
if n > len(s.fds) {
panic(fmt.Sprintf("openForRead called out of order got %d, expected %d", n, len(s.fds)))
}
fn := s.filename(n)
f, err := os.Open(fn)
if err != nil {
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for read %q", fn)
s.... | go | {
"resource": ""
} |
q31848 | openForWrite | train | func (s *storage) openForWrite(n int) error {
fn := s.filename(n)
l, err := lock.Lock(fn + ".lock")
if err != nil {
return err
}
f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
l.Close()
return err
}
openFdsVar.Add(s.root, 1)
debug.Printf("diskpacked: opened for write %q", fn)
s.... | go | {
"resource": ""
} |
q31849 | closePack | train | func (s *storage) closePack() error {
var err error
if s.writer != nil {
err = s.writer.Close()
openFdsVar.Add(s.root, -1)
s.writer = nil
}
if s.writeLock != nil {
lerr := s.writeLock.Close()
if err == nil {
err = lerr
}
s.writeLock = nil
}
return err
} | go | {
"resource": ""
} |
q31850 | nextPack | train | func (s *storage) nextPack() error {
debug.Println("diskpacked: nextPack")
s.size = 0
if err := s.closePack(); err != nil {
return err
}
n := len(s.fds)
if err := s.openForWrite(n); err != nil {
return err
}
return s.openForRead(n)
} | go | {
"resource": ""
} |
q31851 | openAllPacks | train | func (s *storage) openAllPacks() error {
debug.Println("diskpacked: openAllPacks")
n := 0
for {
err := s.openForRead(n)
if os.IsNotExist(err) {
break
}
if err != nil {
return err
}
n++
}
if n == 0 {
// If no pack files are found, we create one open for read and write.
return s.nextPack()
}
... | go | {
"resource": ""
} |
q31852 | Close | train | func (s *storage) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
var closeErr error
s.closed = true
if err := s.index.Close(); err != nil {
log.Println("diskpacked: closing index:", err)
}
for _, f := range s.fds {
err := f.Close()
openFdsVar.Add(s.root, -1)
if err != nil ... | go | {
"resource": ""
} |
q31853 | fetch | train | func (s *storage) fetch(ctx context.Context, br blob.Ref, offset, length int64) (rc io.ReadCloser, size uint32, err error) {
meta, err := s.meta(br)
if err != nil {
return nil, 0, err
}
if meta.file >= len(s.fds) {
return nil, 0, fmt.Errorf("diskpacked: attempt to fetch blob from out of range pack file %d > %d... | go | {
"resource": ""
} |
q31854 | RemoveBlobs | train | func (s *storage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
batch := s.index.BeginBatch()
var wg syncutil.Group
for _, br := range blobs {
br := br
removeGate.Start()
batch.Delete(br.String())
wg.Go(func() error {
defer removeGate.Done()
if err := s.delete(br); err != nil && err != os.... | go | {
"resource": ""
} |
q31855 | StreamBlobs | train | func (s *storage) StreamBlobs(ctx context.Context, dest chan<- blobserver.BlobAndToken, contToken string) error {
defer close(dest)
fileNum, offset, err := parseContToken(contToken)
if err != nil {
return errors.New("diskpacked: invalid continuation token")
}
debug.Printf("Continuing blob streaming from pack %s... | go | {
"resource": ""
} |
q31856 | append | train | func (s *storage) append(br blob.SizedRef, r io.Reader) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return errors.New("diskpacked: write to closed storage")
}
// to be able to undo the append
origOffset := s.size
fn := s.writer.Name()
n, err := fmt.Fprintf(s.writer, "[%v %v]", br.Ref.String(), br.... | go | {
"resource": ""
} |
q31857 | meta | train | func (s *storage) meta(br blob.Ref) (m blobMeta, err error) {
ms, err := s.index.Get(br.String())
if err != nil {
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
return
}
m, ok := parseBlobMeta(ms)
if !ok {
err = fmt.Errorf("diskpacked: bad blob metadata: %q", ms)
}
return
} | go | {
"resource": ""
} |
q31858 | DumpStats | train | func DumpStats(sr *statspkg.Receiver, destFile string) {
sr.Lock()
defer sr.Unlock()
f, err := os.Create(destFile)
if err != nil {
log.Fatal(err)
}
var sum int64
for _, size := range sr.Have {
fmt.Fprintf(f, "%d\n", size)
}
fmt.Printf("In-memory blob stats: %d blobs, %d bytes\n", len(sr.Have), sum)
err... | go | {
"resource": ""
} |
q31859 | statReceiver | train | func (up *Uploader) statReceiver(n *node) blobserver.StatReceiver {
statReceiver := up.altStatReceiver
if statReceiver == nil {
// TODO(mpl): simplify the altStatReceiver situation as well,
// see TODO in cmd/pk-put/uploader.go
statReceiver = up.Client
}
if android.IsChild() && n != nil && n.fi.Mode()&os.Mode... | go | {
"resource": ""
} |
q31860 | NewTreeUpload | train | func (up *Uploader) NewTreeUpload(dir string) *TreeUpload {
tu := up.NewRootlessTreeUpload()
tu.rootless = false
tu.base = dir
return tu
} | go | {
"resource": ""
} |
q31861 | ReceiveBlob | train | func (sto *overlayStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
sb, err = sto.upper.ReceiveBlob(ctx, br, src)
if err == nil && sto.deleted != nil {
err = sto.deleted.Delete(br.String())
}
return sb, err
} | go | {
"resource": ""
} |
q31862 | RemoveBlobs | train | func (sto *overlayStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if sto.deleted == nil {
return blobserver.ErrNotImplemented
}
err := sto.upper.RemoveBlobs(ctx, blobs)
if err != nil {
return err
}
m := sto.deleted.BeginBatch()
for _, br := range blobs {
m.Set(br.String(), "1")
}
re... | go | {
"resource": ""
} |
q31863 | Fetch | train | func (sto *overlayStorage) Fetch(ctx context.Context, br blob.Ref) (file io.ReadCloser, size uint32, err error) {
if sto.isDeleted(br) {
return nil, 0, os.ErrNotExist
}
file, size, err = sto.upper.Fetch(ctx, br)
if err != os.ErrNotExist {
return file, size, err
}
return sto.lower.Fetch(ctx, br)
} | go | {
"resource": ""
} |
q31864 | EnumerateBlobs | train | func (sto *overlayStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
defer close(dest)
enums := []blobserver.BlobEnumerator{sto.lower, sto.upper}
// Ensure that we send limit blobs if possible.
sent := 0
for sent < limit {
ch := make(chan blob.SizedRef)
e... | go | {
"resource": ""
} |
q31865 | GetAPIKeyPath | train | func GetAPIKeyPath() (string, error) {
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", fmt.Errorf("could not get config dir: %v", err)
}
return filepath.Join(dir, apiKeyName), nil
} | go | {
"resource": ""
} |
q31866 | GetAPIKey | train | func GetAPIKey() (string, error) {
mu.RLock()
key := apiKey
mu.RUnlock()
if apiKey != "" {
return key, nil
}
mu.Lock()
defer mu.Unlock()
dir, err := osutil.PerkeepConfigDir()
if err != nil {
return "", err
}
slurp, err := wkfs.ReadFile(filepath.Join(dir, apiKeyName))
if os.IsNotExist(err) {
return ""... | go | {
"resource": ""
} |
q31867 | Lookup | train | func Lookup(ctx context.Context, address string) ([]Rect, error) {
if AltLookupFn != nil {
return AltLookupFn(ctx, address)
}
mu.RLock()
rects, ok := cache[address]
mu.RUnlock()
if ok {
return rects, nil
}
key, err := GetAPIKey()
if err != nil {
return nil, err
}
rectsi, err := sf.Do(address, func()... | go | {
"resource": ""
} |
q31868 | htmlFmt | train | func htmlFmt(w io.Writer, format string, x ...interface{}) string {
writeAny(w, true, x[0])
return ""
} | go | {
"resource": ""
} |
q31869 | htmlEscFmt | train | func htmlEscFmt(w io.Writer, format string, x ...interface{}) string {
var buf bytes.Buffer
writeAny(&buf, false, x[0])
template.HTMLEscape(w, buf.Bytes())
return ""
} | go | {
"resource": ""
} |
q31870 | writeAny | train | func writeAny(w io.Writer, html bool, x interface{}) {
switch v := x.(type) {
case []byte:
writeText(w, v, html)
case string:
writeText(w, []byte(v), html)
default:
if html {
var buf bytes.Buffer
fmt.Fprint(&buf, x)
writeText(w, buf.Bytes(), true)
} else {
fmt.Fprint(w, x)
}
}
} | go | {
"resource": ""
} |
q31871 | writeText | train | func writeText(w io.Writer, text []byte, html bool) {
if html {
template.HTMLEscape(w, text)
return
}
w.Write(text)
} | go | {
"resource": ""
} |
q31872 | redirectPath | train | func redirectPath(u *url.URL) string {
// Redirect old gitweb URLs to gerrit. Example:
// /code/?p=camlistore.git;a=commit;h=b0d2a8f0e5f27bbfc025a96ec3c7896b42d198ed
if strings.HasPrefix(u.Path, "/code/") {
m := gitwebCommit.FindStringSubmatch(u.RawQuery)
if len(m) == 2 {
return gerritURLPrefix + m[1]
}
}
... | go | {
"resource": ""
} |
q31873 | serveFile | train | func serveFile(w http.ResponseWriter, r *http.Request, absPath string) {
if !strings.HasSuffix(absPath, ".html") && !strings.HasSuffix(absPath, ".md") {
http.ServeFile(w, r, absPath)
return
}
data, err := ioutil.ReadFile(absPath)
if err != nil {
serveError(w, r, absPath, err)
return
}
// AutoHeadingIDs ... | go | {
"resource": ""
} |
q31874 | runAsChild | train | func runAsChild(res string) {
cmdName, err := exec.LookPath(res)
if err != nil {
log.Fatalf("Could not find %v in $PATH: %v", res, err)
}
cmd := exec.Command(cmdName)
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
log.Printf("Running %v", res)
if err := cmd.Start(); err != nil {
log.Fatalf("Program %v failed... | go | {
"resource": ""
} |
q31875 | runDemoBlobServerContainer | train | func runDemoBlobServerContainer(name string) error {
removeContainer(name)
cmd := exec.Command("docker", "run",
"--rm",
"--name="+name,
"-e", "CAMLI_ROOT="+prodSrcDir+"/website/blobserver-example/root",
"-e", "CAMLI_PASSWORD="+randHex(20),
"-v", pkSrcDir()+":"+prodSrcDir,
"--net=host",
"--workdir="+prod... | go | {
"resource": ""
} |
q31876 | httpClient | train | func httpClient(projID string) *http.Client {
if *gceJWTFile == "" {
log.Fatal("Cannot initialize an authorized http Client without --gce_jwt_file")
}
jsonSlurp, err := ioutil.ReadFile(*gceJWTFile)
if err != nil {
log.Fatalf("Error reading --gce_jwt_file value: %v", err)
}
jwtConf, err := google.JWTConfigFrom... | go | {
"resource": ""
} |
q31877 | issueRedirect | train | func issueRedirect(urlPath string) (string, bool) {
m := issueNum.FindStringSubmatch(urlPath)
if m == nil {
return "", false
}
issueNumber := strings.TrimPrefix(m[1], "/")
suffix := ""
if issueNumber != "" {
suffix = "/" + issueNumber
}
return "https://github.com/perkeep/perkeep/issues" + suffix, true
} | go | {
"resource": ""
} |
q31878 | serveRef | train | func serveRef(rw http.ResponseWriter, req *http.Request, ref blob.Ref, fetcher blob.Fetcher) {
if !httputil.IsGet(req) {
http.Error(rw, "Invalid download method.", 400)
return
}
if !httputil.IsLocalhost(req) {
http.Error(rw, "Forbidden.", 403)
return
}
parts := strings.Split(req.URL.Path, "/")
if len(p... | go | {
"resource": ""
} |
q31879 | ParseArmoredPublicKey | train | func ParseArmoredPublicKey(r io.Reader) (shortKeyId, armoredKey string, err error) {
var buf bytes.Buffer
pk, err := openArmoredPublicKeyFile(ioutil.NopCloser(io.TeeReader(r, &buf)))
if err != nil {
return
}
return publicKeyID(pk), buf.String(), nil
} | go | {
"resource": ""
} |
q31880 | NewEntity | train | func NewEntity() (*openpgp.Entity, error) {
name := "" // intentionally empty
comment := "camlistore"
email := "" // intentionally empty
return openpgp.NewEntity(name, comment, email, nil)
} | go | {
"resource": ""
} |
q31881 | KeyIdFromRing | train | func KeyIdFromRing(secRing string) (keyID string, err error) {
f, err := wkfs.Open(secRing)
if err != nil {
return "", fmt.Errorf("Could not open secret ring file %v: %v", secRing, err)
}
defer f.Close()
el, err := openpgp.ReadKeyRing(f)
if err != nil {
return "", fmt.Errorf("Could not read secret ring file %... | go | {
"resource": ""
} |
q31882 | GenerateNewSecRing | train | func GenerateNewSecRing(secRing string) (keyID string, err error) {
ent, err := NewEntity()
if err != nil {
return "", fmt.Errorf("generating new identity: %v", err)
}
if err := os.MkdirAll(filepath.Dir(secRing), 0700); err != nil {
return "", err
}
f, err := wkfs.OpenFile(secRing, os.O_WRONLY|os.O_CREATE|os.... | go | {
"resource": ""
} |
q31883 | New | train | func New(opts ...ClientOption) (*Client, error) {
c := &Client{
haveCache: noHaveCache{},
Logger: log.New(os.Stderr, "", log.Ldate|log.Ltime),
authMode: auth.None{},
}
for _, v := range opts {
v.modifyClient(c)
}
if c.sto != nil && len(opts) > 1 {
return nil, errors.New("use of OptionUseStorageClient... | go | {
"resource": ""
} |
q31884 | NewOrFail | train | func NewOrFail(opts ...ClientOption) *Client {
c, err := New(opts...)
if err != nil {
log.Fatalf("error creating client: %v", err)
}
return c
} | go | {
"resource": ""
} |
q31885 | NewPathClient | train | func (c *Client) NewPathClient(path string) (*Client, error) {
u, err := url.Parse(c.server)
if err != nil {
return nil, fmt.Errorf("bogus server %q for NewPathClient receiver: %v", c.server, err)
}
u.Path = path
pc, err := New(OptionServer(u.String()))
if err != nil {
return nil, err
}
pc.authMode = c.auth... | go | {
"resource": ""
} |
q31886 | transportForConfig | train | func (c *Client) transportForConfig(tc *TransportConfig) http.RoundTripper {
if inGopherJS {
// Calls to net.Dial* functions - which would happen if the client's transport
// is not nil - are prohibited with GopherJS. So we force nil here, so that the
// call to transportForConfig in newClient is of no consequen... | go | {
"resource": ""
} |
q31887 | HTTPStats | train | func (c *Client) HTTPStats() *httputil.StatsTransport {
st, _ := c.httpClient.Transport.(*httputil.StatsTransport)
return st
} | go | {
"resource": ""
} |
q31888 | NewFromShareRoot | train | func NewFromShareRoot(ctx context.Context, shareBlobURL string, opts ...ClientOption) (c *Client, target blob.Ref, err error) {
var root string
m := shareURLRx.FindStringSubmatch(shareBlobURL)
if m == nil {
return nil, blob.Ref{}, fmt.Errorf("Unknown share URL base")
}
c, err = New(append(opts[:len(opts):cap(opt... | go | {
"resource": ""
} |
q31889 | SetHTTPClient | train | func (c *Client) SetHTTPClient(client *http.Client) {
if client == nil {
client = http.DefaultClient
}
c.httpClient = client
} | go | {
"resource": ""
} |
q31890 | BlobRoot | train | func (c *Client) BlobRoot() (string, error) {
prefix, err := c.prefix()
if err != nil {
return "", err
}
return prefix + "/", nil
} | go | {
"resource": ""
} |
q31891 | ServerPublicKeyBlobRef | train | func (c *Client) ServerPublicKeyBlobRef() (blob.Ref, error) {
if err := c.condDiscovery(); err != nil {
return blob.Ref{}, err
}
if !c.serverPublicKeyBlobRef.Valid() {
return blob.Ref{}, ErrNoSigning
}
return c.serverPublicKeyBlobRef, nil
} | go | {
"resource": ""
} |
q31892 | SearchRoot | train | func (c *Client) SearchRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.searchRoot == "" {
return "", ErrNoSearchRoot
}
return c.searchRoot, nil
} | go | {
"resource": ""
} |
q31893 | HelpRoot | train | func (c *Client) HelpRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.helpRoot == "" {
return "", ErrNoHelpRoot
}
return c.helpRoot, nil
} | go | {
"resource": ""
} |
q31894 | ShareRoot | train | func (c *Client) ShareRoot() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.shareRoot == "" {
return "", ErrNoShareRoot
}
return c.shareRoot, nil
} | go | {
"resource": ""
} |
q31895 | SignHandler | train | func (c *Client) SignHandler() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.signHandler == "" {
return "", ErrNoSigning
}
return c.signHandler, nil
} | go | {
"resource": ""
} |
q31896 | StorageGeneration | train | func (c *Client) StorageGeneration() (string, error) {
if err := c.condDiscovery(); err != nil {
return "", err
}
if c.storageGen == "" {
return "", ErrNoStorageGeneration
}
return c.storageGen, nil
} | go | {
"resource": ""
} |
q31897 | HasLegacySHA1 | train | func (c *Client) HasLegacySHA1() (bool, error) {
if err := c.condDiscovery(); err != nil {
return false, err
}
return c.hasLegacySHA1, nil
} | go | {
"resource": ""
} |
q31898 | SyncHandlers | train | func (c *Client) SyncHandlers() ([]*SyncInfo, error) {
if err := c.condDiscovery(); err != nil {
return nil, err
}
if c.syncHandlers == nil {
return nil, ErrNoSync
}
return c.syncHandlers, nil
} | go | {
"resource": ""
} |
q31899 | GetRecentPermanodes | train | func (c *Client) GetRecentPermanodes(ctx context.Context, req *search.RecentRequest) (*search.RecentResponse, error) {
sr, err := c.SearchRoot()
if err != nil {
return nil, err
}
url := sr + req.URLSuffix()
hreq := c.newRequest(ctx, "GET", url)
hres, err := c.expect2XX(hreq)
if err != nil {
return nil, err
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.