id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
160,000 | keybase/client | go/teams/ftl.go | computeFreshLoad | func (s *shoppingList) computeFreshLoad(m libkb.MetaContext, arg fastLoadArg) {
s.needMerkleRefresh = true
s.applications = append([]keybase1.TeamApplication{}, arg.Applications...)
s.downPointers = append([]keybase1.Seqno{}, arg.downPointersNeeded...)
s.generations = append([]keybase1.PerTeamKeyGeneration{}, arg.KeyGenerationsNeeded...)
} | go | func (s *shoppingList) computeFreshLoad(m libkb.MetaContext, arg fastLoadArg) {
s.needMerkleRefresh = true
s.applications = append([]keybase1.TeamApplication{}, arg.Applications...)
s.downPointers = append([]keybase1.Seqno{}, arg.downPointersNeeded...)
s.generations = append([]keybase1.PerTeamKeyGeneration{}, arg.KeyGenerationsNeeded...)
} | [
"func",
"(",
"s",
"*",
"shoppingList",
")",
"computeFreshLoad",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
")",
"{",
"s",
".",
"needMerkleRefresh",
"=",
"true",
"\n",
"s",
".",
"applications",
"=",
"append",
"(",
"[",
"]",
"keybase... | // computeFreshLoad computes a shopping list from a fresh load of the state. | [
"computeFreshLoad",
"computes",
"a",
"shopping",
"list",
"from",
"a",
"fresh",
"load",
"of",
"the",
"state",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L594-L599 |
160,001 | keybase/client | go/teams/ftl.go | applicationsToString | func applicationsToString(applications []keybase1.TeamApplication) string {
var tmp []string
for _, k := range applications {
tmp = append(tmp, fmt.Sprintf("%d", int(k)))
}
return strings.Join(tmp, ",")
} | go | func applicationsToString(applications []keybase1.TeamApplication) string {
var tmp []string
for _, k := range applications {
tmp = append(tmp, fmt.Sprintf("%d", int(k)))
}
return strings.Join(tmp, ",")
} | [
"func",
"applicationsToString",
"(",
"applications",
"[",
"]",
"keybase1",
".",
"TeamApplication",
")",
"string",
"{",
"var",
"tmp",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"applications",
"{",
"tmp",
"=",
"append",
"(",
"tmp",
","... | // applicationsToString converts the list of applications to a comma-separated string. | [
"applicationsToString",
"converts",
"the",
"list",
"of",
"applications",
"to",
"a",
"comma",
"-",
"separated",
"string",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L602-L608 |
160,002 | keybase/client | go/teams/ftl.go | generationsToString | func generationsToString(generations []keybase1.PerTeamKeyGeneration) string {
var tmp []string
for _, k := range generations {
tmp = append(tmp, fmt.Sprintf("%d", int(k)))
}
return strings.Join(tmp, ",")
} | go | func generationsToString(generations []keybase1.PerTeamKeyGeneration) string {
var tmp []string
for _, k := range generations {
tmp = append(tmp, fmt.Sprintf("%d", int(k)))
}
return strings.Join(tmp, ",")
} | [
"func",
"generationsToString",
"(",
"generations",
"[",
"]",
"keybase1",
".",
"PerTeamKeyGeneration",
")",
"string",
"{",
"var",
"tmp",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"generations",
"{",
"tmp",
"=",
"append",
"(",
"tmp",
"... | // generationsToString converts the list of generations to a comma-separated string. | [
"generationsToString",
"converts",
"the",
"list",
"of",
"generations",
"to",
"a",
"comma",
"-",
"separated",
"string",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L611-L617 |
160,003 | keybase/client | go/teams/ftl.go | makeHTTPRequest | func (f *FastTeamChainLoader) makeHTTPRequest(m libkb.MetaContext, args libkb.HTTPArgs, isPublic bool) (t rawTeam, err error) {
apiArg := libkb.NewAPIArg("team/get")
apiArg.Args = args
if isPublic {
apiArg.SessionType = libkb.APISessionTypeOPTIONAL
} else {
apiArg.SessionType = libkb.APISessionTypeREQUIRED
}
err = m.G().API.GetDecode(m, apiArg, &t)
if err != nil {
return t, err
}
return t, nil
} | go | func (f *FastTeamChainLoader) makeHTTPRequest(m libkb.MetaContext, args libkb.HTTPArgs, isPublic bool) (t rawTeam, err error) {
apiArg := libkb.NewAPIArg("team/get")
apiArg.Args = args
if isPublic {
apiArg.SessionType = libkb.APISessionTypeOPTIONAL
} else {
apiArg.SessionType = libkb.APISessionTypeREQUIRED
}
err = m.G().API.GetDecode(m, apiArg, &t)
if err != nil {
return t, err
}
return t, nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"makeHTTPRequest",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"args",
"libkb",
".",
"HTTPArgs",
",",
"isPublic",
"bool",
")",
"(",
"t",
"rawTeam",
",",
"err",
"error",
")",
"{",
"apiArg",
":=",
"libkb",... | // makeHTTPRequest hits the HTTP GET endpoint for the team data. | [
"makeHTTPRequest",
"hits",
"the",
"HTTP",
"GET",
"endpoint",
"for",
"the",
"team",
"data",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L672-L685 |
160,004 | keybase/client | go/teams/ftl.go | checkPrevs | func (f *FastTeamChainLoader) checkPrevs(m libkb.MetaContext, arg fastLoadArg, last *keybase1.LinkTriple, newLinks []*ChainLinkUnpacked) (err error) {
if len(newLinks) == 0 {
return nil
}
var prev keybase1.LinkTriple
if last != nil {
prev = *last
}
cmpHash := func(prev keybase1.LinkTriple, link *ChainLinkUnpacked) (err error) {
// not ideal to have to export here, but it simplifies the code.
prevex := link.Prev().Export()
if prev.LinkID.IsNil() && prevex.IsNil() {
return nil
}
if prev.LinkID.IsNil() || prevex.IsNil() {
m.Debug("Bad prev nil/non-nil pointer check at seqno %d: (prev=%v vs curr=%v)", link.Seqno(), prev.LinkID.IsNil(), prevex.IsNil())
return NewInvalidLink(link, "bad nil/non-nil prev pointer comparison")
}
if !prev.LinkID.Eq(prevex) {
m.Debug("Bad prev comparison at seqno %d: %s != %s", prev.LinkID, prevex)
return NewInvalidLink(link, "bad prev pointer")
}
return nil
}
cmpSeqnos := func(prev keybase1.LinkTriple, link *ChainLinkUnpacked) (err error) {
if prev.Seqno+1 != link.Seqno() {
m.Debug("Bad sequence violation: %d+1 != %d", prev.Seqno, link.Seqno())
return NewInvalidLink(link, "seqno violation")
}
return checkSeqType(m, arg, link)
}
cmp := func(prev keybase1.LinkTriple, link *ChainLinkUnpacked) (err error) {
err = cmpHash(prev, link)
if err != nil {
return err
}
return cmpSeqnos(prev, link)
}
for _, link := range newLinks {
// We might have gotten some links from the past just for the purposes of expanding
// previous links that were stubbed. We don't need to check prevs on them, since
// we previously did.
if last != nil && last.Seqno >= link.Seqno() {
continue
}
err := cmp(prev, link)
if err != nil {
return err
}
prev = link.LinkTriple()
}
return nil
} | go | func (f *FastTeamChainLoader) checkPrevs(m libkb.MetaContext, arg fastLoadArg, last *keybase1.LinkTriple, newLinks []*ChainLinkUnpacked) (err error) {
if len(newLinks) == 0 {
return nil
}
var prev keybase1.LinkTriple
if last != nil {
prev = *last
}
cmpHash := func(prev keybase1.LinkTriple, link *ChainLinkUnpacked) (err error) {
// not ideal to have to export here, but it simplifies the code.
prevex := link.Prev().Export()
if prev.LinkID.IsNil() && prevex.IsNil() {
return nil
}
if prev.LinkID.IsNil() || prevex.IsNil() {
m.Debug("Bad prev nil/non-nil pointer check at seqno %d: (prev=%v vs curr=%v)", link.Seqno(), prev.LinkID.IsNil(), prevex.IsNil())
return NewInvalidLink(link, "bad nil/non-nil prev pointer comparison")
}
if !prev.LinkID.Eq(prevex) {
m.Debug("Bad prev comparison at seqno %d: %s != %s", prev.LinkID, prevex)
return NewInvalidLink(link, "bad prev pointer")
}
return nil
}
cmpSeqnos := func(prev keybase1.LinkTriple, link *ChainLinkUnpacked) (err error) {
if prev.Seqno+1 != link.Seqno() {
m.Debug("Bad sequence violation: %d+1 != %d", prev.Seqno, link.Seqno())
return NewInvalidLink(link, "seqno violation")
}
return checkSeqType(m, arg, link)
}
cmp := func(prev keybase1.LinkTriple, link *ChainLinkUnpacked) (err error) {
err = cmpHash(prev, link)
if err != nil {
return err
}
return cmpSeqnos(prev, link)
}
for _, link := range newLinks {
// We might have gotten some links from the past just for the purposes of expanding
// previous links that were stubbed. We don't need to check prevs on them, since
// we previously did.
if last != nil && last.Seqno >= link.Seqno() {
continue
}
err := cmp(prev, link)
if err != nil {
return err
}
prev = link.LinkTriple()
}
return nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"checkPrevs",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
",",
"last",
"*",
"keybase1",
".",
"LinkTriple",
",",
"newLinks",
"[",
"]",
"*",
"ChainLinkUnpacked",
")",
"(",
"err",
"error... | // checkPrevs checks the previous pointers on the new links that came down from the server. It
// only checks prevs for links that are newer than the last link gotten in this chain.
// We assume the rest are expanding hashes for links we've previously downloaded. | [
"checkPrevs",
"checks",
"the",
"previous",
"pointers",
"on",
"the",
"new",
"links",
"that",
"came",
"down",
"from",
"the",
"server",
".",
"It",
"only",
"checks",
"prevs",
"for",
"links",
"that",
"are",
"newer",
"than",
"the",
"last",
"link",
"gotten",
"in"... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L835-L894 |
160,005 | keybase/client | go/teams/ftl.go | audit | func (f *FastTeamChainLoader) audit(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData) (err error) {
head, ok := state.Chain.MerkleInfo[1]
if !ok {
return NewAuditError("cannot run audit without merkle info for head")
}
last := state.Chain.Last
if last == nil {
return NewAuditError("cannot run audit, no last chain data")
}
return m.G().GetTeamAuditor().AuditTeam(m, arg.ID, arg.Public, head.Seqno, state.Chain.LinkIDs, last.Seqno)
} | go | func (f *FastTeamChainLoader) audit(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData) (err error) {
head, ok := state.Chain.MerkleInfo[1]
if !ok {
return NewAuditError("cannot run audit without merkle info for head")
}
last := state.Chain.Last
if last == nil {
return NewAuditError("cannot run audit, no last chain data")
}
return m.G().GetTeamAuditor().AuditTeam(m, arg.ID, arg.Public, head.Seqno, state.Chain.LinkIDs, last.Seqno)
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"audit",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
",",
"state",
"*",
"keybase1",
".",
"FastTeamData",
")",
"(",
"err",
"error",
")",
"{",
"head",
",",
"ok",
":=",
"state",
".",... | // audit runs probabilistic merkle tree audit on the new links, to make sure that the server isn't
// running odd-even-style attacks against members in a group. | [
"audit",
"runs",
"probabilistic",
"merkle",
"tree",
"audit",
"on",
"the",
"new",
"links",
"to",
"make",
"sure",
"that",
"the",
"server",
"isn",
"t",
"running",
"odd",
"-",
"even",
"-",
"style",
"attacks",
"against",
"members",
"in",
"a",
"group",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L898-L908 |
160,006 | keybase/client | go/teams/ftl.go | readMerkleRoot | func readMerkleRoot(m libkb.MetaContext, link *ChainLinkUnpacked) (*keybase1.MerkleRootV2, error) {
if link.inner == nil {
return nil, nil
}
ret := link.inner.Body.MerkleRoot.ToMerkleRootV2()
return &ret, nil
} | go | func readMerkleRoot(m libkb.MetaContext, link *ChainLinkUnpacked) (*keybase1.MerkleRootV2, error) {
if link.inner == nil {
return nil, nil
}
ret := link.inner.Body.MerkleRoot.ToMerkleRootV2()
return &ret, nil
} | [
"func",
"readMerkleRoot",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"link",
"*",
"ChainLinkUnpacked",
")",
"(",
"*",
"keybase1",
".",
"MerkleRootV2",
",",
"error",
")",
"{",
"if",
"link",
".",
"inner",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"... | // readMerkleRoot reads the merkle root out of the link if this link is unstubbed. | [
"readMerkleRoot",
"reads",
"the",
"merkle",
"root",
"out",
"of",
"the",
"link",
"if",
"this",
"link",
"is",
"unstubbed",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L942-L948 |
160,007 | keybase/client | go/teams/ftl.go | readPerTeamKey | func readPerTeamKey(m libkb.MetaContext, link *ChainLinkUnpacked) (ret *keybase1.PerTeamKey, err error) {
if link.inner == nil || link.inner.Body.Team == nil || link.inner.Body.Team.PerTeamKey == nil {
return nil, nil
}
ptk := link.inner.Body.Team.PerTeamKey
return &keybase1.PerTeamKey{
Gen: ptk.Generation,
Seqno: link.Seqno(),
SigKID: ptk.SigKID,
EncKID: ptk.EncKID,
}, nil
} | go | func readPerTeamKey(m libkb.MetaContext, link *ChainLinkUnpacked) (ret *keybase1.PerTeamKey, err error) {
if link.inner == nil || link.inner.Body.Team == nil || link.inner.Body.Team.PerTeamKey == nil {
return nil, nil
}
ptk := link.inner.Body.Team.PerTeamKey
return &keybase1.PerTeamKey{
Gen: ptk.Generation,
Seqno: link.Seqno(),
SigKID: ptk.SigKID,
EncKID: ptk.EncKID,
}, nil
} | [
"func",
"readPerTeamKey",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"link",
"*",
"ChainLinkUnpacked",
")",
"(",
"ret",
"*",
"keybase1",
".",
"PerTeamKey",
",",
"err",
"error",
")",
"{",
"if",
"link",
".",
"inner",
"==",
"nil",
"||",
"link",
".",
"inn... | // readPerTeamKey reads a PerTeamKey section, if it exists, out of the given unpacked chainlink. | [
"readPerTeamKey",
"reads",
"a",
"PerTeamKey",
"section",
"if",
"it",
"exists",
"out",
"of",
"the",
"given",
"unpacked",
"chainlink",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1006-L1018 |
160,008 | keybase/client | go/teams/ftl.go | putLinks | func (f *FastTeamChainLoader) putLinks(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, newLinks []*ChainLinkUnpacked) (err error) {
if len(newLinks) == 0 {
return nil
}
for _, link := range newLinks {
existing, ok := state.Chain.LinkIDs[link.Seqno()]
linkID := link.LinkID().Export()
if ok {
// NOTE! This is a crucial check, since we might have checked prev's on this link
// in a previous run on the chain. We have to make sure an unstubbed link is
// consistent with that previous check. See checkPrevs for when we skip
// checking prevs in such a case, and need to check here for linkID equality.
if !linkID.Eq(existing) {
return NewInvalidLink(link, "list doesn't match previously cached link")
}
} else {
state.Chain.LinkIDs[link.Seqno()] = linkID
}
dp, err := readDownPointer(m, link)
if err != nil {
return err
}
if dp != nil {
state.Chain.DownPointers[link.Seqno()] = *dp
}
up, err := readUpPointer(m, arg, link)
if err != nil {
return err
}
if up != nil && (state.Chain.LastUpPointer == nil || state.Chain.LastUpPointer.OurSeqno < up.OurSeqno) {
state.Chain.LastUpPointer = up
}
ptk, err := readPerTeamKey(m, link)
if err != nil {
return err
}
if ptk != nil {
state.Chain.PerTeamKeys[ptk.Gen] = *ptk
}
merkleRoot, err := readMerkleRoot(m, link)
if err != nil {
return err
}
if merkleRoot != nil {
state.Chain.MerkleInfo[link.Seqno()] = *merkleRoot
}
}
newLast := newLinks[len(newLinks)-1]
if state.Chain.Last == nil || state.Chain.Last.Seqno < newLast.Seqno() {
tmp := newLast.LinkTriple()
state.Chain.Last = &tmp
}
return nil
} | go | func (f *FastTeamChainLoader) putLinks(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, newLinks []*ChainLinkUnpacked) (err error) {
if len(newLinks) == 0 {
return nil
}
for _, link := range newLinks {
existing, ok := state.Chain.LinkIDs[link.Seqno()]
linkID := link.LinkID().Export()
if ok {
// NOTE! This is a crucial check, since we might have checked prev's on this link
// in a previous run on the chain. We have to make sure an unstubbed link is
// consistent with that previous check. See checkPrevs for when we skip
// checking prevs in such a case, and need to check here for linkID equality.
if !linkID.Eq(existing) {
return NewInvalidLink(link, "list doesn't match previously cached link")
}
} else {
state.Chain.LinkIDs[link.Seqno()] = linkID
}
dp, err := readDownPointer(m, link)
if err != nil {
return err
}
if dp != nil {
state.Chain.DownPointers[link.Seqno()] = *dp
}
up, err := readUpPointer(m, arg, link)
if err != nil {
return err
}
if up != nil && (state.Chain.LastUpPointer == nil || state.Chain.LastUpPointer.OurSeqno < up.OurSeqno) {
state.Chain.LastUpPointer = up
}
ptk, err := readPerTeamKey(m, link)
if err != nil {
return err
}
if ptk != nil {
state.Chain.PerTeamKeys[ptk.Gen] = *ptk
}
merkleRoot, err := readMerkleRoot(m, link)
if err != nil {
return err
}
if merkleRoot != nil {
state.Chain.MerkleInfo[link.Seqno()] = *merkleRoot
}
}
newLast := newLinks[len(newLinks)-1]
if state.Chain.Last == nil || state.Chain.Last.Seqno < newLast.Seqno() {
tmp := newLast.LinkTriple()
state.Chain.Last = &tmp
}
return nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"putLinks",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
",",
"state",
"*",
"keybase1",
".",
"FastTeamData",
",",
"newLinks",
"[",
"]",
"*",
"ChainLinkUnpacked",
")",
"(",
"err",
"erro... | // putLinks takes the links we just downloaded from the server, and stores them to the state.
// It also fills in unstubbed fields for those links that have come back with payloads that
// were previously stubbed. There are several error cases that can come up, when reading down
// or up pointers from the reply. | [
"putLinks",
"takes",
"the",
"links",
"we",
"just",
"downloaded",
"from",
"the",
"server",
"and",
"stores",
"them",
"to",
"the",
"state",
".",
"It",
"also",
"fills",
"in",
"unstubbed",
"fields",
"for",
"those",
"links",
"that",
"have",
"come",
"back",
"with... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1024-L1078 |
160,009 | keybase/client | go/teams/ftl.go | putRKMs | func (f *FastTeamChainLoader) putRKMs(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, rkms []keybase1.ReaderKeyMask) (err error) {
for _, rkm := range rkms {
if _, ok := state.ReaderKeyMasks[rkm.Application]; !ok {
state.ReaderKeyMasks[rkm.Application] = make(map[keybase1.PerTeamKeyGeneration]keybase1.MaskB64)
}
state.ReaderKeyMasks[rkm.Application][rkm.Generation] = rkm.Mask
}
return nil
} | go | func (f *FastTeamChainLoader) putRKMs(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, rkms []keybase1.ReaderKeyMask) (err error) {
for _, rkm := range rkms {
if _, ok := state.ReaderKeyMasks[rkm.Application]; !ok {
state.ReaderKeyMasks[rkm.Application] = make(map[keybase1.PerTeamKeyGeneration]keybase1.MaskB64)
}
state.ReaderKeyMasks[rkm.Application][rkm.Generation] = rkm.Mask
}
return nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"putRKMs",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
",",
"state",
"*",
"keybase1",
".",
"FastTeamData",
",",
"rkms",
"[",
"]",
"keybase1",
".",
"ReaderKeyMask",
")",
"(",
"err",
... | // putRKMs stores the new reader key masks loaded from the server to the state structure. | [
"putRKMs",
"stores",
"the",
"new",
"reader",
"key",
"masks",
"loaded",
"from",
"the",
"server",
"to",
"the",
"state",
"structure",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1081-L1089 |
160,010 | keybase/client | go/teams/ftl.go | putSeeds | func (f *FastTeamChainLoader) putSeeds(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, latestKeyGen keybase1.PerTeamKeyGeneration, seeds []keybase1.PerTeamKeySeed) (err error) {
for i, seed := range seeds {
state.PerTeamKeySeedsUnverified[latestKeyGen-keybase1.PerTeamKeyGeneration(len(seeds)-i-1)] = seed
}
// We might have gotten back 0 seeds from the server, so don't overwrite a valid LatestKeyGeneration
// with 0 in that case.
if latestKeyGen > state.LatestKeyGeneration {
state.LatestKeyGeneration = latestKeyGen
}
return nil
} | go | func (f *FastTeamChainLoader) putSeeds(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, latestKeyGen keybase1.PerTeamKeyGeneration, seeds []keybase1.PerTeamKeySeed) (err error) {
for i, seed := range seeds {
state.PerTeamKeySeedsUnverified[latestKeyGen-keybase1.PerTeamKeyGeneration(len(seeds)-i-1)] = seed
}
// We might have gotten back 0 seeds from the server, so don't overwrite a valid LatestKeyGeneration
// with 0 in that case.
if latestKeyGen > state.LatestKeyGeneration {
state.LatestKeyGeneration = latestKeyGen
}
return nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"putSeeds",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
",",
"state",
"*",
"keybase1",
".",
"FastTeamData",
",",
"latestKeyGen",
"keybase1",
".",
"PerTeamKeyGeneration",
",",
"seeds",
"["... | // putSeeds stores the crypto seeds to the PeterTeamKeySeedsUnverified slot of the state. It returns
// the last n seeds, counting backwards. We exploit this fact to infer the seed generations from their
// order. | [
"putSeeds",
"stores",
"the",
"crypto",
"seeds",
"to",
"the",
"PeterTeamKeySeedsUnverified",
"slot",
"of",
"the",
"state",
".",
"It",
"returns",
"the",
"last",
"n",
"seeds",
"counting",
"backwards",
".",
"We",
"exploit",
"this",
"fact",
"to",
"infer",
"the",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1094-L1105 |
160,011 | keybase/client | go/teams/ftl.go | mutateState | func (f *FastTeamChainLoader) mutateState(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, groceries *groceries) (err error) {
err = f.putName(m, arg, state, groceries.newLinks)
if err != nil {
return err
}
err = f.putLinks(m, arg, state, groceries.newLinks)
if err != nil {
return err
}
err = f.putRKMs(m, arg, state, groceries.rkms)
if err != nil {
return err
}
err = f.putSeeds(m, arg, state, groceries.latestKeyGen, groceries.seeds)
if err != nil {
return err
}
err = f.putMetadata(m, arg, state)
if err != nil {
return err
}
return nil
} | go | func (f *FastTeamChainLoader) mutateState(m libkb.MetaContext, arg fastLoadArg, state *keybase1.FastTeamData, groceries *groceries) (err error) {
err = f.putName(m, arg, state, groceries.newLinks)
if err != nil {
return err
}
err = f.putLinks(m, arg, state, groceries.newLinks)
if err != nil {
return err
}
err = f.putRKMs(m, arg, state, groceries.rkms)
if err != nil {
return err
}
err = f.putSeeds(m, arg, state, groceries.latestKeyGen, groceries.seeds)
if err != nil {
return err
}
err = f.putMetadata(m, arg, state)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"mutateState",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
",",
"state",
"*",
"keybase1",
".",
"FastTeamData",
",",
"groceries",
"*",
"groceries",
")",
"(",
"err",
"error",
")",
"{",
... | // mutateState takes the groceries fetched from the server and applies them to our current state. | [
"mutateState",
"takes",
"the",
"groceries",
"fetched",
"from",
"the",
"server",
"and",
"applies",
"them",
"to",
"our",
"current",
"state",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1120-L1143 |
160,012 | keybase/client | go/teams/ftl.go | makeState | func makeState(arg fastLoadArg, s *keybase1.FastTeamData) *keybase1.FastTeamData {
if s != nil {
tmp := s.DeepCopy()
return &tmp
}
return &keybase1.FastTeamData{
PerTeamKeySeedsUnverified: make(map[keybase1.PerTeamKeyGeneration]keybase1.PerTeamKeySeed),
ReaderKeyMasks: make(map[keybase1.TeamApplication](map[keybase1.PerTeamKeyGeneration]keybase1.MaskB64)),
Chain: keybase1.FastTeamSigChainState{
ID: arg.ID,
Public: arg.Public,
PerTeamKeys: make(map[keybase1.PerTeamKeyGeneration]keybase1.PerTeamKey),
PerTeamKeySeedsVerified: make(map[keybase1.PerTeamKeyGeneration]keybase1.PerTeamKeySeed),
DownPointers: make(map[keybase1.Seqno]keybase1.DownPointer),
LinkIDs: make(map[keybase1.Seqno]keybase1.LinkID),
MerkleInfo: make(map[keybase1.Seqno]keybase1.MerkleRootV2),
},
}
} | go | func makeState(arg fastLoadArg, s *keybase1.FastTeamData) *keybase1.FastTeamData {
if s != nil {
tmp := s.DeepCopy()
return &tmp
}
return &keybase1.FastTeamData{
PerTeamKeySeedsUnverified: make(map[keybase1.PerTeamKeyGeneration]keybase1.PerTeamKeySeed),
ReaderKeyMasks: make(map[keybase1.TeamApplication](map[keybase1.PerTeamKeyGeneration]keybase1.MaskB64)),
Chain: keybase1.FastTeamSigChainState{
ID: arg.ID,
Public: arg.Public,
PerTeamKeys: make(map[keybase1.PerTeamKeyGeneration]keybase1.PerTeamKey),
PerTeamKeySeedsVerified: make(map[keybase1.PerTeamKeyGeneration]keybase1.PerTeamKeySeed),
DownPointers: make(map[keybase1.Seqno]keybase1.DownPointer),
LinkIDs: make(map[keybase1.Seqno]keybase1.LinkID),
MerkleInfo: make(map[keybase1.Seqno]keybase1.MerkleRootV2),
},
}
} | [
"func",
"makeState",
"(",
"arg",
"fastLoadArg",
",",
"s",
"*",
"keybase1",
".",
"FastTeamData",
")",
"*",
"keybase1",
".",
"FastTeamData",
"{",
"if",
"s",
"!=",
"nil",
"{",
"tmp",
":=",
"s",
".",
"DeepCopy",
"(",
")",
"\n",
"return",
"&",
"tmp",
"\n"... | // makeState does a clone on a non-nil state, or makes a new state if nil. | [
"makeState",
"does",
"a",
"clone",
"on",
"a",
"non",
"-",
"nil",
"state",
"or",
"makes",
"a",
"new",
"state",
"if",
"nil",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1146-L1164 |
160,013 | keybase/client | go/teams/ftl.go | updateCache | func (f *FastTeamChainLoader) updateCache(m libkb.MetaContext, state *keybase1.FastTeamData) {
f.storage.Put(m, state)
} | go | func (f *FastTeamChainLoader) updateCache(m libkb.MetaContext, state *keybase1.FastTeamData) {
f.storage.Put(m, state)
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"updateCache",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"state",
"*",
"keybase1",
".",
"FastTeamData",
")",
"{",
"f",
".",
"storage",
".",
"Put",
"(",
"m",
",",
"state",
")",
"\n",
"}"
] | // updateCache puts the new version of the state into the cache on the team's ID. | [
"updateCache",
"puts",
"the",
"new",
"version",
"of",
"the",
"state",
"into",
"the",
"cache",
"on",
"the",
"team",
"s",
"ID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1217-L1219 |
160,014 | keybase/client | go/teams/ftl.go | loadLocked | func (f *FastTeamChainLoader) loadLocked(m libkb.MetaContext, arg fastLoadArg) (res *fastLoadRes, err error) {
state := f.findStateInCache(m, arg.ID)
var shoppingList shoppingList
if state != nil {
f.computeWithPreviousState(m, &shoppingList, arg, state)
if shoppingList.isEmpty() {
return f.toResult(m, arg, state)
}
} else {
shoppingList.computeFreshLoad(m, arg)
}
m.Debug("FastTeamChainLoader#loadLocked: computed shopping list: %+v", shoppingList)
var newState *keybase1.FastTeamData
newState, err = f.refresh(m, arg, state, shoppingList)
if err != nil {
return nil, err
}
// If newState == nil, that means that no updates were required, and the old state
// is fine, we just need to update the cachedAt time. If newState is non-nil,
// then we use if for our state going forward.
if newState == nil {
setCachedAtToNow(m, state)
} else {
state = newState
}
// Always update the cache, even if we're just bumping the cachedAt time.
f.updateCache(m, state)
return f.toResult(m, arg, state)
} | go | func (f *FastTeamChainLoader) loadLocked(m libkb.MetaContext, arg fastLoadArg) (res *fastLoadRes, err error) {
state := f.findStateInCache(m, arg.ID)
var shoppingList shoppingList
if state != nil {
f.computeWithPreviousState(m, &shoppingList, arg, state)
if shoppingList.isEmpty() {
return f.toResult(m, arg, state)
}
} else {
shoppingList.computeFreshLoad(m, arg)
}
m.Debug("FastTeamChainLoader#loadLocked: computed shopping list: %+v", shoppingList)
var newState *keybase1.FastTeamData
newState, err = f.refresh(m, arg, state, shoppingList)
if err != nil {
return nil, err
}
// If newState == nil, that means that no updates were required, and the old state
// is fine, we just need to update the cachedAt time. If newState is non-nil,
// then we use if for our state going forward.
if newState == nil {
setCachedAtToNow(m, state)
} else {
state = newState
}
// Always update the cache, even if we're just bumping the cachedAt time.
f.updateCache(m, state)
return f.toResult(m, arg, state)
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"loadLocked",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"arg",
"fastLoadArg",
")",
"(",
"res",
"*",
"fastLoadRes",
",",
"err",
"error",
")",
"{",
"state",
":=",
"f",
".",
"findStateInCache",
"(",
"m",
... | // loadLocked is the inner loop for loading team. Should be called when holding the lock
// this teamID. | [
"loadLocked",
"is",
"the",
"inner",
"loop",
"for",
"loading",
"team",
".",
"Should",
"be",
"called",
"when",
"holding",
"the",
"lock",
"this",
"teamID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1223-L1257 |
160,015 | keybase/client | go/teams/ftl.go | OnLogout | func (f *FastTeamChainLoader) OnLogout(mctx libkb.MetaContext) error {
f.storage.clearMem()
f.featureFlagGate.Clear()
return nil
} | go | func (f *FastTeamChainLoader) OnLogout(mctx libkb.MetaContext) error {
f.storage.clearMem()
f.featureFlagGate.Clear()
return nil
} | [
"func",
"(",
"f",
"*",
"FastTeamChainLoader",
")",
"OnLogout",
"(",
"mctx",
"libkb",
".",
"MetaContext",
")",
"error",
"{",
"f",
".",
"storage",
".",
"clearMem",
"(",
")",
"\n",
"f",
".",
"featureFlagGate",
".",
"Clear",
"(",
")",
"\n",
"return",
"nil"... | // OnLogout is called when the user logs out, which purges the LRU. | [
"OnLogout",
"is",
"called",
"when",
"the",
"user",
"logs",
"out",
"which",
"purges",
"the",
"LRU",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/ftl.go#L1260-L1264 |
160,016 | keybase/client | go/spotty/spotty_nix.go | Discover | func Discover() (string, error) {
var sstat syscall.Stat_t
if err := syscall.Fstat(0, &sstat); err != nil {
return "", err
}
res, err := findFileIn(&sstat, "/dev", regexp.MustCompile(`^tty[A-Za-z0-9]+$`))
if err != nil {
return "", err
}
if len(res) > 0 {
return res, nil
}
res, err = findFileIn(&sstat, "/dev/pts", regexp.MustCompile(`^[0-9]+$`))
return res, err
} | go | func Discover() (string, error) {
var sstat syscall.Stat_t
if err := syscall.Fstat(0, &sstat); err != nil {
return "", err
}
res, err := findFileIn(&sstat, "/dev", regexp.MustCompile(`^tty[A-Za-z0-9]+$`))
if err != nil {
return "", err
}
if len(res) > 0 {
return res, nil
}
res, err = findFileIn(&sstat, "/dev/pts", regexp.MustCompile(`^[0-9]+$`))
return res, err
} | [
"func",
"Discover",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"sstat",
"syscall",
".",
"Stat_t",
"\n",
"if",
"err",
":=",
"syscall",
".",
"Fstat",
"(",
"0",
",",
"&",
"sstat",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",... | // Discover which named TTY we have open as FD=0. Will return empty string if nothing
// was found, and a non-nil error if there was a problem. Will noop on Windows. | [
"Discover",
"which",
"named",
"TTY",
"we",
"have",
"open",
"as",
"FD",
"=",
"0",
".",
"Will",
"return",
"empty",
"string",
"if",
"nothing",
"was",
"found",
"and",
"a",
"non",
"-",
"nil",
"error",
"if",
"there",
"was",
"a",
"problem",
".",
"Will",
"no... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/spotty/spotty_nix.go#L25-L39 |
160,017 | keybase/client | go/install/install_darwin.go | KeybaseServiceStatus | func KeybaseServiceStatus(context Context, label string, wait time.Duration, log Log) (status keybase1.ServiceStatus) {
if label == "" {
status = keybase1.ServiceStatus{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, "No service label")}
return
}
kbService := launchd.NewService(label)
status, err := serviceStatusFromLaunchd(kbService, context.GetServiceInfoPath(), wait, log)
status.BundleVersion = libkb.VersionString()
if err != nil {
return
}
if status.InstallStatus == keybase1.InstallStatus_NOT_INSTALLED {
return
}
installStatus, installAction, kbStatus := ResolveInstallStatus(status.Version, status.BundleVersion, status.LastExitStatus, log)
status.InstallStatus = installStatus
status.InstallAction = installAction
status.Status = kbStatus
return
} | go | func KeybaseServiceStatus(context Context, label string, wait time.Duration, log Log) (status keybase1.ServiceStatus) {
if label == "" {
status = keybase1.ServiceStatus{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, "No service label")}
return
}
kbService := launchd.NewService(label)
status, err := serviceStatusFromLaunchd(kbService, context.GetServiceInfoPath(), wait, log)
status.BundleVersion = libkb.VersionString()
if err != nil {
return
}
if status.InstallStatus == keybase1.InstallStatus_NOT_INSTALLED {
return
}
installStatus, installAction, kbStatus := ResolveInstallStatus(status.Version, status.BundleVersion, status.LastExitStatus, log)
status.InstallStatus = installStatus
status.InstallAction = installAction
status.Status = kbStatus
return
} | [
"func",
"KeybaseServiceStatus",
"(",
"context",
"Context",
",",
"label",
"string",
",",
"wait",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"(",
"status",
"keybase1",
".",
"ServiceStatus",
")",
"{",
"if",
"label",
"==",
"\"",
"\"",
"{",
"status",
"=... | // KeybaseServiceStatus returns service status for Keybase service | [
"KeybaseServiceStatus",
"returns",
"service",
"status",
"for",
"Keybase",
"service"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L58-L79 |
160,018 | keybase/client | go/install/install_darwin.go | KBFSServiceStatus | func KBFSServiceStatus(context Context, label string, wait time.Duration, log Log) (status keybase1.ServiceStatus) {
if label == "" {
status = keybase1.ServiceStatus{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, "No service label")}
return
}
kbfsService := launchd.NewService(label)
status, err := serviceStatusFromLaunchd(kbfsService, context.GetKBFSInfoPath(), wait, log)
if err != nil {
return
}
bundleVersion, err := KBFSBundleVersion(context, "")
if err != nil {
status.Status = keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, err.Error())
return
}
status.BundleVersion = bundleVersion
if status.InstallStatus == keybase1.InstallStatus_NOT_INSTALLED {
return
}
installStatus, installAction, kbStatus := ResolveInstallStatus(status.Version, status.BundleVersion, status.LastExitStatus, log)
status.InstallStatus = installStatus
status.InstallAction = installAction
status.Status = kbStatus
return
} | go | func KBFSServiceStatus(context Context, label string, wait time.Duration, log Log) (status keybase1.ServiceStatus) {
if label == "" {
status = keybase1.ServiceStatus{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, "No service label")}
return
}
kbfsService := launchd.NewService(label)
status, err := serviceStatusFromLaunchd(kbfsService, context.GetKBFSInfoPath(), wait, log)
if err != nil {
return
}
bundleVersion, err := KBFSBundleVersion(context, "")
if err != nil {
status.Status = keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, err.Error())
return
}
status.BundleVersion = bundleVersion
if status.InstallStatus == keybase1.InstallStatus_NOT_INSTALLED {
return
}
installStatus, installAction, kbStatus := ResolveInstallStatus(status.Version, status.BundleVersion, status.LastExitStatus, log)
status.InstallStatus = installStatus
status.InstallAction = installAction
status.Status = kbStatus
return
} | [
"func",
"KBFSServiceStatus",
"(",
"context",
"Context",
",",
"label",
"string",
",",
"wait",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"(",
"status",
"keybase1",
".",
"ServiceStatus",
")",
"{",
"if",
"label",
"==",
"\"",
"\"",
"{",
"status",
"=",
... | // KBFSServiceStatus returns service status for KBFS | [
"KBFSServiceStatus",
"returns",
"service",
"status",
"for",
"KBFS"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L82-L108 |
160,019 | keybase/client | go/install/install_darwin.go | UpdaterServiceStatus | func UpdaterServiceStatus(context Context, label string) keybase1.ServiceStatus {
if label == "" {
return keybase1.ServiceStatus{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, "No service label")}
}
serviceStatus := keybase1.ServiceStatus{Label: label}
updaterService := launchd.NewService(label)
status, err := updaterService.WaitForStatus(defaultLaunchdWait, 500*time.Millisecond)
if err != nil {
serviceStatus.Status = keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, err.Error())
return serviceStatus
}
if status != nil {
serviceStatus.Pid = status.Pid()
serviceStatus.LastExitStatus = status.LastExitStatus()
}
if serviceStatus.Pid != "" {
serviceStatus.InstallStatus = keybase1.InstallStatus_INSTALLED
serviceStatus.InstallAction = keybase1.InstallAction_NONE
} else {
serviceStatus.InstallStatus = keybase1.InstallStatus_NOT_INSTALLED
serviceStatus.InstallAction = keybase1.InstallAction_INSTALL
}
serviceStatus.Status = keybase1.StatusOK("")
return serviceStatus
} | go | func UpdaterServiceStatus(context Context, label string) keybase1.ServiceStatus {
if label == "" {
return keybase1.ServiceStatus{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, "No service label")}
}
serviceStatus := keybase1.ServiceStatus{Label: label}
updaterService := launchd.NewService(label)
status, err := updaterService.WaitForStatus(defaultLaunchdWait, 500*time.Millisecond)
if err != nil {
serviceStatus.Status = keybase1.StatusFromCode(keybase1.StatusCode_SCServiceStatusError, err.Error())
return serviceStatus
}
if status != nil {
serviceStatus.Pid = status.Pid()
serviceStatus.LastExitStatus = status.LastExitStatus()
}
if serviceStatus.Pid != "" {
serviceStatus.InstallStatus = keybase1.InstallStatus_INSTALLED
serviceStatus.InstallAction = keybase1.InstallAction_NONE
} else {
serviceStatus.InstallStatus = keybase1.InstallStatus_NOT_INSTALLED
serviceStatus.InstallAction = keybase1.InstallAction_INSTALL
}
serviceStatus.Status = keybase1.StatusOK("")
return serviceStatus
} | [
"func",
"UpdaterServiceStatus",
"(",
"context",
"Context",
",",
"label",
"string",
")",
"keybase1",
".",
"ServiceStatus",
"{",
"if",
"label",
"==",
"\"",
"\"",
"{",
"return",
"keybase1",
".",
"ServiceStatus",
"{",
"Status",
":",
"keybase1",
".",
"StatusFromCod... | // UpdaterServiceStatus returns service status for the Updater service | [
"UpdaterServiceStatus",
"returns",
"service",
"status",
"for",
"the",
"Updater",
"service"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L111-L135 |
160,020 | keybase/client | go/install/install_darwin.go | ListServices | func ListServices(context Context, wait time.Duration, log Log) (*keybase1.ServicesStatus, error) {
services, err := launchd.ListServices([]string{"keybase.service", "homebrew.mxcl.keybase"})
if err != nil {
return nil, err
}
kbfs, err := launchd.ListServices([]string{"keybase.kbfs.", "homebrew.mxcl.kbfs"})
if err != nil {
return nil, err
}
updater, err := launchd.ListServices([]string{"keybase.updater."})
if err != nil {
return nil, err
}
return &keybase1.ServicesStatus{
Service: serviceStatusesFromLaunchd(context, services, wait, log),
Kbfs: serviceStatusesFromLaunchd(context, kbfs, wait, log),
Updater: serviceStatusesFromLaunchd(context, updater, wait, log),
}, nil
} | go | func ListServices(context Context, wait time.Duration, log Log) (*keybase1.ServicesStatus, error) {
services, err := launchd.ListServices([]string{"keybase.service", "homebrew.mxcl.keybase"})
if err != nil {
return nil, err
}
kbfs, err := launchd.ListServices([]string{"keybase.kbfs.", "homebrew.mxcl.kbfs"})
if err != nil {
return nil, err
}
updater, err := launchd.ListServices([]string{"keybase.updater."})
if err != nil {
return nil, err
}
return &keybase1.ServicesStatus{
Service: serviceStatusesFromLaunchd(context, services, wait, log),
Kbfs: serviceStatusesFromLaunchd(context, kbfs, wait, log),
Updater: serviceStatusesFromLaunchd(context, updater, wait, log),
}, nil
} | [
"func",
"ListServices",
"(",
"context",
"Context",
",",
"wait",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"(",
"*",
"keybase1",
".",
"ServicesStatus",
",",
"error",
")",
"{",
"services",
",",
"err",
":=",
"launchd",
".",
"ListServices",
"(",
"[",
... | // ListServices returns status for all services | [
"ListServices",
"returns",
"status",
"for",
"all",
"services"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L200-L219 |
160,021 | keybase/client | go/install/install_darwin.go | DefaultLaunchdEnvVars | func DefaultLaunchdEnvVars(label string) []launchd.EnvVar {
return []launchd.EnvVar{
launchd.NewEnvVar("KEYBASE_LABEL", label),
launchd.NewEnvVar("KEYBASE_SERVICE_TYPE", "launchd"),
}
} | go | func DefaultLaunchdEnvVars(label string) []launchd.EnvVar {
return []launchd.EnvVar{
launchd.NewEnvVar("KEYBASE_LABEL", label),
launchd.NewEnvVar("KEYBASE_SERVICE_TYPE", "launchd"),
}
} | [
"func",
"DefaultLaunchdEnvVars",
"(",
"label",
"string",
")",
"[",
"]",
"launchd",
".",
"EnvVar",
"{",
"return",
"[",
"]",
"launchd",
".",
"EnvVar",
"{",
"launchd",
".",
"NewEnvVar",
"(",
"\"",
"\"",
",",
"label",
")",
",",
"launchd",
".",
"NewEnvVar",
... | // DefaultLaunchdEnvVars returns default environment vars for launchd | [
"DefaultLaunchdEnvVars",
"returns",
"default",
"environment",
"vars",
"for",
"launchd"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L222-L227 |
160,022 | keybase/client | go/install/install_darwin.go | DefaultUpdaterLabel | func DefaultUpdaterLabel(runMode libkb.RunMode) string {
label := AppUpdaterLabel.String()
if runMode != libkb.ProductionRunMode {
label = label + "." + string(runMode)
}
return label
} | go | func DefaultUpdaterLabel(runMode libkb.RunMode) string {
label := AppUpdaterLabel.String()
if runMode != libkb.ProductionRunMode {
label = label + "." + string(runMode)
}
return label
} | [
"func",
"DefaultUpdaterLabel",
"(",
"runMode",
"libkb",
".",
"RunMode",
")",
"string",
"{",
"label",
":=",
"AppUpdaterLabel",
".",
"String",
"(",
")",
"\n",
"if",
"runMode",
"!=",
"libkb",
".",
"ProductionRunMode",
"{",
"label",
"=",
"label",
"+",
"\"",
"\... | // DefaultUpdaterLabel returns the default label for the update service in launchd | [
"DefaultUpdaterLabel",
"returns",
"the",
"default",
"label",
"for",
"the",
"update",
"service",
"in",
"launchd"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L262-L268 |
160,023 | keybase/client | go/install/install_darwin.go | NewServiceLabel | func NewServiceLabel(s string) (ServiceLabel, error) {
switch s {
case string(AppServiceLabel):
return AppServiceLabel, nil
case string(BrewServiceLabel):
return BrewServiceLabel, nil
case string(AppKBFSLabel):
return AppKBFSLabel, nil
case string(BrewKBFSLabel):
return BrewKBFSLabel, nil
case string(AppUpdaterLabel):
return AppUpdaterLabel, nil
}
return UnknownLabel, fmt.Errorf("Unknown service label: %s", s)
} | go | func NewServiceLabel(s string) (ServiceLabel, error) {
switch s {
case string(AppServiceLabel):
return AppServiceLabel, nil
case string(BrewServiceLabel):
return BrewServiceLabel, nil
case string(AppKBFSLabel):
return AppKBFSLabel, nil
case string(BrewKBFSLabel):
return BrewKBFSLabel, nil
case string(AppUpdaterLabel):
return AppUpdaterLabel, nil
}
return UnknownLabel, fmt.Errorf("Unknown service label: %s", s)
} | [
"func",
"NewServiceLabel",
"(",
"s",
"string",
")",
"(",
"ServiceLabel",
",",
"error",
")",
"{",
"switch",
"s",
"{",
"case",
"string",
"(",
"AppServiceLabel",
")",
":",
"return",
"AppServiceLabel",
",",
"nil",
"\n",
"case",
"string",
"(",
"BrewServiceLabel",... | // NewServiceLabel constructs a service label | [
"NewServiceLabel",
"constructs",
"a",
"service",
"label"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L356-L370 |
160,024 | keybase/client | go/install/install_darwin.go | ComponentName | func (l ServiceLabel) ComponentName() ComponentName {
switch l {
case AppServiceLabel, BrewServiceLabel:
return ComponentNameService
case AppKBFSLabel, BrewKBFSLabel:
return ComponentNameKBFS
case AppUpdaterLabel:
return ComponentNameUpdater
}
return ComponentNameUnknown
} | go | func (l ServiceLabel) ComponentName() ComponentName {
switch l {
case AppServiceLabel, BrewServiceLabel:
return ComponentNameService
case AppKBFSLabel, BrewKBFSLabel:
return ComponentNameKBFS
case AppUpdaterLabel:
return ComponentNameUpdater
}
return ComponentNameUnknown
} | [
"func",
"(",
"l",
"ServiceLabel",
")",
"ComponentName",
"(",
")",
"ComponentName",
"{",
"switch",
"l",
"{",
"case",
"AppServiceLabel",
",",
"BrewServiceLabel",
":",
"return",
"ComponentNameService",
"\n",
"case",
"AppKBFSLabel",
",",
"BrewKBFSLabel",
":",
"return"... | // ComponentName returns the component name for a service label | [
"ComponentName",
"returns",
"the",
"component",
"name",
"for",
"a",
"service",
"label"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L377-L387 |
160,025 | keybase/client | go/install/install_darwin.go | ServiceStatus | func ServiceStatus(context Context, label ServiceLabel, wait time.Duration, log Log) (*keybase1.ServiceStatus, error) {
switch label.ComponentName() {
case ComponentNameService:
st := KeybaseServiceStatus(context, string(label), wait, log)
return &st, nil
case ComponentNameKBFS:
st := KBFSServiceStatus(context, string(label), wait, log)
return &st, nil
case ComponentNameUpdater:
st := UpdaterServiceStatus(context, string(label))
return &st, nil
default:
return nil, fmt.Errorf("Invalid label: %s", label)
}
} | go | func ServiceStatus(context Context, label ServiceLabel, wait time.Duration, log Log) (*keybase1.ServiceStatus, error) {
switch label.ComponentName() {
case ComponentNameService:
st := KeybaseServiceStatus(context, string(label), wait, log)
return &st, nil
case ComponentNameKBFS:
st := KBFSServiceStatus(context, string(label), wait, log)
return &st, nil
case ComponentNameUpdater:
st := UpdaterServiceStatus(context, string(label))
return &st, nil
default:
return nil, fmt.Errorf("Invalid label: %s", label)
}
} | [
"func",
"ServiceStatus",
"(",
"context",
"Context",
",",
"label",
"ServiceLabel",
",",
"wait",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"(",
"*",
"keybase1",
".",
"ServiceStatus",
",",
"error",
")",
"{",
"switch",
"label",
".",
"ComponentName",
"("... | // ServiceStatus returns status for a service named by label | [
"ServiceStatus",
"returns",
"status",
"for",
"a",
"service",
"named",
"by",
"label"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L390-L404 |
160,026 | keybase/client | go/install/install_darwin.go | InstallAuto | func InstallAuto(context Context, binPath string, sourcePath string, timeout time.Duration, log Log) keybase1.InstallResult {
var components []string
status := KeybaseFuseStatus("", log)
if status.InstallStatus == keybase1.InstallStatus_INSTALLED {
components = []string{
ComponentNameCLI.String(),
ComponentNameUpdater.String(),
ComponentNameService.String(),
ComponentNameKBFS.String(),
ComponentNameHelper.String(),
ComponentNameFuse.String(),
ComponentNameMountDir.String(),
ComponentNameRedirector.String(),
ComponentNameKBFS.String(),
ComponentNameKBNM.String(),
}
} else {
components = []string{
ComponentNameCLI.String(),
ComponentNameUpdater.String(),
ComponentNameService.String(),
ComponentNameKBFS.String(),
ComponentNameKBNM.String(),
}
}
// A force unmount is needed to change from one mountpoint to another
// if the mount is in use after an upgrade, and install-auto is
// invoked from the updater.
forceUnmount := true
return Install(context, binPath, sourcePath, components, forceUnmount, timeout, log)
} | go | func InstallAuto(context Context, binPath string, sourcePath string, timeout time.Duration, log Log) keybase1.InstallResult {
var components []string
status := KeybaseFuseStatus("", log)
if status.InstallStatus == keybase1.InstallStatus_INSTALLED {
components = []string{
ComponentNameCLI.String(),
ComponentNameUpdater.String(),
ComponentNameService.String(),
ComponentNameKBFS.String(),
ComponentNameHelper.String(),
ComponentNameFuse.String(),
ComponentNameMountDir.String(),
ComponentNameRedirector.String(),
ComponentNameKBFS.String(),
ComponentNameKBNM.String(),
}
} else {
components = []string{
ComponentNameCLI.String(),
ComponentNameUpdater.String(),
ComponentNameService.String(),
ComponentNameKBFS.String(),
ComponentNameKBNM.String(),
}
}
// A force unmount is needed to change from one mountpoint to another
// if the mount is in use after an upgrade, and install-auto is
// invoked from the updater.
forceUnmount := true
return Install(context, binPath, sourcePath, components, forceUnmount, timeout, log)
} | [
"func",
"InstallAuto",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"sourcePath",
"string",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"keybase1",
".",
"InstallResult",
"{",
"var",
"components",
"[",
"]",
"string",
"\n",
... | // InstallAuto installs everything it can without asking for privileges or
// extensions. If the user has already installed Fuse, we install everything. | [
"InstallAuto",
"installs",
"everything",
"it",
"can",
"without",
"asking",
"for",
"privileges",
"or",
"extensions",
".",
"If",
"the",
"user",
"has",
"already",
"installed",
"Fuse",
"we",
"install",
"everything",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L408-L439 |
160,027 | keybase/client | go/install/install_darwin.go | InstallService | func InstallService(context Context, binPath string, force bool, timeout time.Duration, log Log) error {
resolvedBinPath, err := chooseBinPath(binPath)
if err != nil {
return err
}
log.Debug("Using binPath: %s", resolvedBinPath)
label := DefaultServiceLabel(context.GetRunMode())
service := launchd.NewService(label)
plist, err := keybasePlist(context, resolvedBinPath, label, log)
if err != nil {
return err
}
UninstallKeybaseServices(context, log)
log.Debug("Installing service (%s, timeout=%s)", label, timeout)
if _, err := installKeybaseService(context, service, plist, timeout, log); err != nil {
log.Errorf("Error installing Keybase service: %s", err)
pid, err := fallbackStartProcessAndWaitForInfo(context, service, plist, context.GetServiceInfoPath(), timeout, log)
if err != nil {
return err
}
log.Debug("fallback keybase service started, pid=%d", pid)
return nil
}
log.Debug("keybase service installed via launchd successfully")
return nil
} | go | func InstallService(context Context, binPath string, force bool, timeout time.Duration, log Log) error {
resolvedBinPath, err := chooseBinPath(binPath)
if err != nil {
return err
}
log.Debug("Using binPath: %s", resolvedBinPath)
label := DefaultServiceLabel(context.GetRunMode())
service := launchd.NewService(label)
plist, err := keybasePlist(context, resolvedBinPath, label, log)
if err != nil {
return err
}
UninstallKeybaseServices(context, log)
log.Debug("Installing service (%s, timeout=%s)", label, timeout)
if _, err := installKeybaseService(context, service, plist, timeout, log); err != nil {
log.Errorf("Error installing Keybase service: %s", err)
pid, err := fallbackStartProcessAndWaitForInfo(context, service, plist, context.GetServiceInfoPath(), timeout, log)
if err != nil {
return err
}
log.Debug("fallback keybase service started, pid=%d", pid)
return nil
}
log.Debug("keybase service installed via launchd successfully")
return nil
} | [
"func",
"InstallService",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"force",
"bool",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"error",
"{",
"resolvedBinPath",
",",
"err",
":=",
"chooseBinPath",
"(",
"binPath",
")",
"... | // InstallService installs the launchd service | [
"InstallService",
"installs",
"the",
"launchd",
"service"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L691-L717 |
160,028 | keybase/client | go/install/install_darwin.go | InstallKBFS | func InstallKBFS(context Context, binPath string, force bool, skipMountIfNotAvailable bool, timeout time.Duration, log Log) error {
runMode := context.GetRunMode()
label := DefaultKBFSLabel(runMode)
kbfsService := launchd.NewService(label)
kbfsBinPath, err := KBFSBinPath(runMode, binPath)
if err != nil {
return err
}
// Unmount any existing KBFS directory for the user.
mountDir, err := context.GetMountDir()
if err != nil {
return err
}
skipMount := false
_, err = os.Stat(mountDir)
if err != nil {
if skipMountIfNotAvailable {
skipMount = true
} else {
return err
}
}
plist, err := kbfsPlist(context, kbfsBinPath, label, mountDir, skipMount, log)
if err != nil {
return err
}
UninstallKBFSServices(context, log)
log.Debug("Installing KBFS (%s, timeout=%s)", label, timeout)
if _, err := installKBFSService(context, kbfsService, plist, timeout, log); err != nil {
log.Errorf("error installing KBFS: %s", err)
pid, err := fallbackStartProcessAndWaitForInfo(context, kbfsService, plist, context.GetKBFSInfoPath(), timeout, log)
if err != nil {
return err
}
log.Debug("fallback KBFS service started, pid=%d", pid)
return nil
}
log.Debug("KBFS installed via launchd successfully")
return nil
} | go | func InstallKBFS(context Context, binPath string, force bool, skipMountIfNotAvailable bool, timeout time.Duration, log Log) error {
runMode := context.GetRunMode()
label := DefaultKBFSLabel(runMode)
kbfsService := launchd.NewService(label)
kbfsBinPath, err := KBFSBinPath(runMode, binPath)
if err != nil {
return err
}
// Unmount any existing KBFS directory for the user.
mountDir, err := context.GetMountDir()
if err != nil {
return err
}
skipMount := false
_, err = os.Stat(mountDir)
if err != nil {
if skipMountIfNotAvailable {
skipMount = true
} else {
return err
}
}
plist, err := kbfsPlist(context, kbfsBinPath, label, mountDir, skipMount, log)
if err != nil {
return err
}
UninstallKBFSServices(context, log)
log.Debug("Installing KBFS (%s, timeout=%s)", label, timeout)
if _, err := installKBFSService(context, kbfsService, plist, timeout, log); err != nil {
log.Errorf("error installing KBFS: %s", err)
pid, err := fallbackStartProcessAndWaitForInfo(context, kbfsService, plist, context.GetKBFSInfoPath(), timeout, log)
if err != nil {
return err
}
log.Debug("fallback KBFS service started, pid=%d", pid)
return nil
}
log.Debug("KBFS installed via launchd successfully")
return nil
} | [
"func",
"InstallKBFS",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"force",
"bool",
",",
"skipMountIfNotAvailable",
"bool",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"error",
"{",
"runMode",
":=",
"context",
".",
"GetRunM... | // InstallKBFS installs the KBFS launchd service | [
"InstallKBFS",
"installs",
"the",
"KBFS",
"launchd",
"service"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L720-L763 |
160,029 | keybase/client | go/install/install_darwin.go | InstallKBNM | func InstallKBNM(context Context, binPath string, log Log) error {
// Find path of the keybase binary
keybasePath, err := chooseBinPath(binPath)
if err != nil {
return err
}
// kbnm binary is next to the keybase binary, same dir
hostPath := filepath.Join(filepath.Dir(keybasePath), "kbnm")
log.Info("Installing KBNM NativeMessaging whitelists for binary: %s", hostPath)
return kbnminstaller.InstallKBNM(hostPath)
} | go | func InstallKBNM(context Context, binPath string, log Log) error {
// Find path of the keybase binary
keybasePath, err := chooseBinPath(binPath)
if err != nil {
return err
}
// kbnm binary is next to the keybase binary, same dir
hostPath := filepath.Join(filepath.Dir(keybasePath), "kbnm")
log.Info("Installing KBNM NativeMessaging whitelists for binary: %s", hostPath)
return kbnminstaller.InstallKBNM(hostPath)
} | [
"func",
"InstallKBNM",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"log",
"Log",
")",
"error",
"{",
"// Find path of the keybase binary",
"keybasePath",
",",
"err",
":=",
"chooseBinPath",
"(",
"binPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // InstallKBNM installs the Keybase NativeMessaging whitelist | [
"InstallKBNM",
"installs",
"the",
"Keybase",
"NativeMessaging",
"whitelist"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L766-L777 |
160,030 | keybase/client | go/install/install_darwin.go | UninstallKBFS | func UninstallKBFS(context Context, mountDir string, forceUnmount bool, log Log) error {
err := UninstallKBFSServices(context, log)
if err != nil {
log.Warning("Couldn't stop KBFS: %+v", err)
// Continue despite the error, since the uninstall doesn't
// seem to be resilient against the "fallback" PID getting out
// of sync with the true KBFS PID. TODO: fix the fallback PID
// logic?
}
return unmount(mountDir, forceUnmount, log)
} | go | func UninstallKBFS(context Context, mountDir string, forceUnmount bool, log Log) error {
err := UninstallKBFSServices(context, log)
if err != nil {
log.Warning("Couldn't stop KBFS: %+v", err)
// Continue despite the error, since the uninstall doesn't
// seem to be resilient against the "fallback" PID getting out
// of sync with the true KBFS PID. TODO: fix the fallback PID
// logic?
}
return unmount(mountDir, forceUnmount, log)
} | [
"func",
"UninstallKBFS",
"(",
"context",
"Context",
",",
"mountDir",
"string",
",",
"forceUnmount",
"bool",
",",
"log",
"Log",
")",
"error",
"{",
"err",
":=",
"UninstallKBFSServices",
"(",
"context",
",",
"log",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // UninstallKBFS uninstalls all KBFS services, unmounts and optionally removes the mount directory | [
"UninstallKBFS",
"uninstalls",
"all",
"KBFS",
"services",
"unmounts",
"and",
"optionally",
"removes",
"the",
"mount",
"directory"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L936-L947 |
160,031 | keybase/client | go/install/install_darwin.go | AutoInstallWithStatus | func AutoInstallWithStatus(context Context, binPath string, force bool, timeout time.Duration, log Log) keybase1.InstallResult {
_, res, err := autoInstall(context, binPath, force, timeout, log)
if err != nil {
return keybase1.InstallResult{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCInstallError, err.Error())}
}
return newInstallResult(res)
} | go | func AutoInstallWithStatus(context Context, binPath string, force bool, timeout time.Duration, log Log) keybase1.InstallResult {
_, res, err := autoInstall(context, binPath, force, timeout, log)
if err != nil {
return keybase1.InstallResult{Status: keybase1.StatusFromCode(keybase1.StatusCode_SCInstallError, err.Error())}
}
return newInstallResult(res)
} | [
"func",
"AutoInstallWithStatus",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"force",
"bool",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"keybase1",
".",
"InstallResult",
"{",
"_",
",",
"res",
",",
"err",
":=",
"autoInst... | // AutoInstallWithStatus runs the auto install and returns a result | [
"AutoInstallWithStatus",
"runs",
"the",
"auto",
"install",
"and",
"returns",
"a",
"result"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L950-L956 |
160,032 | keybase/client | go/install/install_darwin.go | AutoInstall | func AutoInstall(context Context, binPath string, force bool, timeout time.Duration, log Log) (newProc bool, err error) {
if context.GetRunMode() != libkb.ProductionRunMode {
return false, fmt.Errorf("Auto install is only supported in production")
}
newProc, _, err = autoInstall(context, binPath, force, timeout, log)
return
} | go | func AutoInstall(context Context, binPath string, force bool, timeout time.Duration, log Log) (newProc bool, err error) {
if context.GetRunMode() != libkb.ProductionRunMode {
return false, fmt.Errorf("Auto install is only supported in production")
}
newProc, _, err = autoInstall(context, binPath, force, timeout, log)
return
} | [
"func",
"AutoInstall",
"(",
"context",
"Context",
",",
"binPath",
"string",
",",
"force",
"bool",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"(",
"newProc",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"context",
".",
"GetRunMode",
... | // AutoInstall runs the auto install | [
"AutoInstall",
"runs",
"the",
"auto",
"install"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L959-L966 |
160,033 | keybase/client | go/install/install_darwin.go | isPathInDMG | func isPathInDMG(p string) (inDMG bool, bundlePath string, err error) {
var stat syscall.Statfs_t
err = syscall.Statfs(p, &stat)
if err != nil {
return
}
// mntRootFS identifies the root filesystem (http://www.opensource.apple.com/source/xnu/xnu-344.26/bsd/sys/mount.h)
const mntRootFS = 0x00004000
if (stat.Flags & mntRootFS) != 0 {
// We're on the root filesystem so we're not in a DMG
return
}
bundlePath = bundleDirForPath(p)
if bundlePath != "" {
// Look for Applications symlink in the same folder as Keybase.app, and if
// we find it, we're really likely to be in a mounted dmg
appLink := filepath.Join(filepath.Dir(bundlePath), "Applications")
fi, ferr := os.Lstat(appLink)
if os.IsNotExist(ferr) {
return
}
isLink := (fi.Mode()&os.ModeSymlink != 0)
if isLink {
inDMG = true
return
}
}
return
} | go | func isPathInDMG(p string) (inDMG bool, bundlePath string, err error) {
var stat syscall.Statfs_t
err = syscall.Statfs(p, &stat)
if err != nil {
return
}
// mntRootFS identifies the root filesystem (http://www.opensource.apple.com/source/xnu/xnu-344.26/bsd/sys/mount.h)
const mntRootFS = 0x00004000
if (stat.Flags & mntRootFS) != 0 {
// We're on the root filesystem so we're not in a DMG
return
}
bundlePath = bundleDirForPath(p)
if bundlePath != "" {
// Look for Applications symlink in the same folder as Keybase.app, and if
// we find it, we're really likely to be in a mounted dmg
appLink := filepath.Join(filepath.Dir(bundlePath), "Applications")
fi, ferr := os.Lstat(appLink)
if os.IsNotExist(ferr) {
return
}
isLink := (fi.Mode()&os.ModeSymlink != 0)
if isLink {
inDMG = true
return
}
}
return
} | [
"func",
"isPathInDMG",
"(",
"p",
"string",
")",
"(",
"inDMG",
"bool",
",",
"bundlePath",
"string",
",",
"err",
"error",
")",
"{",
"var",
"stat",
"syscall",
".",
"Statfs_t",
"\n",
"err",
"=",
"syscall",
".",
"Statfs",
"(",
"p",
",",
"&",
"stat",
")",
... | // isPathInDMG errors if the path is inside dmg | [
"isPathInDMG",
"errors",
"if",
"the",
"path",
"is",
"inside",
"dmg"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L1024-L1056 |
160,034 | keybase/client | go/install/install_darwin.go | OSVersion | func OSVersion() (semver.Version, error) {
out, err := exec.Command("sw_vers", "-productVersion").Output()
if err != nil {
return semver.Version{}, err
}
swver := strings.TrimSpace(string(out))
// The version might not be semver compliant for beta macOS (e.g. "10.12")
if strings.Count(swver, ".") == 1 {
swver = swver + ".0"
}
return semver.Make(swver)
} | go | func OSVersion() (semver.Version, error) {
out, err := exec.Command("sw_vers", "-productVersion").Output()
if err != nil {
return semver.Version{}, err
}
swver := strings.TrimSpace(string(out))
// The version might not be semver compliant for beta macOS (e.g. "10.12")
if strings.Count(swver, ".") == 1 {
swver = swver + ".0"
}
return semver.Make(swver)
} | [
"func",
"OSVersion",
"(",
")",
"(",
"semver",
".",
"Version",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return"... | // OSVersion returns the OS version | [
"OSVersion",
"returns",
"the",
"OS",
"version"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L1144-L1155 |
160,035 | keybase/client | go/install/install_darwin.go | InstallUpdater | func InstallUpdater(context Context, keybaseBinPath string, force bool, timeout time.Duration, log Log) error {
if context.GetRunMode() != libkb.ProductionRunMode {
return fmt.Errorf("Updater not supported in this run mode")
}
keybaseBinPath, err := chooseBinPath(keybaseBinPath)
if err != nil {
return err
}
updaterBinPath := filepath.Join(filepath.Dir(keybaseBinPath), "updater")
if err != nil {
return err
}
log.Debug("Using updater path: %s", updaterBinPath)
label := DefaultUpdaterLabel(context.GetRunMode())
service := launchd.NewService(label)
plist, err := updaterPlist(context, label, updaterBinPath, keybaseBinPath, log)
if err != nil {
return err
}
UninstallUpdaterService(context, log)
log.Debug("Installing updater service (%s, timeout=%s)", label, timeout)
if _, err := installUpdaterService(context, service, plist, timeout, log); err != nil {
log.Errorf("Error installing updater service: %s", err)
_, err = fallbackStartProcess(context, service, plist, log)
return err
}
return nil
} | go | func InstallUpdater(context Context, keybaseBinPath string, force bool, timeout time.Duration, log Log) error {
if context.GetRunMode() != libkb.ProductionRunMode {
return fmt.Errorf("Updater not supported in this run mode")
}
keybaseBinPath, err := chooseBinPath(keybaseBinPath)
if err != nil {
return err
}
updaterBinPath := filepath.Join(filepath.Dir(keybaseBinPath), "updater")
if err != nil {
return err
}
log.Debug("Using updater path: %s", updaterBinPath)
label := DefaultUpdaterLabel(context.GetRunMode())
service := launchd.NewService(label)
plist, err := updaterPlist(context, label, updaterBinPath, keybaseBinPath, log)
if err != nil {
return err
}
UninstallUpdaterService(context, log)
log.Debug("Installing updater service (%s, timeout=%s)", label, timeout)
if _, err := installUpdaterService(context, service, plist, timeout, log); err != nil {
log.Errorf("Error installing updater service: %s", err)
_, err = fallbackStartProcess(context, service, plist, log)
return err
}
return nil
} | [
"func",
"InstallUpdater",
"(",
"context",
"Context",
",",
"keybaseBinPath",
"string",
",",
"force",
"bool",
",",
"timeout",
"time",
".",
"Duration",
",",
"log",
"Log",
")",
"error",
"{",
"if",
"context",
".",
"GetRunMode",
"(",
")",
"!=",
"libkb",
".",
"... | // InstallUpdater installs the updater launchd service | [
"InstallUpdater",
"installs",
"the",
"updater",
"launchd",
"service"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L1158-L1187 |
160,036 | keybase/client | go/install/install_darwin.go | UninstallUpdaterService | func UninstallUpdaterService(context Context, log Log) error {
runMode := context.GetRunMode()
pidFile := filepath.Join(context.GetCacheDir(), "updater.pid")
err0 := fallbackKillProcess(context, log, DefaultUpdaterLabel(runMode), "", pidFile)
err1 := launchd.Uninstall(DefaultUpdaterLabel(runMode), defaultLaunchdWait, log)
return libkb.CombineErrors(err0, err1)
} | go | func UninstallUpdaterService(context Context, log Log) error {
runMode := context.GetRunMode()
pidFile := filepath.Join(context.GetCacheDir(), "updater.pid")
err0 := fallbackKillProcess(context, log, DefaultUpdaterLabel(runMode), "", pidFile)
err1 := launchd.Uninstall(DefaultUpdaterLabel(runMode), defaultLaunchdWait, log)
return libkb.CombineErrors(err0, err1)
} | [
"func",
"UninstallUpdaterService",
"(",
"context",
"Context",
",",
"log",
"Log",
")",
"error",
"{",
"runMode",
":=",
"context",
".",
"GetRunMode",
"(",
")",
"\n",
"pidFile",
":=",
"filepath",
".",
"Join",
"(",
"context",
".",
"GetCacheDir",
"(",
")",
",",
... | // UninstallUpdaterService removes updater launchd service | [
"UninstallUpdaterService",
"removes",
"updater",
"launchd",
"service"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L1213-L1219 |
160,037 | keybase/client | go/install/install_darwin.go | RunApp | func RunApp(context Context, log Log) error {
appPath, err := libnativeinstaller.AppBundleForPath()
if err != nil {
return err
}
ver, err := OSVersion()
if err != nil {
log.Errorf("Error trying to determine OS version: %s", err)
return nil
}
if ver.LT(semver.MustParse("10.0.0")) {
return fmt.Errorf("App isn't supported on this OS version: %s", ver)
}
log.Info("Opening %s", appPath)
// If app is already open this is a no-op, the -g option will cause to open
// in background.
out, err := exec.Command("/usr/bin/open", "-g", appPath).Output()
if err != nil {
return fmt.Errorf("Error trying to open %s: %s; %s", appPath, err, out)
}
return nil
} | go | func RunApp(context Context, log Log) error {
appPath, err := libnativeinstaller.AppBundleForPath()
if err != nil {
return err
}
ver, err := OSVersion()
if err != nil {
log.Errorf("Error trying to determine OS version: %s", err)
return nil
}
if ver.LT(semver.MustParse("10.0.0")) {
return fmt.Errorf("App isn't supported on this OS version: %s", ver)
}
log.Info("Opening %s", appPath)
// If app is already open this is a no-op, the -g option will cause to open
// in background.
out, err := exec.Command("/usr/bin/open", "-g", appPath).Output()
if err != nil {
return fmt.Errorf("Error trying to open %s: %s; %s", appPath, err, out)
}
return nil
} | [
"func",
"RunApp",
"(",
"context",
"Context",
",",
"log",
"Log",
")",
"error",
"{",
"appPath",
",",
"err",
":=",
"libnativeinstaller",
".",
"AppBundleForPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ver",
",",
... | // RunApp starts the app | [
"RunApp",
"starts",
"the",
"app"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/install_darwin.go#L1231-L1253 |
160,038 | keybase/client | go/libkb/sign.go | SimpleSign | func SimpleSign(payload []byte, key PGPKeyBundle) (out string, id keybase1.SigID, err error) {
var outb bytes.Buffer
var in io.WriteCloser
var h HashSummer
if !key.HasSecretKey() {
err = NoSecretKeyError{}
return
}
if in, h, err = ArmoredAttachedSign(NopWriteCloser{&outb}, *key.Entity, nil, nil); err != nil {
return
}
if _, err = in.Write(payload); err != nil {
return
}
if err = in.Close(); err != nil {
return
}
out = outb.String()
if id, err = keybase1.SigIDFromSlice(h()); err != nil {
return
}
return
} | go | func SimpleSign(payload []byte, key PGPKeyBundle) (out string, id keybase1.SigID, err error) {
var outb bytes.Buffer
var in io.WriteCloser
var h HashSummer
if !key.HasSecretKey() {
err = NoSecretKeyError{}
return
}
if in, h, err = ArmoredAttachedSign(NopWriteCloser{&outb}, *key.Entity, nil, nil); err != nil {
return
}
if _, err = in.Write(payload); err != nil {
return
}
if err = in.Close(); err != nil {
return
}
out = outb.String()
if id, err = keybase1.SigIDFromSlice(h()); err != nil {
return
}
return
} | [
"func",
"SimpleSign",
"(",
"payload",
"[",
"]",
"byte",
",",
"key",
"PGPKeyBundle",
")",
"(",
"out",
"string",
",",
"id",
"keybase1",
".",
"SigID",
",",
"err",
"error",
")",
"{",
"var",
"outb",
"bytes",
".",
"Buffer",
"\n",
"var",
"in",
"io",
".",
... | // SimpleSign signs the given data stream, outputs an armored string which is
// the attached signature of the input data | [
"SimpleSign",
"signs",
"the",
"given",
"data",
"stream",
"outputs",
"an",
"armored",
"string",
"which",
"is",
"the",
"attached",
"signature",
"of",
"the",
"input",
"data"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/sign.go#L20-L42 |
160,039 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | MakeRandomTLFCryptKeyServerHalf | func MakeRandomTLFCryptKeyServerHalf() (
serverHalf TLFCryptKeyServerHalf, err error) {
var data [32]byte
err = RandRead(data[:])
if err != nil {
return TLFCryptKeyServerHalf{}, err
}
serverHalf = MakeTLFCryptKeyServerHalf(data)
return serverHalf, nil
} | go | func MakeRandomTLFCryptKeyServerHalf() (
serverHalf TLFCryptKeyServerHalf, err error) {
var data [32]byte
err = RandRead(data[:])
if err != nil {
return TLFCryptKeyServerHalf{}, err
}
serverHalf = MakeTLFCryptKeyServerHalf(data)
return serverHalf, nil
} | [
"func",
"MakeRandomTLFCryptKeyServerHalf",
"(",
")",
"(",
"serverHalf",
"TLFCryptKeyServerHalf",
",",
"err",
"error",
")",
"{",
"var",
"data",
"[",
"32",
"]",
"byte",
"\n",
"err",
"=",
"RandRead",
"(",
"data",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",... | // MakeRandomTLFCryptKeyServerHalf generates the server-side of a
// top-level folder crypt key. | [
"MakeRandomTLFCryptKeyServerHalf",
"generates",
"the",
"server",
"-",
"side",
"of",
"a",
"top",
"-",
"level",
"folder",
"crypt",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L404-L413 |
160,040 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | MakeTLFCryptKeyServerHalfID | func MakeTLFCryptKeyServerHalfID(
user keybase1.UID, devicePubKey CryptPublicKey,
serverHalf TLFCryptKeyServerHalf) (
TLFCryptKeyServerHalfID, error) {
key, err := serverHalf.MarshalBinary()
if err != nil {
return TLFCryptKeyServerHalfID{}, err
}
data := append(user.ToBytes(), devicePubKey.KID().ToBytes()...)
hmac, err := kbfshash.DefaultHMAC(key, data)
if err != nil {
return TLFCryptKeyServerHalfID{}, err
}
return TLFCryptKeyServerHalfID{
ID: hmac,
}, nil
} | go | func MakeTLFCryptKeyServerHalfID(
user keybase1.UID, devicePubKey CryptPublicKey,
serverHalf TLFCryptKeyServerHalf) (
TLFCryptKeyServerHalfID, error) {
key, err := serverHalf.MarshalBinary()
if err != nil {
return TLFCryptKeyServerHalfID{}, err
}
data := append(user.ToBytes(), devicePubKey.KID().ToBytes()...)
hmac, err := kbfshash.DefaultHMAC(key, data)
if err != nil {
return TLFCryptKeyServerHalfID{}, err
}
return TLFCryptKeyServerHalfID{
ID: hmac,
}, nil
} | [
"func",
"MakeTLFCryptKeyServerHalfID",
"(",
"user",
"keybase1",
".",
"UID",
",",
"devicePubKey",
"CryptPublicKey",
",",
"serverHalf",
"TLFCryptKeyServerHalf",
")",
"(",
"TLFCryptKeyServerHalfID",
",",
"error",
")",
"{",
"key",
",",
"err",
":=",
"serverHalf",
".",
... | // MakeTLFCryptKeyServerHalfID creates a unique ID for this particular
// TLFCryptKeyServerHalf. | [
"MakeTLFCryptKeyServerHalfID",
"creates",
"a",
"unique",
"ID",
"for",
"this",
"particular",
"TLFCryptKeyServerHalf",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L427-L443 |
160,041 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | VerifyTLFCryptKeyServerHalfID | func VerifyTLFCryptKeyServerHalfID(
serverHalfID TLFCryptKeyServerHalfID,
user keybase1.UID, devicePubKey CryptPublicKey,
serverHalf TLFCryptKeyServerHalf) error {
key, err := serverHalf.MarshalBinary()
if err != nil {
return err
}
data := append(user.ToBytes(), devicePubKey.KID().ToBytes()...)
return serverHalfID.ID.Verify(key, data)
} | go | func VerifyTLFCryptKeyServerHalfID(
serverHalfID TLFCryptKeyServerHalfID,
user keybase1.UID, devicePubKey CryptPublicKey,
serverHalf TLFCryptKeyServerHalf) error {
key, err := serverHalf.MarshalBinary()
if err != nil {
return err
}
data := append(user.ToBytes(), devicePubKey.KID().ToBytes()...)
return serverHalfID.ID.Verify(key, data)
} | [
"func",
"VerifyTLFCryptKeyServerHalfID",
"(",
"serverHalfID",
"TLFCryptKeyServerHalfID",
",",
"user",
"keybase1",
".",
"UID",
",",
"devicePubKey",
"CryptPublicKey",
",",
"serverHalf",
"TLFCryptKeyServerHalf",
")",
"error",
"{",
"key",
",",
"err",
":=",
"serverHalf",
"... | // VerifyTLFCryptKeyServerHalfID verifies the ID is the proper HMAC result. | [
"VerifyTLFCryptKeyServerHalfID",
"verifies",
"the",
"ID",
"is",
"the",
"proper",
"HMAC",
"result",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L446-L456 |
160,042 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | DecryptTLFCryptKeyClientHalf | func DecryptTLFCryptKeyClientHalf(
privateKey CryptPrivateKey, publicKey TLFEphemeralPublicKey,
encryptedClientHalf EncryptedTLFCryptKeyClientHalf) (
TLFCryptKeyClientHalf, error) {
nonce, err := prepareTLFCryptKeyClientHalf(encryptedClientHalf)
if err != nil {
return TLFCryptKeyClientHalf{}, err
}
publicKeyData := publicKey.Data()
privateKeyData := privateKey.Data()
decryptedData, ok := box.Open(nil, encryptedClientHalf.EncryptedData,
&nonce, &publicKeyData, &privateKeyData)
if !ok {
return TLFCryptKeyClientHalf{},
errors.WithStack(libkb.DecryptionError{Cause: errors.New(
"Can't unbox TLF crypt key client half")})
}
var clientHalfData [32]byte
if len(decryptedData) != len(clientHalfData) {
return TLFCryptKeyClientHalf{},
errors.WithStack(libkb.DecryptionError{Cause: errors.New(
"TLF crypt key client half has wrong data length")})
}
copy(clientHalfData[:], decryptedData)
return MakeTLFCryptKeyClientHalf(clientHalfData), nil
} | go | func DecryptTLFCryptKeyClientHalf(
privateKey CryptPrivateKey, publicKey TLFEphemeralPublicKey,
encryptedClientHalf EncryptedTLFCryptKeyClientHalf) (
TLFCryptKeyClientHalf, error) {
nonce, err := prepareTLFCryptKeyClientHalf(encryptedClientHalf)
if err != nil {
return TLFCryptKeyClientHalf{}, err
}
publicKeyData := publicKey.Data()
privateKeyData := privateKey.Data()
decryptedData, ok := box.Open(nil, encryptedClientHalf.EncryptedData,
&nonce, &publicKeyData, &privateKeyData)
if !ok {
return TLFCryptKeyClientHalf{},
errors.WithStack(libkb.DecryptionError{Cause: errors.New(
"Can't unbox TLF crypt key client half")})
}
var clientHalfData [32]byte
if len(decryptedData) != len(clientHalfData) {
return TLFCryptKeyClientHalf{},
errors.WithStack(libkb.DecryptionError{Cause: errors.New(
"TLF crypt key client half has wrong data length")})
}
copy(clientHalfData[:], decryptedData)
return MakeTLFCryptKeyClientHalf(clientHalfData), nil
} | [
"func",
"DecryptTLFCryptKeyClientHalf",
"(",
"privateKey",
"CryptPrivateKey",
",",
"publicKey",
"TLFEphemeralPublicKey",
",",
"encryptedClientHalf",
"EncryptedTLFCryptKeyClientHalf",
")",
"(",
"TLFCryptKeyClientHalf",
",",
"error",
")",
"{",
"nonce",
",",
"err",
":=",
"pr... | // DecryptTLFCryptKeyClientHalf decrypts a
// TLFCryptKeyClientHalf using the given device private key
// and the TLF's ephemeral public key. | [
"DecryptTLFCryptKeyClientHalf",
"decrypts",
"a",
"TLFCryptKeyClientHalf",
"using",
"the",
"given",
"device",
"private",
"key",
"and",
"the",
"TLF",
"s",
"ephemeral",
"public",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L510-L538 |
160,043 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | MakeRandomTLFCryptKey | func MakeRandomTLFCryptKey() (TLFCryptKey, error) {
var data [32]byte
err := RandRead(data[:])
if err != nil {
return TLFCryptKey{}, err
}
return MakeTLFCryptKey(data), nil
} | go | func MakeRandomTLFCryptKey() (TLFCryptKey, error) {
var data [32]byte
err := RandRead(data[:])
if err != nil {
return TLFCryptKey{}, err
}
return MakeTLFCryptKey(data), nil
} | [
"func",
"MakeRandomTLFCryptKey",
"(",
")",
"(",
"TLFCryptKey",
",",
"error",
")",
"{",
"var",
"data",
"[",
"32",
"]",
"byte",
"\n",
"err",
":=",
"RandRead",
"(",
"data",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"TLFCryptKey"... | // MakeRandomTLFCryptKey returns a random top-level folder crypt key. | [
"MakeRandomTLFCryptKey",
"returns",
"a",
"random",
"top",
"-",
"level",
"folder",
"crypt",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L562-L569 |
160,044 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | MakeRandomBlockCryptKeyServerHalf | func MakeRandomBlockCryptKeyServerHalf() (
serverHalf BlockCryptKeyServerHalf, err error) {
var data [32]byte
err = RandRead(data[:])
if err != nil {
return BlockCryptKeyServerHalf{}, err
}
serverHalf = MakeBlockCryptKeyServerHalf(data)
return serverHalf, nil
} | go | func MakeRandomBlockCryptKeyServerHalf() (
serverHalf BlockCryptKeyServerHalf, err error) {
var data [32]byte
err = RandRead(data[:])
if err != nil {
return BlockCryptKeyServerHalf{}, err
}
serverHalf = MakeBlockCryptKeyServerHalf(data)
return serverHalf, nil
} | [
"func",
"MakeRandomBlockCryptKeyServerHalf",
"(",
")",
"(",
"serverHalf",
"BlockCryptKeyServerHalf",
",",
"err",
"error",
")",
"{",
"var",
"data",
"[",
"32",
"]",
"byte",
"\n",
"err",
"=",
"RandRead",
"(",
"data",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"... | // MakeRandomBlockCryptKeyServerHalf generates the server-side of a
// block crypt key. | [
"MakeRandomBlockCryptKeyServerHalf",
"generates",
"the",
"server",
"-",
"side",
"of",
"a",
"block",
"crypt",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L606-L615 |
160,045 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | ParseBlockCryptKeyServerHalf | func ParseBlockCryptKeyServerHalf(s string) (BlockCryptKeyServerHalf, error) {
buf, err := hex.DecodeString(s)
if err != nil {
return BlockCryptKeyServerHalf{}, errors.WithStack(err)
}
var serverHalf BlockCryptKeyServerHalf
err = serverHalf.UnmarshalBinary(buf)
if err != nil {
return BlockCryptKeyServerHalf{}, err
}
return serverHalf, nil
} | go | func ParseBlockCryptKeyServerHalf(s string) (BlockCryptKeyServerHalf, error) {
buf, err := hex.DecodeString(s)
if err != nil {
return BlockCryptKeyServerHalf{}, errors.WithStack(err)
}
var serverHalf BlockCryptKeyServerHalf
err = serverHalf.UnmarshalBinary(buf)
if err != nil {
return BlockCryptKeyServerHalf{}, err
}
return serverHalf, nil
} | [
"func",
"ParseBlockCryptKeyServerHalf",
"(",
"s",
"string",
")",
"(",
"BlockCryptKeyServerHalf",
",",
"error",
")",
"{",
"buf",
",",
"err",
":=",
"hex",
".",
"DecodeString",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"BlockCryptKeyServerHa... | // ParseBlockCryptKeyServerHalf returns a BlockCryptKeyServerHalf
// containing the given hex-encoded data, or an error. | [
"ParseBlockCryptKeyServerHalf",
"returns",
"a",
"BlockCryptKeyServerHalf",
"containing",
"the",
"given",
"hex",
"-",
"encoded",
"data",
"or",
"an",
"error",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L619-L630 |
160,046 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | MaskTLFCryptKey | func MaskTLFCryptKey(serverHalf TLFCryptKeyServerHalf,
key TLFCryptKey) TLFCryptKeyClientHalf {
return MakeTLFCryptKeyClientHalf(xorKeys(serverHalf.data, key.data))
} | go | func MaskTLFCryptKey(serverHalf TLFCryptKeyServerHalf,
key TLFCryptKey) TLFCryptKeyClientHalf {
return MakeTLFCryptKeyClientHalf(xorKeys(serverHalf.data, key.data))
} | [
"func",
"MaskTLFCryptKey",
"(",
"serverHalf",
"TLFCryptKeyServerHalf",
",",
"key",
"TLFCryptKey",
")",
"TLFCryptKeyClientHalf",
"{",
"return",
"MakeTLFCryptKeyClientHalf",
"(",
"xorKeys",
"(",
"serverHalf",
".",
"data",
",",
"key",
".",
"data",
")",
")",
"\n",
"}"... | // MaskTLFCryptKey returns the client side of a top-level folder crypt
// key. | [
"MaskTLFCryptKey",
"returns",
"the",
"client",
"side",
"of",
"a",
"top",
"-",
"level",
"folder",
"crypt",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L662-L665 |
160,047 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | UnmaskTLFCryptKey | func UnmaskTLFCryptKey(serverHalf TLFCryptKeyServerHalf,
clientHalf TLFCryptKeyClientHalf) TLFCryptKey {
return MakeTLFCryptKey(xorKeys(serverHalf.data, clientHalf.data))
} | go | func UnmaskTLFCryptKey(serverHalf TLFCryptKeyServerHalf,
clientHalf TLFCryptKeyClientHalf) TLFCryptKey {
return MakeTLFCryptKey(xorKeys(serverHalf.data, clientHalf.data))
} | [
"func",
"UnmaskTLFCryptKey",
"(",
"serverHalf",
"TLFCryptKeyServerHalf",
",",
"clientHalf",
"TLFCryptKeyClientHalf",
")",
"TLFCryptKey",
"{",
"return",
"MakeTLFCryptKey",
"(",
"xorKeys",
"(",
"serverHalf",
".",
"data",
",",
"clientHalf",
".",
"data",
")",
")",
"\n",... | // UnmaskTLFCryptKey returns the top-level folder crypt key. | [
"UnmaskTLFCryptKey",
"returns",
"the",
"top",
"-",
"level",
"folder",
"crypt",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L668-L671 |
160,048 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | UnmaskBlockCryptKey | func UnmaskBlockCryptKey(serverHalf BlockCryptKeyServerHalf,
tlfCryptKey TLFCryptKey) BlockCryptKey {
return MakeBlockCryptKey(xorKeys(serverHalf.data, tlfCryptKey.data))
} | go | func UnmaskBlockCryptKey(serverHalf BlockCryptKeyServerHalf,
tlfCryptKey TLFCryptKey) BlockCryptKey {
return MakeBlockCryptKey(xorKeys(serverHalf.data, tlfCryptKey.data))
} | [
"func",
"UnmaskBlockCryptKey",
"(",
"serverHalf",
"BlockCryptKeyServerHalf",
",",
"tlfCryptKey",
"TLFCryptKey",
")",
"BlockCryptKey",
"{",
"return",
"MakeBlockCryptKey",
"(",
"xorKeys",
"(",
"serverHalf",
".",
"data",
",",
"tlfCryptKey",
".",
"data",
")",
")",
"\n",... | // UnmaskBlockCryptKey returns the block crypt key. | [
"UnmaskBlockCryptKey",
"returns",
"the",
"block",
"crypt",
"key",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L674-L677 |
160,049 | keybase/client | go/kbfs/kbfscrypto/crypto_key_types.go | MakeBlockHashKey | func MakeBlockHashKey(
serverHalf BlockCryptKeyServerHalf, key TLFCryptKey) BlockHashKey {
mac := hmac.New(sha512.New, key.Bytes())
mac.Write(serverHalf.Bytes())
hash := mac.Sum(nil)
var hash64 [64]byte
copy(hash64[:], hash)
return BlockHashKey{privateByte64Container{hash64}}
} | go | func MakeBlockHashKey(
serverHalf BlockCryptKeyServerHalf, key TLFCryptKey) BlockHashKey {
mac := hmac.New(sha512.New, key.Bytes())
mac.Write(serverHalf.Bytes())
hash := mac.Sum(nil)
var hash64 [64]byte
copy(hash64[:], hash)
return BlockHashKey{privateByte64Container{hash64}}
} | [
"func",
"MakeBlockHashKey",
"(",
"serverHalf",
"BlockCryptKeyServerHalf",
",",
"key",
"TLFCryptKey",
")",
"BlockHashKey",
"{",
"mac",
":=",
"hmac",
".",
"New",
"(",
"sha512",
".",
"New",
",",
"key",
".",
"Bytes",
"(",
")",
")",
"\n",
"mac",
".",
"Write",
... | // MakeBlockHashKey makes a key used for encryption and decryption for
// the v2 block encryption scheme. | [
"MakeBlockHashKey",
"makes",
"a",
"key",
"used",
"for",
"encryption",
"and",
"decryption",
"for",
"the",
"v2",
"block",
"encryption",
"scheme",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/kbfscrypto/crypto_key_types.go#L687-L695 |
160,050 | keybase/client | go/kbfs/libkbfs/fetch_decider.go | Do | func (fd *fetchDecider) Do(
ctx context.Context, bgTolerance, blockTolerance time.Duration,
cachedTimestamp time.Time) (err error) {
past := fd.Clock().Now().Sub(cachedTimestamp)
switch {
case past > blockTolerance || cachedTimestamp.IsZero():
fd.vlog.CLogf(
ctx, libkb.VLog1, "Blocking on fetch; cached data is %s old", past)
readyCh, errPtr := fd.launchBackgroundFetch(ctx)
if fd.blockingForTest != nil {
fd.blockingForTest <- struct{}{}
}
select {
case <-readyCh:
return *errPtr
case <-ctx.Done():
return ctx.Err()
}
case past > bgTolerance:
fd.vlog.CLogf(ctx, libkb.VLog1, "Cached data is %s old", past)
_, _ = fd.launchBackgroundFetch(ctx)
// Return immediately, with no error, since the caller can
// just use the existing cache value.
return nil
default:
fd.vlog.CLogf(ctx, libkb.VLog1, "Using cached data from %s ago", past)
return nil
}
} | go | func (fd *fetchDecider) Do(
ctx context.Context, bgTolerance, blockTolerance time.Duration,
cachedTimestamp time.Time) (err error) {
past := fd.Clock().Now().Sub(cachedTimestamp)
switch {
case past > blockTolerance || cachedTimestamp.IsZero():
fd.vlog.CLogf(
ctx, libkb.VLog1, "Blocking on fetch; cached data is %s old", past)
readyCh, errPtr := fd.launchBackgroundFetch(ctx)
if fd.blockingForTest != nil {
fd.blockingForTest <- struct{}{}
}
select {
case <-readyCh:
return *errPtr
case <-ctx.Done():
return ctx.Err()
}
case past > bgTolerance:
fd.vlog.CLogf(ctx, libkb.VLog1, "Cached data is %s old", past)
_, _ = fd.launchBackgroundFetch(ctx)
// Return immediately, with no error, since the caller can
// just use the existing cache value.
return nil
default:
fd.vlog.CLogf(ctx, libkb.VLog1, "Using cached data from %s ago", past)
return nil
}
} | [
"func",
"(",
"fd",
"*",
"fetchDecider",
")",
"Do",
"(",
"ctx",
"context",
".",
"Context",
",",
"bgTolerance",
",",
"blockTolerance",
"time",
".",
"Duration",
",",
"cachedTimestamp",
"time",
".",
"Time",
")",
"(",
"err",
"error",
")",
"{",
"past",
":=",
... | // Do decides whether to block on a fetch, launch a background fetch
// and use existing cached value, or simply use the existing cached
// value with no more fetching. The caller can provide a positive
// tolerance, to accept stale LimitBytes and UsageBytes data. If
// tolerance is 0 or negative, this always makes a blocking call using
// `fd.fetcher`.
//
// 1) If the age of cached data is more than blockTolerance, it blocks
// until a new value is fetched and ready in the caller's cache.
// 2) Otherwise, if the age of cached data is more than bgTolerance,
// a background RPC is spawned to refresh cached data using `fd.fetcher`,
// but returns immediately to let the caller use stale data.
// 3) Otherwise, it returns immediately | [
"Do",
"decides",
"whether",
"to",
"block",
"on",
"a",
"fetch",
"launch",
"a",
"background",
"fetch",
"and",
"use",
"existing",
"cached",
"value",
"or",
"simply",
"use",
"the",
"existing",
"cached",
"value",
"with",
"no",
"more",
"fetching",
".",
"The",
"ca... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/fetch_decider.go#L114-L144 |
160,051 | keybase/client | go/kbfs/libfs/fs.go | NewUnwrappedFS | func NewUnwrappedFS(ctx context.Context, config libkbfs.Config,
tlfHandle *tlfhandle.Handle, branch data.BranchName, subdir string,
uniqID string, priority keybase1.MDPriority) (*FS, error) {
return newFS(
ctx, config, tlfHandle, branch, subdir, uniqID, priority, true,
readwrite)
} | go | func NewUnwrappedFS(ctx context.Context, config libkbfs.Config,
tlfHandle *tlfhandle.Handle, branch data.BranchName, subdir string,
uniqID string, priority keybase1.MDPriority) (*FS, error) {
return newFS(
ctx, config, tlfHandle, branch, subdir, uniqID, priority, true,
readwrite)
} | [
"func",
"NewUnwrappedFS",
"(",
"ctx",
"context",
".",
"Context",
",",
"config",
"libkbfs",
".",
"Config",
",",
"tlfHandle",
"*",
"tlfhandle",
".",
"Handle",
",",
"branch",
"data",
".",
"BranchName",
",",
"subdir",
"string",
",",
"uniqID",
"string",
",",
"p... | // NewUnwrappedFS returns a new FS instance, chroot'd to the given TLF
// and subdir within that TLF, but all the nodes are unwrapped.
// `subdir` must exist, and point to a directory, before this function
// is called. `uniqID` needs to uniquely identify this instance among
// all users of this TLF globally; for example, a device ID combined
// with a local tempfile name is recommended. | [
"NewUnwrappedFS",
"returns",
"a",
"new",
"FS",
"instance",
"chroot",
"d",
"to",
"the",
"given",
"TLF",
"and",
"subdir",
"within",
"that",
"TLF",
"but",
"all",
"the",
"nodes",
"are",
"unwrapped",
".",
"subdir",
"must",
"exist",
"and",
"point",
"to",
"a",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L244-L250 |
160,052 | keybase/client | go/kbfs/libfs/fs.go | lookupOrCreateEntryNoFollow | func (fs *FS) lookupOrCreateEntryNoFollow(
dir libkbfs.Node, filename string, flag int, perm os.FileMode) (
libkbfs.Node, data.EntryInfo, error) {
n, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, dir, filename)
switch errors.Cause(err).(type) {
case idutil.NoSuchNameError:
// The file doesn't exist yet; create if requested
if flag&os.O_CREATE == 0 {
return nil, data.EntryInfo{}, err
}
fs.log.CDebugf(
fs.ctx, "Creating %s since it doesn't exist yet", filename)
excl := libkbfs.NoExcl
if flag&os.O_EXCL != 0 {
excl = libkbfs.WithExcl
}
isExec := (perm & 0100) != 0
n, ei, err = fs.config.KBFSOps().CreateFile(
fs.ctx, dir, filename, isExec, excl)
switch errors.Cause(err).(type) {
case data.NameExistsError:
// Someone made it already; recurse to try the lookup again.
fs.log.CDebugf(
fs.ctx, "Attempting lookup again after failed create")
return fs.lookupOrCreateEntryNoFollow(dir, filename, flag, perm)
case nil:
return n, ei, nil
default:
return nil, data.EntryInfo{}, err
}
case nil:
// If we were supposed to have exclusively-created this file,
// we must fail.
if flag&os.O_CREATE != 0 && flag&os.O_EXCL != 0 {
return nil, data.EntryInfo{},
errors.New("Exclusive create failed because the file exists")
}
if ei.Type == data.Sym {
// The caller must retry if desired.
return nil, ei, nil
}
return n, ei, nil
default:
return nil, data.EntryInfo{}, err
}
} | go | func (fs *FS) lookupOrCreateEntryNoFollow(
dir libkbfs.Node, filename string, flag int, perm os.FileMode) (
libkbfs.Node, data.EntryInfo, error) {
n, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, dir, filename)
switch errors.Cause(err).(type) {
case idutil.NoSuchNameError:
// The file doesn't exist yet; create if requested
if flag&os.O_CREATE == 0 {
return nil, data.EntryInfo{}, err
}
fs.log.CDebugf(
fs.ctx, "Creating %s since it doesn't exist yet", filename)
excl := libkbfs.NoExcl
if flag&os.O_EXCL != 0 {
excl = libkbfs.WithExcl
}
isExec := (perm & 0100) != 0
n, ei, err = fs.config.KBFSOps().CreateFile(
fs.ctx, dir, filename, isExec, excl)
switch errors.Cause(err).(type) {
case data.NameExistsError:
// Someone made it already; recurse to try the lookup again.
fs.log.CDebugf(
fs.ctx, "Attempting lookup again after failed create")
return fs.lookupOrCreateEntryNoFollow(dir, filename, flag, perm)
case nil:
return n, ei, nil
default:
return nil, data.EntryInfo{}, err
}
case nil:
// If we were supposed to have exclusively-created this file,
// we must fail.
if flag&os.O_CREATE != 0 && flag&os.O_EXCL != 0 {
return nil, data.EntryInfo{},
errors.New("Exclusive create failed because the file exists")
}
if ei.Type == data.Sym {
// The caller must retry if desired.
return nil, ei, nil
}
return n, ei, nil
default:
return nil, data.EntryInfo{}, err
}
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"lookupOrCreateEntryNoFollow",
"(",
"dir",
"libkbfs",
".",
"Node",
",",
"filename",
"string",
",",
"flag",
"int",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"libkbfs",
".",
"Node",
",",
"data",
".",
"EntryInfo",
",... | // lookupOrCreateEntryNoFollow looks up the entry for a file in a
// given parent node. If the entry is a symlink, it will return a nil
// Node and a nil error. If the entry doesn't exist and O_CREATE is
// set in `flag`, it will create the entry as a file. | [
"lookupOrCreateEntryNoFollow",
"looks",
"up",
"the",
"entry",
"for",
"a",
"file",
"in",
"a",
"given",
"parent",
"node",
".",
"If",
"the",
"entry",
"is",
"a",
"symlink",
"it",
"will",
"return",
"a",
"nil",
"Node",
"and",
"a",
"nil",
"error",
".",
"If",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L308-L355 |
160,053 | keybase/client | go/kbfs/libfs/fs.go | lookupParentWithDepth | func (fs *FS) lookupParentWithDepth(
filename string, exitEarly bool, depth int) (
parent libkbfs.Node, parentDir, base string, err error) {
parts := strings.Split(filename, "/")
n := fs.root
// Iterate through each of the parent directories of the file, but
// not the file itself.
for i := 0; i < len(parts)-1; i++ {
p := parts[i]
nextNode, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, n, p)
switch errors.Cause(err).(type) {
case idutil.NoSuchNameError:
if exitEarly {
parentDir = path.Join(parts[:i]...)
base = path.Join(parts[i:]...)
return n, parentDir, base, nil
}
return nil, "", "", err
case nil:
n = nextNode
default:
return nil, "", "", err
}
switch ei.Type {
case data.Sym:
if depth == maxSymlinkLevels {
return nil, "", "", errors.New("Too many levels of symlinks")
}
parentDir = path.Join(parts[:i]...)
newPath, err := followSymlink(parentDir, ei.SymPath)
if err != nil {
return nil, "", "", err
}
newPathPlusRemainder := append([]string{newPath}, parts[i+1:]...)
return fs.lookupParentWithDepth(
path.Join(newPathPlusRemainder...), exitEarly, depth+1)
case data.Dir:
continue
default:
return nil, "", "", ErrNotADirectory{Name: path.Join(parts[:i+1]...)}
}
}
parentDir = path.Join(parts[:len(parts)-1]...)
base = parts[len(parts)-1]
return n, parentDir, base, nil
} | go | func (fs *FS) lookupParentWithDepth(
filename string, exitEarly bool, depth int) (
parent libkbfs.Node, parentDir, base string, err error) {
parts := strings.Split(filename, "/")
n := fs.root
// Iterate through each of the parent directories of the file, but
// not the file itself.
for i := 0; i < len(parts)-1; i++ {
p := parts[i]
nextNode, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, n, p)
switch errors.Cause(err).(type) {
case idutil.NoSuchNameError:
if exitEarly {
parentDir = path.Join(parts[:i]...)
base = path.Join(parts[i:]...)
return n, parentDir, base, nil
}
return nil, "", "", err
case nil:
n = nextNode
default:
return nil, "", "", err
}
switch ei.Type {
case data.Sym:
if depth == maxSymlinkLevels {
return nil, "", "", errors.New("Too many levels of symlinks")
}
parentDir = path.Join(parts[:i]...)
newPath, err := followSymlink(parentDir, ei.SymPath)
if err != nil {
return nil, "", "", err
}
newPathPlusRemainder := append([]string{newPath}, parts[i+1:]...)
return fs.lookupParentWithDepth(
path.Join(newPathPlusRemainder...), exitEarly, depth+1)
case data.Dir:
continue
default:
return nil, "", "", ErrNotADirectory{Name: path.Join(parts[:i+1]...)}
}
}
parentDir = path.Join(parts[:len(parts)-1]...)
base = parts[len(parts)-1]
return n, parentDir, base, nil
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"lookupParentWithDepth",
"(",
"filename",
"string",
",",
"exitEarly",
"bool",
",",
"depth",
"int",
")",
"(",
"parent",
"libkbfs",
".",
"Node",
",",
"parentDir",
",",
"base",
"string",
",",
"err",
"error",
")",
"{",
"p... | // lookupParentWithDepth looks up the parent node of the given
// filename. It follows symlinks in the path, but doesn't resolve the
// final base name. If `exitEarly` is true, it returns on the first
// not-found error and `base` will contain the subpath of filename not
// yet found. | [
"lookupParentWithDepth",
"looks",
"up",
"the",
"parent",
"node",
"of",
"the",
"given",
"filename",
".",
"It",
"follows",
"symlinks",
"in",
"the",
"path",
"but",
"doesn",
"t",
"resolve",
"the",
"final",
"base",
"name",
".",
"If",
"exitEarly",
"is",
"true",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L362-L409 |
160,054 | keybase/client | go/kbfs/libfs/fs.go | OpenFile | func (fs *FS) OpenFile(filename string, flag int, perm os.FileMode) (
f billy.File, err error) {
fs.log.CDebugf(
fs.ctx, "OpenFile %s, flag=%d, perm=%o", filename, flag, perm)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "OpenFile done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
err = fs.ensureParentDir(filename)
if err != nil {
return nil, err
}
n, ei, err := fs.lookupOrCreateEntry(filename, flag, perm)
if err != nil {
return nil, err
}
// Make sure this is a file.
if !ei.Type.IsFile() {
return nil, errors.Errorf("%s is not a file", filename)
}
if flag&os.O_TRUNC != 0 {
err := fs.config.KBFSOps().Truncate(fs.ctx, n, 0)
if err != nil {
return nil, err
}
}
offset := int64(0)
if flag&os.O_APPEND != 0 {
if ei.Size >= uint64(1<<63) {
return nil, errors.New("offset too large")
}
offset = int64(ei.Size)
}
return &File{
fs: fs,
filename: filename,
node: n,
readOnly: flag == os.O_RDONLY,
offset: offset,
}, nil
} | go | func (fs *FS) OpenFile(filename string, flag int, perm os.FileMode) (
f billy.File, err error) {
fs.log.CDebugf(
fs.ctx, "OpenFile %s, flag=%d, perm=%o", filename, flag, perm)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "OpenFile done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
err = fs.ensureParentDir(filename)
if err != nil {
return nil, err
}
n, ei, err := fs.lookupOrCreateEntry(filename, flag, perm)
if err != nil {
return nil, err
}
// Make sure this is a file.
if !ei.Type.IsFile() {
return nil, errors.Errorf("%s is not a file", filename)
}
if flag&os.O_TRUNC != 0 {
err := fs.config.KBFSOps().Truncate(fs.ctx, n, 0)
if err != nil {
return nil, err
}
}
offset := int64(0)
if flag&os.O_APPEND != 0 {
if ei.Size >= uint64(1<<63) {
return nil, errors.New("offset too large")
}
offset = int64(ei.Size)
}
return &File{
fs: fs,
filename: filename,
node: n,
readOnly: flag == os.O_RDONLY,
offset: offset,
}, nil
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"OpenFile",
"(",
"filename",
"string",
",",
"flag",
"int",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"f",
"billy",
".",
"File",
",",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
"... | // OpenFile implements the billy.Filesystem interface for FS. | [
"OpenFile",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L533-L583 |
160,055 | keybase/client | go/kbfs/libfs/fs.go | Create | func (fs *FS) Create(filename string) (billy.File, error) {
return fs.OpenFile(filename, os.O_CREATE, 0600)
} | go | func (fs *FS) Create(filename string) (billy.File, error) {
return fs.OpenFile(filename, os.O_CREATE, 0600)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Create",
"(",
"filename",
"string",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"fs",
".",
"OpenFile",
"(",
"filename",
",",
"os",
".",
"O_CREATE",
",",
"0600",
")",
"\n",
"}"
] | // Create implements the billy.Filesystem interface for FS. | [
"Create",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L586-L588 |
160,056 | keybase/client | go/kbfs/libfs/fs.go | Open | func (fs *FS) Open(filename string) (billy.File, error) {
return fs.OpenFile(filename, os.O_RDONLY, 0600)
} | go | func (fs *FS) Open(filename string) (billy.File, error) {
return fs.OpenFile(filename, os.O_RDONLY, 0600)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Open",
"(",
"filename",
"string",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"return",
"fs",
".",
"OpenFile",
"(",
"filename",
",",
"os",
".",
"O_RDONLY",
",",
"0600",
")",
"\n",
"}"
] | // Open implements the billy.Filesystem interface for FS. | [
"Open",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L591-L593 |
160,057 | keybase/client | go/kbfs/libfs/fs.go | Stat | func (fs *FS) Stat(filename string) (fi os.FileInfo, err error) {
fs.log.CDebugf(fs.ctx, "Stat %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Stat done: %+v", err)
err = translateErr(err)
}()
if fs.empty && (filename == "" || filename == ".") {
// We can't just uncondionally use FileInfoFast here as that'd result
// in WritePerm unset for non-existent TLFs.
return fs.makeFileInfo(data.EntryInfo{
Type: data.Dir,
}, nil, filename), nil
} else if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
n, ei, err := fs.lookupOrCreateEntry(filename, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
return fs.makeFileInfo(ei, n, n.GetBasename()), nil
} | go | func (fs *FS) Stat(filename string) (fi os.FileInfo, err error) {
fs.log.CDebugf(fs.ctx, "Stat %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Stat done: %+v", err)
err = translateErr(err)
}()
if fs.empty && (filename == "" || filename == ".") {
// We can't just uncondionally use FileInfoFast here as that'd result
// in WritePerm unset for non-existent TLFs.
return fs.makeFileInfo(data.EntryInfo{
Type: data.Dir,
}, nil, filename), nil
} else if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
n, ei, err := fs.lookupOrCreateEntry(filename, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
return fs.makeFileInfo(ei, n, n.GetBasename()), nil
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Stat",
"(",
"filename",
"string",
")",
"(",
"fi",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"filename",
")",
"\n",
... | // Stat implements the billy.Filesystem interface for FS. | [
"Stat",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L612-L635 |
160,058 | keybase/client | go/kbfs/libfs/fs.go | Rename | func (fs *FS) Rename(oldpath, newpath string) (err error) {
fs.log.CDebugf(fs.ctx, "Rename %s -> %s", oldpath, newpath)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Rename done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
err = fs.mkdirAll(path.Dir(newpath), 0755)
if err != nil && !os.IsExist(err) {
return err
}
oldParent, _, oldBase, err := fs.lookupParent(oldpath)
if err != nil {
return err
}
newParent, _, newBase, err := fs.lookupParent(newpath)
if err != nil {
return err
}
return fs.config.KBFSOps().Rename(
fs.ctx, oldParent, oldBase, newParent, newBase)
} | go | func (fs *FS) Rename(oldpath, newpath string) (err error) {
fs.log.CDebugf(fs.ctx, "Rename %s -> %s", oldpath, newpath)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Rename done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
err = fs.mkdirAll(path.Dir(newpath), 0755)
if err != nil && !os.IsExist(err) {
return err
}
oldParent, _, oldBase, err := fs.lookupParent(oldpath)
if err != nil {
return err
}
newParent, _, newBase, err := fs.lookupParent(newpath)
if err != nil {
return err
}
return fs.config.KBFSOps().Rename(
fs.ctx, oldParent, oldBase, newParent, newBase)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Rename",
"(",
"oldpath",
",",
"newpath",
"string",
")",
"(",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"oldpath",
",",
"newpath",
")",
"\n",
"def... | // Rename implements the billy.Filesystem interface for FS. | [
"Rename",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L638-L666 |
160,059 | keybase/client | go/kbfs/libfs/fs.go | Remove | func (fs *FS) Remove(filename string) (err error) {
fs.log.CDebugf(fs.ctx, "Remove %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Remove done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
parent, _, base, err := fs.lookupParent(filename)
if err != nil {
return err
}
_, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, parent, base)
if err != nil {
return err
}
if ei.Type == data.Dir {
return fs.config.KBFSOps().RemoveDir(fs.ctx, parent, base)
}
return fs.config.KBFSOps().RemoveEntry(fs.ctx, parent, base)
} | go | func (fs *FS) Remove(filename string) (err error) {
fs.log.CDebugf(fs.ctx, "Remove %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Remove done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
parent, _, base, err := fs.lookupParent(filename)
if err != nil {
return err
}
_, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, parent, base)
if err != nil {
return err
}
if ei.Type == data.Dir {
return fs.config.KBFSOps().RemoveDir(fs.ctx, parent, base)
}
return fs.config.KBFSOps().RemoveEntry(fs.ctx, parent, base)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Remove",
"(",
"filename",
"string",
")",
"(",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"filename",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
... | // Remove implements the billy.Filesystem interface for FS. | [
"Remove",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L669-L694 |
160,060 | keybase/client | go/kbfs/libfs/fs.go | Join | func (fs *FS) Join(elem ...string) string {
return path.Clean(path.Join(elem...))
} | go | func (fs *FS) Join(elem ...string) string {
return path.Clean(path.Join(elem...))
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Join",
"(",
"elem",
"...",
"string",
")",
"string",
"{",
"return",
"path",
".",
"Clean",
"(",
"path",
".",
"Join",
"(",
"elem",
"...",
")",
")",
"\n",
"}"
] | // Join implements the billy.Filesystem interface for FS. | [
"Join",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L697-L699 |
160,061 | keybase/client | go/kbfs/libfs/fs.go | TempFile | func (fs *FS) TempFile(dir, prefix string) (billy.File, error) {
if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
// We'd have to turn off journaling to support TempFile perfectly,
// but the given uniq ID and a random number should be good
// enough. Especially since most users will end up renaming the
// temp file before journal flushing even happens.
b := make([]byte, 8)
_, err := rand.Read(b)
if err != nil {
return nil, err
}
suffix := fs.uniqID + "-" + base64.URLEncoding.EncodeToString(b)
return fs.OpenFile(path.Join(dir, prefix+suffix),
os.O_CREATE|os.O_EXCL, 0600)
} | go | func (fs *FS) TempFile(dir, prefix string) (billy.File, error) {
if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
// We'd have to turn off journaling to support TempFile perfectly,
// but the given uniq ID and a random number should be good
// enough. Especially since most users will end up renaming the
// temp file before journal flushing even happens.
b := make([]byte, 8)
_, err := rand.Read(b)
if err != nil {
return nil, err
}
suffix := fs.uniqID + "-" + base64.URLEncoding.EncodeToString(b)
return fs.OpenFile(path.Join(dir, prefix+suffix),
os.O_CREATE|os.O_EXCL, 0600)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"TempFile",
"(",
"dir",
",",
"prefix",
"string",
")",
"(",
"billy",
".",
"File",
",",
"error",
")",
"{",
"if",
"err",
":=",
"fs",
".",
"requireNonEmpty",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
... | // TempFile implements the billy.Filesystem interface for FS. | [
"TempFile",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L702-L719 |
160,062 | keybase/client | go/kbfs/libfs/fs.go | ReadDir | func (fs *FS) ReadDir(p string) (fis []os.FileInfo, err error) {
fs.log.CDebugf(fs.ctx, "ReadDir %s", p)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "ReadDir done: %+v", err)
err = translateErr(err)
}()
if fs.empty && (p == "" || p == "." || p == "/") {
return nil, nil
} else if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
n, _, err := fs.lookupOrCreateEntry(p, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
return fs.readDir(n)
} | go | func (fs *FS) ReadDir(p string) (fis []os.FileInfo, err error) {
fs.log.CDebugf(fs.ctx, "ReadDir %s", p)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "ReadDir done: %+v", err)
err = translateErr(err)
}()
if fs.empty && (p == "" || p == "." || p == "/") {
return nil, nil
} else if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
n, _, err := fs.lookupOrCreateEntry(p, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
return fs.readDir(n)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"ReadDir",
"(",
"p",
"string",
")",
"(",
"fis",
"[",
"]",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"p",
")",
"\n"... | // ReadDir implements the billy.Filesystem interface for FS. | [
"ReadDir",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L743-L761 |
160,063 | keybase/client | go/kbfs/libfs/fs.go | MkdirAll | func (fs *FS) MkdirAll(filename string, perm os.FileMode) (err error) {
fs.log.CDebugf(fs.ctx, "MkdirAll %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "MkdirAll done: %+v", err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
return fs.mkdirAll(filename, perm)
} | go | func (fs *FS) MkdirAll(filename string, perm os.FileMode) (err error) {
fs.log.CDebugf(fs.ctx, "MkdirAll %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "MkdirAll done: %+v", err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
return fs.mkdirAll(filename, perm)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"MkdirAll",
"(",
"filename",
"string",
",",
"perm",
"os",
".",
"FileMode",
")",
"(",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"filename",
")",
"\... | // MkdirAll implements the billy.Filesystem interface for FS. | [
"MkdirAll",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L764-L775 |
160,064 | keybase/client | go/kbfs/libfs/fs.go | Lstat | func (fs *FS) Lstat(filename string) (fi os.FileInfo, err error) {
fs.log.CDebugf(fs.ctx, "Lstat %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Lstat done: %+v", err)
err = translateErr(err)
}()
if fs.empty && (filename == "" || filename == ".") {
// We can't just uncondionally use FileInfoFast here as that'd result
// in WritePerm unset for non-existent TLFs.
return fs.makeFileInfo(data.EntryInfo{
Type: data.Dir,
}, nil, filename), nil
} else if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
n, _, base, err := fs.lookupParent(filename)
if err != nil {
return nil, err
}
if base == "" {
ei, err := fs.config.KBFSOps().Stat(fs.ctx, n)
if err != nil {
return nil, err
}
return fs.makeFileInfo(ei, n, ""), nil
}
n, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, n, base)
if err != nil {
return nil, err
}
return fs.makeFileInfo(ei, n, base), nil
} | go | func (fs *FS) Lstat(filename string) (fi os.FileInfo, err error) {
fs.log.CDebugf(fs.ctx, "Lstat %s", filename)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Lstat done: %+v", err)
err = translateErr(err)
}()
if fs.empty && (filename == "" || filename == ".") {
// We can't just uncondionally use FileInfoFast here as that'd result
// in WritePerm unset for non-existent TLFs.
return fs.makeFileInfo(data.EntryInfo{
Type: data.Dir,
}, nil, filename), nil
} else if err := fs.requireNonEmpty(); err != nil {
return nil, err
}
n, _, base, err := fs.lookupParent(filename)
if err != nil {
return nil, err
}
if base == "" {
ei, err := fs.config.KBFSOps().Stat(fs.ctx, n)
if err != nil {
return nil, err
}
return fs.makeFileInfo(ei, n, ""), nil
}
n, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, n, base)
if err != nil {
return nil, err
}
return fs.makeFileInfo(ei, n, base), nil
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Lstat",
"(",
"filename",
"string",
")",
"(",
"fi",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"filename",
")",
"\n",
... | // Lstat implements the billy.Filesystem interface for FS. | [
"Lstat",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L778-L814 |
160,065 | keybase/client | go/kbfs/libfs/fs.go | Symlink | func (fs *FS) Symlink(target, link string) (err error) {
fs.log.CDebugf(fs.ctx, "Symlink target=%s link=%s", target, link)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Symlink done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
err = fs.ensureParentDir(link)
if err != nil {
return err
}
n, _, base, err := fs.lookupParent(link)
if err != nil {
return err
}
_, err = fs.config.KBFSOps().CreateLink(fs.ctx, n, base, target)
return err
} | go | func (fs *FS) Symlink(target, link string) (err error) {
fs.log.CDebugf(fs.ctx, "Symlink target=%s link=%s", target, link)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Symlink done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
err = fs.ensureParentDir(link)
if err != nil {
return err
}
n, _, base, err := fs.lookupParent(link)
if err != nil {
return err
}
_, err = fs.config.KBFSOps().CreateLink(fs.ctx, n, base, target)
return err
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Symlink",
"(",
"target",
",",
"link",
"string",
")",
"(",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"target",
",",
"link",
")",
"\n",
"defer",
... | // Symlink implements the billy.Filesystem interface for FS. | [
"Symlink",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L817-L840 |
160,066 | keybase/client | go/kbfs/libfs/fs.go | Readlink | func (fs *FS) Readlink(link string) (target string, err error) {
fs.log.CDebugf(fs.ctx, "Readlink %s", link)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Readlink done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return "", err
}
n, _, base, err := fs.lookupParent(link)
if err != nil {
return "", err
}
_, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, n, base)
if err != nil {
return "", err
}
if ei.Type != data.Sym {
return "", errors.Errorf("%s is not a symlink", link)
}
return ei.SymPath, nil
} | go | func (fs *FS) Readlink(link string) (target string, err error) {
fs.log.CDebugf(fs.ctx, "Readlink %s", link)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Readlink done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return "", err
}
n, _, base, err := fs.lookupParent(link)
if err != nil {
return "", err
}
_, ei, err := fs.config.KBFSOps().Lookup(fs.ctx, n, base)
if err != nil {
return "", err
}
if ei.Type != data.Sym {
return "", errors.Errorf("%s is not a symlink", link)
}
return ei.SymPath, nil
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Readlink",
"(",
"link",
"string",
")",
"(",
"target",
"string",
",",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"link",
")",
"\n",
"defer",
"func"... | // Readlink implements the billy.Filesystem interface for FS. | [
"Readlink",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L843-L868 |
160,067 | keybase/client | go/kbfs/libfs/fs.go | Chmod | func (fs *FS) Chmod(name string, mode os.FileMode) (err error) {
fs.log.CDebugf(fs.ctx, "Chmod %s %s", name, mode)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Chmod done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
n, _, err := fs.lookupOrCreateEntry(name, os.O_RDONLY, 0)
if err != nil {
return err
}
isExec := (mode & 0100) != 0
return fs.config.KBFSOps().SetEx(fs.ctx, n, isExec)
} | go | func (fs *FS) Chmod(name string, mode os.FileMode) (err error) {
fs.log.CDebugf(fs.ctx, "Chmod %s %s", name, mode)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Chmod done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
n, _, err := fs.lookupOrCreateEntry(name, os.O_RDONLY, 0)
if err != nil {
return err
}
isExec := (mode & 0100) != 0
return fs.config.KBFSOps().SetEx(fs.ctx, n, isExec)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Chmod",
"(",
"name",
"string",
",",
"mode",
"os",
".",
"FileMode",
")",
"(",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"name",
",",
"mode",
")"... | // Chmod implements the billy.Filesystem interface for FS. | [
"Chmod",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L871-L889 |
160,068 | keybase/client | go/kbfs/libfs/fs.go | Chown | func (fs *FS) Chown(name string, uid, gid int) error {
// KBFS doesn't support ownership changes.
fs.log.CDebugf(fs.ctx, "Ignoring Chown %s %d %d", name, uid, gid)
return nil
} | go | func (fs *FS) Chown(name string, uid, gid int) error {
// KBFS doesn't support ownership changes.
fs.log.CDebugf(fs.ctx, "Ignoring Chown %s %d %d", name, uid, gid)
return nil
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Chown",
"(",
"name",
"string",
",",
"uid",
",",
"gid",
"int",
")",
"error",
"{",
"// KBFS doesn't support ownership changes.",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
"\"",
",",
"name",
... | // Chown implements the billy.Filesystem interface for FS. | [
"Chown",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L899-L903 |
160,069 | keybase/client | go/kbfs/libfs/fs.go | Chtimes | func (fs *FS) Chtimes(name string, atime time.Time, mtime time.Time) (
err error) {
fs.log.CDebugf(fs.ctx, "Chtimes %s mtime=%s; ignoring atime=%s",
name, mtime, atime)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Chtimes done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
n, _, err := fs.lookupOrCreateEntry(name, os.O_RDONLY, 0)
if err != nil {
return err
}
return fs.config.KBFSOps().SetMtime(fs.ctx, n, &mtime)
} | go | func (fs *FS) Chtimes(name string, atime time.Time, mtime time.Time) (
err error) {
fs.log.CDebugf(fs.ctx, "Chtimes %s mtime=%s; ignoring atime=%s",
name, mtime, atime)
defer func() {
fs.deferLog.CDebugf(fs.ctx, "Chtimes done: %+v", err)
err = translateErr(err)
}()
if err := fs.requireNonEmpty(); err != nil {
return err
}
n, _, err := fs.lookupOrCreateEntry(name, os.O_RDONLY, 0)
if err != nil {
return err
}
return fs.config.KBFSOps().SetMtime(fs.ctx, n, &mtime)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Chtimes",
"(",
"name",
"string",
",",
"atime",
"time",
".",
"Time",
",",
"mtime",
"time",
".",
"Time",
")",
"(",
"err",
"error",
")",
"{",
"fs",
".",
"log",
".",
"CDebugf",
"(",
"fs",
".",
"ctx",
",",
"\"",
... | // Chtimes implements the billy.Filesystem interface for FS. | [
"Chtimes",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L906-L925 |
160,070 | keybase/client | go/kbfs/libfs/fs.go | Chroot | func (fs *FS) Chroot(p string) (newFS billy.Filesystem, err error) {
return fs.ChrootAsLibFS(p)
} | go | func (fs *FS) Chroot(p string) (newFS billy.Filesystem, err error) {
return fs.ChrootAsLibFS(p)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Chroot",
"(",
"p",
"string",
")",
"(",
"newFS",
"billy",
".",
"Filesystem",
",",
"err",
"error",
")",
"{",
"return",
"fs",
".",
"ChrootAsLibFS",
"(",
"p",
")",
"\n",
"}"
] | // Chroot implements the billy.Filesystem interface for FS. | [
"Chroot",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L973-L975 |
160,071 | keybase/client | go/kbfs/libfs/fs.go | Root | func (fs *FS) Root() string {
return path.Join(fs.h.GetCanonicalPath(), fs.subdir)
} | go | func (fs *FS) Root() string {
return path.Join(fs.h.GetCanonicalPath(), fs.subdir)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"Root",
"(",
")",
"string",
"{",
"return",
"path",
".",
"Join",
"(",
"fs",
".",
"h",
".",
"GetCanonicalPath",
"(",
")",
",",
"fs",
".",
"subdir",
")",
"\n",
"}"
] | // Root implements the billy.Filesystem interface for FS. | [
"Root",
"implements",
"the",
"billy",
".",
"Filesystem",
"interface",
"for",
"FS",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L978-L980 |
160,072 | keybase/client | go/kbfs/libfs/fs.go | SyncAll | func (fs *FS) SyncAll() error {
if err := fs.requireNonEmpty(); err != nil {
return err
}
return fs.config.KBFSOps().SyncAll(fs.ctx, fs.root.GetFolderBranch())
} | go | func (fs *FS) SyncAll() error {
if err := fs.requireNonEmpty(); err != nil {
return err
}
return fs.config.KBFSOps().SyncAll(fs.ctx, fs.root.GetFolderBranch())
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"SyncAll",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"fs",
".",
"requireNonEmpty",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"fs",
".",
"config",
".",
"KBFSOps",
"(",
... | // SyncAll syncs any outstanding buffered writes to the KBFS journal. | [
"SyncAll",
"syncs",
"any",
"outstanding",
"buffered",
"writes",
"to",
"the",
"KBFS",
"journal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L983-L988 |
160,073 | keybase/client | go/kbfs/libfs/fs.go | SetLockNamespace | func (fs *FS) SetLockNamespace(lockNamespace []byte) {
fs.lockNamespace = make([]byte, len(lockNamespace))
copy(fs.lockNamespace, lockNamespace)
} | go | func (fs *FS) SetLockNamespace(lockNamespace []byte) {
fs.lockNamespace = make([]byte, len(lockNamespace))
copy(fs.lockNamespace, lockNamespace)
} | [
"func",
"(",
"fs",
"*",
"FS",
")",
"SetLockNamespace",
"(",
"lockNamespace",
"[",
"]",
"byte",
")",
"{",
"fs",
".",
"lockNamespace",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"lockNamespace",
")",
")",
"\n",
"copy",
"(",
"fs",
".",
"lock... | // SetLockNamespace sets the namespace used in locking. | [
"SetLockNamespace",
"sets",
"the",
"namespace",
"used",
"in",
"locking",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libfs/fs.go#L996-L999 |
160,074 | keybase/client | go/protocol/keybase1/rekey.go | ShowPendingRekeyStatus | func (c RekeyClient) ShowPendingRekeyStatus(ctx context.Context, sessionID int) (err error) {
__arg := ShowPendingRekeyStatusArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.showPendingRekeyStatus", []interface{}{__arg}, nil)
return
} | go | func (c RekeyClient) ShowPendingRekeyStatus(ctx context.Context, sessionID int) (err error) {
__arg := ShowPendingRekeyStatusArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.showPendingRekeyStatus", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"RekeyClient",
")",
"ShowPendingRekeyStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"int",
")",
"(",
"err",
"error",
")",
"{",
"__arg",
":=",
"ShowPendingRekeyStatusArg",
"{",
"SessionID",
":",
"sessionID",
"}",
"\n",
"er... | // ShowPendingRekeyStatus shows either pending gregor-initiated rekey harassments
// or nothing if none were pending. | [
"ShowPendingRekeyStatus",
"shows",
"either",
"pending",
"gregor",
"-",
"initiated",
"rekey",
"harassments",
"or",
"nothing",
"if",
"none",
"were",
"pending",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/rekey.go#L324-L328 |
160,075 | keybase/client | go/protocol/keybase1/rekey.go | GetPendingRekeyStatus | func (c RekeyClient) GetPendingRekeyStatus(ctx context.Context, sessionID int) (res ProblemSetDevices, err error) {
__arg := GetPendingRekeyStatusArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.getPendingRekeyStatus", []interface{}{__arg}, &res)
return
} | go | func (c RekeyClient) GetPendingRekeyStatus(ctx context.Context, sessionID int) (res ProblemSetDevices, err error) {
__arg := GetPendingRekeyStatusArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.getPendingRekeyStatus", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"RekeyClient",
")",
"GetPendingRekeyStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"int",
")",
"(",
"res",
"ProblemSetDevices",
",",
"err",
"error",
")",
"{",
"__arg",
":=",
"GetPendingRekeyStatusArg",
"{",
"SessionID",
":"... | // GetPendingRekeyStatus returns the pending ProblemSetDevices. | [
"GetPendingRekeyStatus",
"returns",
"the",
"pending",
"ProblemSetDevices",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/rekey.go#L331-L335 |
160,076 | keybase/client | go/protocol/keybase1/rekey.go | DebugShowRekeyStatus | func (c RekeyClient) DebugShowRekeyStatus(ctx context.Context, sessionID int) (err error) {
__arg := DebugShowRekeyStatusArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.debugShowRekeyStatus", []interface{}{__arg}, nil)
return
} | go | func (c RekeyClient) DebugShowRekeyStatus(ctx context.Context, sessionID int) (err error) {
__arg := DebugShowRekeyStatusArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.debugShowRekeyStatus", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"RekeyClient",
")",
"DebugShowRekeyStatus",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"int",
")",
"(",
"err",
"error",
")",
"{",
"__arg",
":=",
"DebugShowRekeyStatusArg",
"{",
"SessionID",
":",
"sessionID",
"}",
"\n",
"err",
... | // DebugShowRekeyStatus is used by the CLI to kick off a "ShowRekeyStatus" window for
// the current user. | [
"DebugShowRekeyStatus",
"is",
"used",
"by",
"the",
"CLI",
"to",
"kick",
"off",
"a",
"ShowRekeyStatus",
"window",
"for",
"the",
"current",
"user",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/rekey.go#L339-L343 |
160,077 | keybase/client | go/protocol/keybase1/rekey.go | RekeyStatusFinish | func (c RekeyClient) RekeyStatusFinish(ctx context.Context, sessionID int) (res Outcome, err error) {
__arg := RekeyStatusFinishArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.rekeyStatusFinish", []interface{}{__arg}, &res)
return
} | go | func (c RekeyClient) RekeyStatusFinish(ctx context.Context, sessionID int) (res Outcome, err error) {
__arg := RekeyStatusFinishArg{SessionID: sessionID}
err = c.Cli.Call(ctx, "keybase.1.rekey.rekeyStatusFinish", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"RekeyClient",
")",
"RekeyStatusFinish",
"(",
"ctx",
"context",
".",
"Context",
",",
"sessionID",
"int",
")",
"(",
"res",
"Outcome",
",",
"err",
"error",
")",
"{",
"__arg",
":=",
"RekeyStatusFinishArg",
"{",
"SessionID",
":",
"sessionID",
... | // RekeyStatusFinish is called when work is completed on a given RekeyStatus window. The Outcome
// can be Fixed or Ignored. | [
"RekeyStatusFinish",
"is",
"called",
"when",
"work",
"is",
"completed",
"on",
"a",
"given",
"RekeyStatus",
"window",
".",
"The",
"Outcome",
"can",
"be",
"Fixed",
"or",
"Ignored",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/rekey.go#L347-L351 |
160,078 | keybase/client | go/protocol/keybase1/rekey.go | RekeySync | func (c RekeyClient) RekeySync(ctx context.Context, __arg RekeySyncArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.rekey.rekeySync", []interface{}{__arg}, nil)
return
} | go | func (c RekeyClient) RekeySync(ctx context.Context, __arg RekeySyncArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.rekey.rekeySync", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"RekeyClient",
")",
"RekeySync",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"RekeySyncArg",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[",
"]",
"int... | // RekeySync flushes the current rekey loop and gets to a good stopping point
// to assert state. Good for race-free testing, not very useful in production.
// Force overrides a long-snooze. | [
"RekeySync",
"flushes",
"the",
"current",
"rekey",
"loop",
"and",
"gets",
"to",
"a",
"good",
"stopping",
"point",
"to",
"assert",
"state",
".",
"Good",
"for",
"race",
"-",
"free",
"testing",
"not",
"very",
"useful",
"in",
"production",
".",
"Force",
"overr... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/rekey.go#L356-L359 |
160,079 | keybase/client | go/protocol/keybase1/rekey.go | GetRevokeWarning | func (c RekeyClient) GetRevokeWarning(ctx context.Context, __arg GetRevokeWarningArg) (res RevokeWarning, err error) {
err = c.Cli.Call(ctx, "keybase.1.rekey.getRevokeWarning", []interface{}{__arg}, &res)
return
} | go | func (c RekeyClient) GetRevokeWarning(ctx context.Context, __arg GetRevokeWarningArg) (res RevokeWarning, err error) {
err = c.Cli.Call(ctx, "keybase.1.rekey.getRevokeWarning", []interface{}{__arg}, &res)
return
} | [
"func",
"(",
"c",
"RekeyClient",
")",
"GetRevokeWarning",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"GetRevokeWarningArg",
")",
"(",
"res",
"RevokeWarning",
",",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
... | // GetRevokeWarning computes the TLFs that will be endangered if actingDevice
// revokes targetDevice. | [
"GetRevokeWarning",
"computes",
"the",
"TLFs",
"that",
"will",
"be",
"endangered",
"if",
"actingDevice",
"revokes",
"targetDevice",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/rekey.go#L363-L366 |
160,080 | keybase/client | go/install/winversion.go | FileVersion | func (fi VS_FIXEDFILEINFO) FileVersion() uint64 {
return uint64(fi.FileVersionMS)<<32 | uint64(fi.FileVersionLS)
} | go | func (fi VS_FIXEDFILEINFO) FileVersion() uint64 {
return uint64(fi.FileVersionMS)<<32 | uint64(fi.FileVersionLS)
} | [
"func",
"(",
"fi",
"VS_FIXEDFILEINFO",
")",
"FileVersion",
"(",
")",
"uint64",
"{",
"return",
"uint64",
"(",
"fi",
".",
"FileVersionMS",
")",
"<<",
"32",
"|",
"uint64",
"(",
"fi",
".",
"FileVersionLS",
")",
"\n",
"}"
] | // FileVersion concatenates FileVersionMS and FileVersionLS to a uint64 value. | [
"FileVersion",
"concatenates",
"FileVersionMS",
"and",
"FileVersionLS",
"to",
"a",
"uint64",
"value",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/install/winversion.go#L49-L51 |
160,081 | keybase/client | go/protocol/keybase1/selfprovision.go | SelfProvision | func (c SelfprovisionClient) SelfProvision(ctx context.Context, __arg SelfProvisionArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.selfprovision.selfProvision", []interface{}{__arg}, nil)
return
} | go | func (c SelfprovisionClient) SelfProvision(ctx context.Context, __arg SelfProvisionArg) (err error) {
err = c.Cli.Call(ctx, "keybase.1.selfprovision.selfProvision", []interface{}{__arg}, nil)
return
} | [
"func",
"(",
"c",
"SelfprovisionClient",
")",
"SelfProvision",
"(",
"ctx",
"context",
".",
"Context",
",",
"__arg",
"SelfProvisionArg",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"c",
".",
"Cli",
".",
"Call",
"(",
"ctx",
",",
"\"",
"\"",
",",
"[... | // Performs self provision. If the current device is clone, this function
// will provision it as a new device. | [
"Performs",
"self",
"provision",
".",
"If",
"the",
"current",
"device",
"is",
"clone",
"this",
"function",
"will",
"provision",
"it",
"as",
"a",
"new",
"device",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/keybase1/selfprovision.go#L51-L54 |
160,082 | keybase/client | go/logger/standard.go | LogTagsFromContext | func LogTagsFromContext(ctx context.Context) (CtxLogTags, bool) {
logTags, ok := ctx.Value(CtxLogTagsKey).(CtxLogTags)
return logTags, ok
} | go | func LogTagsFromContext(ctx context.Context) (CtxLogTags, bool) {
logTags, ok := ctx.Value(CtxLogTagsKey).(CtxLogTags)
return logTags, ok
} | [
"func",
"LogTagsFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"CtxLogTags",
",",
"bool",
")",
"{",
"logTags",
",",
"ok",
":=",
"ctx",
".",
"Value",
"(",
"CtxLogTagsKey",
")",
".",
"(",
"CtxLogTags",
")",
"\n",
"return",
"logTags",
",",
... | // LogTagsFromContext returns the log tags being passed along with the
// given context. | [
"LogTagsFromContext",
"returns",
"the",
"log",
"tags",
"being",
"passed",
"along",
"with",
"the",
"given",
"context",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/logger/standard.go#L62-L65 |
160,083 | keybase/client | go/logger/standard.go | ConvertRPCTagsToLogTags | func ConvertRPCTagsToLogTags(ctx context.Context) context.Context {
rpcTags, ok := rpc.RpcTagsFromContext(ctx)
if !ok {
return ctx
}
tags := make(CtxLogTags)
for key, value := range rpcTags {
// The map key should be a proper unique type, but that's not
// passed along in the RPC so just use our own string-like type.
tags[rpcTagKey(key)] = key
ctx = context.WithValue(ctx, rpcTagKey(key), value)
}
ctx = context.WithValue(ctx, rpc.CtxRpcTagsKey, nil)
return NewContextWithLogTags(ctx, tags)
} | go | func ConvertRPCTagsToLogTags(ctx context.Context) context.Context {
rpcTags, ok := rpc.RpcTagsFromContext(ctx)
if !ok {
return ctx
}
tags := make(CtxLogTags)
for key, value := range rpcTags {
// The map key should be a proper unique type, but that's not
// passed along in the RPC so just use our own string-like type.
tags[rpcTagKey(key)] = key
ctx = context.WithValue(ctx, rpcTagKey(key), value)
}
ctx = context.WithValue(ctx, rpc.CtxRpcTagsKey, nil)
return NewContextWithLogTags(ctx, tags)
} | [
"func",
"ConvertRPCTagsToLogTags",
"(",
"ctx",
"context",
".",
"Context",
")",
"context",
".",
"Context",
"{",
"rpcTags",
",",
"ok",
":=",
"rpc",
".",
"RpcTagsFromContext",
"(",
"ctx",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ctx",
"\n",
"}",
"\n\n",
... | // ConvertRPCTagsToLogTags takes any RPC tags in the context and makes
// them log tags. It uses the string representation of the tag key,
// rather than the original uniquely typed key, since the latter isn't
// available in the RPC tags. | [
"ConvertRPCTagsToLogTags",
"takes",
"any",
"RPC",
"tags",
"in",
"the",
"context",
"and",
"makes",
"them",
"log",
"tags",
".",
"It",
"uses",
"the",
"string",
"representation",
"of",
"the",
"tag",
"key",
"rather",
"than",
"the",
"original",
"uniquely",
"typed",
... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/logger/standard.go#L81-L96 |
160,084 | keybase/client | go/logger/standard.go | NewWithCallDepth | func NewWithCallDepth(module string, extraCallDepth int) *Standard {
log := logging.MustGetLogger(module)
log.ExtraCalldepth = 1 + extraCallDepth
ret := &Standard{
internal: log,
module: module,
}
ret.setLogLevelInfo()
return ret
} | go | func NewWithCallDepth(module string, extraCallDepth int) *Standard {
log := logging.MustGetLogger(module)
log.ExtraCalldepth = 1 + extraCallDepth
ret := &Standard{
internal: log,
module: module,
}
ret.setLogLevelInfo()
return ret
} | [
"func",
"NewWithCallDepth",
"(",
"module",
"string",
",",
"extraCallDepth",
"int",
")",
"*",
"Standard",
"{",
"log",
":=",
"logging",
".",
"MustGetLogger",
"(",
"module",
")",
"\n",
"log",
".",
"ExtraCalldepth",
"=",
"1",
"+",
"extraCallDepth",
"\n\n",
"ret"... | // NewWithCallDepth creates a new Standard logger for module, and when
// printing file names and line numbers, it goes extraCallDepth up the
// stack from where logger was invoked. | [
"NewWithCallDepth",
"creates",
"a",
"new",
"Standard",
"logger",
"for",
"module",
"and",
"when",
"printing",
"file",
"names",
"and",
"line",
"numbers",
"it",
"goes",
"extraCallDepth",
"up",
"the",
"stack",
"from",
"where",
"logger",
"was",
"invoked",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/logger/standard.go#L128-L138 |
160,085 | keybase/client | go/libkb/log_send.go | tail | func tail(log logger.Logger, which string, stem string, numBytes int) (ret string) {
numFiles := 0
log.Debug("+ tailing %s file with stem %q", which, stem)
defer func() {
log.Debug("- collected %d bytes from %d files", len(ret), numFiles)
}()
if len(stem) == 0 {
log.Debug("| skipping %s logs (since no stem given)", which)
return
}
lognames := listLogFiles(log, stem)
var parts []string
remaining := numBytes
// Keep reading logs in reverse chronological order until we've read nothing
// more, or we've filled up numBytes worth of buffer, or we didn't have to read
// the whole file.
for _, logname := range lognames {
data, seeked := tailFile(log, which, logname, remaining)
if len(data) == 0 {
break
}
parts = append(parts, data)
numFiles++
remaining -= len(data)
if remaining <= 0 || seeked {
break
}
}
// Reverse the array; took this one-line from StackOverflow answer
for i, j := 0, len(parts)-1; i < j; i, j = i+1, j-1 {
parts[i], parts[j] = parts[j], parts[i]
}
return strings.Join(parts, "")
} | go | func tail(log logger.Logger, which string, stem string, numBytes int) (ret string) {
numFiles := 0
log.Debug("+ tailing %s file with stem %q", which, stem)
defer func() {
log.Debug("- collected %d bytes from %d files", len(ret), numFiles)
}()
if len(stem) == 0 {
log.Debug("| skipping %s logs (since no stem given)", which)
return
}
lognames := listLogFiles(log, stem)
var parts []string
remaining := numBytes
// Keep reading logs in reverse chronological order until we've read nothing
// more, or we've filled up numBytes worth of buffer, or we didn't have to read
// the whole file.
for _, logname := range lognames {
data, seeked := tailFile(log, which, logname, remaining)
if len(data) == 0 {
break
}
parts = append(parts, data)
numFiles++
remaining -= len(data)
if remaining <= 0 || seeked {
break
}
}
// Reverse the array; took this one-line from StackOverflow answer
for i, j := 0, len(parts)-1; i < j; i, j = i+1, j-1 {
parts[i], parts[j] = parts[j], parts[i]
}
return strings.Join(parts, "")
} | [
"func",
"tail",
"(",
"log",
"logger",
".",
"Logger",
",",
"which",
"string",
",",
"stem",
"string",
",",
"numBytes",
"int",
")",
"(",
"ret",
"string",
")",
"{",
"numFiles",
":=",
"0",
"\n\n",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"which",
",",... | // tail the logs that start with the stem `stem`, which are of type `which`.
// Get the most recent `numBytes` from the concatenation of the files. | [
"tail",
"the",
"logs",
"that",
"start",
"with",
"the",
"stem",
"stem",
"which",
"are",
"of",
"type",
"which",
".",
"Get",
"the",
"most",
"recent",
"numBytes",
"from",
"the",
"concatenation",
"of",
"the",
"files",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/log_send.go#L177-L217 |
160,086 | keybase/client | go/libkb/log_send.go | findFirstNewline | func findFirstNewline(b []byte) []byte {
index := bytes.IndexByte(b, '\n')
if index < 0 || index == len(b)-1 {
return nil
}
return b[(index + 1):]
} | go | func findFirstNewline(b []byte) []byte {
index := bytes.IndexByte(b, '\n')
if index < 0 || index == len(b)-1 {
return nil
}
return b[(index + 1):]
} | [
"func",
"findFirstNewline",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"index",
":=",
"bytes",
".",
"IndexByte",
"(",
"b",
",",
"'\\n'",
")",
"\n",
"if",
"index",
"<",
"0",
"||",
"index",
"==",
"len",
"(",
"b",
")",
"-",
"1",
"{",
... | // findFirstNewline first the first newline in the given byte array, and then returns the
// rest of the byte array. Should be safe to use on utf-8 strings. | [
"findFirstNewline",
"first",
"the",
"first",
"newline",
"in",
"the",
"given",
"byte",
"array",
"and",
"then",
"returns",
"the",
"rest",
"of",
"the",
"byte",
"array",
".",
"Should",
"be",
"safe",
"to",
"use",
"on",
"utf",
"-",
"8",
"strings",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/log_send.go#L288-L294 |
160,087 | keybase/client | go/libkb/log_send.go | tailSystemdJournal | func tailSystemdJournal(log logger.Logger, userUnits []string, numBytes int) (ret string) {
log.Debug("+ tailing journalctl for %#v (%d bytes)", userUnits, numBytes)
defer func() {
log.Debug("- scanned %d bytes", len(ret))
}()
// Journalctl doesn't provide a "last N bytes" flag directly, so instead we
// use "last N lines". Large log files in practice seem to be about 150
// bits per line. We'll request lines on that assumption, but if we get
// more than 2x as many bytes as we expected, we'll stop reading and
// include a big error.
guessedLines := numBytes / 150
maxBytes := numBytes * 2
// We intentionally avoid the --user flag to journalctl. That would make us
// skip over the system journal, but in e.g. Ubuntu 16.04, that's where
// user units write their logs.
// Unfortunately, this causes permission errors in some operating systems
// like Debian Stretch, but it is not fatal. as we ignore errors in this
// function.
args := []string{
"--lines=" + strconv.Itoa(guessedLines),
}
if len(userUnits) == 0 {
panic("without --user-unit we would scrape all system logs!!!")
}
for _, userUnit := range userUnits {
args = append(args, "--user-unit="+userUnit)
}
journalCmd := exec.Command("journalctl", args...)
journalCmd.Stderr = os.Stderr
stdout, err := journalCmd.StdoutPipe()
if err != nil {
msg := fmt.Sprintf("Failed to open a pipe for journalctl: %s", err)
log.Errorf(msg)
return msg
}
err = journalCmd.Start()
if err != nil {
msg := fmt.Sprintf("Failed to run journalctl: %s", err)
log.Errorf(msg)
return msg
}
// Once we start reading output, don't short-circuit on errors. Just log
// them, and return whatever we got.
stdoutLimited := io.LimitReader(stdout, int64(maxBytes))
output, err := ioutil.ReadAll(stdoutLimited)
if err != nil {
output = appendError(log, output, "Error reading from journalctl pipe: %s", err)
}
// We must close stdout before Wait, or else Wait might deadlock.
stdout.Close()
err = journalCmd.Wait()
if err != nil {
output = appendError(log, output, "Journalctl exited with an error: %s", err)
}
if len(output) >= maxBytes {
output = appendError(log, output, "Journal lines longer than expected. Logs truncated.")
}
return string(output)
} | go | func tailSystemdJournal(log logger.Logger, userUnits []string, numBytes int) (ret string) {
log.Debug("+ tailing journalctl for %#v (%d bytes)", userUnits, numBytes)
defer func() {
log.Debug("- scanned %d bytes", len(ret))
}()
// Journalctl doesn't provide a "last N bytes" flag directly, so instead we
// use "last N lines". Large log files in practice seem to be about 150
// bits per line. We'll request lines on that assumption, but if we get
// more than 2x as many bytes as we expected, we'll stop reading and
// include a big error.
guessedLines := numBytes / 150
maxBytes := numBytes * 2
// We intentionally avoid the --user flag to journalctl. That would make us
// skip over the system journal, but in e.g. Ubuntu 16.04, that's where
// user units write their logs.
// Unfortunately, this causes permission errors in some operating systems
// like Debian Stretch, but it is not fatal. as we ignore errors in this
// function.
args := []string{
"--lines=" + strconv.Itoa(guessedLines),
}
if len(userUnits) == 0 {
panic("without --user-unit we would scrape all system logs!!!")
}
for _, userUnit := range userUnits {
args = append(args, "--user-unit="+userUnit)
}
journalCmd := exec.Command("journalctl", args...)
journalCmd.Stderr = os.Stderr
stdout, err := journalCmd.StdoutPipe()
if err != nil {
msg := fmt.Sprintf("Failed to open a pipe for journalctl: %s", err)
log.Errorf(msg)
return msg
}
err = journalCmd.Start()
if err != nil {
msg := fmt.Sprintf("Failed to run journalctl: %s", err)
log.Errorf(msg)
return msg
}
// Once we start reading output, don't short-circuit on errors. Just log
// them, and return whatever we got.
stdoutLimited := io.LimitReader(stdout, int64(maxBytes))
output, err := ioutil.ReadAll(stdoutLimited)
if err != nil {
output = appendError(log, output, "Error reading from journalctl pipe: %s", err)
}
// We must close stdout before Wait, or else Wait might deadlock.
stdout.Close()
err = journalCmd.Wait()
if err != nil {
output = appendError(log, output, "Journalctl exited with an error: %s", err)
}
if len(output) >= maxBytes {
output = appendError(log, output, "Journal lines longer than expected. Logs truncated.")
}
return string(output)
} | [
"func",
"tailSystemdJournal",
"(",
"log",
"logger",
".",
"Logger",
",",
"userUnits",
"[",
"]",
"string",
",",
"numBytes",
"int",
")",
"(",
"ret",
"string",
")",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"userUnits",
",",
"numBytes",
")",
"\n",
... | // Get logs from the systemd journal. Currently we don't use this for most of
// our logging, since it's not persisted across boot on some systems. But we do
// use it for startup logs. | [
"Get",
"logs",
"from",
"the",
"systemd",
"journal",
".",
"Currently",
"we",
"don",
"t",
"use",
"this",
"for",
"most",
"of",
"our",
"logging",
"since",
"it",
"s",
"not",
"persisted",
"across",
"boot",
"on",
"some",
"systems",
".",
"But",
"we",
"do",
"us... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/log_send.go#L305-L366 |
160,088 | keybase/client | go/libkb/log_send.go | LogSend | func (l *LogSendContext) LogSend(statusJSON, feedback string, sendLogs bool, numBytes int, uid keybase1.UID, installID InstallID, mergeExtendedStatus bool) (string, error) {
mctx := NewMetaContextBackground(l.G()).WithLogTag("LOGSEND")
logs := l.Logs
var kbfsLog string
var svcLog string
var ekLog string
var desktopLog string
var updaterLog string
var startLog string
var installLog string
var systemLog string
var gitLog string
var traceBundle []byte
var cpuProfileBundle []byte
var watchdogLog string
var processesLog string
if sendLogs {
svcLog = tail(l.G().Log, "service", logs.Service, numBytes)
ekLog = tail(l.G().Log, "ek", logs.EK, numBytes)
kbfsLog = tail(l.G().Log, "kbfs", logs.Kbfs, numBytes)
desktopLog = tail(l.G().Log, "desktop", logs.Desktop, numBytes)
updaterLog = tail(l.G().Log, "updater", logs.Updater, numBytes)
// We don't use the systemd journal to store regular logs, since on
// some systems (e.g. Ubuntu 16.04) it's not persisted across boots.
// However we do use it for startup logs, since that's the only place
// to get them in systemd mode.
if l.G().Env.WantsSystemd() {
startLog = tailSystemdJournal(l.G().Log, []string{"keybase.service", "keybase.ek", "kbfs.service", "keybase.gui.service", "keybase-redirector.service"}, numBytes)
} else {
startLog = tail(l.G().Log, "start", logs.Start, numBytes)
}
installLog = tail(l.G().Log, "install", logs.Install, numBytes)
systemLog = tail(l.G().Log, "system", logs.System, numBytes)
gitLog = tail(l.G().Log, "git", logs.Git, numBytes)
watchdogLog = tail(l.G().Log, "watchdog", logs.Watchdog, numBytes)
if logs.Trace != "" {
traceBundle = getTraceBundle(l.G().Log, logs.Trace)
}
if logs.CPUProfile != "" {
cpuProfileBundle = getCPUProfileBundle(l.G().Log, logs.CPUProfile)
}
// Only add extended status if we're sending logs
if mergeExtendedStatus {
statusJSON = l.mergeExtendedStatus(statusJSON)
}
processesLog = keybaseProcessList()
}
return l.post(mctx, statusJSON, feedback, kbfsLog, svcLog, ekLog, desktopLog, updaterLog, startLog, installLog, systemLog, gitLog, watchdogLog, traceBundle, cpuProfileBundle, uid, installID, processesLog)
} | go | func (l *LogSendContext) LogSend(statusJSON, feedback string, sendLogs bool, numBytes int, uid keybase1.UID, installID InstallID, mergeExtendedStatus bool) (string, error) {
mctx := NewMetaContextBackground(l.G()).WithLogTag("LOGSEND")
logs := l.Logs
var kbfsLog string
var svcLog string
var ekLog string
var desktopLog string
var updaterLog string
var startLog string
var installLog string
var systemLog string
var gitLog string
var traceBundle []byte
var cpuProfileBundle []byte
var watchdogLog string
var processesLog string
if sendLogs {
svcLog = tail(l.G().Log, "service", logs.Service, numBytes)
ekLog = tail(l.G().Log, "ek", logs.EK, numBytes)
kbfsLog = tail(l.G().Log, "kbfs", logs.Kbfs, numBytes)
desktopLog = tail(l.G().Log, "desktop", logs.Desktop, numBytes)
updaterLog = tail(l.G().Log, "updater", logs.Updater, numBytes)
// We don't use the systemd journal to store regular logs, since on
// some systems (e.g. Ubuntu 16.04) it's not persisted across boots.
// However we do use it for startup logs, since that's the only place
// to get them in systemd mode.
if l.G().Env.WantsSystemd() {
startLog = tailSystemdJournal(l.G().Log, []string{"keybase.service", "keybase.ek", "kbfs.service", "keybase.gui.service", "keybase-redirector.service"}, numBytes)
} else {
startLog = tail(l.G().Log, "start", logs.Start, numBytes)
}
installLog = tail(l.G().Log, "install", logs.Install, numBytes)
systemLog = tail(l.G().Log, "system", logs.System, numBytes)
gitLog = tail(l.G().Log, "git", logs.Git, numBytes)
watchdogLog = tail(l.G().Log, "watchdog", logs.Watchdog, numBytes)
if logs.Trace != "" {
traceBundle = getTraceBundle(l.G().Log, logs.Trace)
}
if logs.CPUProfile != "" {
cpuProfileBundle = getCPUProfileBundle(l.G().Log, logs.CPUProfile)
}
// Only add extended status if we're sending logs
if mergeExtendedStatus {
statusJSON = l.mergeExtendedStatus(statusJSON)
}
processesLog = keybaseProcessList()
}
return l.post(mctx, statusJSON, feedback, kbfsLog, svcLog, ekLog, desktopLog, updaterLog, startLog, installLog, systemLog, gitLog, watchdogLog, traceBundle, cpuProfileBundle, uid, installID, processesLog)
} | [
"func",
"(",
"l",
"*",
"LogSendContext",
")",
"LogSend",
"(",
"statusJSON",
",",
"feedback",
"string",
",",
"sendLogs",
"bool",
",",
"numBytes",
"int",
",",
"uid",
"keybase1",
".",
"UID",
",",
"installID",
"InstallID",
",",
"mergeExtendedStatus",
"bool",
")"... | // LogSend sends the tails of log files to kb, and also the last
// few trace output files. | [
"LogSend",
"sends",
"the",
"tails",
"of",
"log",
"files",
"to",
"kb",
"and",
"also",
"the",
"last",
"few",
"trace",
"output",
"files",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/log_send.go#L491-L541 |
160,089 | keybase/client | go/libkb/log_send.go | mergeExtendedStatus | func (l *LogSendContext) mergeExtendedStatus(status string) string {
err := jsonw.EnsureMaxDepthBytesDefault([]byte(status))
if err != nil {
return status
}
var statusObj map[string]interface{}
if err = json.Unmarshal([]byte(status), &statusObj); err != nil {
return status
}
extStatus, err := GetExtendedStatus(NewMetaContextTODO(l.G()))
if err != nil {
return status
}
statusMap := make(map[string]interface{})
statusMap["status"] = statusObj
statusMap["extstatus"] = extStatus
fullStatus, err := json.Marshal(statusMap)
if err != nil {
return status
}
return string(fullStatus)
} | go | func (l *LogSendContext) mergeExtendedStatus(status string) string {
err := jsonw.EnsureMaxDepthBytesDefault([]byte(status))
if err != nil {
return status
}
var statusObj map[string]interface{}
if err = json.Unmarshal([]byte(status), &statusObj); err != nil {
return status
}
extStatus, err := GetExtendedStatus(NewMetaContextTODO(l.G()))
if err != nil {
return status
}
statusMap := make(map[string]interface{})
statusMap["status"] = statusObj
statusMap["extstatus"] = extStatus
fullStatus, err := json.Marshal(statusMap)
if err != nil {
return status
}
return string(fullStatus)
} | [
"func",
"(",
"l",
"*",
"LogSendContext",
")",
"mergeExtendedStatus",
"(",
"status",
"string",
")",
"string",
"{",
"err",
":=",
"jsonw",
".",
"EnsureMaxDepthBytesDefault",
"(",
"[",
"]",
"byte",
"(",
"status",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{"... | // mergeExtendedStatus adds the extended status to the given status json blob.
// If any errors occur the original status is returned unmodified. | [
"mergeExtendedStatus",
"adds",
"the",
"extended",
"status",
"to",
"the",
"given",
"status",
"json",
"blob",
".",
"If",
"any",
"errors",
"occur",
"the",
"original",
"status",
"is",
"returned",
"unmodified",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/log_send.go#L545-L570 |
160,090 | keybase/client | go/kbfs/libkbfs/protected_context.go | context | func (c *protectedContext) context() context.Context {
c.mu.RLock()
defer c.mu.RUnlock()
return c.ctx
} | go | func (c *protectedContext) context() context.Context {
c.mu.RLock()
defer c.mu.RUnlock()
return c.ctx
} | [
"func",
"(",
"c",
"*",
"protectedContext",
")",
"context",
"(",
")",
"context",
".",
"Context",
"{",
"c",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"ctx",
"\n",
"}"
] | // context returns the context stored in the protectedContext. | [
"context",
"returns",
"the",
"context",
"stored",
"in",
"the",
"protectedContext",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/protected_context.go#L42-L46 |
160,091 | keybase/client | go/chat/utils/utils.go | Collar | func Collar(lower int, ideal int, upper int) int {
if ideal > upper {
return upper
}
if ideal < lower {
return lower
}
return ideal
} | go | func Collar(lower int, ideal int, upper int) int {
if ideal > upper {
return upper
}
if ideal < lower {
return lower
}
return ideal
} | [
"func",
"Collar",
"(",
"lower",
"int",
",",
"ideal",
"int",
",",
"upper",
"int",
")",
"int",
"{",
"if",
"ideal",
">",
"upper",
"{",
"return",
"upper",
"\n",
"}",
"\n",
"if",
"ideal",
"<",
"lower",
"{",
"return",
"lower",
"\n",
"}",
"\n",
"return",
... | // upper bounds takes higher priority | [
"upper",
"bounds",
"takes",
"higher",
"priority"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L91-L99 |
160,092 | keybase/client | go/chat/utils/utils.go | AggRateLimitsP | func AggRateLimitsP(rlimits []*chat1.RateLimit) (res []chat1.RateLimit) {
m := make(map[string]chat1.RateLimit)
for _, l := range rlimits {
if l != nil {
m[l.Name] = *l
}
}
for _, v := range m {
res = append(res, v)
}
return res
} | go | func AggRateLimitsP(rlimits []*chat1.RateLimit) (res []chat1.RateLimit) {
m := make(map[string]chat1.RateLimit)
for _, l := range rlimits {
if l != nil {
m[l.Name] = *l
}
}
for _, v := range m {
res = append(res, v)
}
return res
} | [
"func",
"AggRateLimitsP",
"(",
"rlimits",
"[",
"]",
"*",
"chat1",
".",
"RateLimit",
")",
"(",
"res",
"[",
"]",
"chat1",
".",
"RateLimit",
")",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"chat1",
".",
"RateLimit",
")",
"\n",
"for",
"_",... | // AggRateLimitsP takes a list of rate limit responses and dedups them to the last one received
// of each category | [
"AggRateLimitsP",
"takes",
"a",
"list",
"of",
"rate",
"limit",
"responses",
"and",
"dedups",
"them",
"to",
"the",
"last",
"one",
"received",
"of",
"each",
"category"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L103-L114 |
160,093 | keybase/client | go/chat/utils/utils.go | ReorderParticipants | func ReorderParticipants(mctx libkb.MetaContext, g libkb.UIDMapperContext, umapper libkb.UIDMapper,
tlfname string, activeList []gregor1.UID) (writerNames []chat1.ConversationLocalParticipant, err error) {
srcWriterNames, _, _, err := splitAndNormalizeTLFNameCanonicalize(mctx.G(), tlfname, false)
if err != nil {
return writerNames, err
}
var activeKuids []keybase1.UID
for _, a := range activeList {
activeKuids = append(activeKuids, keybase1.UID(a.String()))
}
packages, err := umapper.MapUIDsToUsernamePackages(mctx.Ctx(), g, activeKuids, time.Hour*24, 10*time.Second,
true)
activeMap := make(map[string]chat1.ConversationLocalParticipant)
if err == nil {
for i := 0; i < len(activeKuids); i++ {
activeMap[activeKuids[i].String()] = UsernamePackageToParticipant(packages[i])
}
}
allowedWriters := make(map[string]bool)
// Allow all writers from tlfname.
for _, user := range srcWriterNames {
allowedWriters[user] = true
}
// Fill from the active list first.
for _, uid := range activeList {
kbUID := keybase1.UID(uid.String())
p, ok := activeMap[kbUID.String()]
if !ok {
continue
}
if allowed, _ := allowedWriters[p.Username]; allowed {
writerNames = append(writerNames, p)
// Allow only one occurrence.
allowedWriters[p.Username] = false
}
}
// Include participants even if they weren't in the active list, in stable order.
for _, user := range srcWriterNames {
if allowed, _ := allowedWriters[user]; allowed {
writerNames = append(writerNames, UsernamePackageToParticipant(libkb.UsernamePackage{
NormalizedUsername: libkb.NewNormalizedUsername(user),
FullName: nil,
}))
allowedWriters[user] = false
}
}
return writerNames, nil
} | go | func ReorderParticipants(mctx libkb.MetaContext, g libkb.UIDMapperContext, umapper libkb.UIDMapper,
tlfname string, activeList []gregor1.UID) (writerNames []chat1.ConversationLocalParticipant, err error) {
srcWriterNames, _, _, err := splitAndNormalizeTLFNameCanonicalize(mctx.G(), tlfname, false)
if err != nil {
return writerNames, err
}
var activeKuids []keybase1.UID
for _, a := range activeList {
activeKuids = append(activeKuids, keybase1.UID(a.String()))
}
packages, err := umapper.MapUIDsToUsernamePackages(mctx.Ctx(), g, activeKuids, time.Hour*24, 10*time.Second,
true)
activeMap := make(map[string]chat1.ConversationLocalParticipant)
if err == nil {
for i := 0; i < len(activeKuids); i++ {
activeMap[activeKuids[i].String()] = UsernamePackageToParticipant(packages[i])
}
}
allowedWriters := make(map[string]bool)
// Allow all writers from tlfname.
for _, user := range srcWriterNames {
allowedWriters[user] = true
}
// Fill from the active list first.
for _, uid := range activeList {
kbUID := keybase1.UID(uid.String())
p, ok := activeMap[kbUID.String()]
if !ok {
continue
}
if allowed, _ := allowedWriters[p.Username]; allowed {
writerNames = append(writerNames, p)
// Allow only one occurrence.
allowedWriters[p.Username] = false
}
}
// Include participants even if they weren't in the active list, in stable order.
for _, user := range srcWriterNames {
if allowed, _ := allowedWriters[user]; allowed {
writerNames = append(writerNames, UsernamePackageToParticipant(libkb.UsernamePackage{
NormalizedUsername: libkb.NewNormalizedUsername(user),
FullName: nil,
}))
allowedWriters[user] = false
}
}
return writerNames, nil
} | [
"func",
"ReorderParticipants",
"(",
"mctx",
"libkb",
".",
"MetaContext",
",",
"g",
"libkb",
".",
"UIDMapperContext",
",",
"umapper",
"libkb",
".",
"UIDMapper",
",",
"tlfname",
"string",
",",
"activeList",
"[",
"]",
"gregor1",
".",
"UID",
")",
"(",
"writerNam... | // ReorderParticipants based on the order in activeList.
// Only allows usernames from tlfname in the output.
// This never fails, worse comes to worst it just returns the split of tlfname. | [
"ReorderParticipants",
"based",
"on",
"the",
"order",
"in",
"activeList",
".",
"Only",
"allows",
"usernames",
"from",
"tlfname",
"in",
"the",
"output",
".",
"This",
"never",
"fails",
"worse",
"comes",
"to",
"worst",
"it",
"just",
"returns",
"the",
"split",
"... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L130-L181 |
160,094 | keybase/client | go/chat/utils/utils.go | splitAndNormalizeTLFNameCanonicalize | func splitAndNormalizeTLFNameCanonicalize(g *libkb.GlobalContext, name string, public bool) (writerNames, readerNames []string, extensionSuffix string, err error) {
writerNames, readerNames, extensionSuffix, err = SplitAndNormalizeTLFName(g, name, public)
if retryErr, retry := err.(TlfNameNotCanonical); retry {
return SplitAndNormalizeTLFName(g, retryErr.NameToTry, public)
}
return writerNames, readerNames, extensionSuffix, err
} | go | func splitAndNormalizeTLFNameCanonicalize(g *libkb.GlobalContext, name string, public bool) (writerNames, readerNames []string, extensionSuffix string, err error) {
writerNames, readerNames, extensionSuffix, err = SplitAndNormalizeTLFName(g, name, public)
if retryErr, retry := err.(TlfNameNotCanonical); retry {
return SplitAndNormalizeTLFName(g, retryErr.NameToTry, public)
}
return writerNames, readerNames, extensionSuffix, err
} | [
"func",
"splitAndNormalizeTLFNameCanonicalize",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"name",
"string",
",",
"public",
"bool",
")",
"(",
"writerNames",
",",
"readerNames",
"[",
"]",
"string",
",",
"extensionSuffix",
"string",
",",
"err",
"error",
... | // Drive splitAndNormalizeTLFName with one attempt to follow TlfNameNotCanonical. | [
"Drive",
"splitAndNormalizeTLFName",
"with",
"one",
"attempt",
"to",
"follow",
"TlfNameNotCanonical",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L184-L190 |
160,095 | keybase/client | go/chat/utils/utils.go | GetConversationStatusBehavior | func GetConversationStatusBehavior(s chat1.ConversationStatus) ConversationStatusBehavior {
switch s {
case chat1.ConversationStatus_UNFILED:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
case chat1.ConversationStatus_FAVORITE:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
case chat1.ConversationStatus_IGNORED:
return ConversationStatusBehavior{
ShowInInbox: false,
SendingRemovesStatus: true,
ActivityRemovesStatus: true,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
case chat1.ConversationStatus_REPORTED:
fallthrough
case chat1.ConversationStatus_BLOCKED:
return ConversationStatusBehavior{
ShowInInbox: false,
SendingRemovesStatus: true,
ActivityRemovesStatus: false,
DesktopNotifications: false,
PushNotifications: false,
ShowBadges: false,
}
case chat1.ConversationStatus_MUTED:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: false,
PushNotifications: false,
ShowBadges: false,
}
default:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
}
} | go | func GetConversationStatusBehavior(s chat1.ConversationStatus) ConversationStatusBehavior {
switch s {
case chat1.ConversationStatus_UNFILED:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
case chat1.ConversationStatus_FAVORITE:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
case chat1.ConversationStatus_IGNORED:
return ConversationStatusBehavior{
ShowInInbox: false,
SendingRemovesStatus: true,
ActivityRemovesStatus: true,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
case chat1.ConversationStatus_REPORTED:
fallthrough
case chat1.ConversationStatus_BLOCKED:
return ConversationStatusBehavior{
ShowInInbox: false,
SendingRemovesStatus: true,
ActivityRemovesStatus: false,
DesktopNotifications: false,
PushNotifications: false,
ShowBadges: false,
}
case chat1.ConversationStatus_MUTED:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: false,
PushNotifications: false,
ShowBadges: false,
}
default:
return ConversationStatusBehavior{
ShowInInbox: true,
SendingRemovesStatus: false,
ActivityRemovesStatus: false,
DesktopNotifications: true,
PushNotifications: true,
ShowBadges: true,
}
}
} | [
"func",
"GetConversationStatusBehavior",
"(",
"s",
"chat1",
".",
"ConversationStatus",
")",
"ConversationStatusBehavior",
"{",
"switch",
"s",
"{",
"case",
"chat1",
".",
"ConversationStatus_UNFILED",
":",
"return",
"ConversationStatusBehavior",
"{",
"ShowInInbox",
":",
"... | // GetConversationStatusBehavior gives information about what is allowed for a conversation status.
// When changing these, be sure to update gregor's postMessage as well | [
"GetConversationStatusBehavior",
"gives",
"information",
"about",
"what",
"is",
"allowed",
"for",
"a",
"conversation",
"status",
".",
"When",
"changing",
"these",
"be",
"sure",
"to",
"update",
"gregor",
"s",
"postMessage",
"as",
"well"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L290-L349 |
160,096 | keybase/client | go/chat/utils/utils.go | VisibleChatConversationStatuses | func VisibleChatConversationStatuses() (res []chat1.ConversationStatus) {
for _, s := range chat1.ConversationStatusMap {
if GetConversationStatusBehavior(s).ShowInInbox {
res = append(res, s)
}
}
sort.Sort(byConversationStatus(res))
return
} | go | func VisibleChatConversationStatuses() (res []chat1.ConversationStatus) {
for _, s := range chat1.ConversationStatusMap {
if GetConversationStatusBehavior(s).ShowInInbox {
res = append(res, s)
}
}
sort.Sort(byConversationStatus(res))
return
} | [
"func",
"VisibleChatConversationStatuses",
"(",
")",
"(",
"res",
"[",
"]",
"chat1",
".",
"ConversationStatus",
")",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"chat1",
".",
"ConversationStatusMap",
"{",
"if",
"GetConversationStatusBehavior",
"(",
"s",
")",
".",... | // Which convs show in the inbox. | [
"Which",
"convs",
"show",
"in",
"the",
"inbox",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L358-L366 |
160,097 | keybase/client | go/chat/utils/utils.go | FilterByType | func FilterByType(msgs []chat1.MessageUnboxed, query *chat1.GetThreadQuery, includeAllErrors bool) (res []chat1.MessageUnboxed) {
useTypeFilter := (query != nil && len(query.MessageTypes) > 0)
typmap := make(map[chat1.MessageType]bool)
if useTypeFilter {
for _, mt := range query.MessageTypes {
typmap[mt] = true
}
}
for _, msg := range msgs {
state, err := msg.State()
if err != nil {
if includeAllErrors {
res = append(res, msg)
}
continue
}
switch state {
case chat1.MessageUnboxedState_ERROR:
if includeAllErrors {
res = append(res, msg)
}
case chat1.MessageUnboxedState_PLACEHOLDER:
// We don't know what the type is for these, so just include them
res = append(res, msg)
default:
_, match := typmap[msg.GetMessageType()]
if !useTypeFilter || match {
res = append(res, msg)
}
}
}
return res
} | go | func FilterByType(msgs []chat1.MessageUnboxed, query *chat1.GetThreadQuery, includeAllErrors bool) (res []chat1.MessageUnboxed) {
useTypeFilter := (query != nil && len(query.MessageTypes) > 0)
typmap := make(map[chat1.MessageType]bool)
if useTypeFilter {
for _, mt := range query.MessageTypes {
typmap[mt] = true
}
}
for _, msg := range msgs {
state, err := msg.State()
if err != nil {
if includeAllErrors {
res = append(res, msg)
}
continue
}
switch state {
case chat1.MessageUnboxedState_ERROR:
if includeAllErrors {
res = append(res, msg)
}
case chat1.MessageUnboxedState_PLACEHOLDER:
// We don't know what the type is for these, so just include them
res = append(res, msg)
default:
_, match := typmap[msg.GetMessageType()]
if !useTypeFilter || match {
res = append(res, msg)
}
}
}
return res
} | [
"func",
"FilterByType",
"(",
"msgs",
"[",
"]",
"chat1",
".",
"MessageUnboxed",
",",
"query",
"*",
"chat1",
".",
"GetThreadQuery",
",",
"includeAllErrors",
"bool",
")",
"(",
"res",
"[",
"]",
"chat1",
".",
"MessageUnboxed",
")",
"{",
"useTypeFilter",
":=",
"... | // FilterByType filters messages based on a query.
// If includeAllErrors then MessageUnboxedError are all returned. Otherwise, they are filtered based on type.
// Messages whose type cannot be determined are considered errors. | [
"FilterByType",
"filters",
"messages",
"based",
"on",
"a",
"query",
".",
"If",
"includeAllErrors",
"then",
"MessageUnboxedError",
"are",
"all",
"returned",
".",
"Otherwise",
"they",
"are",
"filtered",
"based",
"on",
"type",
".",
"Messages",
"whose",
"type",
"can... | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L467-L501 |
160,098 | keybase/client | go/chat/utils/utils.go | GetSupersedes | func GetSupersedes(msg chat1.MessageUnboxed) ([]chat1.MessageID, error) {
if !msg.IsValidFull() {
return nil, fmt.Errorf("GetSupersedes called with invalid message: %v", msg.GetMessageID())
}
body := msg.Valid().MessageBody
typ, err := body.MessageType()
if err != nil {
return nil, err
}
// We use the message ID in the body over the field in the client header to
// avoid server trust.
switch typ {
case chat1.MessageType_EDIT:
return []chat1.MessageID{msg.Valid().MessageBody.Edit().MessageID}, nil
case chat1.MessageType_REACTION:
return []chat1.MessageID{msg.Valid().MessageBody.Reaction().MessageID}, nil
case chat1.MessageType_DELETE:
return msg.Valid().MessageBody.Delete().MessageIDs, nil
case chat1.MessageType_ATTACHMENTUPLOADED:
return []chat1.MessageID{msg.Valid().MessageBody.Attachmentuploaded().MessageID}, nil
case chat1.MessageType_UNFURL:
return []chat1.MessageID{msg.Valid().MessageBody.Unfurl().MessageID}, nil
default:
return nil, nil
}
} | go | func GetSupersedes(msg chat1.MessageUnboxed) ([]chat1.MessageID, error) {
if !msg.IsValidFull() {
return nil, fmt.Errorf("GetSupersedes called with invalid message: %v", msg.GetMessageID())
}
body := msg.Valid().MessageBody
typ, err := body.MessageType()
if err != nil {
return nil, err
}
// We use the message ID in the body over the field in the client header to
// avoid server trust.
switch typ {
case chat1.MessageType_EDIT:
return []chat1.MessageID{msg.Valid().MessageBody.Edit().MessageID}, nil
case chat1.MessageType_REACTION:
return []chat1.MessageID{msg.Valid().MessageBody.Reaction().MessageID}, nil
case chat1.MessageType_DELETE:
return msg.Valid().MessageBody.Delete().MessageIDs, nil
case chat1.MessageType_ATTACHMENTUPLOADED:
return []chat1.MessageID{msg.Valid().MessageBody.Attachmentuploaded().MessageID}, nil
case chat1.MessageType_UNFURL:
return []chat1.MessageID{msg.Valid().MessageBody.Unfurl().MessageID}, nil
default:
return nil, nil
}
} | [
"func",
"GetSupersedes",
"(",
"msg",
"chat1",
".",
"MessageUnboxed",
")",
"(",
"[",
"]",
"chat1",
".",
"MessageID",
",",
"error",
")",
"{",
"if",
"!",
"msg",
".",
"IsValidFull",
"(",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
... | // GetSupersedes must be called with a valid msg | [
"GetSupersedes",
"must",
"be",
"called",
"with",
"a",
"valid",
"msg"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L541-L567 |
160,099 | keybase/client | go/chat/utils/utils.go | getSenderPrefix | func getSenderPrefix(mvalid chat1.MessageUnboxedValid, conv chat1.ConversationLocal, currentUsername string) (senderPrefix string) {
if showSenderPrefix(mvalid, conv) {
sender := mvalid.SenderUsername
if sender == currentUsername {
senderPrefix = "You: "
} else {
senderPrefix = fmt.Sprintf("%s: ", sender)
}
}
return senderPrefix
} | go | func getSenderPrefix(mvalid chat1.MessageUnboxedValid, conv chat1.ConversationLocal, currentUsername string) (senderPrefix string) {
if showSenderPrefix(mvalid, conv) {
sender := mvalid.SenderUsername
if sender == currentUsername {
senderPrefix = "You: "
} else {
senderPrefix = fmt.Sprintf("%s: ", sender)
}
}
return senderPrefix
} | [
"func",
"getSenderPrefix",
"(",
"mvalid",
"chat1",
".",
"MessageUnboxedValid",
",",
"conv",
"chat1",
".",
"ConversationLocal",
",",
"currentUsername",
"string",
")",
"(",
"senderPrefix",
"string",
")",
"{",
"if",
"showSenderPrefix",
"(",
"mvalid",
",",
"conv",
"... | // Sender prefix for msg snippets. Will show if a conversation has > 2 members
// or is of type TEAM | [
"Sender",
"prefix",
"for",
"msg",
"snippets",
".",
"Will",
"show",
"if",
"a",
"conversation",
"has",
">",
"2",
"members",
"or",
"is",
"of",
"type",
"TEAM"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/utils/utils.go#L895-L905 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.