_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q31500 | HomeDir | train | func HomeDir() string {
failInTests()
if runtime.GOOS == "windows" {
return os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
}
return os.Getenv("HOME")
} | go | {
"resource": ""
} |
q31501 | NewJSONConfigParser | train | func NewJSONConfigParser() *jsonconfig.ConfigParser {
var cp jsonconfig.ConfigParser
dir, err := PerkeepConfigDir()
if err != nil {
log.Fatalf("NewJSONConfigParser error: %v", err)
}
cp.IncludeDirs = append([]string{dir}, filepath.SplitList(os.Getenv("CAMLI_INCLUDE_PATH"))...)
return &cp
} | go | {
"resource": ""
} |
q31502 | NewMemoryKeyValue | train | func NewMemoryKeyValue() KeyValue {
db := memdb.New(comparer.DefaultComparer, 128)
return &memKeys{db: db}
} | go | {
"resource": ""
} |
q31503 | blobsFromDir | train | func (zh *zipHandler) blobsFromDir(dirPath string, dirBlob blob.Ref) ([]*blobFile, error) {
var list []*blobFile
dr, err := schema.NewDirReader(context.TODO(), zh.fetcher, dirBlob)
if err != nil {
return nil, fmt.Errorf("Could not read dir blob %v: %v", dirBlob, err)
}
ent, err := dr.Readdir(context.TODO(), -1)
... | go | {
"resource": ""
} |
q31504 | renameDuplicates | train | func renameDuplicates(bf []*blobFile) sortedFiles {
noDup := make(map[string]blob.Ref)
// use a map to detect duplicates and rename them
for _, file := range bf {
if _, ok := noDup[file.path]; ok {
// path already exists, so rename
suffix := 0
var newname string
for {
suffix++
ext := path.Ext(f... | go | {
"resource": ""
} |
q31505 | ServeHTTP | train | func (zh *zipHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
// TODO: use http.ServeContent, so Range requests work and downloads can be resumed.
// Will require calculating the zip length once first (ideally as cheaply as possible,
// with dummy counting writer and dummy all-zero-byte-files of a fix... | go | {
"resource": ""
} |
q31506 | Props | train | func (s ShareItemsBtnDef) Props() ShareItemsBtnProps {
uprops := s.ComponentDef.Props()
return uprops.(ShareItemsBtnProps)
} | go | {
"resource": ""
} |
q31507 | appConfig | train | func appConfig() (*config, error) {
configURL := os.Getenv("CAMLI_APP_CONFIG_URL")
if configURL == "" {
return nil, fmt.Errorf("Publisher application needs a CAMLI_APP_CONFIG_URL env var")
}
cl, err := app.Client()
if err != nil {
return nil, fmt.Errorf("could not get a client to fetch extra config: %v", err)
... | go | {
"resource": ""
} |
q31508 | setMasterQuery | train | func (ph *publishHandler) setMasterQuery(topNode blob.Ref) error {
query := &search.SearchQuery{
Sort: search.CreatedDesc,
Limit: -1,
Constraint: &search.Constraint{
Permanode: &search.PermanodeConstraint{
Relation: &search.RelationConstraint{
Relation: "parent",
Any: &search.Constraint{
... | go | {
"resource": ""
} |
q31509 | resolvePrefixHop | train | func (ph *publishHandler) resolvePrefixHop(parent blob.Ref, prefix string) (child blob.Ref, err error) {
// TODO: this is a linear scan right now. this should be
// optimized to use a new database table of members so this is
// a quick lookup. in the meantime it should be in memcached
// at least.
if len(prefix) ... | go | {
"resource": ""
} |
q31510 | serveSubjectTemplate | train | func (pr *publishRequest) serveSubjectTemplate() {
res, err := pr.ph.deepDescribe(pr.subject)
if err != nil {
httputil.ServeError(pr.rw, pr.req, err)
return
}
pr.ph.cacheDescribed(res.Meta)
subdes := res.Meta[pr.subject.String()]
if subdes.CamliType == "file" {
pr.serveFileDownload(subdes)
return
}
he... | go | {
"resource": ""
} |
q31511 | subjectHeader | train | func (pr *publishRequest) subjectHeader(described map[string]*search.DescribedBlob) *publish.PageHeader {
subdes := described[pr.subject.String()]
header := &publish.PageHeader{
Title: html.EscapeString(getTitle(subdes.BlobRef, described)),
CSSFiles: pr.cssFiles(),
JSDeps: pr.jsDeps(),... | go | {
"resource": ""
} |
q31512 | subjectFile | train | func (pr *publishRequest) subjectFile(described map[string]*search.DescribedBlob) (*publish.PageFile, error) {
subdes := described[pr.subject.String()]
contentRef, ok := subdes.ContentRef()
if !ok {
return nil, nil
}
fileDes, err := pr.ph.describe(contentRef)
if err != nil {
return nil, err
}
if fileDes.Fil... | go | {
"resource": ""
} |
q31513 | subjectMembers | train | func (pr *publishRequest) subjectMembers(resMap map[string]*search.DescribedBlob) (*publish.PageMembers, error) {
subdes := resMap[pr.subject.String()]
res, err := pr.ph.describeMembers(pr.subject)
if err != nil {
return nil, err
}
members := []*search.DescribedBlob{}
for _, v := range res.Blobs {
members = a... | go | {
"resource": ""
} |
q31514 | serveZip | train | func (pr *publishRequest) serveZip() {
filename := ""
if len(pr.subres) > len("/=z/") {
filename = pr.subres[4:]
}
zh := &zipHandler{
fetcher: pr.ph.cl,
cl: pr.ph.cl,
root: pr.subject,
filename: filename,
}
zh.ServeHTTP(pr.rw, pr.req)
} | go | {
"resource": ""
} |
q31515 | SubFetch | train | func (s *storage) SubFetch(ctx context.Context, ref blob.Ref, offset, length int64) (io.ReadCloser, error) {
// TODO: pass ctx to more calls within this method.
m, err := s.getMetaRow(ref)
if err != nil {
return nil, err
}
if m.isPacked() {
length, err = capOffsetLength(m.size, offset, length)
if err != nil ... | go | {
"resource": ""
} |
q31516 | NewDeployHandlerFromConfig | train | func NewDeployHandlerFromConfig(host, prefix string, cfg *Config) (*DeployHandler, error) {
if cfg == nil {
panic("NewDeployHandlerFromConfig: nil config")
}
if cfg.ClientID == "" {
return nil, errors.New("oauth2 clientID required in config")
}
if cfg.ClientSecret == "" {
return nil, errors.New("oauth2 clien... | go | {
"resource": ""
} |
q31517 | serveRoot | train | func (h *DeployHandler) serveRoot(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
h.serveSetup(w, r)
return
}
_, err := r.Cookie("user")
if err != nil {
http.SetCookie(w, newCookie())
}
camliRev := h.camliRev()
if r.FormValue("WIP") == "1" {
camliRev = "WORKINPROGRESS"
}
h.tplMu.RLoc... | go | {
"resource": ""
} |
q31518 | serveOldInstance | train | func (h *DeployHandler) serveOldInstance(w http.ResponseWriter, br blob.Ref, depl *Deployer) (found bool) {
inst, err := depl.Get()
if err != nil {
// TODO(mpl,bradfitz): log or do something more
// drastic if the error is something other than
// instance not found.
return false
}
h.logger.Printf("Reusing e... | go | {
"resource": ""
} |
q31519 | serveInstanceState | train | func (h *DeployHandler) serveInstanceState(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if r.Method != "GET" {
h.serveError(w, r, fmt.Errorf("Wrong method: %v", r.Method))
return
}
br := r.URL.Query().Get("instancekey")
stateValue, err := h.instState.Get(br)
if err != nil {
http.Error(w, "un... | go | {
"resource": ""
} |
q31520 | serveProgress | train | func (h *DeployHandler) serveProgress(w http.ResponseWriter, instanceKey blob.Ref) {
h.tplMu.RLock()
defer h.tplMu.RUnlock()
if err := h.tpl.ExecuteTemplate(w, "withform", &TemplateData{
Prefix: h.prefix,
InstanceKey: instanceKey.String(),
PiggyGIF: h.piggyGIF,
}); err != nil {
h.logger.Printf("Coul... | go | {
"resource": ""
} |
q31521 | randomZone | train | func (h *DeployHandler) randomZone(region string) string {
h.zonesMu.RLock()
defer h.zonesMu.RUnlock()
zones, ok := h.zones[region]
if !ok {
return fallbackZone
}
return region + zones[rand.Intn(len(zones))]
} | go | {
"resource": ""
} |
q31522 | fromState | train | func fromState(r *http.Request) (br blob.Ref, xsrfToken string, err error) {
params := strings.Split(r.FormValue("state"), ":")
if len(params) != 2 {
return br, "", fmt.Errorf("Invalid format for state parameter: %q, wanted blobRef:xsrfToken", r.FormValue("state"))
}
br, ok := blob.Parse(params[0])
if !ok {
re... | go | {
"resource": ""
} |
q31523 | dataStores | train | func dataStores() (blobserver.Storage, sorted.KeyValue, error) {
dataDir := os.Getenv("CAMLI_GCE_DATA")
if dataDir == "" {
var err error
dataDir, err = ioutil.TempDir("", "camli-gcedeployer-data")
if err != nil {
return nil, nil, err
}
log.Printf("data dir not provided as env var CAMLI_GCE_DATA, so defau... | go | {
"resource": ""
} |
q31524 | handleMasterQuery | train | func (a *Handler) handleMasterQuery(w http.ResponseWriter, r *http.Request) {
if !(a.auth.AllowedAccess(r)&auth.OpAll == auth.OpAll) {
auth.SendUnauthorized(w, r)
return
}
if r.Method != http.MethodPost {
http.Error(w, "not a POST", http.StatusMethodNotAllowed)
return
}
if a.sh == nil {
http.Error(w, "ap... | go | {
"resource": ""
} |
q31525 | handleSearch | train | func (a *Handler) handleSearch(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
camhttputil.BadRequestError(w, camhttputil.InvalidMethodError{}.Error())
return
}
if a.sh == nil {
http.Error(w, "app proxy has no search handler", 500)
return
}
a.masterQueryMu.RLock()
if a.masterQue... | go | {
"resource": ""
} |
q31526 | allowProxySearchResponse | train | func (a *Handler) allowProxySearchResponse(sr *search.SearchResult) bool {
a.masterQueryMu.RLock()
defer a.masterQueryMu.RUnlock()
for _, v := range sr.Blobs {
if _, ok := a.domainBlobs[v.Blob]; !ok {
return false
}
}
return true
} | go | {
"resource": ""
} |
q31527 | randListenFn | train | func randListenFn(listenAddr string, randPortFn func() (int, error)) (string, error) {
portIdx := strings.LastIndex(listenAddr, ":") + 1
if portIdx <= 0 || portIdx >= len(listenAddr) {
return "", errors.New("invalid listen addr, no port found")
}
port, err := randPortFn()
if err != nil {
return "", err
}
ret... | go | {
"resource": ""
} |
q31528 | baseURL | train | func baseURL(serverBaseURL, listenAddr string) (string, error) {
backendURL, err := url.Parse(serverBaseURL)
if err != nil {
return "", fmt.Errorf("invalid baseURL %q: %v", serverBaseURL, err)
}
scheme := backendURL.Scheme
host := backendURL.Host
if netutil.HasPort(host) {
host = host[:strings.LastIndex(host,... | go | {
"resource": ""
} |
q31529 | FromJSONConfig | train | func FromJSONConfig(config jsonconfig.Obj, prefix, serverBaseURL string) (HandlerConfig, error) {
hc := HandlerConfig{
Program: config.RequiredString("program"),
Prefix: config.OptionalString("prefix", prefix),
BackendURL: config.OptionalString("backendURL", ""),
Listen: config.OptionalS... | go | {
"resource": ""
} |
q31530 | InitHandler | train | func (a *Handler) InitHandler(hl blobserver.FindHandlerByTyper) error {
apName := a.ProgramName()
searchPrefix, _, err := hl.FindHandlerByType("search")
if err != nil {
return fmt.Errorf("No search handler configured, which is necessary for the %v app handler", apName)
}
var sh *search.Handler
_, hi := hl.AllHa... | go | {
"resource": ""
} |
q31531 | Quit | train | func (a *Handler) Quit() error {
err := a.process.Signal(os.Interrupt)
if err != nil {
return err
}
c := make(chan error)
go func() {
_, err := a.process.Wait()
c <- err
}()
select {
case err = <-c:
case <-time.After(5 * time.Second):
// TODO Do we want to SIGKILL here or just leave the app alone?
e... | go | {
"resource": ""
} |
q31532 | NewCachingFetcher | train | func NewCachingFetcher(cache blobserver.Cache, fetcher blob.Fetcher) *CachingFetcher {
return &CachingFetcher{c: cache, sf: fetcher}
} | go | {
"resource": ""
} |
q31533 | SetCacheHitHook | train | func (cf *CachingFetcher) SetCacheHitHook(fn func(br blob.Ref, rc io.ReadCloser) (io.ReadCloser, error)) {
cf.cacheHitHook = fn
} | go | {
"resource": ""
} |
q31534 | maybeAddChild | train | func (n *mutDir) maybeAddChild(name string, permanode *search.DescribedPermanode,
child mutFileOrDir) {
if current, ok := n.children[name]; !ok ||
current.permanodeString() != child.permanodeString() {
child.xattr().load(permanode)
n.children[name] = child
}
} | go | {
"resource": ""
} |
q31535 | Release | train | func (h *mutFileHandle) Release(ctx context.Context, req *fuse.ReleaseRequest) error {
h.tmp.Close()
os.Remove(h.tmp.Name())
h.tmp = nil
return nil
} | go | {
"resource": ""
} |
q31536 | parseCanonicalTime | train | func parseCanonicalTime(in string) (time.Time, error) {
if len(in) < 20 || in[len(in)-1] != 'Z' {
return time.Time{}, errUnparseableTimestamp
}
if !(in[4] == '-' && in[7] == '-' && in[10] == 'T' &&
in[13] == ':' && in[16] == ':' && (in[19] == '.' || in[19] == 'Z')) {
return time.Time{}, fmt.Errorf("positional... | go | {
"resource": ""
} |
q31537 | NewMemoryIndex | train | func NewMemoryIndex() *Index {
ix, err := New(sorted.NewMemoryKeyValue())
if err != nil {
// Nothing to fail in memory, so worth panicing about
// if we ever see something.
panic(err)
}
return ix
} | go | {
"resource": ""
} |
q31538 | pageCountPoppler | train | func pageCountPoppler(filename string) (cnt int, err error) {
cmd := exec.Command("pdfinfo", filename)
out, err := cmd.CombinedOutput()
if err != nil {
return cnt, fmt.Errorf("could not get page count with pdfinfo: %v, %v", err, string(out))
}
sc := bufio.NewScanner(bytes.NewReader(out))
for sc.Scan() {
l := ... | go | {
"resource": ""
} |
q31539 | pageCountNative | train | func pageCountNative(filename string) (int, error) {
f, err := os.Open(filename)
if err != nil {
return 0, err
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return 0, err
}
p, err := pdf.NewReader(f, fi.Size())
if err != nil {
return 0, err
}
c := p.NumPage()
if c < 1 {
return 0, errors.New(... | go | {
"resource": ""
} |
q31540 | pageCount | train | func pageCount(filename string) (int, error) {
n, err := pageCountNative(filename)
if err != nil {
// fallback to using pdfinfo when internal count failed
n, err = pageCountPoppler(filename)
}
return n, err
} | go | {
"resource": ""
} |
q31541 | SearchHelp | train | func SearchHelp() string {
type help struct{ Name, Description string }
h := []help{}
for _, p := range keywords {
h = append(h, help{p.Name(), p.Description()})
}
b, err := json.MarshalIndent(h, "", " ")
if err != nil {
return "Error marshalling"
}
return string(b)
} | go | {
"resource": ""
} |
q31542 | ReceiveString | train | func ReceiveString(ctx context.Context, dst BlobReceiver, s string) (blob.SizedRef, error) {
return Receive(ctx, dst, blob.RefFromString(s), strings.NewReader(s))
} | go | {
"resource": ""
} |
q31543 | Receive | train | func Receive(ctx context.Context, dst BlobReceiver, br blob.Ref, src io.Reader) (blob.SizedRef, error) {
return receive(ctx, dst, br, src, true)
} | go | {
"resource": ""
} |
q31544 | Register | train | func Register(name string, im Importer) {
if _, dup := importers[name]; dup {
panic("Dup registration of importer " + name)
}
if _, dup := reservedImporterKey[name]; dup {
panic("Dup registration of importer " + name)
}
if pt := im.Properties().PermanodeImporterType; pt != "" {
if _, dup := importers[pt]; du... | go | {
"resource": ""
} |
q31545 | Context | train | func (rc *RunContext) Context() context.Context {
if rc.ctx != nil {
return rc.ctx
}
return context.Background()
} | go | {
"resource": ""
} |
q31546 | CreateAccount | train | func CreateAccount(h *Host, impl string) (*RunContext, error) {
imp, ok := h.imp[impl]
if !ok {
return nil, fmt.Errorf("host does not have a %v importer", impl)
}
ia, err := imp.newAccount()
if err != nil {
return nil, fmt.Errorf("could not create new account for importer %v: %v", impl, err)
}
rc := &RunCont... | go | {
"resource": ""
} |
q31547 | AccountsStatus | train | func (h *Host) AccountsStatus() (interface{}, []camtypes.StatusError) {
h.didInit.Wait()
var s []accountStatus
var errs []camtypes.StatusError
for _, impName := range h.importers {
imp := h.imp[impName]
accts, _ := imp.Accounts()
for _, ia := range accts {
as := accountStatus{
Type: impName,
Href: ... | go | {
"resource": ""
} |
q31548 | RunImporterAccount | train | func (h *Host) RunImporterAccount(importerType string, accountNode blob.Ref) error {
h.didInit.Wait()
imp, ok := h.imp[importerType]
if !ok {
return fmt.Errorf("no %q importer for this account", importerType)
}
accounts, err := imp.Accounts()
if err != nil {
return err
}
for _, ia := range accounts {
if i... | go | {
"resource": ""
} |
q31549 | HTTPClient | train | func (h *Host) HTTPClient() *http.Client {
if h.client == nil {
return http.DefaultClient
}
return h.client
} | go | {
"resource": ""
} |
q31550 | HTTPTransport | train | func (h *Host) HTTPTransport() http.RoundTripper {
if h.transport == nil {
return http.DefaultTransport
}
return h.transport
} | go | {
"resource": ""
} |
q31551 | NewObject | train | func (h *Host) NewObject() (*Object, error) {
ctx := context.TODO() // TODO: move the NewObject method to some "ImportRun" type with a context field?
pn, err := h.upload(ctx, schema.NewUnsignedPermanode())
if err != nil {
return nil, err
}
// No need to do a describe query against it: we know it's
// empty (has... | go | {
"resource": ""
} |
q31552 | Attr | train | func (o *Object) Attr(attr string) string {
o.mu.RLock()
defer o.mu.RUnlock()
if v := o.attr[attr]; len(v) > 0 {
return v[0]
}
return ""
} | go | {
"resource": ""
} |
q31553 | Attrs | train | func (o *Object) Attrs(attr string) []string {
o.mu.RLock()
defer o.mu.RUnlock()
return o.attr[attr]
} | go | {
"resource": ""
} |
q31554 | ForeachAttr | train | func (o *Object) ForeachAttr(fn func(key, value string)) {
o.mu.RLock()
defer o.mu.RUnlock()
for k, vv := range o.attr {
for _, v := range vv {
fn(k, v)
}
}
} | go | {
"resource": ""
} |
q31555 | DelAttr | train | func (o *Object) DelAttr(key, value string) error {
ctx := context.TODO()
o.mu.Lock()
defer o.mu.Unlock()
_, err := o.h.upload(ctx, schema.NewDelAttributeClaim(o.pn, key, value))
if err != nil {
return err
}
if o.attr == nil {
o.attr = make(map[string][]string)
return nil
}
if value == "" {
delete(o.at... | go | {
"resource": ""
} |
q31556 | SetAttr | train | func (o *Object) SetAttr(key, value string) error {
ctx := context.TODO() // TODO: make it possible to get a context via Object; either new context field, or via some "ImportRun" field?
if o.Attr(key) == value {
return nil
}
_, err := o.h.upload(ctx, schema.NewSetAttributeClaim(o.pn, key, value))
if err != nil {... | go | {
"resource": ""
} |
q31557 | SetAttrValues | train | func (o *Object) SetAttrValues(key string, attrs []string) error {
ctx := context.TODO() // TODO: make it possible to get a context via Object; either new context field, or via some "ImportRun" field?
exists := asSet(o.Attrs(key))
actual := asSet(attrs)
o.mu.Lock()
defer o.mu.Unlock()
// add new values
for v :=... | go | {
"resource": ""
} |
q31558 | ObjectFromRef | train | func (h *Host) ObjectFromRef(permanodeRef blob.Ref) (*Object, error) {
ctx := context.TODO()
res, err := h.search.Describe(ctx, &search.DescribeRequest{
BlobRef: permanodeRef,
Depth: 1,
})
if err != nil {
return nil, err
}
db, ok := res.Meta[permanodeRef.String()]
if !ok {
return nil, fmt.Errorf("perma... | go | {
"resource": ""
} |
q31559 | NewCache | train | func NewCache(size int64) *Storage {
return &Storage{
maxSize: size,
lru: lru.New(0), // infinite items; we evict by size, not count
}
} | go | {
"resource": ""
} |
q31560 | NumBlobs | train | func (s *Storage) NumBlobs() int {
s.mu.RLock()
defer s.mu.RUnlock()
return len(s.m)
} | go | {
"resource": ""
} |
q31561 | SumBlobSize | train | func (s *Storage) SumBlobSize() int64 {
s.mu.RLock()
defer s.mu.RUnlock()
return s.size
} | go | {
"resource": ""
} |
q31562 | BlobrefStrings | train | func (s *Storage) BlobrefStrings() []string {
s.mu.RLock()
defer s.mu.RUnlock()
sorted := make([]string, 0, len(s.m))
for br := range s.m {
sorted = append(sorted, br.String())
}
sort.Strings(sorted)
return sorted
} | go | {
"resource": ""
} |
q31563 | Stats | train | func (s *Storage) Stats() (blobsFetched, bytesFetched int64) {
return atomic.LoadInt64(&s.blobsFetched), atomic.LoadInt64(&s.bytesFetched)
} | go | {
"resource": ""
} |
q31564 | ConnUserid | train | func ConnUserid(conn net.Conn) (uid int, err error) {
return AddrPairUserid(conn.LocalAddr(), conn.RemoteAddr())
} | go | {
"resource": ""
} |
q31565 | writeNode | train | func writeNode(w io.Writer, fset *token.FileSet, x interface{}) {
// convert trailing tabs into spaces using a tconv filter
// to ensure a good outcome in most browsers (there may still
// be tabs in comments and strings, but converting those into
// the right number of spaces is much harder)
//
// TODO(gri) reth... | go | {
"resource": ""
} |
q31566 | getQuery | train | func (d SelectAllBtnDef) getQuery() *search.SearchQuery {
predicate := d.Props().callbacks.GetQuery()
if !strings.HasPrefix(predicate, "ref:") {
return &search.SearchQuery{
Limit: -1,
Expression: predicate,
}
}
// If we've got a ref: predicate, assume the given blobRef is a container, and
// find i... | go | {
"resource": ""
} |
q31567 | findAll | train | func (d SelectAllBtnDef) findAll() (map[string]bool, error) {
query := d.getQuery()
if query == nil {
return nil, nil
}
authToken := d.Props().authToken
am, err := auth.TokenOrNone(authToken)
if err != nil {
return nil, fmt.Errorf("Error setting up auth: %v", err)
}
cl, err := client.New(client.OptionAuthMo... | go | {
"resource": ""
} |
q31568 | Client | train | func Client() (*client.Client, error) {
server := os.Getenv("CAMLI_API_HOST")
if server == "" {
return nil, errors.New("CAMLI_API_HOST var not set")
}
am, err := basicAuth()
if err != nil {
return nil, err
}
return client.New(
client.OptionNoExternalConfig(),
client.OptionServer(server),
client.OptionA... | go | {
"resource": ""
} |
q31569 | storageFromParam | train | func (c *syncCmd) storageFromParam(which storageType, val string) (blobserver.Storage, error) {
var httpClient *http.Client
if val == "" {
switch which {
case storageThird:
return nil, nil
case storageSource:
discl := c.discoClient()
src, err := discl.BlobRoot()
if err != nil {
return nil, fmt.... | go | {
"resource": ""
} |
q31570 | RemoveBlobs | train | func (c *Client) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
if c.sto != nil {
return c.sto.RemoveBlobs(ctx, blobs)
}
pfx, err := c.prefix()
if err != nil {
return err
}
url_ := fmt.Sprintf("%s/camli/remove", pfx)
params := make(url.Values) // "blobN" -> BlobRefStr
needsDelete := ... | go | {
"resource": ""
} |
q31571 | RemoveBlob | train | func (c *Client) RemoveBlob(ctx context.Context, b blob.Ref) error {
return c.RemoveBlobs(ctx, []blob.Ref{b})
} | go | {
"resource": ""
} |
q31572 | setClient | train | func (c *listCmd) setClient() error {
ss, err := c.syncCmd.storageFromParam("src", c.syncCmd.src)
if err != nil {
fmt.Errorf("Could not set client for describe requests: %v", err)
}
var ok bool
c.cl, ok = ss.(*client.Client)
if !ok {
return fmt.Errorf("storageFromParam returned a %T, was expecting a *client.C... | go | {
"resource": ""
} |
q31573 | NewRegexpFakeTransport | train | func NewRegexpFakeTransport(allMatchers []*Matcher) (http.RoundTripper, error) {
var result regexpFakeTransport = []*regexPair{}
for _, matcher := range allMatchers {
r, err := regexp.Compile(matcher.URLRegex)
if err != nil {
return nil, err
}
pair := regexPair{r, matcher.Fn}
result = append(result, &pai... | go | {
"resource": ""
} |
q31574 | FileResponder | train | func FileResponder(filename string) func() *http.Response {
return func() *http.Response {
f, err := os.Open(filename)
if err != nil {
return &http.Response{StatusCode: 404, Status: "404 Not Found", Body: types.EmptyBody}
}
return &http.Response{StatusCode: 200, Status: "200 OK", Body: f}
}
} | go | {
"resource": ""
} |
q31575 | StaticResponder | train | func StaticResponder(res string) func() *http.Response {
_, err := http.ReadResponse(bufio.NewReader(strings.NewReader(res)), nil)
if err != nil {
panic("Invalid response given to StaticResponder: " + err.Error())
}
return func() *http.Response {
res, _ := http.ReadResponse(bufio.NewReader(strings.NewReader(res... | go | {
"resource": ""
} |
q31576 | Command | train | func (f FFmpegThumbnailer) Command(uri *url.URL) (string, []string) {
return "ffmpeg", []string{
"-seekable", "1",
"-i", uri.String(),
"-vf", "thumbnail",
"-frames:v", "1",
"-f", "image2pipe",
"-c:v", "png",
"pipe:1",
}
} | go | {
"resource": ""
} |
q31577 | NewKeyValue | train | func NewKeyValue(cfg jsonconfig.Obj) (KeyValue, error) {
var s KeyValue
var err error
typ := cfg.RequiredString("type")
ctor, ok := ctors[typ]
if typ != "" && !ok {
return nil, fmt.Errorf("Invalid sorted.KeyValue type %q", typ)
}
if ok {
s, err = ctor(cfg)
if err != nil {
we, ok := err.(NeedWipeError)
... | go | {
"resource": ""
} |
q31578 | NewKeyValueMaybeWipe | train | func NewKeyValueMaybeWipe(cfg jsonconfig.Obj) (KeyValue, error) {
kv, err := NewKeyValue(cfg)
if err == nil {
return kv, nil
}
if _, ok := err.(NeedWipeError); !ok {
return nil, err
}
wiper, ok := kv.(Wiper)
if !ok {
return nil, fmt.Errorf("storage type %T needs wiping because %v. But it doesn't support so... | go | {
"resource": ""
} |
q31579 | CheckSizes | train | func CheckSizes(key, value string) error {
if len(key) > MaxKeySize {
return ErrKeyTooLarge
}
if len(value) > MaxValueSize {
return ErrValueTooLarge
}
return nil
} | go | {
"resource": ""
} |
q31580 | addContinueConstraint | train | func (q *SearchQuery) addContinueConstraint() error {
cont := q.Continue
if cont == "" {
return nil
}
if q.Constraint.onlyMatchesPermanode() {
tokent, lastbr, ok := parsePermanodeContinueToken(cont)
if !ok {
return errors.New("Unexpected continue token")
}
if q.Sort == LastModifiedDesc || q.Sort == Cre... | go | {
"resource": ""
} |
q31581 | matchesPermanodeTypes | train | func (c *Constraint) matchesPermanodeTypes() []string {
if c == nil {
return nil
}
if pc := c.Permanode; pc != nil && pc.Attr == "camliNodeType" && pc.Value != "" {
return []string{pc.Value}
}
if lc := c.Logical; lc != nil {
sa := lc.A.matchesPermanodeTypes()
sb := lc.B.matchesPermanodeTypes()
switch lc.... | go | {
"resource": ""
} |
q31582 | matchesAtMostOneBlob | train | func (c *Constraint) matchesAtMostOneBlob() blob.Ref {
if c == nil {
return blob.Ref{}
}
if c.BlobRefPrefix != "" {
br, ok := blob.Parse(c.BlobRefPrefix)
if ok {
return br
}
}
if c.Logical != nil && c.Logical.Op == "and" {
if br := c.Logical.A.matchesAtMostOneBlob(); br.Valid() {
return br
}
if... | go | {
"resource": ""
} |
q31583 | setResultContinue | train | func (q *SearchQuery) setResultContinue(corpus *index.Corpus, res *SearchResult) {
if !q.Constraint.onlyMatchesPermanode() {
return
}
var pnTimeFunc func(blob.Ref) (t time.Time, ok bool)
switch q.Sort {
case LastModifiedDesc:
pnTimeFunc = corpus.PermanodeModtime
case CreatedDesc:
pnTimeFunc = corpus.Permano... | go | {
"resource": ""
} |
q31584 | hasValueConstraint | train | func (c *PermanodeConstraint) hasValueConstraint() bool {
// If a field has been added or removed, update this after adding the new field to the return statement if necessary.
const expectedFields = 15
if numPermanodeFields != expectedFields {
panic(fmt.Sprintf("PermanodeConstraint field count changed (now %v rath... | go | {
"resource": ""
} |
q31585 | permanodeMatchesAttrVals | train | func (c *PermanodeConstraint) permanodeMatchesAttrVals(ctx context.Context, s *search, vals []string) (bool, error) {
if c.NumValue != nil && !c.NumValue.intMatches(int64(len(vals))) {
return false, nil
}
if c.hasValueConstraint() {
nmatch := 0
for _, val := range vals {
match, err := c.permanodeMatchesAttr... | go | {
"resource": ""
} |
q31586 | hasMatchingParent | train | func (c *DirConstraint) hasMatchingParent(ctx context.Context, s *search, parents map[blob.Ref]struct{}) (bool, error) {
for parent := range parents {
meta, err := s.blobMeta(ctx, parent)
if err != nil {
if os.IsNotExist(err) {
continue
}
return false, err
}
ok, err := c.blobMatches(ctx, s, parent... | go | {
"resource": ""
} |
q31587 | hasMatchingChild | train | func (c *DirConstraint) hasMatchingChild(ctx context.Context, s *search, children map[blob.Ref]struct{},
matcher func(context.Context, *search, blob.Ref, camtypes.BlobMeta) (bool, error)) (bool, error) {
// TODO(mpl): See if we're guaranteed to be CPU-bound (i.e. all resources are in
// corpus), and if not, add some... | go | {
"resource": ""
} |
q31588 | StorageGeneration | train | func (ds *DiskStorage) StorageGeneration() (initTime time.Time, random string, err error) {
return ds.gen.StorageGeneration()
} | go | {
"resource": ""
} |
q31589 | LogWriter | train | func LogWriter() (w io.WriteCloser, err error) {
w = multiWriteCloser{
w: os.Stderr,
// Because we don't actually want to close os.Stderr (which we could).
closer: types.NopCloser,
}
if !env.OnGCE() {
return
}
projID, err := metadata.ProjectID()
if projID == "" {
log.Printf("Error getting project ID: %v... | go | {
"resource": ""
} |
q31590 | resetInstance | train | func resetInstance() error {
if !env.OnGCE() {
return errors.New("cannot reset instance if not on GCE")
}
ctx := context.Background()
inst, err := gceInstance()
if err != nil {
return err
}
cs, projectID, zone, name := inst.cis, inst.projectID, inst.zone, inst.name
call := cs.Reset(projectID, zone, name)... | go | {
"resource": ""
} |
q31591 | OnClick | train | func (d ShareItemsBtnDef) OnClick(e *react.SyntheticMouseEvent) {
go func() {
sharedURL, err := d.shareSelection()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
return
}
prefix, err := d.urlPrefix()
if err != nil {
dom.GetWindow().Alert(fmt.Sprintf("Cannot display full share URL: %v"... | go | {
"resource": ""
} |
q31592 | mkdir | train | func mkdir(am auth.AuthMode, children []blob.Ref) (blob.Ref, error) {
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return blob.Ref{}, err
}
var newdir blob.Ref
ss := schema.NewStaticSet()
subsets := ss.SetStaticSetMembers(children)
for _, v := range subsets {
// TODO(mpl): make them concu... | go | {
"resource": ""
} |
q31593 | shareFile | train | func shareFile(am auth.AuthMode, target blob.Ref, isDir bool) (string, error) {
cl, err := client.New(client.OptionAuthMode(am))
if err != nil {
return "", err
}
claim, err := newShareClaim(cl, target)
if err != nil {
return "", err
}
shareRoot, err := cl.ShareRoot()
if err != nil {
return "", err
}
if ... | go | {
"resource": ""
} |
q31594 | newShareClaim | train | func newShareClaim(cl *client.Client, target blob.Ref) (blob.Ref, error) {
var claim blob.Ref
signer, err := cl.ServerPublicKeyBlobRef()
if err != nil {
return claim, fmt.Errorf("could not get signer: %v", err)
}
shareSchema := schema.NewShareRef(schema.ShareHaveRef, true)
shareSchema.SetShareTarget(target)
un... | go | {
"resource": ""
} |
q31595 | fileAsPhoto | train | func (dl *downloader) fileAsPhoto(f *drive.File) *photo {
if f == nil {
return nil
}
if f.Size == 0 {
// anything non-binary can't be a photo, so skip it.
return nil
}
if !inPhotoSpace(f) {
// not a photo
return nil
}
p := &photo{
ID: f.Id,
Name: f.Name,
Starred: ... | go | {
"resource": ""
} |
q31596 | rateLimit | train | func (dl *downloader) rateLimit(ctx context.Context, f func() error) error {
const (
msgRateLimitExceeded = "Rate Limit Exceeded"
msgUserRateLimitExceeded = "User Rate Limit Exceeded"
msgUserRateLimitExceededShort = "userRateLimitExceeded"
)
// Ensure a 1 minute try limit.
ctx, cancel := contex... | go | {
"resource": ""
} |
q31597 | MIMEType | train | func MIMEType(hdr []byte) string {
hlen := len(hdr)
for _, pte := range matchTable {
if pte.fn != nil {
if pte.fn(hdr) {
return pte.mtype
}
continue
}
plen := pte.offset + len(pte.prefix)
if hlen > plen && bytes.Equal(hdr[pte.offset:plen], pte.prefix) {
return pte.mtype
}
}
t := http.Detec... | go | {
"resource": ""
} |
q31598 | MIMETypeFromReaderAt | train | func MIMETypeFromReaderAt(ra io.ReaderAt) (mime string) {
var buf [1024]byte
n, _ := ra.ReadAt(buf[:], 0)
return MIMEType(buf[:n])
} | go | {
"resource": ""
} |
q31599 | HasExtension | train | func HasExtension(filename string, extensions map[string]bool) bool {
var ext string
if e := filepath.Ext(filename); strings.HasPrefix(e, ".") {
ext = e[1:]
} else {
return false
}
// Case-insensitive lookup.
// Optimistically assume a short ASCII extension and be
// allocation-free in that case.
var buf [... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.