_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q31700 | noteResultFromRule | train | func (dr *DescribeRequest) noteResultFromRule(rule *DescribeRule, br blob.Ref) {
if dr.resFromRule == nil {
dr.resFromRule = make(map[*DescribeRule]map[blob.Ref]bool)
}
m, ok := dr.resFromRule[rule]
if !ok {
m = make(map[blob.Ref]bool)
dr.resFromRule[rule] = m
}
m[br] = true
} | go | {
"resource": ""
} |
q31701 | fileList | train | func fileList() ([]string, error) {
camliRootPath, err := osutil.GoPackagePath("perkeep.org")
if err != nil {
log.Fatal("Package perkeep.org not found in $GOPATH (or $GOPATH not defined).")
}
uiDir := filepath.Join(camliRootPath, "server", "perkeepd", "ui")
closureDepsFile := filepath.Join(closureGitDir, "closur... | go | {
"resource": ""
} |
q31702 | run | train | func (c *command) run() []byte {
cmd := exec.Command(c.program, c.args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
out := stdout.Bytes()
if err != nil {
log.Fatalf("Could not run %v: %v: %v: %v", c, err, string(out), stderr.String())
}
return out
} | go | {
"resource": ""
} |
q31703 | Delete | train | func (kv *keyValue) Delete(key string) error {
kv.mu.Lock()
defer kv.mu.Unlock()
err := kv.db.Remove(&bson.M{mgoKey: key})
if err == mgo.ErrNotFound {
return nil
}
return err
} | go | {
"resource": ""
} |
q31704 | Wipe | train | func (kv *keyValue) Wipe() error {
kv.mu.Lock()
defer kv.mu.Unlock()
_, err := kv.db.RemoveAll(nil)
return err
} | go | {
"resource": ""
} |
q31705 | Ping | train | func Ping(host string, timeout time.Duration) bool {
return (&instance{server: host}).ping(timeout)
} | go | {
"resource": ""
} |
q31706 | SendStatusUpdate | train | func (h *Handler) SendStatusUpdate(status json.RawMessage) {
h.wsHub.statusUpdate <- status
} | go | {
"resource": ""
} |
q31707 | HasLegacySHA1 | train | func (h *Handler) HasLegacySHA1() bool {
idx, ok := h.index.(*index.Index)
if !ok {
log.Printf("Cannot guess for legacy SHA1 because we don't have an *index.Index")
return false
}
ok, err := idx.HasLegacySHA1()
if err != nil {
log.Printf("Cannot guess for legacy SHA1: %v", err)
return false
}
return ok
} | go | {
"resource": ""
} |
q31708 | GetRecentPermanodes | train | func (h *Handler) GetRecentPermanodes(ctx context.Context, req *RecentRequest) (*RecentResponse, error) {
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan camtypes.RecentPermanode)
errch := make(chan error, 1)
before := time.Now()
if !req.Before.IsZero() {
before = req.Before
}
go func() {
// TODO(m... | go | {
"resource": ""
} |
q31709 | GetPermanodesWithAttr | train | func (h *Handler) GetPermanodesWithAttr(req *WithAttrRequest) (*WithAttrResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
ch := make(chan blob.Ref, buffered)
errch := make(chan error, 1)
go func() {
signer := req.Signer
if !signer.Valid() {
signer = h.owner.BlobRef()
}
... | go | {
"resource": ""
} |
q31710 | GetClaims | train | func (h *Handler) GetClaims(req *ClaimsRequest) (*ClaimsResponse, error) {
if !req.Permanode.Valid() {
return nil, errors.New("error getting claims: nil permanode")
}
h.index.RLock()
defer h.index.RUnlock()
ctx := context.TODO()
var claims []camtypes.Claim
claims, err := h.index.AppendClaims(ctx, claims, req.... | go | {
"resource": ""
} |
q31711 | EdgesTo | train | func (h *Handler) EdgesTo(req *EdgesRequest) (*EdgesResponse, error) {
ctx := context.TODO()
h.index.RLock()
defer h.index.RUnlock()
toRef := req.ToRef
toRefStr := toRef.String()
var edgeItems []*EdgeItem
edges, err := h.index.EdgesTo(toRef, nil)
if err != nil {
panic(err)
}
type edgeOrError struct {
e... | go | {
"resource": ""
} |
q31712 | serveEdgesTo | train | func (h *Handler) serveEdgesTo(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var er EdgesRequest
er.fromHTTP(req)
res, err := h.EdgesTo(&er)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
} | go | {
"resource": ""
} |
q31713 | GetSignerPaths | train | func (h *Handler) GetSignerPaths(req *SignerPathsRequest) (*SignerPathsResponse, error) {
ctx := context.TODO()
if !req.Signer.Valid() {
return nil, errors.New("error getting signer paths: nil signer")
}
if !req.Target.Valid() {
return nil, errors.New("error getting signer paths: nil target")
}
h.index.RLock(... | go | {
"resource": ""
} |
q31714 | evalSearchInput | train | func evalSearchInput(in string) (*Constraint, error) {
if len(in) == 0 {
return nil, fmt.Errorf("empty expression")
}
if strings.HasPrefix(in, "{") && strings.HasSuffix(in, "}") {
cs := new(Constraint)
if err := json.NewDecoder(strings.NewReader(in)).Decode(&cs); err != nil {
return nil, err
}
return cs... | go | {
"resource": ""
} |
q31715 | getNamed | train | func (sh *Handler) getNamed(ctx context.Context, name string) (string, error) {
if sh.fetcher == nil {
return "", fmt.Errorf("GetNamed functionality not available")
}
sr, err := sh.Query(ctx, NamedSearch(name))
if err != nil {
return "", err
}
if len(sr.Blobs) < 1 {
return "", fmt.Errorf("No named search f... | go | {
"resource": ""
} |
q31716 | newSeparatedString | train | func newSeparatedString(commaSeparated string) separatedString {
if strings.TrimSpace(commaSeparated) == "" {
return nil
}
split := strings.Split(commaSeparated, ",")
var ss []string
for i, tag := range split {
split[i] = strings.TrimSpace(tag)
if split[i] != "" {
ss = append(ss, split[i])
}
}
if !sor... | go | {
"resource": ""
} |
q31717 | Minus | train | func (css separatedString) Minus(css2 separatedString) separatedString {
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
k := 0
kMax := len(css2)
keep := css[:0]
for _, s := range css {
for k < kMax && css2[k] < s {
k++
}
if k == kMax || c... | go | {
"resource": ""
} |
q31718 | equal | train | func (css separatedString) equal(css2 separatedString) bool {
if len(css) != len(css2) {
return false
}
if !sort.StringsAreSorted(css) {
sort.Strings(css)
}
if !sort.StringsAreSorted(css2) {
sort.Strings(css2)
}
for k, s := range css {
if s != css2[k] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q31719 | Unmount | train | func Unmount(point string) error {
var cmd *exec.Cmd
switch runtime.GOOS {
case "darwin":
cmd = exec.Command("/usr/sbin/diskutil", "umount", "force", point)
case "linux":
cmd = exec.Command("fusermount", "-u", point)
default:
return errors.New("unmount: unimplemented")
}
errc := make(chan error, 1)
go fu... | go | {
"resource": ""
} |
q31720 | markConnDead | train | func (s *Storage) markConnDead() {
s.mu.Lock()
defer s.mu.Unlock()
s.markConnDeadLocked()
} | go | {
"resource": ""
} |
q31721 | fetchJS | train | func fetchJS(jsURL, jsOnDisk string) error {
var currentSum string
_, err := os.Stat(jsOnDisk)
if err != nil {
if !os.IsNotExist(err) {
return err
}
} else {
// If yes, compute its hash
h := sha256.New()
f, err := os.Open(jsOnDisk)
if err != nil {
return err
}
defer f.Close()
if _, err := io... | go | {
"resource": ""
} |
q31722 | fullSrcPath | train | func fullSrcPath(fromSrc string) string {
return filepath.Join(pkRoot, filepath.FromSlash(fromSrc))
} | go | {
"resource": ""
} |
q31723 | getVersion | train | func getVersion() string {
slurp, err := ioutil.ReadFile(filepath.Join(pkRoot, "VERSION"))
v := strings.TrimSpace(string(slurp))
if err != nil && !os.IsNotExist(err) {
log.Fatal(err)
}
if v == "" {
return "unknown"
}
return v
} | go | {
"resource": ""
} |
q31724 | getGitVersion | train | func getGitVersion() string {
if _, err := exec.LookPath("git"); err != nil {
return ""
}
if _, err := os.Stat(filepath.Join(pkRoot, ".git")); os.IsNotExist(err) {
return ""
}
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir =... | go | {
"resource": ""
} |
q31725 | verifyPerkeepRoot | train | func verifyPerkeepRoot() {
var err error
pkRoot, err = os.Getwd()
if err != nil {
log.Fatalf("Failed to get current directory: %v", err)
}
testFile := filepath.Join(pkRoot, "pkg", "blob", "ref.go")
if _, err := os.Stat(testFile); err != nil {
log.Fatalf("make.go must be run from the Perkeep src root directory... | go | {
"resource": ""
} |
q31726 | verifyGoVersion | train | func verifyGoVersion() {
_, err := exec.LookPath("go")
if err != nil {
log.Fatalf("Go doesn't appear to be installed ('go' isn't in your PATH). Install Go 1.%d or newer.", goVersionMinor)
}
out, err := exec.Command("go", "version").Output()
if err != nil {
log.Fatalf("Error checking Go version with the 'go' co... | go | {
"resource": ""
} |
q31727 | quote | train | func quote(dest *bytes.Buffer, bs []byte) {
dest.WriteByte('"')
for _, b := range bs {
if b == '\n' {
dest.WriteString(`\n`)
continue
}
if b == '\\' {
dest.WriteString(`\\`)
continue
}
if b == '"' {
dest.WriteString(`\"`)
continue
}
if (b >= 32 && b <= 126) || b == '\t' {
dest.Write... | go | {
"resource": ""
} |
q31728 | ReceiveBlob | train | func (sto *unionStorage) ReceiveBlob(ctx context.Context, br blob.Ref, src io.Reader) (sb blob.SizedRef, err error) {
return blob.SizedRef{}, blobserver.ErrReadonly
} | go | {
"resource": ""
} |
q31729 | RemoveBlobs | train | func (sto *unionStorage) RemoveBlobs(ctx context.Context, blobs []blob.Ref) error {
return blobserver.ErrReadonly
} | go | {
"resource": ""
} |
q31730 | Fetch | train | func (sto *unionStorage) Fetch(ctx context.Context, b blob.Ref) (file io.ReadCloser, size uint32, err error) {
type result struct {
file io.ReadCloser
size uint32
err error
}
results := make(chan result, len(sto.subsets))
var wg sync.WaitGroup
for _, bs := range sto.subsets {
bs := bs
wg.Add(1)
go fun... | go | {
"resource": ""
} |
q31731 | EnumerateBlobs | train | func (sto *unionStorage) EnumerateBlobs(ctx context.Context, dest chan<- blob.SizedRef, after string, limit int) error {
return blobserver.MergedEnumerateStorage(ctx, dest, sto.subsets, after, limit)
} | go | {
"resource": ""
} |
q31732 | Set | train | func (cs cachedStore) Set(key, value string) error {
// check if record already exists
ctx := context.Background()
dk := datastore.NewKey(ctx, "camnetdns", key, 0, nil)
var oldValue dsValue
if err := cs.dsClient.Get(ctx, dk, &oldValue); err != nil {
if err != datastore.ErrNoSuchEntity {
return fmt.Errorf("err... | go | {
"resource": ""
} |
q31733 | newFromConfigWithTransport | train | func newFromConfigWithTransport(_ blobserver.Loader, config jsonconfig.Obj, transport http.RoundTripper) (blobserver.Storage, error) {
hostname := config.OptionalString("hostname", "")
region := config.OptionalString("aws_region", "us-east-1")
cacheSize := config.OptionalInt64("cacheSize", 32<<20)
s3Cfg := aws.New... | go | {
"resource": ""
} |
q31734 | isNotFound | train | func isNotFound(err error) bool {
if err == nil {
return false
}
if aerr, ok := err.(awserr.Error); ok {
return aerr.Code() == s3.ErrCodeNoSuchKey ||
// Check 'NotFound' as well because it's returned for some requests, even
// though the API model doesn't include it (hence why there isn't an
// 's3.ErrC... | go | {
"resource": ""
} |
q31735 | bytesHaveSchemaLink | train | func bytesHaveSchemaLink(br blob.Ref, bb []byte, target blob.Ref) bool {
// Fast path for no:
if !bytes.Contains(bb, []byte(target.String())) {
return false
}
b, err := schema.BlobFromReader(br, bytes.NewReader(bb))
if err != nil {
return false
}
typ := b.Type()
switch typ {
case "file", "bytes":
for _, ... | go | {
"resource": ""
} |
q31736 | Reindex | train | func Reindex(root string, overwrite bool, indexConf jsonconfig.Obj) (err error) {
// there is newStorage, but that may open a file for writing
var s = &storage{root: root}
index, err := newIndex(root, indexConf)
if err != nil {
return err
}
defer func() {
closeErr := index.Close()
// just returning the firs... | go | {
"resource": ""
} |
q31737 | Walk | train | func (s *storage) Walk(ctx context.Context,
walker func(packID int, ref blob.Ref, offset int64, size uint32) error) error {
// TODO(tgulacsi): proper verbose flag from context
verbose := env.IsDebug()
for i := 0; i >= 0; i++ {
fh, err := os.Open(s.filename(i))
if err != nil {
if os.IsNotExist(err) {
br... | go | {
"resource": ""
} |
q31738 | makeSingleMetaBlob | train | func (s *storage) makeSingleMetaBlob(plainBR, encBR blob.Ref, plainSize uint32) []byte {
plain := fmt.Sprintf("#camlistore/encmeta=2\n%s/%d/%s\n", plainBR, plainSize, encBR)
return s.encryptBlob(nil, []byte(plain))
} | go | {
"resource": ""
} |
q31739 | fetchMeta | train | func (s *storage) fetchMeta(ctx context.Context, b blob.Ref) (plainSize uint32, encBR blob.Ref, err error) {
v, err := s.index.Get(b.String())
if err == sorted.ErrNotFound {
err = os.ErrNotExist
}
if err != nil {
return 0, blob.Ref{}, err
}
return unpackIndexEntry(v)
} | go | {
"resource": ""
} |
q31740 | Props | train | func (a AboutMenuItemDef) Props() AboutMenuItemProps {
uprops := a.ComponentDef.Props()
return uprops.(AboutMenuItemProps)
} | go | {
"resource": ""
} |
q31741 | AwaitReachable | train | func AwaitReachable(addr string, maxWait time.Duration) error {
done := time.Now().Add(maxWait)
for time.Now().Before(done) {
c, err := net.Dial("tcp", addr)
if err == nil {
c.Close()
return nil
}
time.Sleep(100 * time.Millisecond)
}
return fmt.Errorf("%v unreachable for %v", addr, maxWait)
} | go | {
"resource": ""
} |
q31742 | ListenOnLocalRandomPort | train | func ListenOnLocalRandomPort() (net.Listener, error) {
ip, err := Localhost()
if err != nil {
return nil, err
}
return net.ListenTCP("tcp", &net.TCPAddr{IP: ip, Port: 0})
} | go | {
"resource": ""
} |
q31743 | Localhost | train | func Localhost() (net.IP, error) {
if ip := localhostLookup(); ip != nil {
return ip, nil
}
if ip := loopbackIP(); ip != nil {
return ip, nil
}
return nil, errors.New("no loopback ip found")
} | go | {
"resource": ""
} |
q31744 | localhostLookup | train | func localhostLookup() net.IP {
if ips, err := net.LookupIP("localhost"); err == nil && len(ips) > 0 {
return ips[0]
}
return nil
} | go | {
"resource": ""
} |
q31745 | loopbackIP | train | func loopbackIP() net.IP {
interfaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, inf := range interfaces {
const flagUpLoopback = net.FlagUp | net.FlagLoopback
if inf.Flags&flagUpLoopback == flagUpLoopback {
addrs, _ := inf.Addrs()
for _, addr := range addrs {
ip, _, err := net.Par... | go | {
"resource": ""
} |
q31746 | RandPort | train | func RandPort() (int, error) {
var port int
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
if err != nil {
return port, err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
return port, fmt.Errorf("could not listen to find random port: %v", err)
}
randAddr := listener.Addr().(*net.TCPAdd... | go | {
"resource": ""
} |
q31747 | IsFQDN | train | func IsFQDN(domain string) bool {
// TODO(mpl): there's probably a regexp for all this...
if domain == "localhost" {
return false
}
if !strings.Contains(domain, ".") {
return false
}
if strings.Contains(domain, "/") {
return false
}
if net.ParseIP(domain) != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q31748 | IsLocMapPredicate | train | func IsLocMapPredicate(predicate string) bool {
if _, err := rectangleFromPredicate(predicate, LocMapPredicatePrefix); err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q31749 | rectangleFromPredicate | train | func rectangleFromPredicate(predicate, kind string) (*camtypes.LocationBounds, error) {
errNotARectangle := fmt.Errorf("not a valid %v predicate", kind)
if !strings.HasPrefix(predicate, kind+":") {
return nil, errNotARectangle
}
loc := strings.TrimPrefix(predicate, kind+":")
coords := strings.Split(loc, ",")
if... | go | {
"resource": ""
} |
q31750 | NewChecker | train | func NewChecker() *Checker {
pc := make([]uintptr, 50)
ch := &Checker{pc[:runtime.Callers(0, pc)]}
runtime.SetFinalizer(ch, (*Checker).finalize)
return ch
} | go | {
"resource": ""
} |
q31751 | autoDiscover | train | func autoDiscover(body []byte) (feedURL string, err error) {
r := bytes.NewReader(body)
z := html.NewTokenizer(r)
for {
if z.Next() == html.ErrorToken {
break
}
t := z.Token()
switch t.DataAtom {
case atom.Link:
if t.Type == html.StartTagToken || t.Type == html.SelfClosingTagToken {
attrs := make... | go | {
"resource": ""
} |
q31752 | importStatuses | train | func (r *run) importStatuses(userID mastodon.ID) error {
statusesNode, err := r.RootNode().ChildPathObject(nodeStatuses)
if err != nil {
return err
}
nodeTitle := fmt.Sprintf("Mastodon statuses for %s", r.userAddress)
if err := statusesNode.SetAttr(nodeattr.Title, nodeTitle); err != nil {
return err
}
log.... | go | {
"resource": ""
} |
q31753 | importStatus | train | func (r *run) importStatus(listNode *importer.Object, st *mastodon.Status) (bool, error) {
select {
case <-r.Context().Done():
return false, r.Context().Err()
default:
}
// We store child nodes by their URI, since the URI is supposed to be an
// unchanging, globally unique identifier for the status
statusNode... | go | {
"resource": ""
} |
q31754 | auth | train | func (im *imp) auth(ctx *importer.SetupContext) (*oauth2.Config, error) {
baseURL, err := url.Parse(ctx.AccountNode.Attr(acctAttrInstanceURL))
if err != nil {
return nil, err
}
tokenURL := *baseURL
tokenURL.Path = path.Join(tokenURL.Path, tokenPath)
authURL := *baseURL
authURL.Path = path.Join(authURL.Path, ... | go | {
"resource": ""
} |
q31755 | createMastodonClient | train | func createMastodonClient(ctx context.Context, acct *importer.Object) *mastodon.Client {
// Although the client can take client_id and client_secret, we won't need
// those for token auth
cl := mastodon.NewClient(&mastodon.Config{
Server: acct.Attr(acctAttrInstanceURL),
AccessToken: acct.Attr(importer.Acct... | go | {
"resource": ""
} |
q31756 | getExpandedAddress | train | func getExpandedAddress(user, instanceURL string) (string, error) {
if user == "" || instanceURL == "" {
return "", errors.New("some required account data is missing")
}
parsedURL, err := url.Parse(instanceURL)
if err != nil {
return "", err
}
return fmt.Sprintf("@%s@%s", user, parsedURL.Host), nil
} | go | {
"resource": ""
} |
q31757 | Body | train | func (sn *BlobSniffer) Body() ([]byte, error) {
if sn.IsTruncated() {
return nil, errors.New("index.Body: was truncated")
}
return sn.contents, nil
} | go | {
"resource": ""
} |
q31758 | cacheScaled | train | func (ih *ImageHandler) cacheScaled(ctx context.Context, thumbBytes []byte, name string) error {
br, err := writeToCache(ctx, ih.Cache, thumbBytes, name)
if err != nil {
return err
}
ih.ThumbMeta.Put(name, br)
return nil
} | go | {
"resource": ""
} |
q31759 | scaledCached | train | func (ih *ImageHandler) scaledCached(ctx context.Context, buf *bytes.Buffer, file blob.Ref) (format string) {
key := cacheKey(file.String(), ih.MaxWidth, ih.MaxHeight)
br, err := ih.ThumbMeta.Get(key)
if err == errCacheMiss {
return
}
if err != nil {
log.Printf("Warning: thumbnail cachekey(%q)->meta lookup err... | go | {
"resource": ""
} |
q31760 | Sizes | train | func (sr *Receiver) Sizes() []int {
sr.Lock()
defer sr.Unlock()
sizes := make([]int, 0, len(sr.Have))
for _, size := range sr.Have {
sizes = append(sizes, int(size))
}
sort.Ints(sizes)
return sizes
} | go | {
"resource": ""
} |
q31761 | resizeYCbCr | train | func resizeYCbCr(m *image.YCbCr, r image.Rectangle, w, h int) (image.Image, bool) {
dst := image.NewRGBA(image.Rect(0, 0, w, h))
xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), m, m.Bounds(), xdraw.Src, nil)
return dst, true
} | go | {
"resource": ""
} |
q31762 | ResampleInplace | train | func ResampleInplace(m image.Image, r image.Rectangle, w, h int) image.Image {
// We don't support scaling up.
if r.Dx() < w || r.Dy() < h {
return m
}
switch m := m.(type) {
case *image.YCbCr:
xStep := float64(r.Dx()) / float64(w)
yStep := float64(r.Dy()) / float64(h)
for y := r.Min.Y; y < r.Min.Y+h; y++... | go | {
"resource": ""
} |
q31763 | wipeMongo | train | func (c *dbinitCmd) wipeMongo() error {
if c.dbType != "mongo" {
return nil
}
session, err := c.mongoSession()
if err != nil {
return err
}
defer session.Close()
if _, err := session.DB(c.dbName).C(mongo.CollectionName).RemoveAll(nil); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q31764 | RedirectURL | train | func (OAuth2) RedirectURL(imp Importer, ctx *SetupContext) string {
// We strip our callback URL of its query component, because the Redirect URI
// we send during authorization has to match exactly the registered redirect
// URI(s). This query component should be stored in the "state" paremeter instead.
// See htt... | go | {
"resource": ""
} |
q31765 | IsAccountReady | train | func (OAuth2) IsAccountReady(acctNode *Object) (ok bool, err error) {
if acctNode.Attr(AcctAttrUserID) != "" &&
acctNode.Attr(AcctAttrAccessToken) != "" {
return true, nil
}
return false, nil
} | go | {
"resource": ""
} |
q31766 | do | train | func (octx OAuthContext) do(method string, url string, form url.Values) (*http.Response, error) {
if octx.Creds == nil {
return nil, errors.New("no OAuth credentials. Not logged in?")
}
if octx.Client == nil {
return nil, errors.New("no OAuth client")
}
var (
res *http.Response
err error
)
if method == h... | go | {
"resource": ""
} |
q31767 | PopulateJSONFromURL | train | func (octx OAuthContext) PopulateJSONFromURL(result interface{}, method string, apiURL string, keyval ...string) error {
if method != http.MethodGet && method != http.MethodPost {
return fmt.Errorf("only HTTP Get or Post supported: found %v", method)
}
if len(keyval)%2 == 1 {
return errors.New("incorrect number ... | go | {
"resource": ""
} |
q31768 | NewOAuthClient | train | func (ctx *SetupContext) NewOAuthClient(uris OAuthURIs) (*oauth.Client, error) {
clientID, secret, err := ctx.Credentials()
if err != nil {
return nil, err
}
return &oauth.Client{
TemporaryCredentialRequestURI: uris.TemporaryCredentialRequestURI,
ResourceOwnerAuthorizationURI: uris.ResourceOwnerAuthorizationU... | go | {
"resource": ""
} |
q31769 | RegisterHandlerConstructor | train | func RegisterHandlerConstructor(typ string, ctor HandlerConstructor) {
mapLock.Lock()
defer mapLock.Unlock()
if _, ok := handlerConstructors[typ]; ok {
panic("blobserver: HandlerConstrutor already registered for type: " + typ)
}
handlerConstructors[typ] = ctor
} | go | {
"resource": ""
} |
q31770 | CreateHandler | train | func CreateHandler(typ string, loader Loader, config jsonconfig.Obj) (http.Handler, error) {
mapLock.Lock()
ctor, ok := handlerConstructors[typ]
mapLock.Unlock()
if !ok {
return nil, fmt.Errorf("blobserver: Handler type %q not known or loaded", typ)
}
return ctor(loader, config)
} | go | {
"resource": ""
} |
q31771 | genLowLevelConfig | train | func genLowLevelConfig(conf *serverconfig.Config) (lowLevelConf *Config, err error) {
b := &lowBuilder{
high: conf,
low: jsonconfig.Obj{
"prefixes": make(map[string]interface{}),
},
}
return b.build()
} | go | {
"resource": ""
} |
q31772 | dbUnique | train | func (b *lowBuilder) dbUnique() string {
if b.high.DBUnique != "" {
return b.high.DBUnique
}
if b.high.Identity != "" {
return strings.ToLower(b.high.Identity)
}
return osutil.Username() // may be empty, if $USER unset
} | go | {
"resource": ""
} |
q31773 | oldDBNames | train | func (b *lowBuilder) oldDBNames(of dbname) string {
switch of {
case dbIndex:
return "camlistore_index"
case dbBlobpackedIndex:
return "blobpacked_index"
case "queue-sync-to-index":
return "sync_index_queue"
case dbUIThumbcache:
return "ui_thumbmeta_cache"
}
return ""
} | go | {
"resource": ""
} |
q31774 | searchOwner | train | func (b *lowBuilder) searchOwner() (owner *serverconfig.Owner, err error) {
if b.high.Identity == "" {
return nil, errNoOwner
}
if b.high.IdentitySecretRing == "" {
return nil, errNoOwner
}
return &serverconfig.Owner{
Identity: b.high.Identity,
SecringFile: b.high.IdentitySecretRing,
}, nil
} | go | {
"resource": ""
} |
q31775 | kvFileType | train | func (b *lowBuilder) kvFileType() string {
switch {
case b.high.SQLite != "":
return "sqlite"
case b.high.KVFile != "":
return "kv"
case b.high.LevelDB != "":
return "leveldb"
default:
return sorted.DefaultKVFileType
}
} | go | {
"resource": ""
} |
q31776 | sortedDBMS | train | func (b *lowBuilder) sortedDBMS(named dbname) (map[string]interface{}, error) {
if b.high.MySQL != "" {
return b.dbIndexStorage("mysql", b.high.MySQL, named)
}
if b.high.PostgreSQL != "" {
return b.dbIndexStorage("postgres", b.high.PostgreSQL, named)
}
if b.high.Mongo != "" {
return b.mongoIndexStorage(b.hig... | go | {
"resource": ""
} |
q31777 | sortedStorageAt | train | func (b *lowBuilder) sortedStorageAt(sortedType dbname, filePrefix string) (map[string]interface{}, error) {
dbms, err := b.sortedDBMS(sortedType)
if err != nil {
return nil, err
}
if dbms != nil {
return dbms, nil
}
if b.high.MemoryIndex {
return map[string]interface{}{
"type": "memory",
}, nil
}
if... | go | {
"resource": ""
} |
q31778 | indexFileDir | train | func (b *lowBuilder) indexFileDir() string {
switch {
case b.high.SQLite != "":
return filepath.Dir(b.high.SQLite)
case b.high.KVFile != "":
return filepath.Dir(b.high.KVFile)
case b.high.LevelDB != "":
return filepath.Dir(b.high.LevelDB)
}
return ""
} | go | {
"resource": ""
} |
q31779 | WriteDefaultConfigFile | train | func WriteDefaultConfigFile(filePath string, useSQLite bool) error {
conf := defaultBaseConfig
blobDir, err := osutil.CamliBlobRoot()
if err != nil {
return err
}
varDir, err := osutil.CamliVarDir()
if err != nil {
return err
}
if err := wkfs.MkdirAll(blobDir, 0700); err != nil {
return fmt.Errorf("Could ... | go | {
"resource": ""
} |
q31780 | listenForCamliNet | train | func listenForCamliNet(ws *webserver.Server, config *serverinit.Config) (baseURL string, err error) {
camliNetIP := config.CamliNetIP()
if camliNetIP == "" {
return "", errors.New("no camliNetIP")
}
if ip := net.ParseIP(camliNetIP); ip == nil {
return "", fmt.Errorf("camliNetIP value %q is not a valid IP addres... | go | {
"resource": ""
} |
q31781 | markItem | train | func (c *Collector) markItem(ctx context.Context, it Item, isRoot bool) error {
if !isRoot {
marked, err := c.Marker.IsMarked(it)
if err != nil {
return err
}
if marked {
return nil
}
}
if err := c.Marker.Mark(it); err != nil {
return err
}
// FIXME(tgulacsi): is it a problem that we cannot canc... | go | {
"resource": ""
} |
q31782 | Collect | train | func (c *Collector) Collect(ctx context.Context) (err error) {
if c.World == nil {
return errors.New("no World")
}
if c.Marker == nil {
return errors.New("no Marker")
}
if c.Roots == nil {
return errors.New("no Roots")
}
if c.Sweeper == nil {
return errors.New("no Sweeper")
}
if c.ItemEnumerator == nil... | go | {
"resource": ""
} |
q31783 | New | train | func New(buffer, backing sorted.KeyValue, maxBufferBytes int64) *KeyValue {
return &KeyValue{
buf: buffer,
back: backing,
maxBuffer: maxBufferBytes,
}
} | go | {
"resource": ""
} |
q31784 | maybeRunCompaction | train | func maybeRunCompaction(dbname string, db *leveldb.DB) error {
val, err := db.GetProperty("leveldb.num-files-at-level0")
if err != nil {
return fmt.Errorf("could not get number of level-0 files of %v's LevelDB: %v", dbname, err)
}
nbFiles, err := strconv.Atoi(val)
if err != nil {
return fmt.Errorf("could not c... | go | {
"resource": ""
} |
q31785 | marshalBinary | train | func (sk *statCacheKey) marshalBinary() ([]byte, error) {
if sk == nil {
return nil, errors.New("Can not marshal from a nil stat cache key")
}
data := make([]byte, 0, len(sk.Filepath)+3)
data = append(data, 1) // version number
data = append(data, sk.Filepath...)
data = append(data, '|')
if sk.Permanode {
da... | go | {
"resource": ""
} |
q31786 | marshalBinary | train | func (scv *statCacheValue) marshalBinary() ([]byte, error) {
if scv == nil {
return nil, errors.New("Can not marshal from a nil stat cache value")
}
binBr, _ := scv.Result.BlobRef.MarshalBinary()
// Blob size fits on 4 bytes when binary encoded
data := make([]byte, 0, len(scv.Fingerprint)+1+4+1+len(binBr))
buf ... | go | {
"resource": ""
} |
q31787 | RestartProcess | train | func RestartProcess(arg ...string) error {
path, err := SelfPath()
if err != nil {
return fmt.Errorf("RestartProcess failed: %v", err)
}
var args []string
if len(arg) > 0 {
args = append(args, os.Args[0])
for _, v := range arg {
args = append(args, v)
}
} else {
args = os.Args
}
return syscall.Ex... | go | {
"resource": ""
} |
q31788 | buildDockerImage | train | func buildDockerImage(imageDir, imageName string) {
if dockDir == "" {
panic("dockDir should be set before calling buildDockerImage")
}
cmd := exec.Command("docker", "build", "-t", imageName, ".")
cmd.Dir = filepath.Join(dockDir, imageDir)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err ... | go | {
"resource": ""
} |
q31789 | MergedEnumerate | train | func MergedEnumerate(ctx context.Context, dest chan<- blob.SizedRef, sources []BlobEnumerator, after string, limit int) error {
return mergedEnumerate(ctx, dest, len(sources), func(i int) BlobEnumerator { return sources[i] }, after, limit)
} | go | {
"resource": ""
} |
q31790 | NewOAuthConfig | train | func NewOAuthConfig(clientID, clientSecret string) *oauth2.Config {
return &oauth2.Config{
Scopes: []string{
logging.WriteScope,
compute.DevstorageFullControlScope,
compute.ComputeScope,
cloudresourcemanager.CloudPlatformScope,
servicemanagement.CloudPlatformScope,
"https://www.googleapis.com/auth/... | go | {
"resource": ""
} |
q31791 | Get | train | func (d *Deployer) Get() (*compute.Instance, error) {
computeService, err := compute.New(d.Client)
if err != nil {
return nil, err
}
return computeService.Instances.Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
} | go | {
"resource": ""
} |
q31792 | projectHasInstance | train | func (d *Deployer) projectHasInstance() (zone string, err error) {
s, err := compute.New(d.Client)
if err != nil {
return "", err
}
// TODO(mpl): make use of the handler's cached zones.
zl, err := compute.NewZonesService(s).List(d.Conf.Project).Do()
if err != nil {
return "", fmt.Errorf("could not get a list ... | go | {
"resource": ""
} |
q31793 | getInstanceAttribute | train | func (d *Deployer) getInstanceAttribute(attr string) (string, error) {
s, err := compute.New(d.Client)
if err != nil {
return "", fmt.Errorf("error getting compute service: %v", err)
}
inst, err := compute.NewInstancesService(s).Get(d.Conf.Project, d.Conf.Zone, d.Conf.Name).Do()
if err != nil {
return "", fmt.... | go | {
"resource": ""
} |
q31794 | Create | train | func (d *Deployer) Create(ctx context.Context) (*compute.Instance, error) {
if err := d.enableAPIs(); err != nil {
return nil, projectIDError{
id: d.Conf.Project,
cause: err,
}
}
if err := d.checkProjectID(); err != nil {
return nil, err
}
computeService, _ := compute.New(d.Client)
storageService,... | go | {
"resource": ""
} |
q31795 | setBuckets | train | func (d *Deployer) setBuckets(ctx context.Context, storageService *storage.Service) error {
projBucket := d.Conf.Project + "-camlistore"
needBucket := map[string]bool{
projBucket: true,
}
buckets, err := storageService.Buckets.List(d.Conf.Project).Do()
if err != nil {
return fmt.Errorf("error listing buckets... | go | {
"resource": ""
} |
q31796 | setFirewall | train | func (d *Deployer) setFirewall(ctx context.Context, computeService *compute.Service) error {
defaultNet, err := computeService.Networks.Get(d.Conf.Project, "default").Do()
if err != nil {
return fmt.Errorf("error getting default network: %v", err)
}
needRules := map[string]compute.Firewall{
"default-allow-http... | go | {
"resource": ""
} |
q31797 | loadX509KeyPair | train | func loadX509KeyPair(certFile, keyFile string) (cert tls.Certificate, err error) {
certPEMBlock, err := wkfs.ReadFile(certFile)
if err != nil {
return
}
keyPEMBlock, err := wkfs.ReadFile(keyFile)
if err != nil {
return
}
return tls.X509KeyPair(certPEMBlock, keyPEMBlock)
} | go | {
"resource": ""
} |
q31798 | RequestTargetPort | train | func RequestTargetPort(req *http.Request) int {
_, portStr, err := net.SplitHostPort(req.Host)
if err == nil && portStr != "" {
port, err := strconv.ParseInt(portStr, 0, 64)
if err == nil {
return int(port)
}
}
if req.TLS != nil {
return 443
}
return 80
} | go | {
"resource": ""
} |
q31799 | RecoverJSON | train | func RecoverJSON(rw http.ResponseWriter, req *http.Request) {
e := recover()
if e == nil {
return
}
ServeJSONError(rw, e)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.