_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q32000 | importTweets | train | func (r *run) importTweets(userID string, apiPath string) error {
maxId := ""
continueRequests := true
var tweetsNode *importer.Object
var err error
var importType string
if apiPath == userLikesAPIPath {
importType = "likes"
} else {
importType = "tweets"
}
tweetsNode, err = r.getTopLevelNode(importType)
... | go | {
"resource": ""
} |
q32001 | detectConfigChange | train | func detectConfigChange(conf jsonconfig.Obj) error {
oldHTTPSKey, oldHTTPSCert := conf.OptionalString("HTTPSKeyFile", ""), conf.OptionalString("HTTPSCertFile", "")
if oldHTTPSKey != "" || oldHTTPSCert != "" {
return fmt.Errorf("config keys %q and %q have respectively been renamed to %q and %q, please fix your serve... | go | {
"resource": ""
} |
q32002 | Load | train | func Load(config []byte) (*Config, error) {
return load("", func(filename string) (jsonconfig.File, error) {
if filename != "" {
return nil, errors.New("JSON files with includes not supported with jsonconfig.Load")
}
return jsonFileImpl{bytes.NewReader(config), "config file"}, nil
})
} | go | {
"resource": ""
} |
q32003 | readFields | train | func (c *Config) readFields() error {
c.camliNetIP = c.jconf.OptionalString("camliNetIP", "")
c.listenAddr = c.jconf.OptionalString("listen", "")
c.baseURL = strings.TrimSuffix(c.jconf.OptionalString("baseURL", ""), "/")
c.httpsCert = c.jconf.OptionalString("httpsCert", "")
c.httpsKey = c.jconf.OptionalString("htt... | go | {
"resource": ""
} |
q32004 | StartApps | train | func (c *Config) StartApps() error {
for _, ap := range c.apps {
if err := ap.Start(); err != nil {
return fmt.Errorf("error starting app %v: %v", ap.ProgramName(), err)
}
}
return nil
} | go | {
"resource": ""
} |
q32005 | UploadPublicKey | train | func (c *Config) UploadPublicKey(ctx context.Context) error {
if c.signHandler == nil {
return nil
}
return c.signHandler.UploadPublicKey(ctx)
} | go | {
"resource": ""
} |
q32006 | AppURL | train | func (c *Config) AppURL() map[string]string {
appURL := make(map[string]string, len(c.apps))
for _, ap := range c.apps {
appURL[ap.ProgramName()] = ap.BackendURL()
}
return appURL
} | go | {
"resource": ""
} |
q32007 | highLevelConfFields | train | func highLevelConfFields() map[string]bool {
knownFields := make(map[string]bool)
var c serverconfig.Config
s := reflect.ValueOf(&c).Elem()
for i := 0; i < s.NumField(); i++ {
f := s.Type().Field(i)
jsonTag, ok := f.Tag.Lookup("json")
if !ok {
panic(fmt.Sprintf("%q field in serverconfig.Config does not hav... | go | {
"resource": ""
} |
q32008 | containerURL | train | func (c *Client) containerURL(container string) string {
return fmt.Sprintf("https://%s/%s/", c.hostname(), container)
} | go | {
"resource": ""
} |
q32009 | Containers | train | func (c *Client) Containers(ctx context.Context) ([]*Container, error) {
req := newReq(ctx, "https://"+c.hostname()+"/")
c.Auth.SignRequest(req)
res, err := c.transport().RoundTrip(req)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("azure... | go | {
"resource": ""
} |
q32010 | Stat | train | func (c *Client) Stat(ctx context.Context, key, container string) (size int64, reterr error) {
req := newReq(ctx, c.keyURL(container, key))
req.Method = "HEAD"
c.Auth.SignRequest(req)
res, err := c.transport().RoundTrip(req)
if err != nil {
return 0, err
}
if res.Body != nil {
defer res.Body.Close()
}
swit... | go | {
"resource": ""
} |
q32011 | PutObject | train | func (c *Client) PutObject(ctx context.Context, key, container string, md5 hash.Hash, size int64, body io.Reader) error {
req := newReq(ctx, c.keyURL(container, key))
req.Method = "PUT"
req.ContentLength = size
if md5 != nil {
b64 := new(bytes.Buffer)
encoder := base64.NewEncoder(base64.StdEncoding, b64)
enco... | go | {
"resource": ""
} |
q32012 | Get | train | func (c *Client) Get(ctx context.Context, container, key string) (body io.ReadCloser, size int64, err error) {
req := newReq(ctx, c.keyURL(container, key))
c.Auth.SignRequest(req)
res, err := c.transport().RoundTrip(req)
if err != nil {
return
}
switch res.StatusCode {
case http.StatusOK:
return res.Body, re... | go | {
"resource": ""
} |
q32013 | GetPartial | train | func (c *Client) GetPartial(ctx context.Context, container, key string, offset, length int64) (rc io.ReadCloser, err error) {
if offset < 0 {
return nil, errors.New("invalid negative length")
}
req := newReq(ctx, c.keyURL(container, key))
if length >= 0 {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offs... | go | {
"resource": ""
} |
q32014 | Delete | train | func (c *Client) Delete(ctx context.Context, container, key string) error {
req := newReq(ctx, c.keyURL(container, key))
req.Method = "DELETE"
c.Auth.SignRequest(req)
res, err := c.transport().RoundTrip(req)
if err != nil {
return err
}
if res != nil && res.Body != nil {
defer res.Body.Close()
}
if res.Sta... | go | {
"resource": ""
} |
q32015 | Error | train | func (e *Error) Error() string {
if e.AzureError.Code != "" {
return fmt.Sprintf("azure.%s: status %d, code: %s", e.Op, e.Code, e.AzureError.Code)
}
return fmt.Sprintf("azure.%s: status %d", e.Op, e.Code)
} | go | {
"resource": ""
} |
q32016 | NewDefaultCamliFileSystem | train | func NewDefaultCamliFileSystem(client *client.Client, fetcher blob.Fetcher) *CamliFileSystem {
if client == nil || fetcher == nil {
panic("nil argument")
}
fs := newCamliFileSystem(fetcher)
fs.root = &root{fs: fs} // root.go
fs.client = client
return fs
} | go | {
"resource": ""
} |
q32017 | NewRootedCamliFileSystem | train | func NewRootedCamliFileSystem(cli *client.Client, fetcher blob.Fetcher, root blob.Ref) (*CamliFileSystem, error) {
fs := newCamliFileSystem(fetcher)
fs.client = cli
n, err := fs.newNodeFromBlobRef(root)
if err != nil {
return nil, err
}
fs.root = n
return fs, nil
} | go | {
"resource": ""
} |
q32018 | populateAttr | train | func (n *node) populateAttr() error {
meta := n.meta
n.attr.Mode = meta.FileMode()
if n.fs.IgnoreOwners {
n.attr.Uid = uint32(os.Getuid())
n.attr.Gid = uint32(os.Getgid())
executeBit := n.attr.Mode & 0100
n.attr.Mode = (n.attr.Mode ^ n.attr.Mode.Perm()) | 0400 | executeBit
} else {
n.attr.Uid = uint32(m... | go | {
"resource": ""
} |
q32019 | newNodeFromBlobRef | train | func (fs *CamliFileSystem) newNodeFromBlobRef(root blob.Ref) (fusefs.Node, error) {
blob, err := fs.fetchSchemaMeta(context.TODO(), root)
if err != nil {
return nil, err
}
switch blob.Type() {
case "directory":
n := &node{fs: fs, blobref: root, meta: blob}
n.populateAttr()
return n, nil
case "permanode"... | go | {
"resource": ""
} |
q32020 | build | train | func build(targets ...string) error {
if v, _ := strconv.ParseBool(os.Getenv("CAMLI_FAST_DEV")); v {
// Demo mode. See dev/demo.sh.
return nil
}
var fullTargets []string
for _, t := range targets {
t = filepath.ToSlash(t)
if !strings.HasPrefix(t, "perkeep.org") {
t = pathpkg.Join("perkeep.org", t)
}
... | go | {
"resource": ""
} |
q32021 | NewLocationHelper | train | func NewLocationHelper(ix *Index) *LocationHelper {
lh := &LocationHelper{index: ix}
if ix.corpus != nil {
lh.corpus = ix.corpus
}
return lh
} | go | {
"resource": ""
} |
q32022 | get | train | func (pa permAttr) get(attr string) string {
if pa.attrs != nil {
v := pa.attrs[attr]
if len(v) != 0 {
return v[0]
}
return ""
}
if pa.claims != nil {
return claimsIntfAttrValue(pa.claims, attr, pa.at, pa.signerFilter)
}
return ""
} | go | {
"resource": ""
} |
q32023 | IsEmpty | train | func (f *Files) IsEmpty() bool {
f.lk.Lock()
defer f.lk.Unlock()
return len(f.file) == 0
} | go | {
"resource": ""
} |
q32024 | Add | train | func (f *Files) Add(filename string, size int64, modtime time.Time, o Opener) {
f.lk.Lock()
defer f.lk.Unlock()
r, err := o.Open()
if err != nil {
log.Printf("Could not add file %v: %v", filename, err)
return
}
contents, err := ioutil.ReadAll(r)
if err != nil {
log.Printf("Could not read contents of file ... | go | {
"resource": ""
} |
q32025 | add | train | func (f *Files) add(filename string, sf *staticFile) {
if f.file == nil {
f.file = make(map[string]*staticFile)
}
f.file[filename] = sf
} | go | {
"resource": ""
} |
q32026 | openFallback | train | func (f *Files) openFallback(filename string) (http.File, error) {
if f.DirFallback == "" {
return nil, os.ErrNotExist
}
of, err := os.Open(filepath.Join(f.DirFallback, filename))
switch {
case err != nil:
return nil, err
case f.SlurpToMemory:
defer of.Close()
bs, err := ioutil.ReadAll(of)
if err != nil... | go | {
"resource": ""
} |
q32027 | commentSelection | train | func commentSelection(src []byte) Selection {
var s scanner.Scanner
fset := token.NewFileSet()
file := fset.AddFile("", fset.Base(), len(src))
s.Init(file, src, nil, scanner.ScanComments)
return func() (seg []int) {
for {
pos, tok, lit := s.Scan()
if tok == token.EOF {
break
}
offs := file.Offset... | go | {
"resource": ""
} |
q32028 | makeSelection | train | func makeSelection(matches [][]int) Selection {
return func() (seg []int) {
if len(matches) > 0 {
seg = matches[0]
matches = matches[1:]
}
return
}
} | go | {
"resource": ""
} |
q32029 | regexpSelection | train | func regexpSelection(text []byte, expr string) Selection {
var matches [][]int
if rx, err := regexp.Compile(expr); err == nil {
matches = rx.FindAllIndex(text, -1)
}
return makeSelection(matches)
} | go | {
"resource": ""
} |
q32030 | rangeSelection | train | func rangeSelection(str string) Selection {
m := selRx.FindStringSubmatch(str)
if len(m) >= 2 {
from, _ := strconv.Atoi(m[1])
to, _ := strconv.Atoi(m[2])
if from < to {
return makeSelection([][]int{{from, to}})
}
}
return nil
} | go | {
"resource": ""
} |
q32031 | getVersion | train | func getVersion() string {
slurp, err := ioutil.ReadFile(filepath.Join(camliDir, "VERSION"))
if err == nil {
return strings.TrimSpace(string(slurp))
}
return gitVersion()
} | go | {
"resource": ""
} |
q32032 | gitVersion | train | func gitVersion() string {
cmd := exec.Command("git", "rev-list", "--max-count=1", "--pretty=format:'%ad-%h'",
"--date=short", "--abbrev=10", "HEAD")
cmd.Dir = camliDir
out, err := cmd.Output()
if err != nil {
log.Fatalf("Error running git rev-list in %s: %v", camliDir, err)
}
v := strings.TrimSpace(string(ou... | go | {
"resource": ""
} |
q32033 | findExistingPermanode | train | func findExistingPermanode(ctx context.Context, qs search.QueryDescriber, wholeRef blob.Ref) (pn blob.Ref, err error) {
res, err := qs.Query(ctx, &search.SearchQuery{
Constraint: &search.Constraint{
Permanode: &search.PermanodeConstraint{
Attr: "camliContent",
ValueInSet: &search.Constraint{
File: &s... | go | {
"resource": ""
} |
q32034 | Import | train | func Import(ctx context.Context, config map[string]string, shareURL string,
updateDialogFunc func(message string, importedBlobRef string)) {
printerr := func(msg string) {
showError(msg, func(msg string) {
updateDialogFunc(msg, "")
})
}
if config == nil {
printerr("Nil config for Import share")
return
}... | go | {
"resource": ""
} |
q32035 | updateDialog | train | func updateDialog(progress camtypes.ShareImportProgress,
updateDialogFunc func(message string, importedBlobRef string)) {
if progress.Running {
if progress.Assembled {
updateDialogFunc("Importing file in progress", "")
return
}
updateDialogFunc(fmt.Sprintf("Working - %d/%d files imported", progress.FilesC... | go | {
"resource": ""
} |
q32036 | NewFlag | train | func NewFlag(flagName, defaultValue string, serverType string) *Addr {
addr := &Addr{
s: defaultValue,
}
flag.Var(addr, flagName, Usage(serverType))
return addr
} | go | {
"resource": ""
} |
q32037 | Usage | train | func Usage(name string) string {
if name == "" {
name = "Listen address"
}
if !strings.HasSuffix(name, " address") {
name += " address"
}
return name + "; may be port, :port, ip:port, or FD:<fd_num>"
} | go | {
"resource": ""
} |
q32038 | Listen | train | func (a *Addr) Listen() (net.Listener, error) {
// Start the listener now, if there's a default
// and nothing's called Set yet.
if a.err == nil && a.ln == nil && a.s != "" {
if err := a.Set(a.s); err != nil {
return nil, err
}
}
if a.err != nil {
return nil, a.err
}
if a.ln != nil {
return a.ln, nil
... | go | {
"resource": ""
} |
q32039 | NewDirReader | train | func NewDirReader(ctx context.Context, fetcher blob.Fetcher, dirBlobRef blob.Ref) (*DirReader, error) {
ss := new(superset)
err := ss.setFromBlobRef(ctx, fetcher, dirBlobRef)
if err != nil {
return nil, err
}
if ss.Type != "directory" {
return nil, fmt.Errorf("schema/dirreader: expected \"directory\" schema bl... | go | {
"resource": ""
} |
q32040 | StaticSet | train | func (dr *DirReader) StaticSet(ctx context.Context) ([]blob.Ref, error) {
if dr.staticSet != nil {
return dr.staticSet, nil
}
staticSetBlobref := dr.ss.Entries
if !staticSetBlobref.Valid() {
return nil, errors.New("schema/dirreader: Invalid blobref")
}
members, err := staticSet(ctx, staticSetBlobref, dr.fetch... | go | {
"resource": ""
} |
q32041 | Readdir | train | func (dr *DirReader) Readdir(ctx context.Context, n int) (entries []DirectoryEntry, err error) {
sts, err := dr.StaticSet(ctx)
if err != nil {
return nil, fmt.Errorf("schema/dirreader: can't get StaticSet: %v", err)
}
up := dr.current + n
if n <= 0 {
dr.current = 0
up = len(sts)
} else {
if n > (len(sts) ... | go | {
"resource": ""
} |
q32042 | Props | train | func (s SelectAllBtnDef) Props() SelectAllBtnProps {
uprops := s.ComponentDef.Props()
return uprops.(SelectAllBtnProps)
} | go | {
"resource": ""
} |
q32043 | New | train | func New(dir string) (blobserver.Storage, error) {
if v, err := diskpacked.IsDir(dir); err != nil {
return nil, err
} else if v {
return diskpacked.New(dir)
}
if v, err := localdisk.IsDir(dir); err != nil {
return nil, err
} else if v {
return localdisk.New(dir)
}
return diskpacked.New(dir)
} | go | {
"resource": ""
} |
q32044 | New | train | func New(root string) (*DiskStorage, error) {
// Local disk.
fi, err := os.Stat(root)
if os.IsNotExist(err) {
// As a special case, we auto-created the "packed" directory for subpacked.
if filepath.Base(root) == "packed" {
if err := os.Mkdir(root, 0700); err != nil {
return nil, fmt.Errorf("failed to mkdi... | go | {
"resource": ""
} |
q32045 | MakeMediaObjectViewModels | train | func MakeMediaObjectViewModels(mediaObjects []mediaObject) []MediaObjectVM {
models := make([]MediaObjectVM, len(mediaObjects))
for i := 0; i < len(mediaObjects); i++ {
models[i] = mediaObjects[i].MakeViewModel()
}
return models
} | go | {
"resource": ""
} |
q32046 | someTitle | train | func (doc *document) someTitle() string {
if doc.title != "" {
return doc.title
}
if doc.tags.isEmpty() {
return fmt.Sprintf("Doc Ref %s", doc.permanode)
}
return strings.Join(doc.tags, ",")
} | go | {
"resource": ""
} |
q32047 | formatYyyyMmDd | train | func formatYyyyMmDd(indate time.Time) string {
if indate.IsZero() {
return ""
}
return indate.Format(dateformatYyyyMmDd)
} | go | {
"resource": ""
} |
q32048 | MakeDocumentViewModels | train | func MakeDocumentViewModels(docs []*document) []DocumentVM {
models := make([]DocumentVM, len(docs))
for i := 0; i < len(docs); i++ {
models[i] = docs[i].MakeViewModel()
}
return models
} | go | {
"resource": ""
} |
q32049 | ServeBlobRef | train | func ServeBlobRef(rw http.ResponseWriter, req *http.Request, blobRef blob.Ref, fetcher blob.Fetcher) {
ctx := req.Context()
if fetcher == nil {
log.Printf("gethandler: no fetcher configured for %s (ref=%v)", req.URL.Path, blobRef)
rw.WriteHeader(http.StatusNotFound)
io.WriteString(rw, "no fetcher configured")
... | go | {
"resource": ""
} |
q32050 | simulatePrematurelyClosedConnection | train | func simulatePrematurelyClosedConnection(rw http.ResponseWriter, req *http.Request) {
flusher, ok := rw.(http.Flusher)
if !ok {
return
}
hj, ok := rw.(http.Hijacker)
if !ok {
return
}
for n := 1; n <= 100; n++ {
fmt.Fprintf(rw, "line %d\n", n)
flusher.Flush()
}
wrc, _, _ := hj.Hijack()
wrc.Close() // ... | go | {
"resource": ""
} |
q32051 | matchingFiles | train | func matchingFiles(p *regexp.Regexp) []string {
var f []string
err := filepath.Walk(".", func(path string, fi os.FileInfo, err error) error {
if err != nil {
return err
}
n := filepath.Base(path)
if !fi.IsDir() && !strings.HasPrefix(n, "zembed_") && p.MatchString(n) {
f = append(f, path)
}
return ni... | go | {
"resource": ""
} |
q32052 | UploadPublicKey | train | func (h *Handler) UploadPublicKey(ctx context.Context) error {
h.pubKeyUploadMu.RLock()
if h.pubKeyUploaded {
h.pubKeyUploadMu.RUnlock()
return nil
}
h.pubKeyUploadMu.RUnlock()
sto := h.pubKeyDest
h.pubKeyUploadMu.Lock()
defer h.pubKeyUploadMu.Unlock()
if h.pubKeyUploaded {
return nil
}
_, err := blob... | go | {
"resource": ""
} |
q32053 | Discovery | train | func (h *Handler) Discovery(base string) *camtypes.SignDiscovery {
sd := &camtypes.SignDiscovery{
PublicKeyID: h.entity.PrimaryKey.KeyIdString(),
SignHandler: base + "camli/sig/sign",
VerifyHandler: base + "camli/sig/verify",
}
if h.pubKeyBlobRef.Valid() {
sd.PublicKeyBlobRef = h.pubKeyBlobRef
sd.Publi... | go | {
"resource": ""
} |
q32054 | generalizedGroupBy | train | func generalizedGroupBy(funcName string, entries interface{}, getValue func(interface{}) (interface{}, error), addEntry func(map[string][]interface{}, interface{}, interface{})) (map[string][]interface{}, error) {
entriesVal, err := getArrayValues(funcName, entries)
if err != nil {
return nil, err
}
groups := m... | go | {
"resource": ""
} |
q32055 | groupBy | train | func groupBy(entries interface{}, key string) (map[string][]interface{}, error) {
return generalizedGroupByKey("groupBy", entries, key, func(groups map[string][]interface{}, value interface{}, v interface{}) {
groups[value.(string)] = append(groups[value.(string)], v)
})
} | go | {
"resource": ""
} |
q32056 | groupByKeys | train | func groupByKeys(entries interface{}, key string) ([]string, error) {
keys, err := generalizedGroupByKey("groupByKeys", entries, key, func(groups map[string][]interface{}, value interface{}, v interface{}) {
groups[value.(string)] = append(groups[value.(string)], v)
})
if err != nil {
return nil, err
}
ret :... | go | {
"resource": ""
} |
q32057 | groupByLabel | train | func groupByLabel(entries interface{}, label string) (map[string][]interface{}, error) {
getLabel := func(v interface{}) (interface{}, error) {
if container, ok := v.(RuntimeContainer); ok {
if value, ok := container.Labels[label]; ok {
return value, nil
}
return nil, nil
}
return nil, fmt.Errorf("M... | go | {
"resource": ""
} |
q32058 | generalizedWhere | train | func generalizedWhere(funcName string, entries interface{}, key string, test func(interface{}) bool) (interface{}, error) {
entriesVal, err := getArrayValues(funcName, entries)
if err != nil {
return nil, err
}
selection := make([]interface{}, 0)
for i := 0; i < entriesVal.Len(); i++ {
v := reflect.Indirect(... | go | {
"resource": ""
} |
q32059 | where | train | func where(entries interface{}, key string, cmp interface{}) (interface{}, error) {
return generalizedWhere("where", entries, key, func(value interface{}) bool {
return reflect.DeepEqual(value, cmp)
})
} | go | {
"resource": ""
} |
q32060 | whereExist | train | func whereExist(entries interface{}, key string) (interface{}, error) {
return generalizedWhere("whereExist", entries, key, func(value interface{}) bool {
return value != nil
})
} | go | {
"resource": ""
} |
q32061 | whereAny | train | func whereAny(entries interface{}, key, sep string, cmp []string) (interface{}, error) {
return generalizedWhere("whereAny", entries, key, func(value interface{}) bool {
if value == nil {
return false
} else {
items := strings.Split(value.(string), sep)
return len(intersect(cmp, items)) > 0
}
})
} | go | {
"resource": ""
} |
q32062 | generalizedWhereLabel | train | func generalizedWhereLabel(funcName string, containers Context, label string, test func(string, bool) bool) (Context, error) {
selection := make([]*RuntimeContainer, 0)
for i := 0; i < len(containers); i++ {
container := containers[i]
value, ok := container.Labels[label]
if test(value, ok) {
selection = ap... | go | {
"resource": ""
} |
q32063 | whereLabelExists | train | func whereLabelExists(containers Context, label string) (Context, error) {
return generalizedWhereLabel("whereLabelExists", containers, label, func(_ string, ok bool) bool {
return ok
})
} | go | {
"resource": ""
} |
q32064 | whereLabelValueMatches | train | func whereLabelValueMatches(containers Context, label, pattern string) (Context, error) {
rx, err := regexp.Compile(pattern)
if err != nil {
return nil, err
}
return generalizedWhereLabel("whereLabelValueMatches", containers, label, func(value string, ok bool) bool {
return ok && rx.MatchString(value)
})
} | go | {
"resource": ""
} |
q32065 | arrayFirst | train | func arrayFirst(input interface{}) interface{} {
if input == nil {
return nil
}
arr := reflect.ValueOf(input)
if arr.Len() == 0 {
return nil
}
return arr.Index(0).Interface()
} | go | {
"resource": ""
} |
q32066 | arrayLast | train | func arrayLast(input interface{}) interface{} {
arr := reflect.ValueOf(input)
return arr.Index(arr.Len() - 1).Interface()
} | go | {
"resource": ""
} |
q32067 | arrayClosest | train | func arrayClosest(values []string, input string) string {
best := ""
for _, v := range values {
if strings.Contains(input, v) && len(v) > len(best) {
best = v
}
}
return best
} | go | {
"resource": ""
} |
q32068 | dirList | train | func dirList(path string) ([]string, error) {
names := []string{}
files, err := ioutil.ReadDir(path)
if err != nil {
log.Printf("Template error: %v", err)
return names, nil
}
for _, f := range files {
names = append(names, f.Name())
}
return names, nil
} | go | {
"resource": ""
} |
q32069 | LogStreamer | train | func LogStreamer() http.Handler {
logs := mux.NewRouter()
logsHandler := func(w http.ResponseWriter, req *http.Request) {
params := mux.Vars(req)
route := new(router.Route)
if params["value"] != "" {
switch params["predicate"] {
case "id":
route.FilterID = params["value"]
if len(route.ID) > 12 {
... | go | {
"resource": ""
} |
q32070 | RoutesAPI | train | func RoutesAPI() http.Handler {
routes := router.Routes
r := mux.NewRouter()
r.HandleFunc("/routes/{id}", func(w http.ResponseWriter, req *http.Request) {
params := mux.Vars(req)
route, _ := routes.Get(params["id"])
if route == nil {
http.NotFound(w, req)
return
}
w.Write(append(marshal(route), '\n'... | go | {
"resource": ""
} |
q32071 | createTLSConfig | train | func createTLSConfig() (tlsConfig *tls.Config, err error) {
tlsConfig = &tls.Config{}
// use stronger TLS settings if enabled
// TODO: perhaps this should be default setting
if os.Getenv(envTLSHardening) == "true" {
tlsConfig.InsecureSkipVerify = false
tlsConfig.MinVersion = hardenedMinVersion
tlsConfig.Ciph... | go | {
"resource": ""
} |
q32072 | NewSyslogAdapter | train | func NewSyslogAdapter(route *router.Route) (router.LogAdapter, error) {
transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
if !found {
return nil, errors.New("bad transport: " + route.Adapter)
}
conn, err := transport.Dial(route.Address, route.Options)
if err != nil {
return nil... | go | {
"resource": ""
} |
q32073 | Render | train | func (m *Message) Render(tmpl *template.Template) ([]byte, error) {
buf := new(bytes.Buffer)
err := tmpl.Execute(buf, m)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q32074 | Priority | train | func (m *Message) Priority() syslog.Priority {
switch m.Message.Source {
case "stdout":
return syslog.LOG_USER | syslog.LOG_INFO
case "stderr":
return syslog.LOG_USER | syslog.LOG_ERR
default:
return syslog.LOG_DAEMON | syslog.LOG_INFO
}
} | go | {
"resource": ""
} |
q32075 | Timestamp | train | func (m *Message) Timestamp() string {
return m.Message.Time.Format(time.RFC3339)
} | go | {
"resource": ""
} |
q32076 | HealthCheck | train | func HealthCheck() http.Handler {
r := mux.NewRouter()
r.HandleFunc("/health", func(w http.ResponseWriter, req *http.Request) {
w.Write([]byte("Healthy!\n"))
})
return r
} | go | {
"resource": ""
} |
q32077 | AdapterTransport | train | func (r *Route) AdapterTransport(dfault string) string {
parts := strings.Split(r.Adapter, "+")
if len(parts) > 1 {
return parts[1]
}
return dfault
} | go | {
"resource": ""
} |
q32078 | Closer | train | func (r *Route) Closer() <-chan bool {
if r.closerRcv != nil {
return r.closerRcv
}
return r.closer
} | go | {
"resource": ""
} |
q32079 | MultiContainer | train | func (r *Route) MultiContainer() bool {
return r.matchAll() || strings.Contains(r.FilterName, "*")
} | go | {
"resource": ""
} |
q32080 | MatchContainer | train | func (r *Route) MatchContainer(id, name string, labels map[string]string) bool {
if r.matchAll() {
return true
}
if r.FilterID != "" && !strings.HasPrefix(id, r.FilterID) {
return false
}
match, err := path.Match(r.FilterName, name)
if err != nil || (r.FilterName != "" && !match) {
return false
}
for _, l... | go | {
"resource": ""
} |
q32081 | MatchMessage | train | func (r *Route) MatchMessage(message *Message) bool {
if r.matchAll() {
return true
}
if len(r.FilterSources) > 0 && !contains(r.FilterSources, message.Source) {
return false
}
return true
} | go | {
"resource": ""
} |
q32082 | Remove | train | func (fs RouteFileStore) Remove(id string) bool {
if _, err := os.Stat(fs.Filename(id)); err == nil {
if err := os.Remove(fs.Filename(id)); err != nil {
return true
}
}
return false
} | go | {
"resource": ""
} |
q32083 | Load | train | func (rm *RouteManager) Load(persistor RouteStore) error {
routes, err := persistor.GetAll()
if err != nil {
return err
}
for _, route := range routes {
rm.Add(route)
}
rm.persistor = persistor
return nil
} | go | {
"resource": ""
} |
q32084 | Get | train | func (rm *RouteManager) Get(id string) (*Route, error) {
rm.Lock()
defer rm.Unlock()
route, ok := rm.routes[id]
if !ok {
return nil, os.ErrNotExist
}
return route, nil
} | go | {
"resource": ""
} |
q32085 | GetAll | train | func (rm *RouteManager) GetAll() ([]*Route, error) {
rm.Lock()
defer rm.Unlock()
routes := make([]*Route, 0)
for _, route := range rm.routes {
routes = append(routes, route)
}
return routes, nil
} | go | {
"resource": ""
} |
q32086 | Remove | train | func (rm *RouteManager) Remove(id string) bool {
rm.Lock()
defer rm.Unlock()
route, ok := rm.routes[id]
if ok && route.closer != nil {
route.closer <- true
}
delete(rm.routes, id)
if rm.persistor != nil {
rm.persistor.Remove(id)
}
return ok
} | go | {
"resource": ""
} |
q32087 | AddFromURI | train | func (rm *RouteManager) AddFromURI(uri string) error {
expandedRoute := os.ExpandEnv(uri)
u, err := url.Parse(expandedRoute)
if err != nil {
return err
}
r := &Route{
Address: u.Host,
Adapter: u.Scheme,
Options: make(map[string]string),
}
if u.RawQuery != "" {
params, err := url.ParseQuery(u.RawQuery)
... | go | {
"resource": ""
} |
q32088 | Add | train | func (rm *RouteManager) Add(route *Route) error {
rm.Lock()
defer rm.Unlock()
factory, found := AdapterFactories.Lookup(route.AdapterType())
if !found {
return errors.New("bad adapter: " + route.Adapter)
}
adapter, err := factory(route)
if err != nil {
return err
}
if route.ID == "" {
h := sha1.New()
i... | go | {
"resource": ""
} |
q32089 | Route | train | func (rm *RouteManager) Route(route *Route, logstream chan *Message) {
for _, router := range LogRouters.All() {
go router.Route(route, logstream)
}
} | go | {
"resource": ""
} |
q32090 | RoutingFrom | train | func (rm *RouteManager) RoutingFrom(containerID string) bool {
for _, router := range LogRouters.All() {
if router.RoutingFrom(containerID) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q32091 | Run | train | func (rm *RouteManager) Run() error {
rm.Lock()
for _, route := range rm.routes {
rm.wg.Add(1)
go func(route *Route) {
rm.route(route)
rm.wg.Done()
}(route)
}
rm.routing = true
rm.Unlock()
rm.wg.Wait()
// Temp fix to allow logspout to run without routes defined.
if len(rm.routes) == 0 {
select {}
... | go | {
"resource": ""
} |
q32092 | Setup | train | func (rm *RouteManager) Setup() error {
var uris string
if os.Getenv("ROUTE_URIS") != "" {
uris = os.Getenv("ROUTE_URIS")
}
if len(os.Args) > 1 {
uris = os.Args[1]
}
if uris != "" {
for _, uri := range strings.Split(uris, ",") {
err := rm.AddFromURI(uri)
if err != nil {
return err
}
}
}
pe... | go | {
"resource": ""
} |
q32093 | NewRawAdapter | train | func NewRawAdapter(route *router.Route) (router.LogAdapter, error) {
transport, found := router.AdapterTransports.Lookup(route.AdapterTransport("udp"))
if !found {
return nil, errors.New("bad transport: " + route.Adapter)
}
conn, err := transport.Dial(route.Address, route.Options)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q32094 | NewMultilineAdapter | train | func NewMultilineAdapter(route *router.Route) (a router.LogAdapter, err error) {
enableByDefault := true
enableStr := os.Getenv("MULTILINE_ENABLE_DEFAULT")
if enableStr != "" {
var err error
enableByDefault, err = strconv.ParseBool(enableStr)
if err != nil {
return nil, errors.New("multiline: invalid value ... | go | {
"resource": ""
} |
q32095 | Stream | train | func (a *Adapter) Stream(logstream chan *router.Message) {
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
a.subAdapter.Stream(a.out)
wg.Done()
}()
defer func() {
for _, message := range a.buffers {
a.out <- message
}
close(a.out)
wg.Wait()
}()
for {
select {
case message, ok := <-logstream:
... | go | {
"resource": ""
} |
q32096 | Setup | train | func (p *LogsPump) Setup() error {
var err error
p.client, err = docker.NewClientFromEnv()
return err
} | go | {
"resource": ""
} |
q32097 | Run | train | func (p *LogsPump) Run() error {
inactivityTimeout := getInactivityTimeoutFromEnv()
debug("pump.Run(): using inactivity timeout: ", inactivityTimeout)
containers, err := p.client.ListContainers(docker.ListContainersOptions{})
if err != nil {
return err
}
for _, listing := range containers {
p.pumpLogs(&docke... | go | {
"resource": ""
} |
q32098 | RoutingFrom | train | func (p *LogsPump) RoutingFrom(id string) bool {
p.mu.Lock()
defer p.mu.Unlock()
_, monitoring := p.pumps[normalID(id)]
return monitoring
} | go | {
"resource": ""
} |
q32099 | Route | train | func (p *LogsPump) Route(route *Route, logstream chan *Message) {
p.mu.Lock()
for _, pump := range p.pumps {
if route.MatchContainer(
normalID(pump.container.ID),
normalName(pump.container.Name),
pump.container.Config.Labels) {
pump.add(logstream, route)
defer pump.remove(logstream)
}
}
updates ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.