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
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
158,900 | keybase/client | go/tools/runquiet/runquiet.go | doRun | func doRun(elevated bool) error {
argsIndex := 1 // 0 is the name of this program, 1 is either the one to launch or the "wait" option
if len(os.Args) < 2 {
log.Fatal("ERROR: no arguments. Use [-wait] programname [arg arg arg]\n")
}
// Do this awkward thing so we can pass along the rest of the command line as-is
doWait := false
doHide := true
for i := 1; i < 3 && (i+1) < len(os.Args); i++ {
if strings.EqualFold(os.Args[argsIndex], "-wait") {
argsIndex++
doWait = true
} else if strings.EqualFold(os.Args[argsIndex], "-show") {
argsIndex++
doHide = false
}
}
attr := &syscall.ProcAttr{
Files: []uintptr{uintptr(syscall.Stdin), uintptr(syscall.Stdout), uintptr(syscall.Stderr)},
Env: syscall.Environ(),
Sys: &syscall.SysProcAttr{
HideWindow: doHide,
CreationFlags: flagCreateNewConsole,
},
}
fmt.Printf("Launching %s with args %v\n", os.Args[argsIndex], os.Args[argsIndex:])
var err error
var pid int
if elevated {
token, _ := getUserToken()
pid, _, err = CreateProcessWithTokenW(token, os.Args[argsIndex:], attr)
defer syscall.CloseHandle(syscall.Handle(token))
if err != nil {
fmt.Printf("CreateProcessWithTokenW error: %s\n", err.Error())
return err
}
} else {
pid, _, err = syscall.StartProcess(os.Args[argsIndex], os.Args[argsIndex:], attr)
}
if err != nil {
fmt.Printf("StartProcess error: %s\n", err.Error())
return err
} else if doWait {
p, err := os.FindProcess(pid)
if err != nil {
fmt.Printf("Launcher can't find %d\n", pid)
return err
}
timeout := make(chan time.Time, 1)
go func() {
pstate, err := p.Wait()
if err == nil && pstate.Success() {
time.Sleep(100 * time.Millisecond)
} else {
fmt.Printf("Unsuccessful wait: Error %v, pstate %v\n", err, *pstate)
}
timeout <- time.Now()
}()
// Only wait 15 seconds because an erroring command was shown to hang
// up an installer on Win7
select {
case _ = <-timeout:
// success
case <-time.After(15 * time.Second):
fmt.Println("timed out")
}
}
return nil
} | go | func doRun(elevated bool) error {
argsIndex := 1 // 0 is the name of this program, 1 is either the one to launch or the "wait" option
if len(os.Args) < 2 {
log.Fatal("ERROR: no arguments. Use [-wait] programname [arg arg arg]\n")
}
// Do this awkward thing so we can pass along the rest of the command line as-is
doWait := false
doHide := true
for i := 1; i < 3 && (i+1) < len(os.Args); i++ {
if strings.EqualFold(os.Args[argsIndex], "-wait") {
argsIndex++
doWait = true
} else if strings.EqualFold(os.Args[argsIndex], "-show") {
argsIndex++
doHide = false
}
}
attr := &syscall.ProcAttr{
Files: []uintptr{uintptr(syscall.Stdin), uintptr(syscall.Stdout), uintptr(syscall.Stderr)},
Env: syscall.Environ(),
Sys: &syscall.SysProcAttr{
HideWindow: doHide,
CreationFlags: flagCreateNewConsole,
},
}
fmt.Printf("Launching %s with args %v\n", os.Args[argsIndex], os.Args[argsIndex:])
var err error
var pid int
if elevated {
token, _ := getUserToken()
pid, _, err = CreateProcessWithTokenW(token, os.Args[argsIndex:], attr)
defer syscall.CloseHandle(syscall.Handle(token))
if err != nil {
fmt.Printf("CreateProcessWithTokenW error: %s\n", err.Error())
return err
}
} else {
pid, _, err = syscall.StartProcess(os.Args[argsIndex], os.Args[argsIndex:], attr)
}
if err != nil {
fmt.Printf("StartProcess error: %s\n", err.Error())
return err
} else if doWait {
p, err := os.FindProcess(pid)
if err != nil {
fmt.Printf("Launcher can't find %d\n", pid)
return err
}
timeout := make(chan time.Time, 1)
go func() {
pstate, err := p.Wait()
if err == nil && pstate.Success() {
time.Sleep(100 * time.Millisecond)
} else {
fmt.Printf("Unsuccessful wait: Error %v, pstate %v\n", err, *pstate)
}
timeout <- time.Now()
}()
// Only wait 15 seconds because an erroring command was shown to hang
// up an installer on Win7
select {
case _ = <-timeout:
// success
case <-time.After(15 * time.Second):
fmt.Println("timed out")
}
}
return nil
} | [
"func",
"doRun",
"(",
"elevated",
"bool",
")",
"error",
"{",
"argsIndex",
":=",
"1",
"// 0 is the name of this program, 1 is either the one to launch or the \"wait\" option",
"\n\n",
"if",
"len",
"(",
"os",
".",
"Args",
")",
"<",
"2",
"{",
"log",
".",
"Fatal",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n\n",
"// Do this awkward thing so we can pass along the rest of the command line as-is",
"doWait",
":=",
"false",
"\n",
"doHide",
":=",
"true",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"3",
"&&",
"(",
"i",
"+",
"1",
")",
"<",
"len",
"(",
"os",
".",
"Args",
")",
";",
"i",
"++",
"{",
"if",
"strings",
".",
"EqualFold",
"(",
"os",
".",
"Args",
"[",
"argsIndex",
"]",
",",
"\"",
"\"",
")",
"{",
"argsIndex",
"++",
"\n",
"doWait",
"=",
"true",
"\n",
"}",
"else",
"if",
"strings",
".",
"EqualFold",
"(",
"os",
".",
"Args",
"[",
"argsIndex",
"]",
",",
"\"",
"\"",
")",
"{",
"argsIndex",
"++",
"\n",
"doHide",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"attr",
":=",
"&",
"syscall",
".",
"ProcAttr",
"{",
"Files",
":",
"[",
"]",
"uintptr",
"{",
"uintptr",
"(",
"syscall",
".",
"Stdin",
")",
",",
"uintptr",
"(",
"syscall",
".",
"Stdout",
")",
",",
"uintptr",
"(",
"syscall",
".",
"Stderr",
")",
"}",
",",
"Env",
":",
"syscall",
".",
"Environ",
"(",
")",
",",
"Sys",
":",
"&",
"syscall",
".",
"SysProcAttr",
"{",
"HideWindow",
":",
"doHide",
",",
"CreationFlags",
":",
"flagCreateNewConsole",
",",
"}",
",",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"os",
".",
"Args",
"[",
"argsIndex",
"]",
",",
"os",
".",
"Args",
"[",
"argsIndex",
":",
"]",
")",
"\n\n",
"var",
"err",
"error",
"\n",
"var",
"pid",
"int",
"\n\n",
"if",
"elevated",
"{",
"token",
",",
"_",
":=",
"getUserToken",
"(",
")",
"\n\n",
"pid",
",",
"_",
",",
"err",
"=",
"CreateProcessWithTokenW",
"(",
"token",
",",
"os",
".",
"Args",
"[",
"argsIndex",
":",
"]",
",",
"attr",
")",
"\n",
"defer",
"syscall",
".",
"CloseHandle",
"(",
"syscall",
".",
"Handle",
"(",
"token",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"pid",
",",
"_",
",",
"err",
"=",
"syscall",
".",
"StartProcess",
"(",
"os",
".",
"Args",
"[",
"argsIndex",
"]",
",",
"os",
".",
"Args",
"[",
"argsIndex",
":",
"]",
",",
"attr",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}",
"else",
"if",
"doWait",
"{",
"p",
",",
"err",
":=",
"os",
".",
"FindProcess",
"(",
"pid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"pid",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"timeout",
":=",
"make",
"(",
"chan",
"time",
".",
"Time",
",",
"1",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"pstate",
",",
"err",
":=",
"p",
".",
"Wait",
"(",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"&&",
"pstate",
".",
"Success",
"(",
")",
"{",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
",",
"*",
"pstate",
")",
"\n",
"}",
"\n",
"timeout",
"<-",
"time",
".",
"Now",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Only wait 15 seconds because an erroring command was shown to hang",
"// up an installer on Win7",
"select",
"{",
"case",
"_",
"=",
"<-",
"timeout",
":",
"// success",
"case",
"<-",
"time",
".",
"After",
"(",
"15",
"*",
"time",
".",
"Second",
")",
":",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // elevated means we try running as user | [
"elevated",
"means",
"we",
"try",
"running",
"as",
"user"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/tools/runquiet/runquiet.go#L169-L248 |
158,901 | keybase/client | go/kbfs/libgit/git_config_without_remotes_storer.go | NewGitConfigWithoutRemotesStorer | func NewGitConfigWithoutRemotesStorer(fs *libfs.FS) (
*GitConfigWithoutRemotesStorer, error) {
fsStorer, err := filesystem.NewStorage(fs)
if err != nil {
return nil, err
}
cfg, err := fsStorer.Config()
if err != nil {
return nil, err
}
// To figure out if this config has been written already, check if
// it differs from the zero Core value (probably because the
// IsBare bit is flipped).
return &GitConfigWithoutRemotesStorer{
fsStorer,
cfg,
cfg.Core != gogitcfg.Config{}.Core,
}, nil
} | go | func NewGitConfigWithoutRemotesStorer(fs *libfs.FS) (
*GitConfigWithoutRemotesStorer, error) {
fsStorer, err := filesystem.NewStorage(fs)
if err != nil {
return nil, err
}
cfg, err := fsStorer.Config()
if err != nil {
return nil, err
}
// To figure out if this config has been written already, check if
// it differs from the zero Core value (probably because the
// IsBare bit is flipped).
return &GitConfigWithoutRemotesStorer{
fsStorer,
cfg,
cfg.Core != gogitcfg.Config{}.Core,
}, nil
} | [
"func",
"NewGitConfigWithoutRemotesStorer",
"(",
"fs",
"*",
"libfs",
".",
"FS",
")",
"(",
"*",
"GitConfigWithoutRemotesStorer",
",",
"error",
")",
"{",
"fsStorer",
",",
"err",
":=",
"filesystem",
".",
"NewStorage",
"(",
"fs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"fsStorer",
".",
"Config",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// To figure out if this config has been written already, check if",
"// it differs from the zero Core value (probably because the",
"// IsBare bit is flipped).",
"return",
"&",
"GitConfigWithoutRemotesStorer",
"{",
"fsStorer",
",",
"cfg",
",",
"cfg",
".",
"Core",
"!=",
"gogitcfg",
".",
"Config",
"{",
"}",
".",
"Core",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewGitConfigWithoutRemotesStorer creates a new git config
// implementation that strips remotes from the config before writing
// them to disk. | [
"NewGitConfigWithoutRemotesStorer",
"creates",
"a",
"new",
"git",
"config",
"implementation",
"that",
"strips",
"remotes",
"from",
"the",
"config",
"before",
"writing",
"them",
"to",
"disk",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libgit/git_config_without_remotes_storer.go#L29-L47 |
158,902 | keybase/client | go/kbfs/libgit/git_config_without_remotes_storer.go | SetConfig | func (cwrs *GitConfigWithoutRemotesStorer) SetConfig(c *gogitcfg.Config) (
err error) {
if cwrs.stored && c.Core == cwrs.cfg.Core {
// Ignore any change that doesn't change the core we know
// about, to avoid attempting to write config files with
// read-only access.
return nil
}
defer func() {
if err != nil {
cwrs.stored = true
}
}()
cwrs.cfg = c
if len(c.Remotes) != 0 {
// If there are remotes, we need to strip them out before
// writing them out to disk. Do that by making a copy of
// everything but the remotes. (Note that we can't just
// Marshal+Unmarshal for a deep-copy, since Unmarshal is where
// the gcfg bug is.)
cCopy := gogitcfg.NewConfig()
cCopy.Core = c.Core
for k, v := range c.Submodules {
v2 := *v
cCopy.Submodules[k] = &v2
}
// Get the raw config so we don't lose any unsupported fields
// from c, but clear out the remotes.
_, err := c.Marshal()
if err != nil {
return err
}
s := c.Raw.Section("remote")
s.Subsections = make(format.Subsections, 0)
cCopy.Raw = c.Raw
c = cCopy
}
return cwrs.Storage.SetConfig(c)
} | go | func (cwrs *GitConfigWithoutRemotesStorer) SetConfig(c *gogitcfg.Config) (
err error) {
if cwrs.stored && c.Core == cwrs.cfg.Core {
// Ignore any change that doesn't change the core we know
// about, to avoid attempting to write config files with
// read-only access.
return nil
}
defer func() {
if err != nil {
cwrs.stored = true
}
}()
cwrs.cfg = c
if len(c.Remotes) != 0 {
// If there are remotes, we need to strip them out before
// writing them out to disk. Do that by making a copy of
// everything but the remotes. (Note that we can't just
// Marshal+Unmarshal for a deep-copy, since Unmarshal is where
// the gcfg bug is.)
cCopy := gogitcfg.NewConfig()
cCopy.Core = c.Core
for k, v := range c.Submodules {
v2 := *v
cCopy.Submodules[k] = &v2
}
// Get the raw config so we don't lose any unsupported fields
// from c, but clear out the remotes.
_, err := c.Marshal()
if err != nil {
return err
}
s := c.Raw.Section("remote")
s.Subsections = make(format.Subsections, 0)
cCopy.Raw = c.Raw
c = cCopy
}
return cwrs.Storage.SetConfig(c)
} | [
"func",
"(",
"cwrs",
"*",
"GitConfigWithoutRemotesStorer",
")",
"SetConfig",
"(",
"c",
"*",
"gogitcfg",
".",
"Config",
")",
"(",
"err",
"error",
")",
"{",
"if",
"cwrs",
".",
"stored",
"&&",
"c",
".",
"Core",
"==",
"cwrs",
".",
"cfg",
".",
"Core",
"{",
"// Ignore any change that doesn't change the core we know",
"// about, to avoid attempting to write config files with",
"// read-only access.",
"return",
"nil",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"cwrs",
".",
"stored",
"=",
"true",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"cwrs",
".",
"cfg",
"=",
"c",
"\n",
"if",
"len",
"(",
"c",
".",
"Remotes",
")",
"!=",
"0",
"{",
"// If there are remotes, we need to strip them out before",
"// writing them out to disk. Do that by making a copy of",
"// everything but the remotes. (Note that we can't just",
"// Marshal+Unmarshal for a deep-copy, since Unmarshal is where",
"// the gcfg bug is.)",
"cCopy",
":=",
"gogitcfg",
".",
"NewConfig",
"(",
")",
"\n",
"cCopy",
".",
"Core",
"=",
"c",
".",
"Core",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"c",
".",
"Submodules",
"{",
"v2",
":=",
"*",
"v",
"\n",
"cCopy",
".",
"Submodules",
"[",
"k",
"]",
"=",
"&",
"v2",
"\n",
"}",
"\n\n",
"// Get the raw config so we don't lose any unsupported fields",
"// from c, but clear out the remotes.",
"_",
",",
"err",
":=",
"c",
".",
"Marshal",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"s",
":=",
"c",
".",
"Raw",
".",
"Section",
"(",
"\"",
"\"",
")",
"\n",
"s",
".",
"Subsections",
"=",
"make",
"(",
"format",
".",
"Subsections",
",",
"0",
")",
"\n",
"cCopy",
".",
"Raw",
"=",
"c",
".",
"Raw",
"\n\n",
"c",
"=",
"cCopy",
"\n",
"}",
"\n",
"return",
"cwrs",
".",
"Storage",
".",
"SetConfig",
"(",
"c",
")",
"\n",
"}"
] | // SetConfig implements the `storer.Storer` interface. | [
"SetConfig",
"implements",
"the",
"storer",
".",
"Storer",
"interface",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libgit/git_config_without_remotes_storer.go#L60-L102 |
158,903 | keybase/client | go/teams/member_set.go | AddRemainingRecipients | func (m *memberSet) AddRemainingRecipients(ctx context.Context, g *libkb.GlobalContext, existing keybase1.TeamMembers) (err error) {
defer g.CTrace(ctx, "memberSet#AddRemainingRecipients", func() error { return err })()
// make a map of the None members
noneMap := make(map[keybase1.UserVersion]bool)
for _, n := range m.None {
noneMap[n.version] = true
}
auv := existing.AllUserVersions()
forceUserPoll := true
if len(auv) > 50 {
forceUserPoll = false
}
for _, uv := range auv {
if noneMap[uv] {
continue
}
if _, ok := m.recipients[uv]; ok {
continue
}
if _, err := m.loadMember(ctx, g, uv, true, forceUserPoll); err != nil {
if _, reset := err.(libkb.AccountResetError); reset {
g.Log.CDebugf(ctx, "Skipping user who was reset: %s", uv.String())
continue
}
return err
}
}
return nil
} | go | func (m *memberSet) AddRemainingRecipients(ctx context.Context, g *libkb.GlobalContext, existing keybase1.TeamMembers) (err error) {
defer g.CTrace(ctx, "memberSet#AddRemainingRecipients", func() error { return err })()
// make a map of the None members
noneMap := make(map[keybase1.UserVersion]bool)
for _, n := range m.None {
noneMap[n.version] = true
}
auv := existing.AllUserVersions()
forceUserPoll := true
if len(auv) > 50 {
forceUserPoll = false
}
for _, uv := range auv {
if noneMap[uv] {
continue
}
if _, ok := m.recipients[uv]; ok {
continue
}
if _, err := m.loadMember(ctx, g, uv, true, forceUserPoll); err != nil {
if _, reset := err.(libkb.AccountResetError); reset {
g.Log.CDebugf(ctx, "Skipping user who was reset: %s", uv.String())
continue
}
return err
}
}
return nil
} | [
"func",
"(",
"m",
"*",
"memberSet",
")",
"AddRemainingRecipients",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"existing",
"keybase1",
".",
"TeamMembers",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"g",
".",
"CTrace",
"(",
"ctx",
",",
"\"",
"\"",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
")",
"(",
")",
"\n\n",
"// make a map of the None members",
"noneMap",
":=",
"make",
"(",
"map",
"[",
"keybase1",
".",
"UserVersion",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"m",
".",
"None",
"{",
"noneMap",
"[",
"n",
".",
"version",
"]",
"=",
"true",
"\n",
"}",
"\n\n",
"auv",
":=",
"existing",
".",
"AllUserVersions",
"(",
")",
"\n",
"forceUserPoll",
":=",
"true",
"\n",
"if",
"len",
"(",
"auv",
")",
">",
"50",
"{",
"forceUserPoll",
"=",
"false",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"uv",
":=",
"range",
"auv",
"{",
"if",
"noneMap",
"[",
"uv",
"]",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"m",
".",
"recipients",
"[",
"uv",
"]",
";",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"m",
".",
"loadMember",
"(",
"ctx",
",",
"g",
",",
"uv",
",",
"true",
",",
"forceUserPoll",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"reset",
":=",
"err",
".",
"(",
"libkb",
".",
"AccountResetError",
")",
";",
"reset",
"{",
"g",
".",
"Log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"uv",
".",
"String",
"(",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // AddRemainingRecipients adds everyone in existing to m.recipients that isn't in m.None. | [
"AddRemainingRecipients",
"adds",
"everyone",
"in",
"existing",
"to",
"m",
".",
"recipients",
"that",
"isn",
"t",
"in",
"m",
".",
"None",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/member_set.go#L231-L264 |
158,904 | keybase/client | go/teams/member_set.go | Section | func (m *memberSet) Section() (res *SCTeamMembers, err error) {
if m.empty() {
return nil, nil
}
res = &SCTeamMembers{}
res.Owners, err = m.nameSeqList(m.Owners)
if err != nil {
return nil, err
}
res.Admins, err = m.nameSeqList(m.Admins)
if err != nil {
return nil, err
}
res.Writers, err = m.nameSeqList(m.Writers)
if err != nil {
return nil, err
}
res.Readers, err = m.nameSeqList(m.Readers)
if err != nil {
return nil, err
}
res.None, err = m.nameSeqList(m.None)
if err != nil {
return nil, err
}
return res, nil
} | go | func (m *memberSet) Section() (res *SCTeamMembers, err error) {
if m.empty() {
return nil, nil
}
res = &SCTeamMembers{}
res.Owners, err = m.nameSeqList(m.Owners)
if err != nil {
return nil, err
}
res.Admins, err = m.nameSeqList(m.Admins)
if err != nil {
return nil, err
}
res.Writers, err = m.nameSeqList(m.Writers)
if err != nil {
return nil, err
}
res.Readers, err = m.nameSeqList(m.Readers)
if err != nil {
return nil, err
}
res.None, err = m.nameSeqList(m.None)
if err != nil {
return nil, err
}
return res, nil
} | [
"func",
"(",
"m",
"*",
"memberSet",
")",
"Section",
"(",
")",
"(",
"res",
"*",
"SCTeamMembers",
",",
"err",
"error",
")",
"{",
"if",
"m",
".",
"empty",
"(",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"res",
"=",
"&",
"SCTeamMembers",
"{",
"}",
"\n",
"res",
".",
"Owners",
",",
"err",
"=",
"m",
".",
"nameSeqList",
"(",
"m",
".",
"Owners",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
".",
"Admins",
",",
"err",
"=",
"m",
".",
"nameSeqList",
"(",
"m",
".",
"Admins",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
".",
"Writers",
",",
"err",
"=",
"m",
".",
"nameSeqList",
"(",
"m",
".",
"Writers",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
".",
"Readers",
",",
"err",
"=",
"m",
".",
"nameSeqList",
"(",
"m",
".",
"Readers",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
".",
"None",
",",
"err",
"=",
"m",
".",
"nameSeqList",
"(",
"m",
".",
"None",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // can return nil | [
"can",
"return",
"nil"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/teams/member_set.go#L278-L305 |
158,905 | keybase/client | go/kbfs/libkbfs/init.go | defaultBServer | func defaultBServer(ctx Context) string {
switch ctx.GetRunMode() {
case kbconst.DevelRunMode:
return memoryAddr
case kbconst.StagingRunMode:
return `
bserver-0.dev.keybase.io:443,bserver-1.dev.keybase.io:443`
case kbconst.ProductionRunMode:
return `
bserver-0.kbfs.keybaseapi.com:443,bserver-1.kbfs.keybaseapi.com:443;
bserver-0.kbfs.keybase.io:443,bserver-1.kbfs.keybase.io:443`
default:
return ""
}
} | go | func defaultBServer(ctx Context) string {
switch ctx.GetRunMode() {
case kbconst.DevelRunMode:
return memoryAddr
case kbconst.StagingRunMode:
return `
bserver-0.dev.keybase.io:443,bserver-1.dev.keybase.io:443`
case kbconst.ProductionRunMode:
return `
bserver-0.kbfs.keybaseapi.com:443,bserver-1.kbfs.keybaseapi.com:443;
bserver-0.kbfs.keybase.io:443,bserver-1.kbfs.keybase.io:443`
default:
return ""
}
} | [
"func",
"defaultBServer",
"(",
"ctx",
"Context",
")",
"string",
"{",
"switch",
"ctx",
".",
"GetRunMode",
"(",
")",
"{",
"case",
"kbconst",
".",
"DevelRunMode",
":",
"return",
"memoryAddr",
"\n",
"case",
"kbconst",
".",
"StagingRunMode",
":",
"return",
"`\n\t\t\tbserver-0.dev.keybase.io:443,bserver-1.dev.keybase.io:443`",
"\n",
"case",
"kbconst",
".",
"ProductionRunMode",
":",
"return",
"`\n\t\t\tbserver-0.kbfs.keybaseapi.com:443,bserver-1.kbfs.keybaseapi.com:443;\n\t\t\tbserver-0.kbfs.keybase.io:443,bserver-1.kbfs.keybase.io:443`",
"\n",
"default",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"}"
] | // defaultBServer returns the default value for the -bserver flag. | [
"defaultBServer",
"returns",
"the",
"default",
"value",
"for",
"the",
"-",
"bserver",
"flag",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L154-L168 |
158,906 | keybase/client | go/kbfs/libkbfs/init.go | defaultMetadataVersion | func defaultMetadataVersion(ctx Context) kbfsmd.MetadataVer {
switch ctx.GetRunMode() {
case kbconst.DevelRunMode:
return kbfsmd.ImplicitTeamsVer
case kbconst.StagingRunMode:
return kbfsmd.ImplicitTeamsVer
case kbconst.ProductionRunMode:
return kbfsmd.ImplicitTeamsVer
default:
return kbfsmd.ImplicitTeamsVer
}
} | go | func defaultMetadataVersion(ctx Context) kbfsmd.MetadataVer {
switch ctx.GetRunMode() {
case kbconst.DevelRunMode:
return kbfsmd.ImplicitTeamsVer
case kbconst.StagingRunMode:
return kbfsmd.ImplicitTeamsVer
case kbconst.ProductionRunMode:
return kbfsmd.ImplicitTeamsVer
default:
return kbfsmd.ImplicitTeamsVer
}
} | [
"func",
"defaultMetadataVersion",
"(",
"ctx",
"Context",
")",
"kbfsmd",
".",
"MetadataVer",
"{",
"switch",
"ctx",
".",
"GetRunMode",
"(",
")",
"{",
"case",
"kbconst",
".",
"DevelRunMode",
":",
"return",
"kbfsmd",
".",
"ImplicitTeamsVer",
"\n",
"case",
"kbconst",
".",
"StagingRunMode",
":",
"return",
"kbfsmd",
".",
"ImplicitTeamsVer",
"\n",
"case",
"kbconst",
".",
"ProductionRunMode",
":",
"return",
"kbfsmd",
".",
"ImplicitTeamsVer",
"\n",
"default",
":",
"return",
"kbfsmd",
".",
"ImplicitTeamsVer",
"\n",
"}",
"\n",
"}"
] | // defaultMetadataVersion returns the default metadata version per run mode. | [
"defaultMetadataVersion",
"returns",
"the",
"default",
"metadata",
"version",
"per",
"run",
"mode",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L188-L199 |
158,907 | keybase/client | go/kbfs/libkbfs/init.go | DefaultInitParams | func DefaultInitParams(ctx Context) InitParams {
journalEnv := os.Getenv("KBFS_DEFAULT_ENABLE_JOURNAL_VALUE")
if journalEnv == "" {
journalEnv = "true"
}
return InitParams{
Debug: BoolForString(os.Getenv("KBFS_DEBUG")),
BServerAddr: defaultBServer(ctx),
MDServerAddr: defaultMDServer(ctx),
TLFValidDuration: tlfValidDurationDefault,
MetadataVersion: defaultMetadataVersion(ctx),
BlockCryptVersion: kbfscrypto.EncryptionSecretboxWithKeyNonce,
LogFileConfig: logger.LogFileConfig{
MaxAge: 30 * 24 * time.Hour,
MaxSize: 128 * 1024 * 1024,
MaxKeepFiles: 3,
},
TLFJournalBackgroundWorkStatus: TLFJournalBackgroundWorkEnabled,
StorageRoot: ctx.GetDataDir(),
BGFlushPeriod: bgFlushPeriodDefault,
BGFlushDirOpBatchSize: bgFlushDirOpBatchSizeDefault,
EnableJournal: BoolForString(journalEnv),
DiskCacheMode: DiskCacheModeLocal,
DiskBlockCacheFraction: 0.10,
SyncBlockCacheFraction: 1.00,
Mode: InitDefaultString,
}
} | go | func DefaultInitParams(ctx Context) InitParams {
journalEnv := os.Getenv("KBFS_DEFAULT_ENABLE_JOURNAL_VALUE")
if journalEnv == "" {
journalEnv = "true"
}
return InitParams{
Debug: BoolForString(os.Getenv("KBFS_DEBUG")),
BServerAddr: defaultBServer(ctx),
MDServerAddr: defaultMDServer(ctx),
TLFValidDuration: tlfValidDurationDefault,
MetadataVersion: defaultMetadataVersion(ctx),
BlockCryptVersion: kbfscrypto.EncryptionSecretboxWithKeyNonce,
LogFileConfig: logger.LogFileConfig{
MaxAge: 30 * 24 * time.Hour,
MaxSize: 128 * 1024 * 1024,
MaxKeepFiles: 3,
},
TLFJournalBackgroundWorkStatus: TLFJournalBackgroundWorkEnabled,
StorageRoot: ctx.GetDataDir(),
BGFlushPeriod: bgFlushPeriodDefault,
BGFlushDirOpBatchSize: bgFlushDirOpBatchSizeDefault,
EnableJournal: BoolForString(journalEnv),
DiskCacheMode: DiskCacheModeLocal,
DiskBlockCacheFraction: 0.10,
SyncBlockCacheFraction: 1.00,
Mode: InitDefaultString,
}
} | [
"func",
"DefaultInitParams",
"(",
"ctx",
"Context",
")",
"InitParams",
"{",
"journalEnv",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"journalEnv",
"==",
"\"",
"\"",
"{",
"journalEnv",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"InitParams",
"{",
"Debug",
":",
"BoolForString",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
")",
",",
"BServerAddr",
":",
"defaultBServer",
"(",
"ctx",
")",
",",
"MDServerAddr",
":",
"defaultMDServer",
"(",
"ctx",
")",
",",
"TLFValidDuration",
":",
"tlfValidDurationDefault",
",",
"MetadataVersion",
":",
"defaultMetadataVersion",
"(",
"ctx",
")",
",",
"BlockCryptVersion",
":",
"kbfscrypto",
".",
"EncryptionSecretboxWithKeyNonce",
",",
"LogFileConfig",
":",
"logger",
".",
"LogFileConfig",
"{",
"MaxAge",
":",
"30",
"*",
"24",
"*",
"time",
".",
"Hour",
",",
"MaxSize",
":",
"128",
"*",
"1024",
"*",
"1024",
",",
"MaxKeepFiles",
":",
"3",
",",
"}",
",",
"TLFJournalBackgroundWorkStatus",
":",
"TLFJournalBackgroundWorkEnabled",
",",
"StorageRoot",
":",
"ctx",
".",
"GetDataDir",
"(",
")",
",",
"BGFlushPeriod",
":",
"bgFlushPeriodDefault",
",",
"BGFlushDirOpBatchSize",
":",
"bgFlushDirOpBatchSizeDefault",
",",
"EnableJournal",
":",
"BoolForString",
"(",
"journalEnv",
")",
",",
"DiskCacheMode",
":",
"DiskCacheModeLocal",
",",
"DiskBlockCacheFraction",
":",
"0.10",
",",
"SyncBlockCacheFraction",
":",
"1.00",
",",
"Mode",
":",
"InitDefaultString",
",",
"}",
"\n",
"}"
] | // DefaultInitParams returns default init params | [
"DefaultInitParams",
"returns",
"default",
"init",
"params"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L206-L233 |
158,908 | keybase/client | go/kbfs/libkbfs/init.go | AddFlags | func AddFlags(flags *flag.FlagSet, ctx Context) *InitParams {
return AddFlagsWithDefaults(
flags, DefaultInitParams(ctx), defaultLogPath(ctx))
} | go | func AddFlags(flags *flag.FlagSet, ctx Context) *InitParams {
return AddFlagsWithDefaults(
flags, DefaultInitParams(ctx), defaultLogPath(ctx))
} | [
"func",
"AddFlags",
"(",
"flags",
"*",
"flag",
".",
"FlagSet",
",",
"ctx",
"Context",
")",
"*",
"InitParams",
"{",
"return",
"AddFlagsWithDefaults",
"(",
"flags",
",",
"DefaultInitParams",
"(",
"ctx",
")",
",",
"defaultLogPath",
"(",
"ctx",
")",
")",
"\n",
"}"
] | // AddFlags adds libkbfs flags to the given FlagSet. Returns an
// InitParams that will be filled in once the given FlagSet is parsed. | [
"AddFlags",
"adds",
"libkbfs",
"flags",
"to",
"the",
"given",
"FlagSet",
".",
"Returns",
"an",
"InitParams",
"that",
"will",
"be",
"filled",
"in",
"once",
"the",
"given",
"FlagSet",
"is",
"parsed",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L328-L331 |
158,909 | keybase/client | go/kbfs/libkbfs/init.go | GetDefaultsUsageString | func GetDefaultsUsageString(ctx Context) string {
runMode := ctx.GetRunMode()
defaultBServer := defaultBServer(ctx)
defaultMDServer := defaultMDServer(ctx)
return fmt.Sprintf(` (KEYBASE_RUN_MODE=%s)
-bserver=%s
-mdserver=%s`,
runMode, defaultBServer, defaultMDServer)
} | go | func GetDefaultsUsageString(ctx Context) string {
runMode := ctx.GetRunMode()
defaultBServer := defaultBServer(ctx)
defaultMDServer := defaultMDServer(ctx)
return fmt.Sprintf(` (KEYBASE_RUN_MODE=%s)
-bserver=%s
-mdserver=%s`,
runMode, defaultBServer, defaultMDServer)
} | [
"func",
"GetDefaultsUsageString",
"(",
"ctx",
"Context",
")",
"string",
"{",
"runMode",
":=",
"ctx",
".",
"GetRunMode",
"(",
")",
"\n",
"defaultBServer",
":=",
"defaultBServer",
"(",
"ctx",
")",
"\n",
"defaultMDServer",
":=",
"defaultMDServer",
"(",
"ctx",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"` (KEYBASE_RUN_MODE=%s)\n -bserver=%s\n -mdserver=%s`",
",",
"runMode",
",",
"defaultBServer",
",",
"defaultMDServer",
")",
"\n",
"}"
] | // GetDefaultsUsageString returns a string describing the default
// values of flags based on the run mode. | [
"GetDefaultsUsageString",
"returns",
"a",
"string",
"describing",
"the",
"default",
"values",
"of",
"flags",
"based",
"on",
"the",
"run",
"mode",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L354-L362 |
158,910 | keybase/client | go/kbfs/libkbfs/init.go | InitLogWithPrefix | func InitLogWithPrefix(
params InitParams, ctx Context, prefix string,
defaultLogPath string) (logger.Logger, error) {
var err error
// Set log file to default if log-to-file was specified
if params.LogToFile {
if params.LogFileConfig.Path != "" {
return nil, fmt.Errorf(
"log-to-file and log-file flags can't be specified together")
}
params.LogFileConfig.Path = defaultLogPath
}
if params.LogFileConfig.Path != "" {
err = logger.SetLogFileConfig(¶ms.LogFileConfig)
}
log := logger.New(prefix)
log.Configure("", params.Debug, "")
log.Info("KBFS version %s", VersionString())
if err != nil {
log.Warning("Failed to setup log file %q: %+v",
params.LogFileConfig.Path, err)
}
return log, err
} | go | func InitLogWithPrefix(
params InitParams, ctx Context, prefix string,
defaultLogPath string) (logger.Logger, error) {
var err error
// Set log file to default if log-to-file was specified
if params.LogToFile {
if params.LogFileConfig.Path != "" {
return nil, fmt.Errorf(
"log-to-file and log-file flags can't be specified together")
}
params.LogFileConfig.Path = defaultLogPath
}
if params.LogFileConfig.Path != "" {
err = logger.SetLogFileConfig(¶ms.LogFileConfig)
}
log := logger.New(prefix)
log.Configure("", params.Debug, "")
log.Info("KBFS version %s", VersionString())
if err != nil {
log.Warning("Failed to setup log file %q: %+v",
params.LogFileConfig.Path, err)
}
return log, err
} | [
"func",
"InitLogWithPrefix",
"(",
"params",
"InitParams",
",",
"ctx",
"Context",
",",
"prefix",
"string",
",",
"defaultLogPath",
"string",
")",
"(",
"logger",
".",
"Logger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Set log file to default if log-to-file was specified",
"if",
"params",
".",
"LogToFile",
"{",
"if",
"params",
".",
"LogFileConfig",
".",
"Path",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"params",
".",
"LogFileConfig",
".",
"Path",
"=",
"defaultLogPath",
"\n",
"}",
"\n\n",
"if",
"params",
".",
"LogFileConfig",
".",
"Path",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"logger",
".",
"SetLogFileConfig",
"(",
"&",
"params",
".",
"LogFileConfig",
")",
"\n",
"}",
"\n",
"log",
":=",
"logger",
".",
"New",
"(",
"prefix",
")",
"\n\n",
"log",
".",
"Configure",
"(",
"\"",
"\"",
",",
"params",
".",
"Debug",
",",
"\"",
"\"",
")",
"\n",
"log",
".",
"Info",
"(",
"\"",
"\"",
",",
"VersionString",
"(",
")",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"params",
".",
"LogFileConfig",
".",
"Path",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"log",
",",
"err",
"\n",
"}"
] | // InitLogWithPrefix sets up logging switching to a log file if
// necessary, given a prefix and a default log path. Returns a valid
// logger even on error, which are non-fatal, thus errors from this
// function may be ignored. Possible errors are logged to the logger
// returned. | [
"InitLogWithPrefix",
"sets",
"up",
"logging",
"switching",
"to",
"a",
"log",
"file",
"if",
"necessary",
"given",
"a",
"prefix",
"and",
"a",
"default",
"log",
"path",
".",
"Returns",
"a",
"valid",
"logger",
"even",
"on",
"error",
"which",
"are",
"non",
"-",
"fatal",
"thus",
"errors",
"from",
"this",
"function",
"may",
"be",
"ignored",
".",
"Possible",
"errors",
"are",
"logged",
"to",
"the",
"logger",
"returned",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L476-L504 |
158,911 | keybase/client | go/kbfs/libkbfs/init.go | InitLog | func InitLog(params InitParams, ctx Context) (logger.Logger, error) {
return InitLogWithPrefix(params, ctx, "kbfs", defaultLogPath(ctx))
} | go | func InitLog(params InitParams, ctx Context) (logger.Logger, error) {
return InitLogWithPrefix(params, ctx, "kbfs", defaultLogPath(ctx))
} | [
"func",
"InitLog",
"(",
"params",
"InitParams",
",",
"ctx",
"Context",
")",
"(",
"logger",
".",
"Logger",
",",
"error",
")",
"{",
"return",
"InitLogWithPrefix",
"(",
"params",
",",
"ctx",
",",
"\"",
"\"",
",",
"defaultLogPath",
"(",
"ctx",
")",
")",
"\n",
"}"
] | // InitLog sets up logging switching to a log file if necessary.
// Returns a valid logger even on error, which are non-fatal, thus
// errors from this function may be ignored.
// Possible errors are logged to the logger returned. | [
"InitLog",
"sets",
"up",
"logging",
"switching",
"to",
"a",
"log",
"file",
"if",
"necessary",
".",
"Returns",
"a",
"valid",
"logger",
"even",
"on",
"error",
"which",
"are",
"non",
"-",
"fatal",
"thus",
"errors",
"from",
"this",
"function",
"may",
"be",
"ignored",
".",
"Possible",
"errors",
"are",
"logged",
"to",
"the",
"logger",
"returned",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/init.go#L510-L512 |
158,912 | keybase/client | go/engine/account_delete.go | NewAccountDelete | func NewAccountDelete(g *libkb.GlobalContext) *AccountDelete {
return &AccountDelete{
Contextified: libkb.NewContextified(g),
}
} | go | func NewAccountDelete(g *libkb.GlobalContext) *AccountDelete {
return &AccountDelete{
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewAccountDelete",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
")",
"*",
"AccountDelete",
"{",
"return",
"&",
"AccountDelete",
"{",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"}",
"\n",
"}"
] | // NewAccountDelete creates a AccountDelete engine. | [
"NewAccountDelete",
"creates",
"a",
"AccountDelete",
"engine",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/account_delete.go#L18-L22 |
158,913 | keybase/client | go/kbfs/libgit/autogit_node_wrappers.go | ShouldCreateMissedLookup | func (rdn *repoDirNode) ShouldCreateMissedLookup(
ctx context.Context, name string) (
bool, context.Context, data.EntryType, os.FileInfo, string) {
switch {
case strings.HasPrefix(name, AutogitBranchPrefix):
branchName := strings.TrimPrefix(name, AutogitBranchPrefix)
if len(branchName) == 0 {
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
// It's difficult to tell if a given name is a legitimate
// prefix for a branch name or not, so just accept everything.
// If it's not legit, trying to read the data will error out.
return true, ctx, data.FakeDir, nil, ""
case strings.HasPrefix(name, AutogitCommitPrefix):
commit := strings.TrimPrefix(name, AutogitCommitPrefix)
if len(commit) == 0 {
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
rcn := &repoCommitNode{
Node: nil,
am: rdn.am,
gitRootFS: rdn.gitRootFS,
repo: rdn.repo,
hash: plumbing.NewHash(commit),
}
f := rcn.GetFile(ctx)
if f == nil {
rdn.am.log.CDebugf(ctx, "Error getting commit file")
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
return true, ctx, data.FakeFile, f.(*diffFile).GetInfo(), ""
default:
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
} | go | func (rdn *repoDirNode) ShouldCreateMissedLookup(
ctx context.Context, name string) (
bool, context.Context, data.EntryType, os.FileInfo, string) {
switch {
case strings.HasPrefix(name, AutogitBranchPrefix):
branchName := strings.TrimPrefix(name, AutogitBranchPrefix)
if len(branchName) == 0 {
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
// It's difficult to tell if a given name is a legitimate
// prefix for a branch name or not, so just accept everything.
// If it's not legit, trying to read the data will error out.
return true, ctx, data.FakeDir, nil, ""
case strings.HasPrefix(name, AutogitCommitPrefix):
commit := strings.TrimPrefix(name, AutogitCommitPrefix)
if len(commit) == 0 {
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
rcn := &repoCommitNode{
Node: nil,
am: rdn.am,
gitRootFS: rdn.gitRootFS,
repo: rdn.repo,
hash: plumbing.NewHash(commit),
}
f := rcn.GetFile(ctx)
if f == nil {
rdn.am.log.CDebugf(ctx, "Error getting commit file")
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
return true, ctx, data.FakeFile, f.(*diffFile).GetInfo(), ""
default:
return rdn.Node.ShouldCreateMissedLookup(ctx, name)
}
} | [
"func",
"(",
"rdn",
"*",
"repoDirNode",
")",
"ShouldCreateMissedLookup",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"bool",
",",
"context",
".",
"Context",
",",
"data",
".",
"EntryType",
",",
"os",
".",
"FileInfo",
",",
"string",
")",
"{",
"switch",
"{",
"case",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"AutogitBranchPrefix",
")",
":",
"branchName",
":=",
"strings",
".",
"TrimPrefix",
"(",
"name",
",",
"AutogitBranchPrefix",
")",
"\n",
"if",
"len",
"(",
"branchName",
")",
"==",
"0",
"{",
"return",
"rdn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n",
"// It's difficult to tell if a given name is a legitimate",
"// prefix for a branch name or not, so just accept everything.",
"// If it's not legit, trying to read the data will error out.",
"return",
"true",
",",
"ctx",
",",
"data",
".",
"FakeDir",
",",
"nil",
",",
"\"",
"\"",
"\n",
"case",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"AutogitCommitPrefix",
")",
":",
"commit",
":=",
"strings",
".",
"TrimPrefix",
"(",
"name",
",",
"AutogitCommitPrefix",
")",
"\n",
"if",
"len",
"(",
"commit",
")",
"==",
"0",
"{",
"return",
"rdn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n\n",
"rcn",
":=",
"&",
"repoCommitNode",
"{",
"Node",
":",
"nil",
",",
"am",
":",
"rdn",
".",
"am",
",",
"gitRootFS",
":",
"rdn",
".",
"gitRootFS",
",",
"repo",
":",
"rdn",
".",
"repo",
",",
"hash",
":",
"plumbing",
".",
"NewHash",
"(",
"commit",
")",
",",
"}",
"\n",
"f",
":=",
"rcn",
".",
"GetFile",
"(",
"ctx",
")",
"\n",
"if",
"f",
"==",
"nil",
"{",
"rdn",
".",
"am",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n",
"return",
"rdn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"true",
",",
"ctx",
",",
"data",
".",
"FakeFile",
",",
"f",
".",
"(",
"*",
"diffFile",
")",
".",
"GetInfo",
"(",
")",
",",
"\"",
"\"",
"\n",
"default",
":",
"return",
"rdn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n\n",
"}"
] | // ShouldCreateMissedLookup implements the Node interface for
// repoDirNode. | [
"ShouldCreateMissedLookup",
"implements",
"the",
"Node",
"interface",
"for",
"repoDirNode",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libgit/autogit_node_wrappers.go#L138-L174 |
158,914 | keybase/client | go/kbfs/libgit/autogit_node_wrappers.go | WrapChild | func (arn autogitRootNode) WrapChild(child libkbfs.Node) libkbfs.Node {
child = arn.Node.WrapChild(child)
repo := normalizeRepoName(child.GetBasename())
return &repoDirNode{
Node: child,
am: arn.am,
gitRootFS: arn.fs,
repo: repo,
subdir: "",
branch: "",
}
} | go | func (arn autogitRootNode) WrapChild(child libkbfs.Node) libkbfs.Node {
child = arn.Node.WrapChild(child)
repo := normalizeRepoName(child.GetBasename())
return &repoDirNode{
Node: child,
am: arn.am,
gitRootFS: arn.fs,
repo: repo,
subdir: "",
branch: "",
}
} | [
"func",
"(",
"arn",
"autogitRootNode",
")",
"WrapChild",
"(",
"child",
"libkbfs",
".",
"Node",
")",
"libkbfs",
".",
"Node",
"{",
"child",
"=",
"arn",
".",
"Node",
".",
"WrapChild",
"(",
"child",
")",
"\n",
"repo",
":=",
"normalizeRepoName",
"(",
"child",
".",
"GetBasename",
"(",
")",
")",
"\n",
"return",
"&",
"repoDirNode",
"{",
"Node",
":",
"child",
",",
"am",
":",
"arn",
".",
"am",
",",
"gitRootFS",
":",
"arn",
".",
"fs",
",",
"repo",
":",
"repo",
",",
"subdir",
":",
"\"",
"\"",
",",
"branch",
":",
"\"",
"\"",
",",
"}",
"\n",
"}"
] | // WrapChild implements the Node interface for autogitRootNode. | [
"WrapChild",
"implements",
"the",
"Node",
"interface",
"for",
"autogitRootNode",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libgit/autogit_node_wrappers.go#L288-L299 |
158,915 | keybase/client | go/kbfs/libgit/autogit_node_wrappers.go | ShouldCreateMissedLookup | func (rn *rootNode) ShouldCreateMissedLookup(ctx context.Context, name string) (
bool, context.Context, data.EntryType, os.FileInfo, string) {
if name != AutogitRoot {
return rn.Node.ShouldCreateMissedLookup(ctx, name)
}
rn.lock.Lock()
defer rn.lock.Unlock()
if rn.fs == nil {
// Make the FS once, in a place where we know the NodeCache
// won't be locked (to avoid deadlock).
h, err := rn.am.config.KBFSOps().GetTLFHandle(ctx, rn)
if err != nil {
rn.am.log.CDebugf(ctx, "Error getting handle: %+v", err)
return rn.Node.ShouldCreateMissedLookup(ctx, name)
}
// Wrap this child so that it will show all the repos.
ctx := libkbfs.CtxWithRandomIDReplayable(
context.Background(), ctxAutogitIDKey, ctxAutogitOpID, rn.am.log)
fs, err := libfs.NewReadonlyFS(
ctx, rn.am.config, h, rn.GetFolderBranch().Branch, kbfsRepoDir, "",
keybase1.MDPriorityNormal)
if err != nil {
rn.am.log.CDebugf(ctx, "Error making repo FS: %+v", err)
return rn.Node.ShouldCreateMissedLookup(ctx, name)
}
rn.fs = fs
}
return true, ctx, data.FakeDir, nil, ""
} | go | func (rn *rootNode) ShouldCreateMissedLookup(ctx context.Context, name string) (
bool, context.Context, data.EntryType, os.FileInfo, string) {
if name != AutogitRoot {
return rn.Node.ShouldCreateMissedLookup(ctx, name)
}
rn.lock.Lock()
defer rn.lock.Unlock()
if rn.fs == nil {
// Make the FS once, in a place where we know the NodeCache
// won't be locked (to avoid deadlock).
h, err := rn.am.config.KBFSOps().GetTLFHandle(ctx, rn)
if err != nil {
rn.am.log.CDebugf(ctx, "Error getting handle: %+v", err)
return rn.Node.ShouldCreateMissedLookup(ctx, name)
}
// Wrap this child so that it will show all the repos.
ctx := libkbfs.CtxWithRandomIDReplayable(
context.Background(), ctxAutogitIDKey, ctxAutogitOpID, rn.am.log)
fs, err := libfs.NewReadonlyFS(
ctx, rn.am.config, h, rn.GetFolderBranch().Branch, kbfsRepoDir, "",
keybase1.MDPriorityNormal)
if err != nil {
rn.am.log.CDebugf(ctx, "Error making repo FS: %+v", err)
return rn.Node.ShouldCreateMissedLookup(ctx, name)
}
rn.fs = fs
}
return true, ctx, data.FakeDir, nil, ""
} | [
"func",
"(",
"rn",
"*",
"rootNode",
")",
"ShouldCreateMissedLookup",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
")",
"(",
"bool",
",",
"context",
".",
"Context",
",",
"data",
".",
"EntryType",
",",
"os",
".",
"FileInfo",
",",
"string",
")",
"{",
"if",
"name",
"!=",
"AutogitRoot",
"{",
"return",
"rn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n\n",
"rn",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rn",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"rn",
".",
"fs",
"==",
"nil",
"{",
"// Make the FS once, in a place where we know the NodeCache",
"// won't be locked (to avoid deadlock).",
"h",
",",
"err",
":=",
"rn",
".",
"am",
".",
"config",
".",
"KBFSOps",
"(",
")",
".",
"GetTLFHandle",
"(",
"ctx",
",",
"rn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"rn",
".",
"am",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"rn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n\n",
"// Wrap this child so that it will show all the repos.",
"ctx",
":=",
"libkbfs",
".",
"CtxWithRandomIDReplayable",
"(",
"context",
".",
"Background",
"(",
")",
",",
"ctxAutogitIDKey",
",",
"ctxAutogitOpID",
",",
"rn",
".",
"am",
".",
"log",
")",
"\n",
"fs",
",",
"err",
":=",
"libfs",
".",
"NewReadonlyFS",
"(",
"ctx",
",",
"rn",
".",
"am",
".",
"config",
",",
"h",
",",
"rn",
".",
"GetFolderBranch",
"(",
")",
".",
"Branch",
",",
"kbfsRepoDir",
",",
"\"",
"\"",
",",
"keybase1",
".",
"MDPriorityNormal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"rn",
".",
"am",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"rn",
".",
"Node",
".",
"ShouldCreateMissedLookup",
"(",
"ctx",
",",
"name",
")",
"\n",
"}",
"\n",
"rn",
".",
"fs",
"=",
"fs",
"\n",
"}",
"\n",
"return",
"true",
",",
"ctx",
",",
"data",
".",
"FakeDir",
",",
"nil",
",",
"\"",
"\"",
"\n",
"}"
] | // ShouldCreateMissedLookup implements the Node interface for
// rootNode. | [
"ShouldCreateMissedLookup",
"implements",
"the",
"Node",
"interface",
"for",
"rootNode",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libgit/autogit_node_wrappers.go#L315-L346 |
158,916 | keybase/client | go/kbfs/libgit/autogit_node_wrappers.go | WrapChild | func (rn *rootNode) WrapChild(child libkbfs.Node) libkbfs.Node {
child = rn.Node.WrapChild(child)
if child.GetBasename() != AutogitRoot {
return child
}
rn.lock.RLock()
defer rn.lock.RUnlock()
if rn.fs == nil {
rn.am.log.CDebugf(nil, "FS not available on WrapChild")
return child
}
rn.am.log.CDebugf(nil, "Making autogit root node")
return &autogitRootNode{
Node: &libkbfs.ReadonlyNode{Node: child},
am: rn.am,
fs: rn.fs,
}
} | go | func (rn *rootNode) WrapChild(child libkbfs.Node) libkbfs.Node {
child = rn.Node.WrapChild(child)
if child.GetBasename() != AutogitRoot {
return child
}
rn.lock.RLock()
defer rn.lock.RUnlock()
if rn.fs == nil {
rn.am.log.CDebugf(nil, "FS not available on WrapChild")
return child
}
rn.am.log.CDebugf(nil, "Making autogit root node")
return &autogitRootNode{
Node: &libkbfs.ReadonlyNode{Node: child},
am: rn.am,
fs: rn.fs,
}
} | [
"func",
"(",
"rn",
"*",
"rootNode",
")",
"WrapChild",
"(",
"child",
"libkbfs",
".",
"Node",
")",
"libkbfs",
".",
"Node",
"{",
"child",
"=",
"rn",
".",
"Node",
".",
"WrapChild",
"(",
"child",
")",
"\n",
"if",
"child",
".",
"GetBasename",
"(",
")",
"!=",
"AutogitRoot",
"{",
"return",
"child",
"\n",
"}",
"\n\n",
"rn",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"rn",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"rn",
".",
"fs",
"==",
"nil",
"{",
"rn",
".",
"am",
".",
"log",
".",
"CDebugf",
"(",
"nil",
",",
"\"",
"\"",
")",
"\n",
"return",
"child",
"\n",
"}",
"\n\n",
"rn",
".",
"am",
".",
"log",
".",
"CDebugf",
"(",
"nil",
",",
"\"",
"\"",
")",
"\n",
"return",
"&",
"autogitRootNode",
"{",
"Node",
":",
"&",
"libkbfs",
".",
"ReadonlyNode",
"{",
"Node",
":",
"child",
"}",
",",
"am",
":",
"rn",
".",
"am",
",",
"fs",
":",
"rn",
".",
"fs",
",",
"}",
"\n",
"}"
] | // WrapChild implements the Node interface for rootNode. | [
"WrapChild",
"implements",
"the",
"Node",
"interface",
"for",
"rootNode",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libgit/autogit_node_wrappers.go#L349-L368 |
158,917 | keybase/client | go/engine/paperkey_primary.go | NewPaperKeyPrimary | func NewPaperKeyPrimary(g *libkb.GlobalContext, args *PaperKeyPrimaryArgs) *PaperKeyPrimary {
return &PaperKeyPrimary{
args: args,
Contextified: libkb.NewContextified(g),
}
} | go | func NewPaperKeyPrimary(g *libkb.GlobalContext, args *PaperKeyPrimaryArgs) *PaperKeyPrimary {
return &PaperKeyPrimary{
args: args,
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewPaperKeyPrimary",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"args",
"*",
"PaperKeyPrimaryArgs",
")",
"*",
"PaperKeyPrimary",
"{",
"return",
"&",
"PaperKeyPrimary",
"{",
"args",
":",
"args",
",",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"}",
"\n",
"}"
] | // NewPaperKeyPrimary creates a PaperKeyPrimary engine. | [
"NewPaperKeyPrimary",
"creates",
"a",
"PaperKeyPrimary",
"engine",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/paperkey_primary.go#L30-L35 |
158,918 | keybase/client | go/libkb/uid.go | CheckUIDAgainstCasedUsername | func CheckUIDAgainstCasedUsername(uid keybase1.UID, username string) (err error) {
u2 := UsernameToUIDPreserveCase(username)
if uid.NotEqual(u2) {
err = UIDMismatchError{fmt.Sprintf("%s != %s (via %s)", uid, u2, username)}
}
return
} | go | func CheckUIDAgainstCasedUsername(uid keybase1.UID, username string) (err error) {
u2 := UsernameToUIDPreserveCase(username)
if uid.NotEqual(u2) {
err = UIDMismatchError{fmt.Sprintf("%s != %s (via %s)", uid, u2, username)}
}
return
} | [
"func",
"CheckUIDAgainstCasedUsername",
"(",
"uid",
"keybase1",
".",
"UID",
",",
"username",
"string",
")",
"(",
"err",
"error",
")",
"{",
"u2",
":=",
"UsernameToUIDPreserveCase",
"(",
"username",
")",
"\n",
"if",
"uid",
".",
"NotEqual",
"(",
"u2",
")",
"{",
"err",
"=",
"UIDMismatchError",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"uid",
",",
"u2",
",",
"username",
")",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // CheckUIDAgainstCasedUsername takes the input string, does not convert toLower,
// and then hashes it to recover a UID. This is a workaround for some
// users whose UIDs were computed incorrectly. | [
"CheckUIDAgainstCasedUsername",
"takes",
"the",
"input",
"string",
"does",
"not",
"convert",
"toLower",
"and",
"then",
"hashes",
"it",
"to",
"recover",
"a",
"UID",
".",
"This",
"is",
"a",
"workaround",
"for",
"some",
"users",
"whose",
"UIDs",
"were",
"computed",
"incorrectly",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/uid.go#L80-L86 |
158,919 | keybase/client | go/merklestore/store.go | fetch | func (s *MerkleStoreImpl) fetch(m libkb.MetaContext, hash keybase1.MerkleStoreKitHash) (keybase1.MerkleStoreKit, error) {
m.Debug("MerkleStore: fetching from server: %s", hash)
var res merkleStoreServerRes
err := m.G().API.GetDecode(m, libkb.APIArg{
Endpoint: s.endpoint,
SessionType: libkb.APISessionTypeNONE,
Args: libkb.HTTPArgs{
"hash": libkb.S{Val: string(hash)},
},
}, &res)
if err != nil {
return "", NewMerkleStoreError(err.Error())
}
if res.KitJSON == "" {
return "", NewMerkleStoreError("server returned empty kit for %s", s.tag)
}
if s.hash(res.KitJSON) != hash {
m.Debug("%s hash mismatch: got:%s expected:%s", s.tag, s.hash(res.KitJSON), hash)
return "", NewMerkleStoreError("server returned wrong kit for %s", s.tag)
}
return res.KitJSON, nil
} | go | func (s *MerkleStoreImpl) fetch(m libkb.MetaContext, hash keybase1.MerkleStoreKitHash) (keybase1.MerkleStoreKit, error) {
m.Debug("MerkleStore: fetching from server: %s", hash)
var res merkleStoreServerRes
err := m.G().API.GetDecode(m, libkb.APIArg{
Endpoint: s.endpoint,
SessionType: libkb.APISessionTypeNONE,
Args: libkb.HTTPArgs{
"hash": libkb.S{Val: string(hash)},
},
}, &res)
if err != nil {
return "", NewMerkleStoreError(err.Error())
}
if res.KitJSON == "" {
return "", NewMerkleStoreError("server returned empty kit for %s", s.tag)
}
if s.hash(res.KitJSON) != hash {
m.Debug("%s hash mismatch: got:%s expected:%s", s.tag, s.hash(res.KitJSON), hash)
return "", NewMerkleStoreError("server returned wrong kit for %s", s.tag)
}
return res.KitJSON, nil
} | [
"func",
"(",
"s",
"*",
"MerkleStoreImpl",
")",
"fetch",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"hash",
"keybase1",
".",
"MerkleStoreKitHash",
")",
"(",
"keybase1",
".",
"MerkleStoreKit",
",",
"error",
")",
"{",
"m",
".",
"Debug",
"(",
"\"",
"\"",
",",
"hash",
")",
"\n",
"var",
"res",
"merkleStoreServerRes",
"\n",
"err",
":=",
"m",
".",
"G",
"(",
")",
".",
"API",
".",
"GetDecode",
"(",
"m",
",",
"libkb",
".",
"APIArg",
"{",
"Endpoint",
":",
"s",
".",
"endpoint",
",",
"SessionType",
":",
"libkb",
".",
"APISessionTypeNONE",
",",
"Args",
":",
"libkb",
".",
"HTTPArgs",
"{",
"\"",
"\"",
":",
"libkb",
".",
"S",
"{",
"Val",
":",
"string",
"(",
"hash",
")",
"}",
",",
"}",
",",
"}",
",",
"&",
"res",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"NewMerkleStoreError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"res",
".",
"KitJSON",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"NewMerkleStoreError",
"(",
"\"",
"\"",
",",
"s",
".",
"tag",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"hash",
"(",
"res",
".",
"KitJSON",
")",
"!=",
"hash",
"{",
"m",
".",
"Debug",
"(",
"\"",
"\"",
",",
"s",
".",
"tag",
",",
"s",
".",
"hash",
"(",
"res",
".",
"KitJSON",
")",
",",
"hash",
")",
"\n",
"return",
"\"",
"\"",
",",
"NewMerkleStoreError",
"(",
"\"",
"\"",
",",
"s",
".",
"tag",
")",
"\n",
"}",
"\n",
"return",
"res",
".",
"KitJSON",
",",
"nil",
"\n",
"}"
] | // Fetch data and check the hash. | [
"Fetch",
"data",
"and",
"check",
"the",
"hash",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/merklestore/store.go#L247-L268 |
158,920 | keybase/client | go/merklestore/store.go | refreshRoot | func (s *MerkleStoreImpl) refreshRoot(m libkb.MetaContext) error {
q := libkb.NewHTTPArgs()
// The user lookup here is unnecessary. It is done because that is what is
// easy with MerkleClient. The user looked up is you if known, otherwise
// arbitrarily t_alice. If t_alice is removed, this path will break.
uid := s.G().GetMyUID()
if len(uid) == 0 {
// Use t_alice's uid.
uid = libkb.TAliceUID
}
q.Add("uid", libkb.UIDArg(uid))
_, err := s.G().MerkleClient.LookupUser(m, q, nil)
return err
} | go | func (s *MerkleStoreImpl) refreshRoot(m libkb.MetaContext) error {
q := libkb.NewHTTPArgs()
// The user lookup here is unnecessary. It is done because that is what is
// easy with MerkleClient. The user looked up is you if known, otherwise
// arbitrarily t_alice. If t_alice is removed, this path will break.
uid := s.G().GetMyUID()
if len(uid) == 0 {
// Use t_alice's uid.
uid = libkb.TAliceUID
}
q.Add("uid", libkb.UIDArg(uid))
_, err := s.G().MerkleClient.LookupUser(m, q, nil)
return err
} | [
"func",
"(",
"s",
"*",
"MerkleStoreImpl",
")",
"refreshRoot",
"(",
"m",
"libkb",
".",
"MetaContext",
")",
"error",
"{",
"q",
":=",
"libkb",
".",
"NewHTTPArgs",
"(",
")",
"\n",
"// The user lookup here is unnecessary. It is done because that is what is",
"// easy with MerkleClient. The user looked up is you if known, otherwise",
"// arbitrarily t_alice. If t_alice is removed, this path will break.",
"uid",
":=",
"s",
".",
"G",
"(",
")",
".",
"GetMyUID",
"(",
")",
"\n",
"if",
"len",
"(",
"uid",
")",
"==",
"0",
"{",
"// Use t_alice's uid.",
"uid",
"=",
"libkb",
".",
"TAliceUID",
"\n",
"}",
"\n",
"q",
".",
"Add",
"(",
"\"",
"\"",
",",
"libkb",
".",
"UIDArg",
"(",
"uid",
")",
")",
"\n",
"_",
",",
"err",
":=",
"s",
".",
"G",
"(",
")",
".",
"MerkleClient",
".",
"LookupUser",
"(",
"m",
",",
"q",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // updateRoot kicks MerkleClient to update its merkle root
// by doing a LookupUser on some arbitrary user. | [
"updateRoot",
"kicks",
"MerkleClient",
"to",
"update",
"its",
"merkle",
"root",
"by",
"doing",
"a",
"LookupUser",
"on",
"some",
"arbitrary",
"user",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/merklestore/store.go#L272-L285 |
158,921 | keybase/client | go/merklestore/store.go | dbGet | func (s *MerkleStoreImpl) dbGet(m libkb.MetaContext, hash keybase1.MerkleStoreKitHash) *keybase1.MerkleStoreKit {
db := m.G().LocalDb
if db == nil {
return nil
}
var entry dbKit
if found, err := db.GetInto(&entry, s.dbKey()); err != nil {
m.Debug("MerkleStore: error reading from db: %s", err)
return nil
} else if !found {
return nil
}
if entry.DBVersion != dbVersion {
return nil
}
if entry.Hash == hash {
return &entry.Kit
}
return nil
} | go | func (s *MerkleStoreImpl) dbGet(m libkb.MetaContext, hash keybase1.MerkleStoreKitHash) *keybase1.MerkleStoreKit {
db := m.G().LocalDb
if db == nil {
return nil
}
var entry dbKit
if found, err := db.GetInto(&entry, s.dbKey()); err != nil {
m.Debug("MerkleStore: error reading from db: %s", err)
return nil
} else if !found {
return nil
}
if entry.DBVersion != dbVersion {
return nil
}
if entry.Hash == hash {
return &entry.Kit
}
return nil
} | [
"func",
"(",
"s",
"*",
"MerkleStoreImpl",
")",
"dbGet",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"hash",
"keybase1",
".",
"MerkleStoreKitHash",
")",
"*",
"keybase1",
".",
"MerkleStoreKit",
"{",
"db",
":=",
"m",
".",
"G",
"(",
")",
".",
"LocalDb",
"\n",
"if",
"db",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"entry",
"dbKit",
"\n",
"if",
"found",
",",
"err",
":=",
"db",
".",
"GetInto",
"(",
"&",
"entry",
",",
"s",
".",
"dbKey",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"m",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"else",
"if",
"!",
"found",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"entry",
".",
"DBVersion",
"!=",
"dbVersion",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"entry",
".",
"Hash",
"==",
"hash",
"{",
"return",
"&",
"entry",
".",
"Kit",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Get from local db. Can return nil. | [
"Get",
"from",
"local",
"db",
".",
"Can",
"return",
"nil",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/merklestore/store.go#L306-L325 |
158,922 | keybase/client | go/merklestore/store.go | dbSet | func (s *MerkleStoreImpl) dbSet(m libkb.MetaContext, hash keybase1.MerkleStoreKitHash, kitJSON keybase1.MerkleStoreKit) {
db := m.G().LocalDb
if db == nil {
m.Debug("dbSet: no db")
return
}
entry := dbKit{
DBVersion: dbVersion,
Hash: hash,
Kit: kitJSON,
}
if err := db.PutObj(s.dbKey(), nil, entry); err != nil {
m.Debug("dbSet: %s", err)
}
} | go | func (s *MerkleStoreImpl) dbSet(m libkb.MetaContext, hash keybase1.MerkleStoreKitHash, kitJSON keybase1.MerkleStoreKit) {
db := m.G().LocalDb
if db == nil {
m.Debug("dbSet: no db")
return
}
entry := dbKit{
DBVersion: dbVersion,
Hash: hash,
Kit: kitJSON,
}
if err := db.PutObj(s.dbKey(), nil, entry); err != nil {
m.Debug("dbSet: %s", err)
}
} | [
"func",
"(",
"s",
"*",
"MerkleStoreImpl",
")",
"dbSet",
"(",
"m",
"libkb",
".",
"MetaContext",
",",
"hash",
"keybase1",
".",
"MerkleStoreKitHash",
",",
"kitJSON",
"keybase1",
".",
"MerkleStoreKit",
")",
"{",
"db",
":=",
"m",
".",
"G",
"(",
")",
".",
"LocalDb",
"\n",
"if",
"db",
"==",
"nil",
"{",
"m",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"entry",
":=",
"dbKit",
"{",
"DBVersion",
":",
"dbVersion",
",",
"Hash",
":",
"hash",
",",
"Kit",
":",
"kitJSON",
",",
"}",
"\n",
"if",
"err",
":=",
"db",
".",
"PutObj",
"(",
"s",
".",
"dbKey",
"(",
")",
",",
"nil",
",",
"entry",
")",
";",
"err",
"!=",
"nil",
"{",
"m",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // Logs errors. | [
"Logs",
"errors",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/merklestore/store.go#L328-L342 |
158,923 | keybase/client | go/merklestore/store.go | hash | func (s *MerkleStoreImpl) hash(in keybase1.MerkleStoreKit) keybase1.MerkleStoreKitHash {
buf := sha512.Sum512([]byte(in))
out := hex.EncodeToString(buf[:])
return keybase1.MerkleStoreKitHash(out)
} | go | func (s *MerkleStoreImpl) hash(in keybase1.MerkleStoreKit) keybase1.MerkleStoreKitHash {
buf := sha512.Sum512([]byte(in))
out := hex.EncodeToString(buf[:])
return keybase1.MerkleStoreKitHash(out)
} | [
"func",
"(",
"s",
"*",
"MerkleStoreImpl",
")",
"hash",
"(",
"in",
"keybase1",
".",
"MerkleStoreKit",
")",
"keybase1",
".",
"MerkleStoreKitHash",
"{",
"buf",
":=",
"sha512",
".",
"Sum512",
"(",
"[",
"]",
"byte",
"(",
"in",
")",
")",
"\n",
"out",
":=",
"hex",
".",
"EncodeToString",
"(",
"buf",
"[",
":",
"]",
")",
"\n",
"return",
"keybase1",
".",
"MerkleStoreKitHash",
"(",
"out",
")",
"\n",
"}"
] | // hex of sha512 | [
"hex",
"of",
"sha512"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/merklestore/store.go#L345-L349 |
158,924 | keybase/client | go/kbfs/tlf/errors.go | Error | func (e HandleExtensionMismatchError) Error() string {
return fmt.Sprintf("Folder handle extension mismatch, "+
"expected: %s, actual: %s", e.Expected, e.Actual)
} | go | func (e HandleExtensionMismatchError) Error() string {
return fmt.Sprintf("Folder handle extension mismatch, "+
"expected: %s, actual: %s", e.Expected, e.Actual)
} | [
"func",
"(",
"e",
"HandleExtensionMismatchError",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"e",
".",
"Expected",
",",
"e",
".",
"Actual",
")",
"\n",
"}"
] | // Error implements the error interface for HandleExtensionMismatchError | [
"Error",
"implements",
"the",
"error",
"interface",
"for",
"HandleExtensionMismatchError"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/errors.go#L28-L31 |
158,925 | keybase/client | go/kbfs/libdokan/common.go | fillStat | func fillStat(a *dokan.Stat, de *data.EntryInfo) {
a.FileSize = int64(de.Size)
a.LastWrite = time.Unix(0, de.Mtime)
a.LastAccess = a.LastWrite
a.Creation = time.Unix(0, de.Ctime)
switch de.Type {
case data.File, data.Exec:
a.FileAttributes = dokan.FileAttributeNormal
case data.Dir:
a.FileAttributes = dokan.FileAttributeDirectory
case data.Sym:
a.FileAttributes = dokan.FileAttributeReparsePoint
a.ReparsePointTag = dokan.IOReparseTagSymlink
}
} | go | func fillStat(a *dokan.Stat, de *data.EntryInfo) {
a.FileSize = int64(de.Size)
a.LastWrite = time.Unix(0, de.Mtime)
a.LastAccess = a.LastWrite
a.Creation = time.Unix(0, de.Ctime)
switch de.Type {
case data.File, data.Exec:
a.FileAttributes = dokan.FileAttributeNormal
case data.Dir:
a.FileAttributes = dokan.FileAttributeDirectory
case data.Sym:
a.FileAttributes = dokan.FileAttributeReparsePoint
a.ReparsePointTag = dokan.IOReparseTagSymlink
}
} | [
"func",
"fillStat",
"(",
"a",
"*",
"dokan",
".",
"Stat",
",",
"de",
"*",
"data",
".",
"EntryInfo",
")",
"{",
"a",
".",
"FileSize",
"=",
"int64",
"(",
"de",
".",
"Size",
")",
"\n",
"a",
".",
"LastWrite",
"=",
"time",
".",
"Unix",
"(",
"0",
",",
"de",
".",
"Mtime",
")",
"\n",
"a",
".",
"LastAccess",
"=",
"a",
".",
"LastWrite",
"\n",
"a",
".",
"Creation",
"=",
"time",
".",
"Unix",
"(",
"0",
",",
"de",
".",
"Ctime",
")",
"\n",
"switch",
"de",
".",
"Type",
"{",
"case",
"data",
".",
"File",
",",
"data",
".",
"Exec",
":",
"a",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeNormal",
"\n",
"case",
"data",
".",
"Dir",
":",
"a",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeDirectory",
"\n",
"case",
"data",
".",
"Sym",
":",
"a",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeReparsePoint",
"\n",
"a",
".",
"ReparsePointTag",
"=",
"dokan",
".",
"IOReparseTagSymlink",
"\n",
"}",
"\n",
"}"
] | // fillStat fill a dokan.Stat from a libkbfs.DirEntry.
// Note that handling symlinks to directories requires extra processing not done here. | [
"fillStat",
"fill",
"a",
"dokan",
".",
"Stat",
"from",
"a",
"libkbfs",
".",
"DirEntry",
".",
"Note",
"that",
"handling",
"symlinks",
"to",
"directories",
"requires",
"extra",
"processing",
"not",
"done",
"here",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L59-L73 |
158,926 | keybase/client | go/kbfs/libdokan/common.go | addFileAttribute | func addFileAttribute(a *dokan.Stat, fa dokan.FileAttribute) {
// FileAttributeNormal is valid only if no other attribute is set.
// Thus clear the normal flag (if set) from the attributes and or
// the new flag.
a.FileAttributes = (a.FileAttributes &^ dokan.FileAttributeNormal) | fa
} | go | func addFileAttribute(a *dokan.Stat, fa dokan.FileAttribute) {
// FileAttributeNormal is valid only if no other attribute is set.
// Thus clear the normal flag (if set) from the attributes and or
// the new flag.
a.FileAttributes = (a.FileAttributes &^ dokan.FileAttributeNormal) | fa
} | [
"func",
"addFileAttribute",
"(",
"a",
"*",
"dokan",
".",
"Stat",
",",
"fa",
"dokan",
".",
"FileAttribute",
")",
"{",
"// FileAttributeNormal is valid only if no other attribute is set.",
"// Thus clear the normal flag (if set) from the attributes and or",
"// the new flag.",
"a",
".",
"FileAttributes",
"=",
"(",
"a",
".",
"FileAttributes",
"&^",
"dokan",
".",
"FileAttributeNormal",
")",
"|",
"fa",
"\n",
"}"
] | // addFileAttribute adds a file attribute to the stat struct. | [
"addFileAttribute",
"adds",
"a",
"file",
"attribute",
"to",
"the",
"stat",
"struct",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L76-L81 |
158,927 | keybase/client | go/kbfs/libdokan/common.go | errToDokan | func errToDokan(err error) error {
switch err.(type) {
case idutil.NoSuchNameError:
return dokan.ErrObjectNameNotFound
case idutil.NoSuchUserError:
return dokan.ErrObjectNameNotFound
case kbfsmd.ServerErrorUnauthorized:
return dokan.ErrAccessDenied
case nil:
return nil
}
return err
} | go | func errToDokan(err error) error {
switch err.(type) {
case idutil.NoSuchNameError:
return dokan.ErrObjectNameNotFound
case idutil.NoSuchUserError:
return dokan.ErrObjectNameNotFound
case kbfsmd.ServerErrorUnauthorized:
return dokan.ErrAccessDenied
case nil:
return nil
}
return err
} | [
"func",
"errToDokan",
"(",
"err",
"error",
")",
"error",
"{",
"switch",
"err",
".",
"(",
"type",
")",
"{",
"case",
"idutil",
".",
"NoSuchNameError",
":",
"return",
"dokan",
".",
"ErrObjectNameNotFound",
"\n",
"case",
"idutil",
".",
"NoSuchUserError",
":",
"return",
"dokan",
".",
"ErrObjectNameNotFound",
"\n",
"case",
"kbfsmd",
".",
"ServerErrorUnauthorized",
":",
"return",
"dokan",
".",
"ErrAccessDenied",
"\n",
"case",
"nil",
":",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // errToDokan makes some libkbfs errors easier to digest in dokan. Not needed in most places. | [
"errToDokan",
"makes",
"some",
"libkbfs",
"errors",
"easier",
"to",
"digest",
"in",
"dokan",
".",
"Not",
"needed",
"in",
"most",
"places",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L84-L96 |
158,928 | keybase/client | go/kbfs/libdokan/common.go | defaultDirectoryInformation | func defaultDirectoryInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeDirectory
return &st, nil
} | go | func defaultDirectoryInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeDirectory
return &st, nil
} | [
"func",
"defaultDirectoryInformation",
"(",
")",
"(",
"*",
"dokan",
".",
"Stat",
",",
"error",
")",
"{",
"var",
"st",
"dokan",
".",
"Stat",
"\n",
"st",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeDirectory",
"\n",
"return",
"&",
"st",
",",
"nil",
"\n",
"}"
] | // defaultDirectoryInformation returns default directory information. | [
"defaultDirectoryInformation",
"returns",
"default",
"directory",
"information",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L99-L103 |
158,929 | keybase/client | go/kbfs/libdokan/common.go | defaultFileInformation | func defaultFileInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeNormal
return &st, nil
} | go | func defaultFileInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeNormal
return &st, nil
} | [
"func",
"defaultFileInformation",
"(",
")",
"(",
"*",
"dokan",
".",
"Stat",
",",
"error",
")",
"{",
"var",
"st",
"dokan",
".",
"Stat",
"\n",
"st",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeNormal",
"\n",
"return",
"&",
"st",
",",
"nil",
"\n",
"}"
] | // defaultFileInformation returns default file information. | [
"defaultFileInformation",
"returns",
"default",
"file",
"information",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L106-L110 |
158,930 | keybase/client | go/kbfs/libdokan/common.go | defaultSymlinkFileInformation | func defaultSymlinkFileInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeReparsePoint
st.ReparsePointTag = dokan.IOReparseTagSymlink
return &st, nil
} | go | func defaultSymlinkFileInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeReparsePoint
st.ReparsePointTag = dokan.IOReparseTagSymlink
return &st, nil
} | [
"func",
"defaultSymlinkFileInformation",
"(",
")",
"(",
"*",
"dokan",
".",
"Stat",
",",
"error",
")",
"{",
"var",
"st",
"dokan",
".",
"Stat",
"\n",
"st",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeReparsePoint",
"\n",
"st",
".",
"ReparsePointTag",
"=",
"dokan",
".",
"IOReparseTagSymlink",
"\n",
"return",
"&",
"st",
",",
"nil",
"\n",
"}"
] | // defaultSymlinkFileInformation returns default symlink to file information. | [
"defaultSymlinkFileInformation",
"returns",
"default",
"symlink",
"to",
"file",
"information",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L113-L118 |
158,931 | keybase/client | go/kbfs/libdokan/common.go | defaultSymlinkDirInformation | func defaultSymlinkDirInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeReparsePoint | dokan.FileAttributeDirectory
st.ReparsePointTag = dokan.IOReparseTagSymlink
return &st, nil
} | go | func defaultSymlinkDirInformation() (*dokan.Stat, error) {
var st dokan.Stat
st.FileAttributes = dokan.FileAttributeReparsePoint | dokan.FileAttributeDirectory
st.ReparsePointTag = dokan.IOReparseTagSymlink
return &st, nil
} | [
"func",
"defaultSymlinkDirInformation",
"(",
")",
"(",
"*",
"dokan",
".",
"Stat",
",",
"error",
")",
"{",
"var",
"st",
"dokan",
".",
"Stat",
"\n",
"st",
".",
"FileAttributes",
"=",
"dokan",
".",
"FileAttributeReparsePoint",
"|",
"dokan",
".",
"FileAttributeDirectory",
"\n",
"st",
".",
"ReparsePointTag",
"=",
"dokan",
".",
"IOReparseTagSymlink",
"\n",
"return",
"&",
"st",
",",
"nil",
"\n",
"}"
] | // defaultSymlinkDirInformation returns default symlink to directory information. | [
"defaultSymlinkDirInformation",
"returns",
"default",
"symlink",
"to",
"directory",
"information",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/common.go#L121-L126 |
158,932 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | makeBlockDiskStore | func makeBlockDiskStore(codec kbfscodec.Codec, dir string) *blockDiskStore {
return &blockDiskStore{
codec: codec,
dir: dir,
puts: make(map[kbfsblock.ID]<-chan struct{}),
}
} | go | func makeBlockDiskStore(codec kbfscodec.Codec, dir string) *blockDiskStore {
return &blockDiskStore{
codec: codec,
dir: dir,
puts: make(map[kbfsblock.ID]<-chan struct{}),
}
} | [
"func",
"makeBlockDiskStore",
"(",
"codec",
"kbfscodec",
".",
"Codec",
",",
"dir",
"string",
")",
"*",
"blockDiskStore",
"{",
"return",
"&",
"blockDiskStore",
"{",
"codec",
":",
"codec",
",",
"dir",
":",
"dir",
",",
"puts",
":",
"make",
"(",
"map",
"[",
"kbfsblock",
".",
"ID",
"]",
"<-",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // makeBlockDiskStore returns a new blockDiskStore for the given
// directory. | [
"makeBlockDiskStore",
"returns",
"a",
"new",
"blockDiskStore",
"for",
"the",
"given",
"directory",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L96-L102 |
158,933 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | blockPath | func (s *blockDiskStore) blockPath(id kbfsblock.ID) string {
// Truncate to 34 characters, which corresponds to 16 random
// bytes (since the first byte is a hash type) or 128 random
// bits, which means that the expected number of blocks
// generated before getting a path collision is 2^64 (see
// https://en.wikipedia.org/wiki/Birthday_problem#Cast_as_a_collision_problem
// ).
idStr := id.String()
return filepath.Join(s.dir, idStr[:4], idStr[4:34])
} | go | func (s *blockDiskStore) blockPath(id kbfsblock.ID) string {
// Truncate to 34 characters, which corresponds to 16 random
// bytes (since the first byte is a hash type) or 128 random
// bits, which means that the expected number of blocks
// generated before getting a path collision is 2^64 (see
// https://en.wikipedia.org/wiki/Birthday_problem#Cast_as_a_collision_problem
// ).
idStr := id.String()
return filepath.Join(s.dir, idStr[:4], idStr[4:34])
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"blockPath",
"(",
"id",
"kbfsblock",
".",
"ID",
")",
"string",
"{",
"// Truncate to 34 characters, which corresponds to 16 random",
"// bytes (since the first byte is a hash type) or 128 random",
"// bits, which means that the expected number of blocks",
"// generated before getting a path collision is 2^64 (see",
"// https://en.wikipedia.org/wiki/Birthday_problem#Cast_as_a_collision_problem",
"// ).",
"idStr",
":=",
"id",
".",
"String",
"(",
")",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"s",
".",
"dir",
",",
"idStr",
"[",
":",
"4",
"]",
",",
"idStr",
"[",
"4",
":",
"34",
"]",
")",
"\n",
"}"
] | // The functions below are for building various paths. | [
"The",
"functions",
"below",
"are",
"for",
"building",
"various",
"paths",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L106-L115 |
158,934 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | makeDir | func (s *blockDiskStore) makeDir(id kbfsblock.ID) error {
err := ioutil.MkdirAll(s.blockPath(id), 0700)
if err != nil {
return err
}
// TODO: Only write if the file doesn't exist.
return ioutil.WriteFile(s.idPath(id), []byte(id.String()), 0600)
} | go | func (s *blockDiskStore) makeDir(id kbfsblock.ID) error {
err := ioutil.MkdirAll(s.blockPath(id), 0700)
if err != nil {
return err
}
// TODO: Only write if the file doesn't exist.
return ioutil.WriteFile(s.idPath(id), []byte(id.String()), 0600)
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"makeDir",
"(",
"id",
"kbfsblock",
".",
"ID",
")",
"error",
"{",
"err",
":=",
"ioutil",
".",
"MkdirAll",
"(",
"s",
".",
"blockPath",
"(",
"id",
")",
",",
"0700",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// TODO: Only write if the file doesn't exist.",
"return",
"ioutil",
".",
"WriteFile",
"(",
"s",
".",
"idPath",
"(",
"id",
")",
",",
"[",
"]",
"byte",
"(",
"id",
".",
"String",
"(",
")",
")",
",",
"0600",
")",
"\n",
"}"
] | // makeDir makes the directory for the given block ID and writes the
// ID file, if necessary. | [
"makeDir",
"makes",
"the",
"directory",
"for",
"the",
"given",
"block",
"ID",
"and",
"writes",
"the",
"ID",
"file",
"if",
"necessary",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L139-L148 |
158,935 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | getInfo | func (s *blockDiskStore) getInfo(id kbfsblock.ID) (blockJournalInfo, error) {
var info blockJournalInfo
err := kbfscodec.DeserializeFromFile(s.codec, s.infoPath(id), &info)
if !ioutil.IsNotExist(err) && err != nil {
return blockJournalInfo{}, err
}
if info.Refs == nil {
info.Refs = make(blockRefMap)
}
return info, nil
} | go | func (s *blockDiskStore) getInfo(id kbfsblock.ID) (blockJournalInfo, error) {
var info blockJournalInfo
err := kbfscodec.DeserializeFromFile(s.codec, s.infoPath(id), &info)
if !ioutil.IsNotExist(err) && err != nil {
return blockJournalInfo{}, err
}
if info.Refs == nil {
info.Refs = make(blockRefMap)
}
return info, nil
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"getInfo",
"(",
"id",
"kbfsblock",
".",
"ID",
")",
"(",
"blockJournalInfo",
",",
"error",
")",
"{",
"var",
"info",
"blockJournalInfo",
"\n",
"err",
":=",
"kbfscodec",
".",
"DeserializeFromFile",
"(",
"s",
".",
"codec",
",",
"s",
".",
"infoPath",
"(",
"id",
")",
",",
"&",
"info",
")",
"\n",
"if",
"!",
"ioutil",
".",
"IsNotExist",
"(",
"err",
")",
"&&",
"err",
"!=",
"nil",
"{",
"return",
"blockJournalInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"info",
".",
"Refs",
"==",
"nil",
"{",
"info",
".",
"Refs",
"=",
"make",
"(",
"blockRefMap",
")",
"\n",
"}",
"\n\n",
"return",
"info",
",",
"nil",
"\n",
"}"
] | // getRefInfo returns the references for the given ID. exclusify must
// have been called by the caller. | [
"getRefInfo",
"returns",
"the",
"references",
"for",
"the",
"given",
"ID",
".",
"exclusify",
"must",
"have",
"been",
"called",
"by",
"the",
"caller",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L210-L222 |
158,936 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | putInfo | func (s *blockDiskStore) putInfo(
id kbfsblock.ID, info blockJournalInfo) error {
return kbfscodec.SerializeToFile(s.codec, info, s.infoPath(id))
} | go | func (s *blockDiskStore) putInfo(
id kbfsblock.ID, info blockJournalInfo) error {
return kbfscodec.SerializeToFile(s.codec, info, s.infoPath(id))
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"putInfo",
"(",
"id",
"kbfsblock",
".",
"ID",
",",
"info",
"blockJournalInfo",
")",
"error",
"{",
"return",
"kbfscodec",
".",
"SerializeToFile",
"(",
"s",
".",
"codec",
",",
"info",
",",
"s",
".",
"infoPath",
"(",
"id",
")",
")",
"\n",
"}"
] | // putRefInfo stores the given references for the given ID. exclusify
// must have been called by the caller. | [
"putRefInfo",
"stores",
"the",
"given",
"references",
"for",
"the",
"given",
"ID",
".",
"exclusify",
"must",
"have",
"been",
"called",
"by",
"the",
"caller",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L226-L229 |
158,937 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | addRefsExclusive | func (s *blockDiskStore) addRefsExclusive(
id kbfsblock.ID, contexts []kbfsblock.Context, status blockRefStatus,
tag string) error {
info, err := s.getInfo(id)
if len(info.Refs) > 0 {
// Check existing contexts, if any.
for _, context := range contexts {
_, _, err := info.Refs.checkExists(context)
if err != nil {
return err
}
}
}
for _, context := range contexts {
err = info.Refs.put(context, status, tag)
if err != nil {
return err
}
}
return s.putInfo(id, info)
} | go | func (s *blockDiskStore) addRefsExclusive(
id kbfsblock.ID, contexts []kbfsblock.Context, status blockRefStatus,
tag string) error {
info, err := s.getInfo(id)
if len(info.Refs) > 0 {
// Check existing contexts, if any.
for _, context := range contexts {
_, _, err := info.Refs.checkExists(context)
if err != nil {
return err
}
}
}
for _, context := range contexts {
err = info.Refs.put(context, status, tag)
if err != nil {
return err
}
}
return s.putInfo(id, info)
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"addRefsExclusive",
"(",
"id",
"kbfsblock",
".",
"ID",
",",
"contexts",
"[",
"]",
"kbfsblock",
".",
"Context",
",",
"status",
"blockRefStatus",
",",
"tag",
"string",
")",
"error",
"{",
"info",
",",
"err",
":=",
"s",
".",
"getInfo",
"(",
"id",
")",
"\n\n",
"if",
"len",
"(",
"info",
".",
"Refs",
")",
">",
"0",
"{",
"// Check existing contexts, if any.",
"for",
"_",
",",
"context",
":=",
"range",
"contexts",
"{",
"_",
",",
"_",
",",
"err",
":=",
"info",
".",
"Refs",
".",
"checkExists",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"context",
":=",
"range",
"contexts",
"{",
"err",
"=",
"info",
".",
"Refs",
".",
"put",
"(",
"context",
",",
"status",
",",
"tag",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"putInfo",
"(",
"id",
",",
"info",
")",
"\n",
"}"
] | // addRefs adds references for the given contexts to the given ID, all
// with the same status and tag. `exclusify` must be called by the
// caller. | [
"addRefs",
"adds",
"references",
"for",
"the",
"given",
"contexts",
"to",
"the",
"given",
"ID",
"all",
"with",
"the",
"same",
"status",
"and",
"tag",
".",
"exclusify",
"must",
"be",
"called",
"by",
"the",
"caller",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L234-L257 |
158,938 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | getDataExclusive | func (s *blockDiskStore) getDataExclusive(id kbfsblock.ID) (
[]byte, kbfscrypto.BlockCryptKeyServerHalf, error) {
data, err := ioutil.ReadFile(s.dataPath(id))
if ioutil.IsNotExist(err) {
return nil, kbfscrypto.BlockCryptKeyServerHalf{},
blockNonExistentError{id}
} else if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
keyServerHalfPath := s.keyServerHalfPath(id)
buf, err := ioutil.ReadFile(keyServerHalfPath)
if ioutil.IsNotExist(err) {
return nil, kbfscrypto.BlockCryptKeyServerHalf{},
blockNonExistentError{id}
} else if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
// Check integrity.
err = kbfsblock.VerifyID(data, id)
if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
var serverHalf kbfscrypto.BlockCryptKeyServerHalf
err = serverHalf.UnmarshalBinary(buf)
if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
return data, serverHalf, nil
} | go | func (s *blockDiskStore) getDataExclusive(id kbfsblock.ID) (
[]byte, kbfscrypto.BlockCryptKeyServerHalf, error) {
data, err := ioutil.ReadFile(s.dataPath(id))
if ioutil.IsNotExist(err) {
return nil, kbfscrypto.BlockCryptKeyServerHalf{},
blockNonExistentError{id}
} else if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
keyServerHalfPath := s.keyServerHalfPath(id)
buf, err := ioutil.ReadFile(keyServerHalfPath)
if ioutil.IsNotExist(err) {
return nil, kbfscrypto.BlockCryptKeyServerHalf{},
blockNonExistentError{id}
} else if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
// Check integrity.
err = kbfsblock.VerifyID(data, id)
if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
var serverHalf kbfscrypto.BlockCryptKeyServerHalf
err = serverHalf.UnmarshalBinary(buf)
if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
return data, serverHalf, nil
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"getDataExclusive",
"(",
"id",
"kbfsblock",
".",
"ID",
")",
"(",
"[",
"]",
"byte",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"s",
".",
"dataPath",
"(",
"id",
")",
")",
"\n",
"if",
"ioutil",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"blockNonExistentError",
"{",
"id",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"keyServerHalfPath",
":=",
"s",
".",
"keyServerHalfPath",
"(",
"id",
")",
"\n",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"keyServerHalfPath",
")",
"\n",
"if",
"ioutil",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"blockNonExistentError",
"{",
"id",
"}",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"// Check integrity.",
"err",
"=",
"kbfsblock",
".",
"VerifyID",
"(",
"data",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"serverHalf",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"\n",
"err",
"=",
"serverHalf",
".",
"UnmarshalBinary",
"(",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"data",
",",
"serverHalf",
",",
"nil",
"\n",
"}"
] | // getData returns the data and server half for the given ID, if
// present. `exclusify` must be called by the caller. | [
"getData",
"returns",
"the",
"data",
"and",
"server",
"half",
"for",
"the",
"given",
"ID",
"if",
"present",
".",
"exclusify",
"must",
"be",
"called",
"by",
"the",
"caller",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L261-L294 |
158,939 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | getData | func (s *blockDiskStore) getData(ctx context.Context, id kbfsblock.ID) (
[]byte, kbfscrypto.BlockCryptKeyServerHalf, error) {
cleanup, err := s.exclusify(ctx, id)
if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
defer cleanup()
return s.getDataExclusive(id)
} | go | func (s *blockDiskStore) getData(ctx context.Context, id kbfsblock.ID) (
[]byte, kbfscrypto.BlockCryptKeyServerHalf, error) {
cleanup, err := s.exclusify(ctx, id)
if err != nil {
return nil, kbfscrypto.BlockCryptKeyServerHalf{}, err
}
defer cleanup()
return s.getDataExclusive(id)
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"getData",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"kbfsblock",
".",
"ID",
")",
"(",
"[",
"]",
"byte",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
",",
"error",
")",
"{",
"cleanup",
",",
"err",
":=",
"s",
".",
"exclusify",
"(",
"ctx",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"return",
"s",
".",
"getDataExclusive",
"(",
"id",
")",
"\n",
"}"
] | // getData returns the data and server half for the given ID, if
// present. | [
"getData",
"returns",
"the",
"data",
"and",
"server",
"half",
"for",
"the",
"given",
"ID",
"if",
"present",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L298-L307 |
158,940 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | put | func (s *blockDiskStore) put(
ctx context.Context, isRegularPut bool, id kbfsblock.ID,
context kbfsblock.Context, buf []byte,
serverHalf kbfscrypto.BlockCryptKeyServerHalf) (
putData bool, err error) {
cleanup, err := s.exclusify(ctx, id)
if err != nil {
return false, err
}
defer cleanup()
err = validateBlockPut(isRegularPut, id, context, buf)
if err != nil {
return false, err
}
// Check the data and retrieve the server half, if they exist.
_, existingServerHalf, err := s.getDataWithContextExclusive(id, context)
var exists bool
switch err.(type) {
case blockNonExistentError:
exists = false
case nil:
exists = true
default:
return false, err
}
if exists {
// If the entry already exists, everything should be
// the same, except for possibly additional
// references.
// We checked that both buf and the existing data hash
// to id, so no need to check that they're both equal.
if isRegularPut && existingServerHalf != serverHalf {
return false, errors.Errorf(
"key server half mismatch: expected %s, got %s",
existingServerHalf, serverHalf)
}
} else {
err = s.makeDir(id)
if err != nil {
return false, err
}
err = ioutil.WriteFile(s.dataPath(id), buf, 0600)
if err != nil {
return false, err
}
// TODO: Add integrity-checking for key server half?
data, err := serverHalf.MarshalBinary()
if err != nil {
return false, err
}
err = ioutil.WriteFile(s.keyServerHalfPath(id), data, 0600)
if err != nil {
return false, err
}
}
return !exists, nil
} | go | func (s *blockDiskStore) put(
ctx context.Context, isRegularPut bool, id kbfsblock.ID,
context kbfsblock.Context, buf []byte,
serverHalf kbfscrypto.BlockCryptKeyServerHalf) (
putData bool, err error) {
cleanup, err := s.exclusify(ctx, id)
if err != nil {
return false, err
}
defer cleanup()
err = validateBlockPut(isRegularPut, id, context, buf)
if err != nil {
return false, err
}
// Check the data and retrieve the server half, if they exist.
_, existingServerHalf, err := s.getDataWithContextExclusive(id, context)
var exists bool
switch err.(type) {
case blockNonExistentError:
exists = false
case nil:
exists = true
default:
return false, err
}
if exists {
// If the entry already exists, everything should be
// the same, except for possibly additional
// references.
// We checked that both buf and the existing data hash
// to id, so no need to check that they're both equal.
if isRegularPut && existingServerHalf != serverHalf {
return false, errors.Errorf(
"key server half mismatch: expected %s, got %s",
existingServerHalf, serverHalf)
}
} else {
err = s.makeDir(id)
if err != nil {
return false, err
}
err = ioutil.WriteFile(s.dataPath(id), buf, 0600)
if err != nil {
return false, err
}
// TODO: Add integrity-checking for key server half?
data, err := serverHalf.MarshalBinary()
if err != nil {
return false, err
}
err = ioutil.WriteFile(s.keyServerHalfPath(id), data, 0600)
if err != nil {
return false, err
}
}
return !exists, nil
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"put",
"(",
"ctx",
"context",
".",
"Context",
",",
"isRegularPut",
"bool",
",",
"id",
"kbfsblock",
".",
"ID",
",",
"context",
"kbfsblock",
".",
"Context",
",",
"buf",
"[",
"]",
"byte",
",",
"serverHalf",
"kbfscrypto",
".",
"BlockCryptKeyServerHalf",
")",
"(",
"putData",
"bool",
",",
"err",
"error",
")",
"{",
"cleanup",
",",
"err",
":=",
"s",
".",
"exclusify",
"(",
"ctx",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"err",
"=",
"validateBlockPut",
"(",
"isRegularPut",
",",
"id",
",",
"context",
",",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"// Check the data and retrieve the server half, if they exist.",
"_",
",",
"existingServerHalf",
",",
"err",
":=",
"s",
".",
"getDataWithContextExclusive",
"(",
"id",
",",
"context",
")",
"\n",
"var",
"exists",
"bool",
"\n",
"switch",
"err",
".",
"(",
"type",
")",
"{",
"case",
"blockNonExistentError",
":",
"exists",
"=",
"false",
"\n",
"case",
"nil",
":",
"exists",
"=",
"true",
"\n",
"default",
":",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"exists",
"{",
"// If the entry already exists, everything should be",
"// the same, except for possibly additional",
"// references.",
"// We checked that both buf and the existing data hash",
"// to id, so no need to check that they're both equal.",
"if",
"isRegularPut",
"&&",
"existingServerHalf",
"!=",
"serverHalf",
"{",
"return",
"false",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"existingServerHalf",
",",
"serverHalf",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
"=",
"s",
".",
"makeDir",
"(",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"s",
".",
"dataPath",
"(",
"id",
")",
",",
"buf",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"// TODO: Add integrity-checking for key server half?",
"data",
",",
"err",
":=",
"serverHalf",
".",
"MarshalBinary",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"s",
".",
"keyServerHalfPath",
"(",
"id",
")",
",",
"data",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"!",
"exists",
",",
"nil",
"\n",
"}"
] | // put puts the given data for the block, which may already exist, and
// adds a reference for the given context. If isRegularPut is true,
// additional validity checks are performed. If err is nil, putData
// indicates whether the data didn't already exist and was put; if
// false, it means that the data already exists, but this might have
// added a new ref.
//
// For performance reasons, this method can be called concurrently by
// many goroutines for different blocks.
//
// Note that the block won't be get-able until `addReference`
// explicitly adds a tag for it. | [
"put",
"puts",
"the",
"given",
"data",
"for",
"the",
"block",
"which",
"may",
"already",
"exist",
"and",
"adds",
"a",
"reference",
"for",
"the",
"given",
"context",
".",
"If",
"isRegularPut",
"is",
"true",
"additional",
"validity",
"checks",
"are",
"performed",
".",
"If",
"err",
"is",
"nil",
"putData",
"indicates",
"whether",
"the",
"data",
"didn",
"t",
"already",
"exist",
"and",
"was",
"put",
";",
"if",
"false",
"it",
"means",
"that",
"the",
"data",
"already",
"exists",
"but",
"this",
"might",
"have",
"added",
"a",
"new",
"ref",
".",
"For",
"performance",
"reasons",
"this",
"method",
"can",
"be",
"called",
"concurrently",
"by",
"many",
"goroutines",
"for",
"different",
"blocks",
".",
"Note",
"that",
"the",
"block",
"won",
"t",
"be",
"get",
"-",
"able",
"until",
"addReference",
"explicitly",
"adds",
"a",
"tag",
"for",
"it",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L573-L638 |
158,941 | keybase/client | go/kbfs/libkbfs/block_disk_store.go | remove | func (s *blockDiskStore) remove(ctx context.Context, id kbfsblock.ID) error {
cleanup, err := s.exclusify(ctx, id)
if err != nil {
return err
}
defer cleanup()
hasAnyRef, err := s.hasAnyRefExclusive(id)
if err != nil {
return err
}
if hasAnyRef {
return errors.Errorf(
"Trying to remove data for referenced block %s", id)
}
path := s.blockPath(id)
err = ioutil.RemoveAll(path)
if err != nil {
return err
}
// Remove the parent (splayed) directory if it exists and is
// empty.
err = ioutil.Remove(filepath.Dir(path))
if ioutil.IsNotExist(err) || ioutil.IsExist(err) {
err = nil
}
return err
} | go | func (s *blockDiskStore) remove(ctx context.Context, id kbfsblock.ID) error {
cleanup, err := s.exclusify(ctx, id)
if err != nil {
return err
}
defer cleanup()
hasAnyRef, err := s.hasAnyRefExclusive(id)
if err != nil {
return err
}
if hasAnyRef {
return errors.Errorf(
"Trying to remove data for referenced block %s", id)
}
path := s.blockPath(id)
err = ioutil.RemoveAll(path)
if err != nil {
return err
}
// Remove the parent (splayed) directory if it exists and is
// empty.
err = ioutil.Remove(filepath.Dir(path))
if ioutil.IsNotExist(err) || ioutil.IsExist(err) {
err = nil
}
return err
} | [
"func",
"(",
"s",
"*",
"blockDiskStore",
")",
"remove",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"kbfsblock",
".",
"ID",
")",
"error",
"{",
"cleanup",
",",
"err",
":=",
"s",
".",
"exclusify",
"(",
"ctx",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"cleanup",
"(",
")",
"\n\n",
"hasAnyRef",
",",
"err",
":=",
"s",
".",
"hasAnyRefExclusive",
"(",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"hasAnyRef",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n",
"path",
":=",
"s",
".",
"blockPath",
"(",
"id",
")",
"\n\n",
"err",
"=",
"ioutil",
".",
"RemoveAll",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Remove the parent (splayed) directory if it exists and is",
"// empty.",
"err",
"=",
"ioutil",
".",
"Remove",
"(",
"filepath",
".",
"Dir",
"(",
"path",
")",
")",
"\n",
"if",
"ioutil",
".",
"IsNotExist",
"(",
"err",
")",
"||",
"ioutil",
".",
"IsExist",
"(",
"err",
")",
"{",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // remove removes any existing data for the given ID, which must not
// have any references left. | [
"remove",
"removes",
"any",
"existing",
"data",
"for",
"the",
"given",
"ID",
"which",
"must",
"not",
"have",
"any",
"references",
"left",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/block_disk_store.go#L728-L757 |
158,942 | keybase/client | go/chat/storage/inbox.go | getConvsForTeam | func (i *Inbox) getConvsForTeam(ctx context.Context, teamID keybase1.TeamID, convs []types.RemoteConversation) (res []*types.RemoteConversation) {
tlfID, err := chat1.TeamIDToTLFID(teamID)
if err != nil {
i.Debug(ctx, "getConvsForTeam: teamIDToTLFID failed: %v", err)
return nil
}
for i := range convs {
conv := &convs[i]
if conv.Conv.GetMembersType() == chat1.ConversationMembersType_TEAM && conv.Conv.Metadata.IdTriple.Tlfid.Eq(tlfID) {
res = append(res, conv)
}
}
return res
} | go | func (i *Inbox) getConvsForTeam(ctx context.Context, teamID keybase1.TeamID, convs []types.RemoteConversation) (res []*types.RemoteConversation) {
tlfID, err := chat1.TeamIDToTLFID(teamID)
if err != nil {
i.Debug(ctx, "getConvsForTeam: teamIDToTLFID failed: %v", err)
return nil
}
for i := range convs {
conv := &convs[i]
if conv.Conv.GetMembersType() == chat1.ConversationMembersType_TEAM && conv.Conv.Metadata.IdTriple.Tlfid.Eq(tlfID) {
res = append(res, conv)
}
}
return res
} | [
"func",
"(",
"i",
"*",
"Inbox",
")",
"getConvsForTeam",
"(",
"ctx",
"context",
".",
"Context",
",",
"teamID",
"keybase1",
".",
"TeamID",
",",
"convs",
"[",
"]",
"types",
".",
"RemoteConversation",
")",
"(",
"res",
"[",
"]",
"*",
"types",
".",
"RemoteConversation",
")",
"{",
"tlfID",
",",
"err",
":=",
"chat1",
".",
"TeamIDToTLFID",
"(",
"teamID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"i",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"convs",
"{",
"conv",
":=",
"&",
"convs",
"[",
"i",
"]",
"\n",
"if",
"conv",
".",
"Conv",
".",
"GetMembersType",
"(",
")",
"==",
"chat1",
".",
"ConversationMembersType_TEAM",
"&&",
"conv",
".",
"Conv",
".",
"Metadata",
".",
"IdTriple",
".",
"Tlfid",
".",
"Eq",
"(",
"tlfID",
")",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"conv",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // Return pointers into `convs` for the convs belonging to `teamID`. | [
"Return",
"pointers",
"into",
"convs",
"for",
"the",
"convs",
"belonging",
"to",
"teamID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/storage/inbox.go#L893-L906 |
158,943 | keybase/client | go/chat/storage/inbox.go | SetTeamRetention | func (i *Inbox) SetTeamRetention(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers,
teamID keybase1.TeamID, policy chat1.RetentionPolicy) (res []chat1.ConversationID, err Error) {
defer i.Trace(ctx, func() error { return err }, "SetTeamRetention")()
locks.Inbox.Lock()
defer locks.Inbox.Unlock()
defer i.maybeNukeFn(func() Error { return err }, i.dbKey(uid))
i.Debug(ctx, "SetTeamRetention: vers: %d teamID: %s", vers, teamID)
ibox, err := i.readDiskInbox(ctx, uid, true)
if err != nil {
if _, ok := err.(MissError); !ok {
return res, nil
}
return res, err
}
// Check inbox versions, make sure it makes sense (clear otherwise)
var cont bool
if vers, cont, err = i.handleVersion(ctx, ibox.InboxVersion, vers); !cont {
return res, err
}
// Update conversations
convs := i.getConvsForTeam(ctx, teamID, ibox.Conversations)
for _, conv := range convs {
conv.Conv.TeamRetention = &policy
conv.Conv.Metadata.Version = vers.ToConvVers()
res = append(res, conv.Conv.GetConvID())
}
// Write out to disk
ibox.InboxVersion = vers
err = i.writeDiskInbox(ctx, uid, ibox)
return res, err
} | go | func (i *Inbox) SetTeamRetention(ctx context.Context, uid gregor1.UID, vers chat1.InboxVers,
teamID keybase1.TeamID, policy chat1.RetentionPolicy) (res []chat1.ConversationID, err Error) {
defer i.Trace(ctx, func() error { return err }, "SetTeamRetention")()
locks.Inbox.Lock()
defer locks.Inbox.Unlock()
defer i.maybeNukeFn(func() Error { return err }, i.dbKey(uid))
i.Debug(ctx, "SetTeamRetention: vers: %d teamID: %s", vers, teamID)
ibox, err := i.readDiskInbox(ctx, uid, true)
if err != nil {
if _, ok := err.(MissError); !ok {
return res, nil
}
return res, err
}
// Check inbox versions, make sure it makes sense (clear otherwise)
var cont bool
if vers, cont, err = i.handleVersion(ctx, ibox.InboxVersion, vers); !cont {
return res, err
}
// Update conversations
convs := i.getConvsForTeam(ctx, teamID, ibox.Conversations)
for _, conv := range convs {
conv.Conv.TeamRetention = &policy
conv.Conv.Metadata.Version = vers.ToConvVers()
res = append(res, conv.Conv.GetConvID())
}
// Write out to disk
ibox.InboxVersion = vers
err = i.writeDiskInbox(ctx, uid, ibox)
return res, err
} | [
"func",
"(",
"i",
"*",
"Inbox",
")",
"SetTeamRetention",
"(",
"ctx",
"context",
".",
"Context",
",",
"uid",
"gregor1",
".",
"UID",
",",
"vers",
"chat1",
".",
"InboxVers",
",",
"teamID",
"keybase1",
".",
"TeamID",
",",
"policy",
"chat1",
".",
"RetentionPolicy",
")",
"(",
"res",
"[",
"]",
"chat1",
".",
"ConversationID",
",",
"err",
"Error",
")",
"{",
"defer",
"i",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"locks",
".",
"Inbox",
".",
"Lock",
"(",
")",
"\n",
"defer",
"locks",
".",
"Inbox",
".",
"Unlock",
"(",
")",
"\n",
"defer",
"i",
".",
"maybeNukeFn",
"(",
"func",
"(",
")",
"Error",
"{",
"return",
"err",
"}",
",",
"i",
".",
"dbKey",
"(",
"uid",
")",
")",
"\n\n",
"i",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"vers",
",",
"teamID",
")",
"\n",
"ibox",
",",
"err",
":=",
"i",
".",
"readDiskInbox",
"(",
"ctx",
",",
"uid",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"MissError",
")",
";",
"!",
"ok",
"{",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"// Check inbox versions, make sure it makes sense (clear otherwise)",
"var",
"cont",
"bool",
"\n",
"if",
"vers",
",",
"cont",
",",
"err",
"=",
"i",
".",
"handleVersion",
"(",
"ctx",
",",
"ibox",
".",
"InboxVersion",
",",
"vers",
")",
";",
"!",
"cont",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"// Update conversations",
"convs",
":=",
"i",
".",
"getConvsForTeam",
"(",
"ctx",
",",
"teamID",
",",
"ibox",
".",
"Conversations",
")",
"\n",
"for",
"_",
",",
"conv",
":=",
"range",
"convs",
"{",
"conv",
".",
"Conv",
".",
"TeamRetention",
"=",
"&",
"policy",
"\n",
"conv",
".",
"Conv",
".",
"Metadata",
".",
"Version",
"=",
"vers",
".",
"ToConvVers",
"(",
")",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"conv",
".",
"Conv",
".",
"GetConvID",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Write out to disk",
"ibox",
".",
"InboxVersion",
"=",
"vers",
"\n",
"err",
"=",
"i",
".",
"writeDiskInbox",
"(",
"ctx",
",",
"uid",
",",
"ibox",
")",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // Update any local conversations with this team ID. | [
"Update",
"any",
"local",
"conversations",
"with",
"this",
"team",
"ID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/storage/inbox.go#L1301-L1334 |
158,944 | keybase/client | go/kbfs/tlf/id.go | FolderType | func (t Type) FolderType() keybase1.FolderType {
switch t {
case Private:
return keybase1.FolderType_PRIVATE
case Public:
return keybase1.FolderType_PUBLIC
case SingleTeam:
return keybase1.FolderType_TEAM
default:
return keybase1.FolderType_UNKNOWN
}
} | go | func (t Type) FolderType() keybase1.FolderType {
switch t {
case Private:
return keybase1.FolderType_PRIVATE
case Public:
return keybase1.FolderType_PUBLIC
case SingleTeam:
return keybase1.FolderType_TEAM
default:
return keybase1.FolderType_UNKNOWN
}
} | [
"func",
"(",
"t",
"Type",
")",
"FolderType",
"(",
")",
"keybase1",
".",
"FolderType",
"{",
"switch",
"t",
"{",
"case",
"Private",
":",
"return",
"keybase1",
".",
"FolderType_PRIVATE",
"\n",
"case",
"Public",
":",
"return",
"keybase1",
".",
"FolderType_PUBLIC",
"\n",
"case",
"SingleTeam",
":",
"return",
"keybase1",
".",
"FolderType_TEAM",
"\n",
"default",
":",
"return",
"keybase1",
".",
"FolderType_UNKNOWN",
"\n",
"}",
"\n",
"}"
] | // FolderType returns the keybase1.FolderType corresponding to the
// given TLF type. | [
"FolderType",
"returns",
"the",
"keybase1",
".",
"FolderType",
"corresponding",
"to",
"the",
"given",
"TLF",
"type",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L88-L99 |
158,945 | keybase/client | go/kbfs/tlf/id.go | ParseTlfTypeFromPath | func ParseTlfTypeFromPath(str string) (Type, error) {
switch strings.ToLower(str) {
case strPrivate:
return Private, nil
case strPublic:
return Public, nil
case strTeam:
return SingleTeam, nil
default:
return Unknown, ErrUnknownTLFType{unknownType: str}
}
} | go | func ParseTlfTypeFromPath(str string) (Type, error) {
switch strings.ToLower(str) {
case strPrivate:
return Private, nil
case strPublic:
return Public, nil
case strTeam:
return SingleTeam, nil
default:
return Unknown, ErrUnknownTLFType{unknownType: str}
}
} | [
"func",
"ParseTlfTypeFromPath",
"(",
"str",
"string",
")",
"(",
"Type",
",",
"error",
")",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"str",
")",
"{",
"case",
"strPrivate",
":",
"return",
"Private",
",",
"nil",
"\n",
"case",
"strPublic",
":",
"return",
"Public",
",",
"nil",
"\n",
"case",
"strTeam",
":",
"return",
"SingleTeam",
",",
"nil",
"\n",
"default",
":",
"return",
"Unknown",
",",
"ErrUnknownTLFType",
"{",
"unknownType",
":",
"str",
"}",
"\n",
"}",
"\n",
"}"
] | // ParseTlfTypeFromPath parses str into a Type. | [
"ParseTlfTypeFromPath",
"parses",
"str",
"into",
"a",
"Type",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L113-L124 |
158,946 | keybase/client | go/kbfs/tlf/id.go | TypeFromFolderType | func TypeFromFolderType(ft keybase1.FolderType) Type {
switch ft {
case keybase1.FolderType_PRIVATE:
return Private
case keybase1.FolderType_PUBLIC:
return Public
case keybase1.FolderType_TEAM:
return SingleTeam
default:
return Unknown
}
} | go | func TypeFromFolderType(ft keybase1.FolderType) Type {
switch ft {
case keybase1.FolderType_PRIVATE:
return Private
case keybase1.FolderType_PUBLIC:
return Public
case keybase1.FolderType_TEAM:
return SingleTeam
default:
return Unknown
}
} | [
"func",
"TypeFromFolderType",
"(",
"ft",
"keybase1",
".",
"FolderType",
")",
"Type",
"{",
"switch",
"ft",
"{",
"case",
"keybase1",
".",
"FolderType_PRIVATE",
":",
"return",
"Private",
"\n",
"case",
"keybase1",
".",
"FolderType_PUBLIC",
":",
"return",
"Public",
"\n",
"case",
"keybase1",
".",
"FolderType_TEAM",
":",
"return",
"SingleTeam",
"\n",
"default",
":",
"return",
"Unknown",
"\n",
"}",
"\n",
"}"
] | // TypeFromFolderType returns the Type corresponding to the given
// keybase1.FolderType. | [
"TypeFromFolderType",
"returns",
"the",
"Type",
"corresponding",
"to",
"the",
"given",
"keybase1",
".",
"FolderType",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L128-L139 |
158,947 | keybase/client | go/kbfs/tlf/id.go | MarshalBinary | func (id ID) MarshalBinary() (data []byte, err error) {
suffix := id.id[idByteLen-1]
if suffix != idSuffix && suffix != pubIDSuffix &&
suffix != singleTeamIDSuffix {
return nil, errors.WithStack(InvalidIDError{id.String()})
}
return id.id[:], nil
} | go | func (id ID) MarshalBinary() (data []byte, err error) {
suffix := id.id[idByteLen-1]
if suffix != idSuffix && suffix != pubIDSuffix &&
suffix != singleTeamIDSuffix {
return nil, errors.WithStack(InvalidIDError{id.String()})
}
return id.id[:], nil
} | [
"func",
"(",
"id",
"ID",
")",
"MarshalBinary",
"(",
")",
"(",
"data",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"suffix",
":=",
"id",
".",
"id",
"[",
"idByteLen",
"-",
"1",
"]",
"\n",
"if",
"suffix",
"!=",
"idSuffix",
"&&",
"suffix",
"!=",
"pubIDSuffix",
"&&",
"suffix",
"!=",
"singleTeamIDSuffix",
"{",
"return",
"nil",
",",
"errors",
".",
"WithStack",
"(",
"InvalidIDError",
"{",
"id",
".",
"String",
"(",
")",
"}",
")",
"\n",
"}",
"\n",
"return",
"id",
".",
"id",
"[",
":",
"]",
",",
"nil",
"\n",
"}"
] | // MarshalBinary implements the encoding.BinaryMarshaler interface for ID. | [
"MarshalBinary",
"implements",
"the",
"encoding",
".",
"BinaryMarshaler",
"interface",
"for",
"ID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L201-L208 |
158,948 | keybase/client | go/kbfs/tlf/id.go | UnmarshalBinary | func (id *ID) UnmarshalBinary(data []byte) error {
if len(data) != idByteLen {
return errors.WithStack(
InvalidIDError{hex.EncodeToString(data)})
}
suffix := data[idByteLen-1]
if suffix != idSuffix && suffix != pubIDSuffix &&
suffix != singleTeamIDSuffix {
return errors.WithStack(
InvalidIDError{hex.EncodeToString(data)})
}
copy(id.id[:], data)
return nil
} | go | func (id *ID) UnmarshalBinary(data []byte) error {
if len(data) != idByteLen {
return errors.WithStack(
InvalidIDError{hex.EncodeToString(data)})
}
suffix := data[idByteLen-1]
if suffix != idSuffix && suffix != pubIDSuffix &&
suffix != singleTeamIDSuffix {
return errors.WithStack(
InvalidIDError{hex.EncodeToString(data)})
}
copy(id.id[:], data)
return nil
} | [
"func",
"(",
"id",
"*",
"ID",
")",
"UnmarshalBinary",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"data",
")",
"!=",
"idByteLen",
"{",
"return",
"errors",
".",
"WithStack",
"(",
"InvalidIDError",
"{",
"hex",
".",
"EncodeToString",
"(",
"data",
")",
"}",
")",
"\n",
"}",
"\n",
"suffix",
":=",
"data",
"[",
"idByteLen",
"-",
"1",
"]",
"\n",
"if",
"suffix",
"!=",
"idSuffix",
"&&",
"suffix",
"!=",
"pubIDSuffix",
"&&",
"suffix",
"!=",
"singleTeamIDSuffix",
"{",
"return",
"errors",
".",
"WithStack",
"(",
"InvalidIDError",
"{",
"hex",
".",
"EncodeToString",
"(",
"data",
")",
"}",
")",
"\n",
"}",
"\n",
"copy",
"(",
"id",
".",
"id",
"[",
":",
"]",
",",
"data",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface
// for ID. | [
"UnmarshalBinary",
"implements",
"the",
"encoding",
".",
"BinaryUnmarshaler",
"interface",
"for",
"ID",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L212-L225 |
158,949 | keybase/client | go/kbfs/tlf/id.go | SafeType | func (id ID) SafeType() (Type, error) {
switch id.id[idByteLen-1] {
case idSuffix:
return Private, nil
case pubIDSuffix:
return Public, nil
case singleTeamIDSuffix:
return SingleTeam, nil
default:
return Unknown, fmt.Errorf("Unknown ID suffix %x", id.id[idByteLen-1])
}
} | go | func (id ID) SafeType() (Type, error) {
switch id.id[idByteLen-1] {
case idSuffix:
return Private, nil
case pubIDSuffix:
return Public, nil
case singleTeamIDSuffix:
return SingleTeam, nil
default:
return Unknown, fmt.Errorf("Unknown ID suffix %x", id.id[idByteLen-1])
}
} | [
"func",
"(",
"id",
"ID",
")",
"SafeType",
"(",
")",
"(",
"Type",
",",
"error",
")",
"{",
"switch",
"id",
".",
"id",
"[",
"idByteLen",
"-",
"1",
"]",
"{",
"case",
"idSuffix",
":",
"return",
"Private",
",",
"nil",
"\n",
"case",
"pubIDSuffix",
":",
"return",
"Public",
",",
"nil",
"\n",
"case",
"singleTeamIDSuffix",
":",
"return",
"SingleTeam",
",",
"nil",
"\n",
"default",
":",
"return",
"Unknown",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
".",
"id",
"[",
"idByteLen",
"-",
"1",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // SafeType returns the type of TLF represented by this ID. If the ID
// isn't valid, it returns tlf.Unknown along with an error. | [
"SafeType",
"returns",
"the",
"type",
"of",
"TLF",
"represented",
"by",
"this",
"ID",
".",
"If",
"the",
"ID",
"isn",
"t",
"valid",
"it",
"returns",
"tlf",
".",
"Unknown",
"along",
"with",
"an",
"error",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L249-L260 |
158,950 | keybase/client | go/kbfs/tlf/id.go | Type | func (id ID) Type() Type {
t, err := id.SafeType()
if err != nil {
panic(err)
}
return t
} | go | func (id ID) Type() Type {
t, err := id.SafeType()
if err != nil {
panic(err)
}
return t
} | [
"func",
"(",
"id",
"ID",
")",
"Type",
"(",
")",
"Type",
"{",
"t",
",",
"err",
":=",
"id",
".",
"SafeType",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] | // Type returns the type of TLF represented by this ID.
//
// Note that this function panics if the ID suffix is unknown, rather than
// returning tlf.Unknown. | [
"Type",
"returns",
"the",
"type",
"of",
"TLF",
"represented",
"by",
"this",
"ID",
".",
"Note",
"that",
"this",
"function",
"panics",
"if",
"the",
"ID",
"suffix",
"is",
"unknown",
"rather",
"than",
"returning",
"tlf",
".",
"Unknown",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L266-L272 |
158,951 | keybase/client | go/kbfs/tlf/id.go | ParseID | func ParseID(s string) (ID, error) {
var id ID
err := id.UnmarshalText([]byte(s))
if err != nil {
return ID{}, err
}
return id, nil
} | go | func ParseID(s string) (ID, error) {
var id ID
err := id.UnmarshalText([]byte(s))
if err != nil {
return ID{}, err
}
return id, nil
} | [
"func",
"ParseID",
"(",
"s",
"string",
")",
"(",
"ID",
",",
"error",
")",
"{",
"var",
"id",
"ID",
"\n",
"err",
":=",
"id",
".",
"UnmarshalText",
"(",
"[",
"]",
"byte",
"(",
"s",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"ID",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] | // ParseID parses a hex encoded ID. Returns NullID and an
// InvalidIDError on failure. | [
"ParseID",
"parses",
"a",
"hex",
"encoded",
"ID",
".",
"Returns",
"NullID",
"and",
"an",
"InvalidIDError",
"on",
"failure",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L276-L283 |
158,952 | keybase/client | go/kbfs/tlf/id.go | MakeRandomID | func MakeRandomID(t Type) (ID, error) {
var idBytes [idByteLen]byte
err := kbfscrypto.RandRead(idBytes[:])
if err != nil {
return NullID, err
}
switch t {
case Private:
idBytes[idByteLen-1] = idSuffix
case Public:
idBytes[idByteLen-1] = pubIDSuffix
case SingleTeam:
idBytes[idByteLen-1] = singleTeamIDSuffix
default:
panic(fmt.Sprintf("Unknown TLF type %d", t))
}
var id ID
err = id.UnmarshalBinary(idBytes[:])
if err != nil {
return NullID, err
}
return id, nil
} | go | func MakeRandomID(t Type) (ID, error) {
var idBytes [idByteLen]byte
err := kbfscrypto.RandRead(idBytes[:])
if err != nil {
return NullID, err
}
switch t {
case Private:
idBytes[idByteLen-1] = idSuffix
case Public:
idBytes[idByteLen-1] = pubIDSuffix
case SingleTeam:
idBytes[idByteLen-1] = singleTeamIDSuffix
default:
panic(fmt.Sprintf("Unknown TLF type %d", t))
}
var id ID
err = id.UnmarshalBinary(idBytes[:])
if err != nil {
return NullID, err
}
return id, nil
} | [
"func",
"MakeRandomID",
"(",
"t",
"Type",
")",
"(",
"ID",
",",
"error",
")",
"{",
"var",
"idBytes",
"[",
"idByteLen",
"]",
"byte",
"\n",
"err",
":=",
"kbfscrypto",
".",
"RandRead",
"(",
"idBytes",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"NullID",
",",
"err",
"\n",
"}",
"\n",
"switch",
"t",
"{",
"case",
"Private",
":",
"idBytes",
"[",
"idByteLen",
"-",
"1",
"]",
"=",
"idSuffix",
"\n",
"case",
"Public",
":",
"idBytes",
"[",
"idByteLen",
"-",
"1",
"]",
"=",
"pubIDSuffix",
"\n",
"case",
"SingleTeam",
":",
"idBytes",
"[",
"idByteLen",
"-",
"1",
"]",
"=",
"singleTeamIDSuffix",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
")",
")",
"\n",
"}",
"\n",
"var",
"id",
"ID",
"\n",
"err",
"=",
"id",
".",
"UnmarshalBinary",
"(",
"idBytes",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"NullID",
",",
"err",
"\n",
"}",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] | // MakeRandomID makes a random ID using a cryptographically secure
// RNG. Returns NullID on failure. | [
"MakeRandomID",
"makes",
"a",
"random",
"ID",
"using",
"a",
"cryptographically",
"secure",
"RNG",
".",
"Returns",
"NullID",
"on",
"failure",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L287-L309 |
158,953 | keybase/client | go/kbfs/tlf/id.go | MakeIDFromTeam | func MakeIDFromTeam(t Type, tid keybase1.TeamID, epoch byte) (ID, error) {
idBytes := tid.ToBytes()
if len(idBytes) != idByteLen {
return NullID, errors.Errorf(
"The length of team ID %s doesn't match that of a TLF ID", tid)
}
idBytes[idByteLen-2] = epoch
switch t {
case Private:
if tid.IsPublic() {
return NullID, errors.Errorf(
"Cannot make a private TLF for a public team ID %s", tid)
}
idBytes[idByteLen-1] = idSuffix
case Public:
if !tid.IsPublic() {
return NullID, errors.Errorf(
"Cannot make a public TLF for a private team ID %s", tid)
}
idBytes[idByteLen-1] = pubIDSuffix
case SingleTeam:
if tid.IsPublic() {
return NullID, errors.Errorf(
"Cannot make a single-team TLF for a public team ID %s", tid)
}
idBytes[idByteLen-1] = singleTeamIDSuffix
default:
panic(fmt.Sprintf("Unknown TLF type %d", t))
}
var id ID
err := id.UnmarshalBinary(idBytes[:])
if err != nil {
return NullID, err
}
return id, nil
} | go | func MakeIDFromTeam(t Type, tid keybase1.TeamID, epoch byte) (ID, error) {
idBytes := tid.ToBytes()
if len(idBytes) != idByteLen {
return NullID, errors.Errorf(
"The length of team ID %s doesn't match that of a TLF ID", tid)
}
idBytes[idByteLen-2] = epoch
switch t {
case Private:
if tid.IsPublic() {
return NullID, errors.Errorf(
"Cannot make a private TLF for a public team ID %s", tid)
}
idBytes[idByteLen-1] = idSuffix
case Public:
if !tid.IsPublic() {
return NullID, errors.Errorf(
"Cannot make a public TLF for a private team ID %s", tid)
}
idBytes[idByteLen-1] = pubIDSuffix
case SingleTeam:
if tid.IsPublic() {
return NullID, errors.Errorf(
"Cannot make a single-team TLF for a public team ID %s", tid)
}
idBytes[idByteLen-1] = singleTeamIDSuffix
default:
panic(fmt.Sprintf("Unknown TLF type %d", t))
}
var id ID
err := id.UnmarshalBinary(idBytes[:])
if err != nil {
return NullID, err
}
return id, nil
} | [
"func",
"MakeIDFromTeam",
"(",
"t",
"Type",
",",
"tid",
"keybase1",
".",
"TeamID",
",",
"epoch",
"byte",
")",
"(",
"ID",
",",
"error",
")",
"{",
"idBytes",
":=",
"tid",
".",
"ToBytes",
"(",
")",
"\n",
"if",
"len",
"(",
"idBytes",
")",
"!=",
"idByteLen",
"{",
"return",
"NullID",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tid",
")",
"\n",
"}",
"\n\n",
"idBytes",
"[",
"idByteLen",
"-",
"2",
"]",
"=",
"epoch",
"\n\n",
"switch",
"t",
"{",
"case",
"Private",
":",
"if",
"tid",
".",
"IsPublic",
"(",
")",
"{",
"return",
"NullID",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tid",
")",
"\n",
"}",
"\n",
"idBytes",
"[",
"idByteLen",
"-",
"1",
"]",
"=",
"idSuffix",
"\n",
"case",
"Public",
":",
"if",
"!",
"tid",
".",
"IsPublic",
"(",
")",
"{",
"return",
"NullID",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tid",
")",
"\n",
"}",
"\n",
"idBytes",
"[",
"idByteLen",
"-",
"1",
"]",
"=",
"pubIDSuffix",
"\n",
"case",
"SingleTeam",
":",
"if",
"tid",
".",
"IsPublic",
"(",
")",
"{",
"return",
"NullID",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tid",
")",
"\n",
"}",
"\n",
"idBytes",
"[",
"idByteLen",
"-",
"1",
"]",
"=",
"singleTeamIDSuffix",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
")",
")",
"\n",
"}",
"\n",
"var",
"id",
"ID",
"\n",
"err",
":=",
"id",
".",
"UnmarshalBinary",
"(",
"idBytes",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"NullID",
",",
"err",
"\n",
"}",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] | // MakeIDFromTeam makes a deterministic TLF ID from a team ID and an epoch
// representing how many times a new TLF has been needed for this
// team. Returns NullID on failure. | [
"MakeIDFromTeam",
"makes",
"a",
"deterministic",
"TLF",
"ID",
"from",
"a",
"team",
"ID",
"and",
"an",
"epoch",
"representing",
"how",
"many",
"times",
"a",
"new",
"TLF",
"has",
"been",
"needed",
"for",
"this",
"team",
".",
"Returns",
"NullID",
"on",
"failure",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L314-L351 |
158,954 | keybase/client | go/kbfs/tlf/id.go | GetEpochFromTeamTLF | func (id ID) GetEpochFromTeamTLF(tid keybase1.TeamID) (
matches bool, epoch byte, err error) {
tidBytes := tid.ToBytes()
if len(tidBytes) != idByteLen {
return false, 0, errors.Errorf(
"The length of team ID %s doesn't match that of a TLF ID", tid)
}
epochIndex := idByteLen - 2
if !bytes.Equal(tidBytes[:epochIndex], id.id[:epochIndex]) {
return false, 0, nil
}
return true, id.id[epochIndex], nil
} | go | func (id ID) GetEpochFromTeamTLF(tid keybase1.TeamID) (
matches bool, epoch byte, err error) {
tidBytes := tid.ToBytes()
if len(tidBytes) != idByteLen {
return false, 0, errors.Errorf(
"The length of team ID %s doesn't match that of a TLF ID", tid)
}
epochIndex := idByteLen - 2
if !bytes.Equal(tidBytes[:epochIndex], id.id[:epochIndex]) {
return false, 0, nil
}
return true, id.id[epochIndex], nil
} | [
"func",
"(",
"id",
"ID",
")",
"GetEpochFromTeamTLF",
"(",
"tid",
"keybase1",
".",
"TeamID",
")",
"(",
"matches",
"bool",
",",
"epoch",
"byte",
",",
"err",
"error",
")",
"{",
"tidBytes",
":=",
"tid",
".",
"ToBytes",
"(",
")",
"\n",
"if",
"len",
"(",
"tidBytes",
")",
"!=",
"idByteLen",
"{",
"return",
"false",
",",
"0",
",",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tid",
")",
"\n",
"}",
"\n\n",
"epochIndex",
":=",
"idByteLen",
"-",
"2",
"\n",
"if",
"!",
"bytes",
".",
"Equal",
"(",
"tidBytes",
"[",
":",
"epochIndex",
"]",
",",
"id",
".",
"id",
"[",
":",
"epochIndex",
"]",
")",
"{",
"return",
"false",
",",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"id",
".",
"id",
"[",
"epochIndex",
"]",
",",
"nil",
"\n",
"}"
] | // GetEpochFromTeamTLF returns 1) whether this ID matches the given
// team TID, and 2) if so, which epoch it is. | [
"GetEpochFromTeamTLF",
"returns",
"1",
")",
"whether",
"this",
"ID",
"matches",
"the",
"given",
"team",
"TID",
"and",
"2",
")",
"if",
"so",
"which",
"epoch",
"it",
"is",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/tlf/id.go#L355-L369 |
158,955 | keybase/client | go/kbfs/libpages/config/passwords.go | GenerateSHA256PasswordHash | func GenerateSHA256PasswordHash(cleartext string) (string, error) {
salt := make([]byte, saltSize)
n, err := rand.Read(salt)
if err != nil || n != saltSize {
return "", errors.New("reading random bytes error")
}
hash := sha256.Sum256(append(salt, cleartext...))
return sha256PasswordHashPrefix + passwordHashDivider +
hex.EncodeToString(salt[:]) + passwordHashDivider +
hex.EncodeToString(hash[:]), nil
} | go | func GenerateSHA256PasswordHash(cleartext string) (string, error) {
salt := make([]byte, saltSize)
n, err := rand.Read(salt)
if err != nil || n != saltSize {
return "", errors.New("reading random bytes error")
}
hash := sha256.Sum256(append(salt, cleartext...))
return sha256PasswordHashPrefix + passwordHashDivider +
hex.EncodeToString(salt[:]) + passwordHashDivider +
hex.EncodeToString(hash[:]), nil
} | [
"func",
"GenerateSHA256PasswordHash",
"(",
"cleartext",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"salt",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"saltSize",
")",
"\n",
"n",
",",
"err",
":=",
"rand",
".",
"Read",
"(",
"salt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"n",
"!=",
"saltSize",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"hash",
":=",
"sha256",
".",
"Sum256",
"(",
"append",
"(",
"salt",
",",
"cleartext",
"...",
")",
")",
"\n",
"return",
"sha256PasswordHashPrefix",
"+",
"passwordHashDivider",
"+",
"hex",
".",
"EncodeToString",
"(",
"salt",
"[",
":",
"]",
")",
"+",
"passwordHashDivider",
"+",
"hex",
".",
"EncodeToString",
"(",
"hash",
"[",
":",
"]",
")",
",",
"nil",
"\n",
"}"
] | // GenerateSHA256PasswordHash generates a SHA256 based password hash. | [
"GenerateSHA256PasswordHash",
"generates",
"a",
"SHA256",
"based",
"password",
"hash",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libpages/config/passwords.go#L130-L141 |
158,956 | keybase/client | go/engine/sigslist.go | NewSigsList | func NewSigsList(g *libkb.GlobalContext, args SigsListArgs) *SigsList {
return &SigsList{
SigsListArgs: args,
Contextified: libkb.NewContextified(g),
}
} | go | func NewSigsList(g *libkb.GlobalContext, args SigsListArgs) *SigsList {
return &SigsList{
SigsListArgs: args,
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewSigsList",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"args",
"SigsListArgs",
")",
"*",
"SigsList",
"{",
"return",
"&",
"SigsList",
"{",
"SigsListArgs",
":",
"args",
",",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"}",
"\n",
"}"
] | // NewSigsList creates a SigsList engine. | [
"NewSigsList",
"creates",
"a",
"SigsList",
"engine",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/sigslist.go#L33-L38 |
158,957 | keybase/client | go/engine/sigslist.go | Sigs | func (e *SigsList) Sigs() []keybase1.Sig {
res := make([]keybase1.Sig, len(e.sigs))
for i, s := range e.sigs {
var key string
fp := s.GetPGPFingerprint()
if fp != nil {
key = fp.ToDisplayString(e.Verbose)
}
res[i] = keybase1.Sig{
Seqno: s.GetSeqno(),
SigIDDisplay: s.GetSigID().ToDisplayString(e.Verbose),
Type: s.Type(),
CTime: keybase1.ToTime(s.GetCTime()),
Revoked: s.IsRevoked(),
Active: e.isActiveKey(s),
Key: key,
Body: s.ToDisplayString(),
}
}
return res
} | go | func (e *SigsList) Sigs() []keybase1.Sig {
res := make([]keybase1.Sig, len(e.sigs))
for i, s := range e.sigs {
var key string
fp := s.GetPGPFingerprint()
if fp != nil {
key = fp.ToDisplayString(e.Verbose)
}
res[i] = keybase1.Sig{
Seqno: s.GetSeqno(),
SigIDDisplay: s.GetSigID().ToDisplayString(e.Verbose),
Type: s.Type(),
CTime: keybase1.ToTime(s.GetCTime()),
Revoked: s.IsRevoked(),
Active: e.isActiveKey(s),
Key: key,
Body: s.ToDisplayString(),
}
}
return res
} | [
"func",
"(",
"e",
"*",
"SigsList",
")",
"Sigs",
"(",
")",
"[",
"]",
"keybase1",
".",
"Sig",
"{",
"res",
":=",
"make",
"(",
"[",
"]",
"keybase1",
".",
"Sig",
",",
"len",
"(",
"e",
".",
"sigs",
")",
")",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"e",
".",
"sigs",
"{",
"var",
"key",
"string",
"\n",
"fp",
":=",
"s",
".",
"GetPGPFingerprint",
"(",
")",
"\n",
"if",
"fp",
"!=",
"nil",
"{",
"key",
"=",
"fp",
".",
"ToDisplayString",
"(",
"e",
".",
"Verbose",
")",
"\n",
"}",
"\n",
"res",
"[",
"i",
"]",
"=",
"keybase1",
".",
"Sig",
"{",
"Seqno",
":",
"s",
".",
"GetSeqno",
"(",
")",
",",
"SigIDDisplay",
":",
"s",
".",
"GetSigID",
"(",
")",
".",
"ToDisplayString",
"(",
"e",
".",
"Verbose",
")",
",",
"Type",
":",
"s",
".",
"Type",
"(",
")",
",",
"CTime",
":",
"keybase1",
".",
"ToTime",
"(",
"s",
".",
"GetCTime",
"(",
")",
")",
",",
"Revoked",
":",
"s",
".",
"IsRevoked",
"(",
")",
",",
"Active",
":",
"e",
".",
"isActiveKey",
"(",
"s",
")",
",",
"Key",
":",
"key",
",",
"Body",
":",
"s",
".",
"ToDisplayString",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // Sigs returns the sig list, after processing. | [
"Sigs",
"returns",
"the",
"sig",
"list",
"after",
"processing",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/sigslist.go#L80-L100 |
158,958 | keybase/client | go/libkb/skb_keyring.go | FindSecretKey | func (k *SKBKeyringFile) FindSecretKey(kids []keybase1.KID) (ret *SKB) {
k.Lock()
defer k.Unlock()
for _, kid := range kids {
if ret = k.lookupByKidLocked(kid); ret != nil {
return
}
}
return
} | go | func (k *SKBKeyringFile) FindSecretKey(kids []keybase1.KID) (ret *SKB) {
k.Lock()
defer k.Unlock()
for _, kid := range kids {
if ret = k.lookupByKidLocked(kid); ret != nil {
return
}
}
return
} | [
"func",
"(",
"k",
"*",
"SKBKeyringFile",
")",
"FindSecretKey",
"(",
"kids",
"[",
"]",
"keybase1",
".",
"KID",
")",
"(",
"ret",
"*",
"SKB",
")",
"{",
"k",
".",
"Lock",
"(",
")",
"\n",
"defer",
"k",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"kid",
":=",
"range",
"kids",
"{",
"if",
"ret",
"=",
"k",
".",
"lookupByKidLocked",
"(",
"kid",
")",
";",
"ret",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // FindSecretKey will, given a list of KIDs, find the first one in the
// list that has a corresponding secret key in the keyring file. | [
"FindSecretKey",
"will",
"given",
"a",
"list",
"of",
"KIDs",
"find",
"the",
"first",
"one",
"in",
"the",
"list",
"that",
"has",
"a",
"corresponding",
"secret",
"key",
"in",
"the",
"keyring",
"file",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/skb_keyring.go#L332-L341 |
158,959 | keybase/client | go/libkb/skb_keyring.go | WriteTo | func (k *SKBKeyringFile) WriteTo(w io.Writer) (n int64, err error) {
k.G().Log.Debug("+ SKBKeyringFile WriteTo")
defer k.G().Log.Debug("- SKBKeyringFile WriteTo")
b64 := base64.NewEncoder(base64.StdEncoding, w)
defer func() {
// explicitly check for error on Close:
if closeErr := b64.Close(); closeErr != nil {
k.G().Log.Warning("SKBKeyringFile: WriteTo b64.Close() error: %s", closeErr)
if err == nil {
n = 0
err = closeErr
return
}
}
k.G().Log.Debug("SKBKeyringFile: b64 stream closed successfully")
}()
if err := encodeSKBPacketList(k.Blocks, b64); err != nil {
k.G().Log.Warning("Encoding problem: %s", err)
return 0, err
}
return 0, nil
} | go | func (k *SKBKeyringFile) WriteTo(w io.Writer) (n int64, err error) {
k.G().Log.Debug("+ SKBKeyringFile WriteTo")
defer k.G().Log.Debug("- SKBKeyringFile WriteTo")
b64 := base64.NewEncoder(base64.StdEncoding, w)
defer func() {
// explicitly check for error on Close:
if closeErr := b64.Close(); closeErr != nil {
k.G().Log.Warning("SKBKeyringFile: WriteTo b64.Close() error: %s", closeErr)
if err == nil {
n = 0
err = closeErr
return
}
}
k.G().Log.Debug("SKBKeyringFile: b64 stream closed successfully")
}()
if err := encodeSKBPacketList(k.Blocks, b64); err != nil {
k.G().Log.Warning("Encoding problem: %s", err)
return 0, err
}
return 0, nil
} | [
"func",
"(",
"k",
"*",
"SKBKeyringFile",
")",
"WriteTo",
"(",
"w",
"io",
".",
"Writer",
")",
"(",
"n",
"int64",
",",
"err",
"error",
")",
"{",
"k",
".",
"G",
"(",
")",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"k",
".",
"G",
"(",
")",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"b64",
":=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"StdEncoding",
",",
"w",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"// explicitly check for error on Close:",
"if",
"closeErr",
":=",
"b64",
".",
"Close",
"(",
")",
";",
"closeErr",
"!=",
"nil",
"{",
"k",
".",
"G",
"(",
")",
".",
"Log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"closeErr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"n",
"=",
"0",
"\n",
"err",
"=",
"closeErr",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"k",
".",
"G",
"(",
")",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"err",
":=",
"encodeSKBPacketList",
"(",
"k",
".",
"Blocks",
",",
"b64",
")",
";",
"err",
"!=",
"nil",
"{",
"k",
".",
"G",
"(",
")",
".",
"Log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] | // WriteTo is similar to GetFilename described just above in terms of
// locking discipline. | [
"WriteTo",
"is",
"similar",
"to",
"GetFilename",
"described",
"just",
"above",
"in",
"terms",
"of",
"locking",
"discipline",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/skb_keyring.go#L374-L397 |
158,960 | keybase/client | go/client/cmd_chat_delete_history.go | parseAge | func (c *CmdChatDeleteHistory) parseAge(s string) (gregor1.DurationSec, string, error) {
generalErr := fmt.Errorf("duration must be an integer and suffix [s,h,d,w,m] like: 10d")
if len(s) < 2 {
return 0, "", generalErr
}
factor := time.Second
unitName := ""
switch s[len(s)-1] {
case 's':
factor = time.Second
unitName = "second"
case 'h':
factor = time.Hour
unitName = "hour"
case 'd':
factor = 24 * time.Hour
unitName = "day"
case 'w':
factor = 7 * 24 * time.Hour
unitName = "week"
case 'm':
factor = 30 * 24 * time.Hour
unitName = "month"
default:
return 0, "", generalErr
}
base, err := strconv.Atoi(s[:len(s)-1])
if err != nil {
return 0, "", generalErr
}
if base < 0 {
return 0, "", fmt.Errorf("age cannot be negative")
}
d := time.Duration(base) * factor
if unitName == "month" {
base *= 30
unitName = "day"
}
plural := "s"
if base == 1 {
plural = ""
}
desc := fmt.Sprintf("%v %v%v", base, unitName, plural)
return gregor1.DurationSec(d.Seconds()), desc, nil
} | go | func (c *CmdChatDeleteHistory) parseAge(s string) (gregor1.DurationSec, string, error) {
generalErr := fmt.Errorf("duration must be an integer and suffix [s,h,d,w,m] like: 10d")
if len(s) < 2 {
return 0, "", generalErr
}
factor := time.Second
unitName := ""
switch s[len(s)-1] {
case 's':
factor = time.Second
unitName = "second"
case 'h':
factor = time.Hour
unitName = "hour"
case 'd':
factor = 24 * time.Hour
unitName = "day"
case 'w':
factor = 7 * 24 * time.Hour
unitName = "week"
case 'm':
factor = 30 * 24 * time.Hour
unitName = "month"
default:
return 0, "", generalErr
}
base, err := strconv.Atoi(s[:len(s)-1])
if err != nil {
return 0, "", generalErr
}
if base < 0 {
return 0, "", fmt.Errorf("age cannot be negative")
}
d := time.Duration(base) * factor
if unitName == "month" {
base *= 30
unitName = "day"
}
plural := "s"
if base == 1 {
plural = ""
}
desc := fmt.Sprintf("%v %v%v", base, unitName, plural)
return gregor1.DurationSec(d.Seconds()), desc, nil
} | [
"func",
"(",
"c",
"*",
"CmdChatDeleteHistory",
")",
"parseAge",
"(",
"s",
"string",
")",
"(",
"gregor1",
".",
"DurationSec",
",",
"string",
",",
"error",
")",
"{",
"generalErr",
":=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"s",
")",
"<",
"2",
"{",
"return",
"0",
",",
"\"",
"\"",
",",
"generalErr",
"\n",
"}",
"\n",
"factor",
":=",
"time",
".",
"Second",
"\n",
"unitName",
":=",
"\"",
"\"",
"\n",
"switch",
"s",
"[",
"len",
"(",
"s",
")",
"-",
"1",
"]",
"{",
"case",
"'s'",
":",
"factor",
"=",
"time",
".",
"Second",
"\n",
"unitName",
"=",
"\"",
"\"",
"\n",
"case",
"'h'",
":",
"factor",
"=",
"time",
".",
"Hour",
"\n",
"unitName",
"=",
"\"",
"\"",
"\n",
"case",
"'d'",
":",
"factor",
"=",
"24",
"*",
"time",
".",
"Hour",
"\n",
"unitName",
"=",
"\"",
"\"",
"\n",
"case",
"'w'",
":",
"factor",
"=",
"7",
"*",
"24",
"*",
"time",
".",
"Hour",
"\n",
"unitName",
"=",
"\"",
"\"",
"\n",
"case",
"'m'",
":",
"factor",
"=",
"30",
"*",
"24",
"*",
"time",
".",
"Hour",
"\n",
"unitName",
"=",
"\"",
"\"",
"\n",
"default",
":",
"return",
"0",
",",
"\"",
"\"",
",",
"generalErr",
"\n",
"}",
"\n",
"base",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"s",
"[",
":",
"len",
"(",
"s",
")",
"-",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"\"",
"\"",
",",
"generalErr",
"\n",
"}",
"\n",
"if",
"base",
"<",
"0",
"{",
"return",
"0",
",",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"d",
":=",
"time",
".",
"Duration",
"(",
"base",
")",
"*",
"factor",
"\n",
"if",
"unitName",
"==",
"\"",
"\"",
"{",
"base",
"*=",
"30",
"\n",
"unitName",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"plural",
":=",
"\"",
"\"",
"\n",
"if",
"base",
"==",
"1",
"{",
"plural",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"desc",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"base",
",",
"unitName",
",",
"plural",
")",
"\n",
"return",
"gregor1",
".",
"DurationSec",
"(",
"d",
".",
"Seconds",
"(",
")",
")",
",",
"desc",
",",
"nil",
"\n",
"}"
] | // Returns a duration and English string like "2 days". | [
"Returns",
"a",
"duration",
"and",
"English",
"string",
"like",
"2",
"days",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_chat_delete_history.go#L110-L154 |
158,961 | keybase/client | go/client/cmd_chat_delete_history.go | chatSendDeleteHistory | func (c *CmdChatDeleteHistory) chatSendDeleteHistory(ctx context.Context) error {
resolver, err := newChatConversationResolver(c.G())
if err != nil {
return err
}
conversation, _, err := resolver.Resolve(ctx, c.resolvingRequest, chatConversationResolvingBehavior{
CreateIfNotExists: false,
MustNotExist: false,
Interactive: c.hasTTY,
IdentifyBehavior: keybase1.TLFIdentifyBehavior_CHAT_CLI,
})
if err != nil {
return err
}
conversationInfo := conversation.Info
arg := chat1.PostDeleteHistoryByAgeArg{
ConversationID: conversationInfo.Id,
TlfName: conversationInfo.TlfName,
TlfPublic: (conversationInfo.Visibility == keybase1.TLFVisibility_PUBLIC),
IdentifyBehavior: keybase1.TLFIdentifyBehavior_CHAT_CLI,
Age: c.age,
}
chatFullName := conversationInfo.TlfName
if conversationInfo.TopicName != "" {
chatFullName = fmt.Sprintf("%s#%s", conversationInfo.TlfName, conversationInfo.TopicName)
}
// Ask for confirmation on this destructive operation.
promptText := fmt.Sprintf("Permanently delete ALL chat history of [%s]?\nHit Enter to confirm, or Ctrl-C to cancel.", chatFullName)
if c.age != gregor1.DurationSec(0) {
promptText = fmt.Sprintf("Permanently delete all chat messages in [%s] older than %v?\nHit Enter to confirm, or Ctrl-C to cancel.",
chatFullName, c.ageDesc)
}
_, err = c.G().UI.GetTerminalUI().Prompt(PromptDescriptorChatDeleteHistory, promptText)
if err != nil {
return err
}
_, err = resolver.ChatClient.PostDeleteHistoryByAge(ctx, arg)
return err
} | go | func (c *CmdChatDeleteHistory) chatSendDeleteHistory(ctx context.Context) error {
resolver, err := newChatConversationResolver(c.G())
if err != nil {
return err
}
conversation, _, err := resolver.Resolve(ctx, c.resolvingRequest, chatConversationResolvingBehavior{
CreateIfNotExists: false,
MustNotExist: false,
Interactive: c.hasTTY,
IdentifyBehavior: keybase1.TLFIdentifyBehavior_CHAT_CLI,
})
if err != nil {
return err
}
conversationInfo := conversation.Info
arg := chat1.PostDeleteHistoryByAgeArg{
ConversationID: conversationInfo.Id,
TlfName: conversationInfo.TlfName,
TlfPublic: (conversationInfo.Visibility == keybase1.TLFVisibility_PUBLIC),
IdentifyBehavior: keybase1.TLFIdentifyBehavior_CHAT_CLI,
Age: c.age,
}
chatFullName := conversationInfo.TlfName
if conversationInfo.TopicName != "" {
chatFullName = fmt.Sprintf("%s#%s", conversationInfo.TlfName, conversationInfo.TopicName)
}
// Ask for confirmation on this destructive operation.
promptText := fmt.Sprintf("Permanently delete ALL chat history of [%s]?\nHit Enter to confirm, or Ctrl-C to cancel.", chatFullName)
if c.age != gregor1.DurationSec(0) {
promptText = fmt.Sprintf("Permanently delete all chat messages in [%s] older than %v?\nHit Enter to confirm, or Ctrl-C to cancel.",
chatFullName, c.ageDesc)
}
_, err = c.G().UI.GetTerminalUI().Prompt(PromptDescriptorChatDeleteHistory, promptText)
if err != nil {
return err
}
_, err = resolver.ChatClient.PostDeleteHistoryByAge(ctx, arg)
return err
} | [
"func",
"(",
"c",
"*",
"CmdChatDeleteHistory",
")",
"chatSendDeleteHistory",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"resolver",
",",
"err",
":=",
"newChatConversationResolver",
"(",
"c",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"conversation",
",",
"_",
",",
"err",
":=",
"resolver",
".",
"Resolve",
"(",
"ctx",
",",
"c",
".",
"resolvingRequest",
",",
"chatConversationResolvingBehavior",
"{",
"CreateIfNotExists",
":",
"false",
",",
"MustNotExist",
":",
"false",
",",
"Interactive",
":",
"c",
".",
"hasTTY",
",",
"IdentifyBehavior",
":",
"keybase1",
".",
"TLFIdentifyBehavior_CHAT_CLI",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conversationInfo",
":=",
"conversation",
".",
"Info",
"\n\n",
"arg",
":=",
"chat1",
".",
"PostDeleteHistoryByAgeArg",
"{",
"ConversationID",
":",
"conversationInfo",
".",
"Id",
",",
"TlfName",
":",
"conversationInfo",
".",
"TlfName",
",",
"TlfPublic",
":",
"(",
"conversationInfo",
".",
"Visibility",
"==",
"keybase1",
".",
"TLFVisibility_PUBLIC",
")",
",",
"IdentifyBehavior",
":",
"keybase1",
".",
"TLFIdentifyBehavior_CHAT_CLI",
",",
"Age",
":",
"c",
".",
"age",
",",
"}",
"\n\n",
"chatFullName",
":=",
"conversationInfo",
".",
"TlfName",
"\n",
"if",
"conversationInfo",
".",
"TopicName",
"!=",
"\"",
"\"",
"{",
"chatFullName",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"conversationInfo",
".",
"TlfName",
",",
"conversationInfo",
".",
"TopicName",
")",
"\n",
"}",
"\n\n",
"// Ask for confirmation on this destructive operation.",
"promptText",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"chatFullName",
")",
"\n",
"if",
"c",
".",
"age",
"!=",
"gregor1",
".",
"DurationSec",
"(",
"0",
")",
"{",
"promptText",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"chatFullName",
",",
"c",
".",
"ageDesc",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"G",
"(",
")",
".",
"UI",
".",
"GetTerminalUI",
"(",
")",
".",
"Prompt",
"(",
"PromptDescriptorChatDeleteHistory",
",",
"promptText",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"resolver",
".",
"ChatClient",
".",
"PostDeleteHistoryByAge",
"(",
"ctx",
",",
"arg",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Like chatSend but uses PostDeleteHistoryByAge. | [
"Like",
"chatSend",
"but",
"uses",
"PostDeleteHistoryByAge",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/client/cmd_chat_delete_history.go#L157-L200 |
158,962 | keybase/client | go/libkb/link_cache.go | NewLinkCache | func NewLinkCache(maxSize int, cleanDur time.Duration) *LinkCache {
c := &LinkCache{
cache: make(map[linkIDFixed]*list.Element),
done: make(chan struct{}),
maxSize: maxSize,
cleanWait: cleanDur,
accessOrder: list.New(),
}
go c.periodic()
return c
} | go | func NewLinkCache(maxSize int, cleanDur time.Duration) *LinkCache {
c := &LinkCache{
cache: make(map[linkIDFixed]*list.Element),
done: make(chan struct{}),
maxSize: maxSize,
cleanWait: cleanDur,
accessOrder: list.New(),
}
go c.periodic()
return c
} | [
"func",
"NewLinkCache",
"(",
"maxSize",
"int",
",",
"cleanDur",
"time",
".",
"Duration",
")",
"*",
"LinkCache",
"{",
"c",
":=",
"&",
"LinkCache",
"{",
"cache",
":",
"make",
"(",
"map",
"[",
"linkIDFixed",
"]",
"*",
"list",
".",
"Element",
")",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"maxSize",
":",
"maxSize",
",",
"cleanWait",
":",
"cleanDur",
",",
"accessOrder",
":",
"list",
".",
"New",
"(",
")",
",",
"}",
"\n",
"go",
"c",
".",
"periodic",
"(",
")",
"\n",
"return",
"c",
"\n",
"}"
] | // NewLinkCache creates a LinkCache. When finished using this
// LinkCache, call Shutdown on it to clean up. | [
"NewLinkCache",
"creates",
"a",
"LinkCache",
".",
"When",
"finished",
"using",
"this",
"LinkCache",
"call",
"Shutdown",
"on",
"it",
"to",
"clean",
"up",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/link_cache.go#L32-L42 |
158,963 | keybase/client | go/libkb/link_cache.go | Get | func (c *LinkCache) Get(id LinkID) (link ChainLink, ok bool) {
c.Lock()
defer c.Unlock()
var linkID linkIDFixed
copy(linkID[:], id)
elt, ok := c.cache[linkID]
if ok {
link, ok := elt.Value.(ChainLink)
if !ok {
panic(fmt.Sprintf("invalid type in cache: %T", elt))
}
// move the element to the back (most recently accessed)
c.accessOrder.MoveToBack(elt)
return link.Copy(), true
}
return link, false
} | go | func (c *LinkCache) Get(id LinkID) (link ChainLink, ok bool) {
c.Lock()
defer c.Unlock()
var linkID linkIDFixed
copy(linkID[:], id)
elt, ok := c.cache[linkID]
if ok {
link, ok := elt.Value.(ChainLink)
if !ok {
panic(fmt.Sprintf("invalid type in cache: %T", elt))
}
// move the element to the back (most recently accessed)
c.accessOrder.MoveToBack(elt)
return link.Copy(), true
}
return link, false
} | [
"func",
"(",
"c",
"*",
"LinkCache",
")",
"Get",
"(",
"id",
"LinkID",
")",
"(",
"link",
"ChainLink",
",",
"ok",
"bool",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"var",
"linkID",
"linkIDFixed",
"\n",
"copy",
"(",
"linkID",
"[",
":",
"]",
",",
"id",
")",
"\n",
"elt",
",",
"ok",
":=",
"c",
".",
"cache",
"[",
"linkID",
"]",
"\n",
"if",
"ok",
"{",
"link",
",",
"ok",
":=",
"elt",
".",
"Value",
".",
"(",
"ChainLink",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"elt",
")",
")",
"\n",
"}",
"\n",
"// move the element to the back (most recently accessed)",
"c",
".",
"accessOrder",
".",
"MoveToBack",
"(",
"elt",
")",
"\n",
"return",
"link",
".",
"Copy",
"(",
")",
",",
"true",
"\n",
"}",
"\n",
"return",
"link",
",",
"false",
"\n",
"}"
] | // Get retrieves a ChainLink from the cache. If nothing
// exists for this LinkID, it will return false for ok. | [
"Get",
"retrieves",
"a",
"ChainLink",
"from",
"the",
"cache",
".",
"If",
"nothing",
"exists",
"for",
"this",
"LinkID",
"it",
"will",
"return",
"false",
"for",
"ok",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/link_cache.go#L46-L62 |
158,964 | keybase/client | go/libkb/link_cache.go | Remove | func (c *LinkCache) Remove(id LinkID) {
c.Lock()
defer c.Unlock()
var linkID linkIDFixed
copy(linkID[:], id)
elt, ok := c.cache[linkID]
if ok {
c.accessOrder.Remove(elt)
}
delete(c.cache, linkID)
} | go | func (c *LinkCache) Remove(id LinkID) {
c.Lock()
defer c.Unlock()
var linkID linkIDFixed
copy(linkID[:], id)
elt, ok := c.cache[linkID]
if ok {
c.accessOrder.Remove(elt)
}
delete(c.cache, linkID)
} | [
"func",
"(",
"c",
"*",
"LinkCache",
")",
"Remove",
"(",
"id",
"LinkID",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"var",
"linkID",
"linkIDFixed",
"\n",
"copy",
"(",
"linkID",
"[",
":",
"]",
",",
"id",
")",
"\n",
"elt",
",",
"ok",
":=",
"c",
".",
"cache",
"[",
"linkID",
"]",
"\n",
"if",
"ok",
"{",
"c",
".",
"accessOrder",
".",
"Remove",
"(",
"elt",
")",
"\n",
"}",
"\n",
"delete",
"(",
"c",
".",
"cache",
",",
"linkID",
")",
"\n",
"}"
] | // Remove deletes a ChainLink from the cache. | [
"Remove",
"deletes",
"a",
"ChainLink",
"from",
"the",
"cache",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/link_cache.go#L96-L106 |
158,965 | keybase/client | go/libkb/link_cache.go | Len | func (c *LinkCache) Len() int {
c.Lock()
defer c.Unlock()
return len(c.cache)
} | go | func (c *LinkCache) Len() int {
c.Lock()
defer c.Unlock()
return len(c.cache)
} | [
"func",
"(",
"c",
"*",
"LinkCache",
")",
"Len",
"(",
")",
"int",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"return",
"len",
"(",
"c",
".",
"cache",
")",
"\n",
"}"
] | // Len returns the number of ChainLinks cached. | [
"Len",
"returns",
"the",
"number",
"of",
"ChainLinks",
"cached",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/libkb/link_cache.go#L109-L113 |
158,966 | keybase/client | go/engine/favorite_ignore.go | NewFavoriteIgnore | func NewFavoriteIgnore(g *libkb.GlobalContext, arg *keybase1.FavoriteIgnoreArg) *FavoriteIgnore {
return &FavoriteIgnore{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | go | func NewFavoriteIgnore(g *libkb.GlobalContext, arg *keybase1.FavoriteIgnoreArg) *FavoriteIgnore {
return &FavoriteIgnore{
arg: arg,
Contextified: libkb.NewContextified(g),
}
} | [
"func",
"NewFavoriteIgnore",
"(",
"g",
"*",
"libkb",
".",
"GlobalContext",
",",
"arg",
"*",
"keybase1",
".",
"FavoriteIgnoreArg",
")",
"*",
"FavoriteIgnore",
"{",
"return",
"&",
"FavoriteIgnore",
"{",
"arg",
":",
"arg",
",",
"Contextified",
":",
"libkb",
".",
"NewContextified",
"(",
"g",
")",
",",
"}",
"\n",
"}"
] | // NewFavoriteIgnore creates a FavoriteIgnore engine. | [
"NewFavoriteIgnore",
"creates",
"a",
"FavoriteIgnore",
"engine",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/engine/favorite_ignore.go#L20-L25 |
158,967 | keybase/client | go/protocol/gregor1/factory.go | Less | func (its itemSlice) Less(i, j int) bool {
mI, mJ := its[i].Metadata(), its[j].Metadata()
if mI != nil && mJ != nil {
if mI.CTime().Equal(mJ.CTime()) {
if mI.MsgID() != nil && mJ.MsgID() != nil {
return bytes.Compare(mI.MsgID().Bytes(), mJ.MsgID().Bytes()) < 0
} else {
return mI.MsgID() == nil
}
}
return mI.CTime().Before(mJ.CTime())
}
return mI == nil
} | go | func (its itemSlice) Less(i, j int) bool {
mI, mJ := its[i].Metadata(), its[j].Metadata()
if mI != nil && mJ != nil {
if mI.CTime().Equal(mJ.CTime()) {
if mI.MsgID() != nil && mJ.MsgID() != nil {
return bytes.Compare(mI.MsgID().Bytes(), mJ.MsgID().Bytes()) < 0
} else {
return mI.MsgID() == nil
}
}
return mI.CTime().Before(mJ.CTime())
}
return mI == nil
} | [
"func",
"(",
"its",
"itemSlice",
")",
"Less",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"mI",
",",
"mJ",
":=",
"its",
"[",
"i",
"]",
".",
"Metadata",
"(",
")",
",",
"its",
"[",
"j",
"]",
".",
"Metadata",
"(",
")",
"\n",
"if",
"mI",
"!=",
"nil",
"&&",
"mJ",
"!=",
"nil",
"{",
"if",
"mI",
".",
"CTime",
"(",
")",
".",
"Equal",
"(",
"mJ",
".",
"CTime",
"(",
")",
")",
"{",
"if",
"mI",
".",
"MsgID",
"(",
")",
"!=",
"nil",
"&&",
"mJ",
".",
"MsgID",
"(",
")",
"!=",
"nil",
"{",
"return",
"bytes",
".",
"Compare",
"(",
"mI",
".",
"MsgID",
"(",
")",
".",
"Bytes",
"(",
")",
",",
"mJ",
".",
"MsgID",
"(",
")",
".",
"Bytes",
"(",
")",
")",
"<",
"0",
"\n",
"}",
"else",
"{",
"return",
"mI",
".",
"MsgID",
"(",
")",
"==",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"mI",
".",
"CTime",
"(",
")",
".",
"Before",
"(",
"mJ",
".",
"CTime",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"mI",
"==",
"nil",
"\n",
"}"
] | // Less returns true if i's ctime is before j's, or if they're equal and
// i's MsgID is lexicographically before j's. | [
"Less",
"returns",
"true",
"if",
"i",
"s",
"ctime",
"is",
"before",
"j",
"s",
"or",
"if",
"they",
"re",
"equal",
"and",
"i",
"s",
"MsgID",
"is",
"lexicographically",
"before",
"j",
"s",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/protocol/gregor1/factory.go#L189-L202 |
158,968 | keybase/client | go/kbfs/libdokan/dir.go | isNoSuchNameError | func isNoSuchNameError(err error) bool {
_, ok := err.(idutil.NoSuchNameError)
return ok
} | go | func isNoSuchNameError(err error) bool {
_, ok := err.(idutil.NoSuchNameError)
return ok
} | [
"func",
"isNoSuchNameError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"idutil",
".",
"NoSuchNameError",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // isNoSuchNameError checks for libkbfs.NoSuchNameError. | [
"isNoSuchNameError",
"checks",
"for",
"libkbfs",
".",
"NoSuchNameError",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/dir.go#L272-L275 |
158,969 | keybase/client | go/kbfs/libdokan/dir.go | isSafeFolder | func isSafeFolder(ctx context.Context, f *Folder) bool {
return libkbfs.IsOnlyWriterInNonTeamTlf(ctx, f.list.fs.config.KBPKI(), f.h)
} | go | func isSafeFolder(ctx context.Context, f *Folder) bool {
return libkbfs.IsOnlyWriterInNonTeamTlf(ctx, f.list.fs.config.KBPKI(), f.h)
} | [
"func",
"isSafeFolder",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
"*",
"Folder",
")",
"bool",
"{",
"return",
"libkbfs",
".",
"IsOnlyWriterInNonTeamTlf",
"(",
"ctx",
",",
"f",
".",
"list",
".",
"fs",
".",
"config",
".",
"KBPKI",
"(",
")",
",",
"f",
".",
"h",
")",
"\n",
"}"
] | // isSafeFolder returns whether a Folder is considered safe. | [
"isSafeFolder",
"returns",
"whether",
"a",
"Folder",
"is",
"considered",
"safe",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libdokan/dir.go#L286-L288 |
158,970 | keybase/client | go/chat/active.go | TouchFirstChatActiveQueryTime | func TouchFirstChatActiveQueryTime(ctx context.Context, g *globals.Context, log utils.DebugLabeler) time.Time {
now := time.Now()
var firstQueryUnixTime int64
found, err := g.LocalChatDb.GetInto(&firstQueryUnixTime, firstQueryTimeDbKey())
// Warn for errors and bail.
if err != nil {
log.Debug(ctx, "Failed to get chat active query time: %s", err)
return now
}
// If the first query time doesn't exist, store Now(). Don't return Now()
// directly, though, since that has extra metadata in it what won't be
// there when we deserialize from the db.
if !found {
log.Debug(ctx, "Chat active query time not found. Storing current time.")
firstQueryUnixTime = now.Unix()
err := g.LocalChatDb.PutObj(firstQueryTimeDbKey(), nil, firstQueryUnixTime)
if err != nil {
log.Debug(ctx, "Failed to store chat active query time: %s", err)
}
}
// Otherwise return what we found.
return time.Unix(firstQueryUnixTime, 0)
} | go | func TouchFirstChatActiveQueryTime(ctx context.Context, g *globals.Context, log utils.DebugLabeler) time.Time {
now := time.Now()
var firstQueryUnixTime int64
found, err := g.LocalChatDb.GetInto(&firstQueryUnixTime, firstQueryTimeDbKey())
// Warn for errors and bail.
if err != nil {
log.Debug(ctx, "Failed to get chat active query time: %s", err)
return now
}
// If the first query time doesn't exist, store Now(). Don't return Now()
// directly, though, since that has extra metadata in it what won't be
// there when we deserialize from the db.
if !found {
log.Debug(ctx, "Chat active query time not found. Storing current time.")
firstQueryUnixTime = now.Unix()
err := g.LocalChatDb.PutObj(firstQueryTimeDbKey(), nil, firstQueryUnixTime)
if err != nil {
log.Debug(ctx, "Failed to store chat active query time: %s", err)
}
}
// Otherwise return what we found.
return time.Unix(firstQueryUnixTime, 0)
} | [
"func",
"TouchFirstChatActiveQueryTime",
"(",
"ctx",
"context",
".",
"Context",
",",
"g",
"*",
"globals",
".",
"Context",
",",
"log",
"utils",
".",
"DebugLabeler",
")",
"time",
".",
"Time",
"{",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"var",
"firstQueryUnixTime",
"int64",
"\n",
"found",
",",
"err",
":=",
"g",
".",
"LocalChatDb",
".",
"GetInto",
"(",
"&",
"firstQueryUnixTime",
",",
"firstQueryTimeDbKey",
"(",
")",
")",
"\n",
"// Warn for errors and bail.",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"now",
"\n",
"}",
"\n",
"// If the first query time doesn't exist, store Now(). Don't return Now()",
"// directly, though, since that has extra metadata in it what won't be",
"// there when we deserialize from the db.",
"if",
"!",
"found",
"{",
"log",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n",
"firstQueryUnixTime",
"=",
"now",
".",
"Unix",
"(",
")",
"\n",
"err",
":=",
"g",
".",
"LocalChatDb",
".",
"PutObj",
"(",
"firstQueryTimeDbKey",
"(",
")",
",",
"nil",
",",
"firstQueryUnixTime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// Otherwise return what we found.",
"return",
"time",
".",
"Unix",
"(",
"firstQueryUnixTime",
",",
"0",
")",
"\n",
"}"
] | // If no first query time is found in the local db, this function writes the
// current time. | [
"If",
"no",
"first",
"query",
"time",
"is",
"found",
"in",
"the",
"local",
"db",
"this",
"function",
"writes",
"the",
"current",
"time",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/active.go#L33-L55 |
158,971 | keybase/client | go/chat/server.go | GetInboxAndUnboxLocal | func (h *Server) GetInboxAndUnboxLocal(ctx context.Context, arg chat1.GetInboxAndUnboxLocalArg) (res chat1.GetInboxAndUnboxLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
if arg.Query != nil && arg.Query.TopicType != nil && *arg.Query.TopicType != chat1.TopicType_CHAT {
// make this cancelable for things like KBFS file edit convs
ctx = globals.CtxAddLocalizerCancelable(ctx)
}
defer h.Trace(ctx, func() error { return err }, "GetInboxAndUnboxLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
defer func() { err = h.handleOfflineError(ctx, err, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
// Read inbox from the source
ib, _, err := h.G().InboxSource.Read(ctx, uid, types.ConversationLocalizerBlocking,
types.InboxSourceDataSourceAll, nil, arg.Query, arg.Pagination)
if err != nil {
if _, ok := err.(UnknownTLFNameError); ok {
h.Debug(ctx, "GetInboxAndUnboxLocal: got unknown TLF name error, returning blank results")
ib.Convs = nil
ib.Pagination = nil
} else {
return res, err
}
}
return chat1.GetInboxAndUnboxLocalRes{
Conversations: ib.Convs,
Pagination: ib.Pagination,
Offline: h.G().InboxSource.IsOffline(ctx),
IdentifyFailures: identBreaks,
}, nil
} | go | func (h *Server) GetInboxAndUnboxLocal(ctx context.Context, arg chat1.GetInboxAndUnboxLocalArg) (res chat1.GetInboxAndUnboxLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
if arg.Query != nil && arg.Query.TopicType != nil && *arg.Query.TopicType != chat1.TopicType_CHAT {
// make this cancelable for things like KBFS file edit convs
ctx = globals.CtxAddLocalizerCancelable(ctx)
}
defer h.Trace(ctx, func() error { return err }, "GetInboxAndUnboxLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
defer func() { err = h.handleOfflineError(ctx, err, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
// Read inbox from the source
ib, _, err := h.G().InboxSource.Read(ctx, uid, types.ConversationLocalizerBlocking,
types.InboxSourceDataSourceAll, nil, arg.Query, arg.Pagination)
if err != nil {
if _, ok := err.(UnknownTLFNameError); ok {
h.Debug(ctx, "GetInboxAndUnboxLocal: got unknown TLF name error, returning blank results")
ib.Convs = nil
ib.Pagination = nil
} else {
return res, err
}
}
return chat1.GetInboxAndUnboxLocalRes{
Conversations: ib.Convs,
Pagination: ib.Pagination,
Offline: h.G().InboxSource.IsOffline(ctx),
IdentifyFailures: identBreaks,
}, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"GetInboxAndUnboxLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"GetInboxAndUnboxLocalArg",
")",
"(",
"res",
"chat1",
".",
"GetInboxAndUnboxLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"if",
"arg",
".",
"Query",
"!=",
"nil",
"&&",
"arg",
".",
"Query",
".",
"TopicType",
"!=",
"nil",
"&&",
"*",
"arg",
".",
"Query",
".",
"TopicType",
"!=",
"chat1",
".",
"TopicType_CHAT",
"{",
"// make this cancelable for things like KBFS file edit convs",
"ctx",
"=",
"globals",
".",
"CtxAddLocalizerCancelable",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"err",
"=",
"h",
".",
"handleOfflineError",
"(",
"ctx",
",",
"err",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"// Read inbox from the source",
"ib",
",",
"_",
",",
"err",
":=",
"h",
".",
"G",
"(",
")",
".",
"InboxSource",
".",
"Read",
"(",
"ctx",
",",
"uid",
",",
"types",
".",
"ConversationLocalizerBlocking",
",",
"types",
".",
"InboxSourceDataSourceAll",
",",
"nil",
",",
"arg",
".",
"Query",
",",
"arg",
".",
"Pagination",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"UnknownTLFNameError",
")",
";",
"ok",
"{",
"h",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
")",
"\n",
"ib",
".",
"Convs",
"=",
"nil",
"\n",
"ib",
".",
"Pagination",
"=",
"nil",
"\n",
"}",
"else",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"chat1",
".",
"GetInboxAndUnboxLocalRes",
"{",
"Conversations",
":",
"ib",
".",
"Convs",
",",
"Pagination",
":",
"ib",
".",
"Pagination",
",",
"Offline",
":",
"h",
".",
"G",
"(",
")",
".",
"InboxSource",
".",
"IsOffline",
"(",
"ctx",
")",
",",
"IdentifyFailures",
":",
"identBreaks",
",",
"}",
",",
"nil",
"\n",
"}"
] | // GetInboxAndUnboxLocal implements keybase.chatLocal.getInboxAndUnboxLocal protocol. | [
"GetInboxAndUnboxLocal",
"implements",
"keybase",
".",
"chatLocal",
".",
"getInboxAndUnboxLocal",
"protocol",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L384-L418 |
158,972 | keybase/client | go/chat/server.go | GetThreadLocal | func (h *Server) GetThreadLocal(ctx context.Context, arg chat1.GetThreadLocalArg) (res chat1.GetThreadLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "GetThreadLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
defer func() { err = h.handleOfflineError(ctx, err, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return chat1.GetThreadLocalRes{}, err
}
// Xlate pager control into pagination if given
if arg.Query != nil && arg.Query.MessageIDControl != nil {
arg.Pagination = h.messageIDControlToPagination(ctx, uid, arg.ConversationID,
*arg.Query.MessageIDControl)
}
// Get messages from the source
thread, err := h.G().ConvSource.Pull(ctx, arg.ConversationID, uid,
arg.Reason, arg.Query, arg.Pagination)
if err != nil {
return chat1.GetThreadLocalRes{}, err
}
return chat1.GetThreadLocalRes{
Thread: thread,
IdentifyFailures: identBreaks,
}, nil
} | go | func (h *Server) GetThreadLocal(ctx context.Context, arg chat1.GetThreadLocalArg) (res chat1.GetThreadLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "GetThreadLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
defer func() { err = h.handleOfflineError(ctx, err, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return chat1.GetThreadLocalRes{}, err
}
// Xlate pager control into pagination if given
if arg.Query != nil && arg.Query.MessageIDControl != nil {
arg.Pagination = h.messageIDControlToPagination(ctx, uid, arg.ConversationID,
*arg.Query.MessageIDControl)
}
// Get messages from the source
thread, err := h.G().ConvSource.Pull(ctx, arg.ConversationID, uid,
arg.Reason, arg.Query, arg.Pagination)
if err != nil {
return chat1.GetThreadLocalRes{}, err
}
return chat1.GetThreadLocalRes{
Thread: thread,
IdentifyFailures: identBreaks,
}, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"GetThreadLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"GetThreadLocalArg",
")",
"(",
"res",
"chat1",
".",
"GetThreadLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"err",
"=",
"h",
".",
"handleOfflineError",
"(",
"ctx",
",",
"err",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"chat1",
".",
"GetThreadLocalRes",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"// Xlate pager control into pagination if given",
"if",
"arg",
".",
"Query",
"!=",
"nil",
"&&",
"arg",
".",
"Query",
".",
"MessageIDControl",
"!=",
"nil",
"{",
"arg",
".",
"Pagination",
"=",
"h",
".",
"messageIDControlToPagination",
"(",
"ctx",
",",
"uid",
",",
"arg",
".",
"ConversationID",
",",
"*",
"arg",
".",
"Query",
".",
"MessageIDControl",
")",
"\n",
"}",
"\n\n",
"// Get messages from the source",
"thread",
",",
"err",
":=",
"h",
".",
"G",
"(",
")",
".",
"ConvSource",
".",
"Pull",
"(",
"ctx",
",",
"arg",
".",
"ConversationID",
",",
"uid",
",",
"arg",
".",
"Reason",
",",
"arg",
".",
"Query",
",",
"arg",
".",
"Pagination",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"chat1",
".",
"GetThreadLocalRes",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"chat1",
".",
"GetThreadLocalRes",
"{",
"Thread",
":",
"thread",
",",
"IdentifyFailures",
":",
"identBreaks",
",",
"}",
",",
"nil",
"\n",
"}"
] | // GetThreadLocal implements keybase.chatLocal.getThreadLocal protocol. | [
"GetThreadLocal",
"implements",
"keybase",
".",
"chatLocal",
".",
"getThreadLocal",
"protocol",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L486-L514 |
158,973 | keybase/client | go/chat/server.go | NewConversationLocal | func (h *Server) NewConversationLocal(ctx context.Context, arg chat1.NewConversationLocalArg) (res chat1.NewConversationLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err },
fmt.Sprintf("NewConversationLocal(%s|%v)", arg.TlfName, arg.MembersType))()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return chat1.NewConversationLocalRes{}, err
}
conv, err := NewConversation(ctx, h.G(), uid, arg.TlfName, arg.TopicName,
arg.TopicType, arg.MembersType, arg.TlfVisibility, h.remoteClient, NewConvFindExistingNormal)
if err != nil {
return res, err
}
res.Conv = conv
res.IdentifyFailures = identBreaks
return res, nil
} | go | func (h *Server) NewConversationLocal(ctx context.Context, arg chat1.NewConversationLocalArg) (res chat1.NewConversationLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err },
fmt.Sprintf("NewConversationLocal(%s|%v)", arg.TlfName, arg.MembersType))()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return chat1.NewConversationLocalRes{}, err
}
conv, err := NewConversation(ctx, h.G(), uid, arg.TlfName, arg.TopicName,
arg.TopicType, arg.MembersType, arg.TlfVisibility, h.remoteClient, NewConvFindExistingNormal)
if err != nil {
return res, err
}
res.Conv = conv
res.IdentifyFailures = identBreaks
return res, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"NewConversationLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"NewConversationLocalArg",
")",
"(",
"res",
"chat1",
".",
"NewConversationLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"arg",
".",
"TlfName",
",",
"arg",
".",
"MembersType",
")",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"chat1",
".",
"NewConversationLocalRes",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"conv",
",",
"err",
":=",
"NewConversation",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"uid",
",",
"arg",
".",
"TlfName",
",",
"arg",
".",
"TopicName",
",",
"arg",
".",
"TopicType",
",",
"arg",
".",
"MembersType",
",",
"arg",
".",
"TlfVisibility",
",",
"h",
".",
"remoteClient",
",",
"NewConvFindExistingNormal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"res",
".",
"Conv",
"=",
"conv",
"\n",
"res",
".",
"IdentifyFailures",
"=",
"identBreaks",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // NewConversationLocal implements keybase.chatLocal.newConversationLocal protocol.
// Create a new conversation. Or in the case of CHAT, create-or-get a conversation. | [
"NewConversationLocal",
"implements",
"keybase",
".",
"chatLocal",
".",
"newConversationLocal",
"protocol",
".",
"Create",
"a",
"new",
"conversation",
".",
"Or",
"in",
"the",
"case",
"of",
"CHAT",
"create",
"-",
"or",
"-",
"get",
"a",
"conversation",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L889-L909 |
158,974 | keybase/client | go/chat/server.go | PostLocal | func (h *Server) PostLocal(ctx context.Context, arg chat1.PostLocalArg) (res chat1.PostLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "PostLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
// Sanity check that we have a TLF name here
if len(arg.Msg.ClientHeader.TlfName) == 0 {
h.Debug(ctx, "PostLocal: no TLF name specified: convID: %s uid: %s",
arg.ConversationID, uid)
return res, fmt.Errorf("no TLF name specified")
}
// Check for any slash command hits for an execute
if handled, err := h.G().CommandsSource.AttemptBuiltinCommand(ctx, uid, arg.ConversationID,
arg.Msg.ClientHeader.TlfName, arg.Msg.MessageBody, arg.ReplyTo); handled {
h.Debug(ctx, "PostLocal: handled slash command with error: %s", err)
return res, nil
}
// Run Stellar UI on any payments in the body
if arg.Msg.MessageBody, err = h.runStellarSendUI(ctx, 0, uid, arg.ConversationID,
arg.Msg.MessageBody); err != nil {
return res, err
}
var prepareOpts chat1.SenderPrepareOptions
prepareOpts.ReplyTo = arg.ReplyTo
sender := NewBlockingSender(h.G(), h.boxer, h.remoteClient)
_, msgBoxed, err := sender.Send(ctx, arg.ConversationID, arg.Msg, 0, nil, nil, &prepareOpts)
if err != nil {
h.Debug(ctx, "PostLocal: unable to send message: %s", err.Error())
return res, err
}
return chat1.PostLocalRes{
MessageID: msgBoxed.GetMessageID(),
IdentifyFailures: identBreaks,
}, nil
} | go | func (h *Server) PostLocal(ctx context.Context, arg chat1.PostLocalArg) (res chat1.PostLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "PostLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
// Sanity check that we have a TLF name here
if len(arg.Msg.ClientHeader.TlfName) == 0 {
h.Debug(ctx, "PostLocal: no TLF name specified: convID: %s uid: %s",
arg.ConversationID, uid)
return res, fmt.Errorf("no TLF name specified")
}
// Check for any slash command hits for an execute
if handled, err := h.G().CommandsSource.AttemptBuiltinCommand(ctx, uid, arg.ConversationID,
arg.Msg.ClientHeader.TlfName, arg.Msg.MessageBody, arg.ReplyTo); handled {
h.Debug(ctx, "PostLocal: handled slash command with error: %s", err)
return res, nil
}
// Run Stellar UI on any payments in the body
if arg.Msg.MessageBody, err = h.runStellarSendUI(ctx, 0, uid, arg.ConversationID,
arg.Msg.MessageBody); err != nil {
return res, err
}
var prepareOpts chat1.SenderPrepareOptions
prepareOpts.ReplyTo = arg.ReplyTo
sender := NewBlockingSender(h.G(), h.boxer, h.remoteClient)
_, msgBoxed, err := sender.Send(ctx, arg.ConversationID, arg.Msg, 0, nil, nil, &prepareOpts)
if err != nil {
h.Debug(ctx, "PostLocal: unable to send message: %s", err.Error())
return res, err
}
return chat1.PostLocalRes{
MessageID: msgBoxed.GetMessageID(),
IdentifyFailures: identBreaks,
}, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"PostLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"PostLocalArg",
")",
"(",
"res",
"chat1",
".",
"PostLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"// Sanity check that we have a TLF name here",
"if",
"len",
"(",
"arg",
".",
"Msg",
".",
"ClientHeader",
".",
"TlfName",
")",
"==",
"0",
"{",
"h",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"arg",
".",
"ConversationID",
",",
"uid",
")",
"\n",
"return",
"res",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check for any slash command hits for an execute",
"if",
"handled",
",",
"err",
":=",
"h",
".",
"G",
"(",
")",
".",
"CommandsSource",
".",
"AttemptBuiltinCommand",
"(",
"ctx",
",",
"uid",
",",
"arg",
".",
"ConversationID",
",",
"arg",
".",
"Msg",
".",
"ClientHeader",
".",
"TlfName",
",",
"arg",
".",
"Msg",
".",
"MessageBody",
",",
"arg",
".",
"ReplyTo",
")",
";",
"handled",
"{",
"h",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n\n",
"// Run Stellar UI on any payments in the body",
"if",
"arg",
".",
"Msg",
".",
"MessageBody",
",",
"err",
"=",
"h",
".",
"runStellarSendUI",
"(",
"ctx",
",",
"0",
",",
"uid",
",",
"arg",
".",
"ConversationID",
",",
"arg",
".",
"Msg",
".",
"MessageBody",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"prepareOpts",
"chat1",
".",
"SenderPrepareOptions",
"\n",
"prepareOpts",
".",
"ReplyTo",
"=",
"arg",
".",
"ReplyTo",
"\n",
"sender",
":=",
"NewBlockingSender",
"(",
"h",
".",
"G",
"(",
")",
",",
"h",
".",
"boxer",
",",
"h",
".",
"remoteClient",
")",
"\n",
"_",
",",
"msgBoxed",
",",
"err",
":=",
"sender",
".",
"Send",
"(",
"ctx",
",",
"arg",
".",
"ConversationID",
",",
"arg",
".",
"Msg",
",",
"0",
",",
"nil",
",",
"nil",
",",
"&",
"prepareOpts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"h",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"chat1",
".",
"PostLocalRes",
"{",
"MessageID",
":",
"msgBoxed",
".",
"GetMessageID",
"(",
")",
",",
"IdentifyFailures",
":",
"identBreaks",
",",
"}",
",",
"nil",
"\n",
"}"
] | // PostLocal implements keybase.chatLocal.postLocal protocol. | [
"PostLocal",
"implements",
"keybase",
".",
"chatLocal",
".",
"postLocal",
"protocol",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1153-L1196 |
158,975 | keybase/client | go/chat/server.go | MakePreview | func (h *Server) MakePreview(ctx context.Context, arg chat1.MakePreviewArg) (res chat1.MakePreviewRes, err error) {
defer h.Trace(ctx, func() error { return err }, "MakePreview")()
return attachments.NewSender(h.G()).MakePreview(ctx, arg.Filename, arg.OutboxID)
} | go | func (h *Server) MakePreview(ctx context.Context, arg chat1.MakePreviewArg) (res chat1.MakePreviewRes, err error) {
defer h.Trace(ctx, func() error { return err }, "MakePreview")()
return attachments.NewSender(h.G()).MakePreview(ctx, arg.Filename, arg.OutboxID)
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"MakePreview",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"MakePreviewArg",
")",
"(",
"res",
"chat1",
".",
"MakePreviewRes",
",",
"err",
"error",
")",
"{",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"return",
"attachments",
".",
"NewSender",
"(",
"h",
".",
"G",
"(",
")",
")",
".",
"MakePreview",
"(",
"ctx",
",",
"arg",
".",
"Filename",
",",
"arg",
".",
"OutboxID",
")",
"\n",
"}"
] | // MakePreview implements chat1.LocalInterface.MakePreview. | [
"MakePreview",
"implements",
"chat1",
".",
"LocalInterface",
".",
"MakePreview",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1508-L1511 |
158,976 | keybase/client | go/chat/server.go | PostFileAttachmentLocal | func (h *Server) PostFileAttachmentLocal(ctx context.Context, arg chat1.PostFileAttachmentLocalArg) (res chat1.PostLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.Arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "PostFileAttachmentLocal")()
defer h.suspendConvLoader(ctx)()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
// Get base of message we are going to send
sender := NewBlockingSender(h.G(), h.boxer, h.remoteClient)
_, msgID, err := attachments.NewSender(h.G()).PostFileAttachment(ctx, sender, uid, arg.Arg.ConversationID,
arg.Arg.TlfName, arg.Arg.Visibility, arg.Arg.OutboxID, arg.Arg.Filename, arg.Arg.Title,
arg.Arg.Metadata, 0, arg.Arg.EphemeralLifetime, arg.Arg.CallerPreview)
if err != nil {
return res, err
}
if msgID == nil {
return res, errors.New("no message ID returned from post")
}
return chat1.PostLocalRes{
MessageID: *msgID,
IdentifyFailures: identBreaks,
}, nil
} | go | func (h *Server) PostFileAttachmentLocal(ctx context.Context, arg chat1.PostFileAttachmentLocalArg) (res chat1.PostLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.Arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "PostFileAttachmentLocal")()
defer h.suspendConvLoader(ctx)()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
// Get base of message we are going to send
sender := NewBlockingSender(h.G(), h.boxer, h.remoteClient)
_, msgID, err := attachments.NewSender(h.G()).PostFileAttachment(ctx, sender, uid, arg.Arg.ConversationID,
arg.Arg.TlfName, arg.Arg.Visibility, arg.Arg.OutboxID, arg.Arg.Filename, arg.Arg.Title,
arg.Arg.Metadata, 0, arg.Arg.EphemeralLifetime, arg.Arg.CallerPreview)
if err != nil {
return res, err
}
if msgID == nil {
return res, errors.New("no message ID returned from post")
}
return chat1.PostLocalRes{
MessageID: *msgID,
IdentifyFailures: identBreaks,
}, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"PostFileAttachmentLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"PostFileAttachmentLocalArg",
")",
"(",
"res",
"chat1",
".",
"PostLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"Arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"defer",
"h",
".",
"suspendConvLoader",
"(",
"ctx",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n\n",
"// Get base of message we are going to send",
"sender",
":=",
"NewBlockingSender",
"(",
"h",
".",
"G",
"(",
")",
",",
"h",
".",
"boxer",
",",
"h",
".",
"remoteClient",
")",
"\n",
"_",
",",
"msgID",
",",
"err",
":=",
"attachments",
".",
"NewSender",
"(",
"h",
".",
"G",
"(",
")",
")",
".",
"PostFileAttachment",
"(",
"ctx",
",",
"sender",
",",
"uid",
",",
"arg",
".",
"Arg",
".",
"ConversationID",
",",
"arg",
".",
"Arg",
".",
"TlfName",
",",
"arg",
".",
"Arg",
".",
"Visibility",
",",
"arg",
".",
"Arg",
".",
"OutboxID",
",",
"arg",
".",
"Arg",
".",
"Filename",
",",
"arg",
".",
"Arg",
".",
"Title",
",",
"arg",
".",
"Arg",
".",
"Metadata",
",",
"0",
",",
"arg",
".",
"Arg",
".",
"EphemeralLifetime",
",",
"arg",
".",
"Arg",
".",
"CallerPreview",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"if",
"msgID",
"==",
"nil",
"{",
"return",
"res",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"chat1",
".",
"PostLocalRes",
"{",
"MessageID",
":",
"*",
"msgID",
",",
"IdentifyFailures",
":",
"identBreaks",
",",
"}",
",",
"nil",
"\n",
"}"
] | // PostFileAttachmentLocal implements chat1.LocalInterface.PostFileAttachmentLocal. | [
"PostFileAttachmentLocal",
"implements",
"chat1",
".",
"LocalInterface",
".",
"PostFileAttachmentLocal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1558-L1584 |
158,977 | keybase/client | go/chat/server.go | DownloadAttachmentLocal | func (h *Server) DownloadAttachmentLocal(ctx context.Context, arg chat1.DownloadAttachmentLocalArg) (res chat1.DownloadAttachmentLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "DownloadAttachmentLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
darg := downloadAttachmentArg{
SessionID: arg.SessionID,
ConversationID: arg.ConversationID,
MessageID: arg.MessageID,
Preview: arg.Preview,
IdentifyBehavior: arg.IdentifyBehavior,
}
cli := h.getStreamUICli()
darg.Sink = libkb.NewRemoteStreamBuffered(arg.Sink, cli, arg.SessionID)
return h.downloadAttachmentLocal(ctx, uid, darg)
} | go | func (h *Server) DownloadAttachmentLocal(ctx context.Context, arg chat1.DownloadAttachmentLocalArg) (res chat1.DownloadAttachmentLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "DownloadAttachmentLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
darg := downloadAttachmentArg{
SessionID: arg.SessionID,
ConversationID: arg.ConversationID,
MessageID: arg.MessageID,
Preview: arg.Preview,
IdentifyBehavior: arg.IdentifyBehavior,
}
cli := h.getStreamUICli()
darg.Sink = libkb.NewRemoteStreamBuffered(arg.Sink, cli, arg.SessionID)
return h.downloadAttachmentLocal(ctx, uid, darg)
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"DownloadAttachmentLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"DownloadAttachmentLocalArg",
")",
"(",
"res",
"chat1",
".",
"DownloadAttachmentLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"darg",
":=",
"downloadAttachmentArg",
"{",
"SessionID",
":",
"arg",
".",
"SessionID",
",",
"ConversationID",
":",
"arg",
".",
"ConversationID",
",",
"MessageID",
":",
"arg",
".",
"MessageID",
",",
"Preview",
":",
"arg",
".",
"Preview",
",",
"IdentifyBehavior",
":",
"arg",
".",
"IdentifyBehavior",
",",
"}",
"\n",
"cli",
":=",
"h",
".",
"getStreamUICli",
"(",
")",
"\n",
"darg",
".",
"Sink",
"=",
"libkb",
".",
"NewRemoteStreamBuffered",
"(",
"arg",
".",
"Sink",
",",
"cli",
",",
"arg",
".",
"SessionID",
")",
"\n\n",
"return",
"h",
".",
"downloadAttachmentLocal",
"(",
"ctx",
",",
"uid",
",",
"darg",
")",
"\n",
"}"
] | // DownloadAttachmentLocal implements chat1.LocalInterface.DownloadAttachmentLocal. | [
"DownloadAttachmentLocal",
"implements",
"chat1",
".",
"LocalInterface",
".",
"DownloadAttachmentLocal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1587-L1607 |
158,978 | keybase/client | go/chat/server.go | DownloadFileAttachmentLocal | func (h *Server) DownloadFileAttachmentLocal(ctx context.Context, arg chat1.DownloadFileAttachmentLocalArg) (res chat1.DownloadFileAttachmentLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "DownloadFileAttachmentLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
darg := downloadAttachmentArg{
SessionID: arg.SessionID,
ConversationID: arg.ConversationID,
MessageID: arg.MessageID,
Preview: arg.Preview,
IdentifyBehavior: arg.IdentifyBehavior,
}
filename, sink, err := attachments.SinkFromFilename(ctx, h.G(), uid,
arg.ConversationID, arg.MessageID, arg.Filename)
if err != nil {
return res, err
}
defer func() {
// In the event of any error delete the file if it's empty.
if err != nil {
h.Debug(ctx, "DownloadFileAttachmentLocal: deleteFileIfEmpty: %v", deleteFileIfEmpty(filename))
}
}()
if err := attachments.Quarantine(ctx, filename); err != nil {
h.Debug(ctx, "DownloadFileAttachmentLocal: failed to quarantine download: %s", err)
}
darg.Sink = sink
ires, err := h.downloadAttachmentLocal(ctx, uid, darg)
if err != nil {
return res, err
}
return chat1.DownloadFileAttachmentLocalRes{
Filename: filename,
IdentifyFailures: ires.IdentifyFailures,
}, nil
} | go | func (h *Server) DownloadFileAttachmentLocal(ctx context.Context, arg chat1.DownloadFileAttachmentLocalArg) (res chat1.DownloadFileAttachmentLocalRes, err error) {
var identBreaks []keybase1.TLFIdentifyFailure
ctx = globals.ChatCtx(ctx, h.G(), arg.IdentifyBehavior, &identBreaks, h.identNotifier)
defer h.Trace(ctx, func() error { return err }, "DownloadFileAttachmentLocal")()
defer func() { h.setResultRateLimit(ctx, &res) }()
uid, err := utils.AssertLoggedInUID(ctx, h.G())
if err != nil {
return res, err
}
darg := downloadAttachmentArg{
SessionID: arg.SessionID,
ConversationID: arg.ConversationID,
MessageID: arg.MessageID,
Preview: arg.Preview,
IdentifyBehavior: arg.IdentifyBehavior,
}
filename, sink, err := attachments.SinkFromFilename(ctx, h.G(), uid,
arg.ConversationID, arg.MessageID, arg.Filename)
if err != nil {
return res, err
}
defer func() {
// In the event of any error delete the file if it's empty.
if err != nil {
h.Debug(ctx, "DownloadFileAttachmentLocal: deleteFileIfEmpty: %v", deleteFileIfEmpty(filename))
}
}()
if err := attachments.Quarantine(ctx, filename); err != nil {
h.Debug(ctx, "DownloadFileAttachmentLocal: failed to quarantine download: %s", err)
}
darg.Sink = sink
ires, err := h.downloadAttachmentLocal(ctx, uid, darg)
if err != nil {
return res, err
}
return chat1.DownloadFileAttachmentLocalRes{
Filename: filename,
IdentifyFailures: ires.IdentifyFailures,
}, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"DownloadFileAttachmentLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"DownloadFileAttachmentLocalArg",
")",
"(",
"res",
"chat1",
".",
"DownloadFileAttachmentLocalRes",
",",
"err",
"error",
")",
"{",
"var",
"identBreaks",
"[",
"]",
"keybase1",
".",
"TLFIdentifyFailure",
"\n",
"ctx",
"=",
"globals",
".",
"ChatCtx",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"arg",
".",
"IdentifyBehavior",
",",
"&",
"identBreaks",
",",
"h",
".",
"identNotifier",
")",
"\n",
"defer",
"h",
".",
"Trace",
"(",
"ctx",
",",
"func",
"(",
")",
"error",
"{",
"return",
"err",
"}",
",",
"\"",
"\"",
")",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"h",
".",
"setResultRateLimit",
"(",
"ctx",
",",
"&",
"res",
")",
"}",
"(",
")",
"\n",
"uid",
",",
"err",
":=",
"utils",
".",
"AssertLoggedInUID",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"darg",
":=",
"downloadAttachmentArg",
"{",
"SessionID",
":",
"arg",
".",
"SessionID",
",",
"ConversationID",
":",
"arg",
".",
"ConversationID",
",",
"MessageID",
":",
"arg",
".",
"MessageID",
",",
"Preview",
":",
"arg",
".",
"Preview",
",",
"IdentifyBehavior",
":",
"arg",
".",
"IdentifyBehavior",
",",
"}",
"\n",
"filename",
",",
"sink",
",",
"err",
":=",
"attachments",
".",
"SinkFromFilename",
"(",
"ctx",
",",
"h",
".",
"G",
"(",
")",
",",
"uid",
",",
"arg",
".",
"ConversationID",
",",
"arg",
".",
"MessageID",
",",
"arg",
".",
"Filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"// In the event of any error delete the file if it's empty.",
"if",
"err",
"!=",
"nil",
"{",
"h",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"deleteFileIfEmpty",
"(",
"filename",
")",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"err",
":=",
"attachments",
".",
"Quarantine",
"(",
"ctx",
",",
"filename",
")",
";",
"err",
"!=",
"nil",
"{",
"h",
".",
"Debug",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"darg",
".",
"Sink",
"=",
"sink",
"\n",
"ires",
",",
"err",
":=",
"h",
".",
"downloadAttachmentLocal",
"(",
"ctx",
",",
"uid",
",",
"darg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"return",
"chat1",
".",
"DownloadFileAttachmentLocalRes",
"{",
"Filename",
":",
"filename",
",",
"IdentifyFailures",
":",
"ires",
".",
"IdentifyFailures",
",",
"}",
",",
"nil",
"\n",
"}"
] | // DownloadFileAttachmentLocal implements chat1.LocalInterface.DownloadFileAttachmentLocal. | [
"DownloadFileAttachmentLocal",
"implements",
"chat1",
".",
"LocalInterface",
".",
"DownloadFileAttachmentLocal",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1610-L1649 |
158,979 | keybase/client | go/chat/server.go | remoteClient | func (h *Server) remoteClient() chat1.RemoteInterface {
if h.rc != nil {
return h.rc
}
return h.serverConn.GetClient()
} | go | func (h *Server) remoteClient() chat1.RemoteInterface {
if h.rc != nil {
return h.rc
}
return h.serverConn.GetClient()
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"remoteClient",
"(",
")",
"chat1",
".",
"RemoteInterface",
"{",
"if",
"h",
".",
"rc",
"!=",
"nil",
"{",
"return",
"h",
".",
"rc",
"\n",
"}",
"\n",
"return",
"h",
".",
"serverConn",
".",
"GetClient",
"(",
")",
"\n",
"}"
] | // remoteClient returns a client connection to gregord. | [
"remoteClient",
"returns",
"a",
"client",
"connection",
"to",
"gregord",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1746-L1751 |
158,980 | keybase/client | go/chat/server.go | deleteConversationLocal | func (h *Server) deleteConversationLocal(ctx context.Context, arg chat1.DeleteConversationLocalArg) (res chat1.DeleteConversationLocalRes, err error) {
ui := h.getChatUI(arg.SessionID)
confirmed := arg.Confirmed
if !confirmed {
confirmed, err = ui.ChatConfirmChannelDelete(ctx, chat1.ChatConfirmChannelDeleteArg{
SessionID: arg.SessionID,
Channel: arg.ChannelName,
})
if err != nil {
return res, err
}
}
if !confirmed {
return res, errors.New("channel delete unconfirmed")
}
_, err = h.remoteClient().DeleteConversation(ctx, arg.ConvID)
if err != nil {
return res, err
}
res.Offline = h.G().InboxSource.IsOffline(ctx)
return res, nil
} | go | func (h *Server) deleteConversationLocal(ctx context.Context, arg chat1.DeleteConversationLocalArg) (res chat1.DeleteConversationLocalRes, err error) {
ui := h.getChatUI(arg.SessionID)
confirmed := arg.Confirmed
if !confirmed {
confirmed, err = ui.ChatConfirmChannelDelete(ctx, chat1.ChatConfirmChannelDeleteArg{
SessionID: arg.SessionID,
Channel: arg.ChannelName,
})
if err != nil {
return res, err
}
}
if !confirmed {
return res, errors.New("channel delete unconfirmed")
}
_, err = h.remoteClient().DeleteConversation(ctx, arg.ConvID)
if err != nil {
return res, err
}
res.Offline = h.G().InboxSource.IsOffline(ctx)
return res, nil
} | [
"func",
"(",
"h",
"*",
"Server",
")",
"deleteConversationLocal",
"(",
"ctx",
"context",
".",
"Context",
",",
"arg",
"chat1",
".",
"DeleteConversationLocalArg",
")",
"(",
"res",
"chat1",
".",
"DeleteConversationLocalRes",
",",
"err",
"error",
")",
"{",
"ui",
":=",
"h",
".",
"getChatUI",
"(",
"arg",
".",
"SessionID",
")",
"\n",
"confirmed",
":=",
"arg",
".",
"Confirmed",
"\n",
"if",
"!",
"confirmed",
"{",
"confirmed",
",",
"err",
"=",
"ui",
".",
"ChatConfirmChannelDelete",
"(",
"ctx",
",",
"chat1",
".",
"ChatConfirmChannelDeleteArg",
"{",
"SessionID",
":",
"arg",
".",
"SessionID",
",",
"Channel",
":",
"arg",
".",
"ChannelName",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"confirmed",
"{",
"return",
"res",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"h",
".",
"remoteClient",
"(",
")",
".",
"DeleteConversation",
"(",
"ctx",
",",
"arg",
".",
"ConvID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"res",
",",
"err",
"\n",
"}",
"\n",
"res",
".",
"Offline",
"=",
"h",
".",
"G",
"(",
")",
".",
"InboxSource",
".",
"IsOffline",
"(",
"ctx",
")",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // deleteConversationLocal contains the functionality of
// DeleteConversationLocal split off for easier testing. | [
"deleteConversationLocal",
"contains",
"the",
"functionality",
"of",
"DeleteConversationLocal",
"split",
"off",
"for",
"easier",
"testing",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/chat/server.go#L1945-L1967 |
158,981 | keybase/client | go/logger/output_windows.go | parseControlCode | func (cw *ColorWriter) parseControlCode(p []byte) []byte {
if p[0] == 'D' {
cw.w.Write([]byte(fmt.Sprintf("\b")))
}
return p[1:]
} | go | func (cw *ColorWriter) parseControlCode(p []byte) []byte {
if p[0] == 'D' {
cw.w.Write([]byte(fmt.Sprintf("\b")))
}
return p[1:]
} | [
"func",
"(",
"cw",
"*",
"ColorWriter",
")",
"parseControlCode",
"(",
"p",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"p",
"[",
"0",
"]",
"==",
"'D'",
"{",
"cw",
".",
"w",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\b",
"\"",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"p",
"[",
"1",
":",
"]",
"\n",
"}"
] | // parseControlCode is for absorbing backspaces, which
// caused junk to come out on the console, and whichever
// other control code we're probably unprepared for | [
"parseControlCode",
"is",
"for",
"absorbing",
"backspaces",
"which",
"caused",
"junk",
"to",
"come",
"out",
"on",
"the",
"console",
"and",
"whichever",
"other",
"control",
"code",
"we",
"re",
"probably",
"unprepared",
"for"
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/logger/output_windows.go#L251-L256 |
158,982 | keybase/client | go/logger/output_windows.go | SaveConsoleMode | func SaveConsoleMode() error {
var err error
consoleMode, err = getConsoleTextAttribute(os.Stdout.Fd())
return err
} | go | func SaveConsoleMode() error {
var err error
consoleMode, err = getConsoleTextAttribute(os.Stdout.Fd())
return err
} | [
"func",
"SaveConsoleMode",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"consoleMode",
",",
"err",
"=",
"getConsoleTextAttribute",
"(",
"os",
".",
"Stdout",
".",
"Fd",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // SaveConsoleMode records the current text attributes in a global, so
// it can be restored later, in case nonstandard colors are expected. | [
"SaveConsoleMode",
"records",
"the",
"current",
"text",
"attributes",
"in",
"a",
"global",
"so",
"it",
"can",
"be",
"restored",
"later",
"in",
"case",
"nonstandard",
"colors",
"are",
"expected",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/logger/output_windows.go#L279-L283 |
158,983 | keybase/client | go/logger/output_windows.go | checkError | func checkError(r1, r2 uintptr, err error) error {
// Windows APIs return non-zero to indicate success
if r1 != 0 {
return nil
}
// Return the error if provided, otherwise default to EINVAL
if err != nil {
return err
}
return syscall.EINVAL
} | go | func checkError(r1, r2 uintptr, err error) error {
// Windows APIs return non-zero to indicate success
if r1 != 0 {
return nil
}
// Return the error if provided, otherwise default to EINVAL
if err != nil {
return err
}
return syscall.EINVAL
} | [
"func",
"checkError",
"(",
"r1",
",",
"r2",
"uintptr",
",",
"err",
"error",
")",
"error",
"{",
"// Windows APIs return non-zero to indicate success",
"if",
"r1",
"!=",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Return the error if provided, otherwise default to EINVAL",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"syscall",
".",
"EINVAL",
"\n",
"}"
] | // checkError evaluates the results of a Windows API call and returns the error if it failed. | [
"checkError",
"evaluates",
"the",
"results",
"of",
"a",
"Windows",
"API",
"call",
"and",
"returns",
"the",
"error",
"if",
"it",
"failed",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/logger/output_windows.go#L294-L305 |
158,984 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | NewKBPKIClient | func NewKBPKIClient(
serviceOwner keybaseServiceOwner, log logger.Logger) *KBPKIClient {
return &KBPKIClient{serviceOwner, log}
} | go | func NewKBPKIClient(
serviceOwner keybaseServiceOwner, log logger.Logger) *KBPKIClient {
return &KBPKIClient{serviceOwner, log}
} | [
"func",
"NewKBPKIClient",
"(",
"serviceOwner",
"keybaseServiceOwner",
",",
"log",
"logger",
".",
"Logger",
")",
"*",
"KBPKIClient",
"{",
"return",
"&",
"KBPKIClient",
"{",
"serviceOwner",
",",
"log",
"}",
"\n",
"}"
] | // NewKBPKIClient returns a new KBPKIClient with the given service. | [
"NewKBPKIClient",
"returns",
"a",
"new",
"KBPKIClient",
"with",
"the",
"given",
"service",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L38-L41 |
158,985 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | GetCurrentSession | func (k *KBPKIClient) GetCurrentSession(ctx context.Context) (
idutil.SessionInfo, error) {
const sessionID = 0
return k.serviceOwner.KeybaseService().CurrentSession(ctx, sessionID)
} | go | func (k *KBPKIClient) GetCurrentSession(ctx context.Context) (
idutil.SessionInfo, error) {
const sessionID = 0
return k.serviceOwner.KeybaseService().CurrentSession(ctx, sessionID)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"GetCurrentSession",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"idutil",
".",
"SessionInfo",
",",
"error",
")",
"{",
"const",
"sessionID",
"=",
"0",
"\n",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"CurrentSession",
"(",
"ctx",
",",
"sessionID",
")",
"\n",
"}"
] | // GetCurrentSession implements the KBPKI interface for KBPKIClient. | [
"GetCurrentSession",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L44-L48 |
158,986 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | Identify | func (k *KBPKIClient) Identify(
ctx context.Context, assertion, reason string,
offline keybase1.OfflineAvailability) (
kbname.NormalizedUsername, keybase1.UserOrTeamID, error) {
return k.serviceOwner.KeybaseService().Identify(
ctx, assertion, reason, offline)
} | go | func (k *KBPKIClient) Identify(
ctx context.Context, assertion, reason string,
offline keybase1.OfflineAvailability) (
kbname.NormalizedUsername, keybase1.UserOrTeamID, error) {
return k.serviceOwner.KeybaseService().Identify(
ctx, assertion, reason, offline)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"Identify",
"(",
"ctx",
"context",
".",
"Context",
",",
"assertion",
",",
"reason",
"string",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"kbname",
".",
"NormalizedUsername",
",",
"keybase1",
".",
"UserOrTeamID",
",",
"error",
")",
"{",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"Identify",
"(",
"ctx",
",",
"assertion",
",",
"reason",
",",
"offline",
")",
"\n",
"}"
] | // Identify implements the KBPKI interface for KBPKIClient. | [
"Identify",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L59-L65 |
158,987 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | NormalizeSocialAssertion | func (k *KBPKIClient) NormalizeSocialAssertion(
ctx context.Context, assertion string) (keybase1.SocialAssertion, error) {
return k.serviceOwner.KeybaseService().NormalizeSocialAssertion(ctx, assertion)
} | go | func (k *KBPKIClient) NormalizeSocialAssertion(
ctx context.Context, assertion string) (keybase1.SocialAssertion, error) {
return k.serviceOwner.KeybaseService().NormalizeSocialAssertion(ctx, assertion)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"NormalizeSocialAssertion",
"(",
"ctx",
"context",
".",
"Context",
",",
"assertion",
"string",
")",
"(",
"keybase1",
".",
"SocialAssertion",
",",
"error",
")",
"{",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"NormalizeSocialAssertion",
"(",
"ctx",
",",
"assertion",
")",
"\n",
"}"
] | // NormalizeSocialAssertion implements the KBPKI interface for KBPKIClient. | [
"NormalizeSocialAssertion",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L68-L71 |
158,988 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | ResolveImplicitTeam | func (k *KBPKIClient) ResolveImplicitTeam(
ctx context.Context, assertions, suffix string, tlfType tlf.Type,
offline keybase1.OfflineAvailability) (
idutil.ImplicitTeamInfo, error) {
return k.serviceOwner.KeybaseService().ResolveIdentifyImplicitTeam(
ctx, assertions, suffix, tlfType, false, "", offline)
} | go | func (k *KBPKIClient) ResolveImplicitTeam(
ctx context.Context, assertions, suffix string, tlfType tlf.Type,
offline keybase1.OfflineAvailability) (
idutil.ImplicitTeamInfo, error) {
return k.serviceOwner.KeybaseService().ResolveIdentifyImplicitTeam(
ctx, assertions, suffix, tlfType, false, "", offline)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"ResolveImplicitTeam",
"(",
"ctx",
"context",
".",
"Context",
",",
"assertions",
",",
"suffix",
"string",
",",
"tlfType",
"tlf",
".",
"Type",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"idutil",
".",
"ImplicitTeamInfo",
",",
"error",
")",
"{",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"ResolveIdentifyImplicitTeam",
"(",
"ctx",
",",
"assertions",
",",
"suffix",
",",
"tlfType",
",",
"false",
",",
"\"",
"\"",
",",
"offline",
")",
"\n",
"}"
] | // ResolveImplicitTeam implements the KBPKI interface for KBPKIClient. | [
"ResolveImplicitTeam",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L74-L80 |
158,989 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | ResolveImplicitTeamByID | func (k *KBPKIClient) ResolveImplicitTeamByID(
ctx context.Context, teamID keybase1.TeamID, tlfType tlf.Type,
offline keybase1.OfflineAvailability) (
idutil.ImplicitTeamInfo, error) {
name, err := k.serviceOwner.KeybaseService().ResolveImplicitTeamByID(
ctx, teamID)
if err != nil {
return idutil.ImplicitTeamInfo{}, err
}
assertions, suffix, err := tlf.SplitExtension(name)
if err != nil {
return idutil.ImplicitTeamInfo{}, err
}
return k.serviceOwner.KeybaseService().ResolveIdentifyImplicitTeam(
ctx, assertions, suffix, tlfType, false, "", offline)
} | go | func (k *KBPKIClient) ResolveImplicitTeamByID(
ctx context.Context, teamID keybase1.TeamID, tlfType tlf.Type,
offline keybase1.OfflineAvailability) (
idutil.ImplicitTeamInfo, error) {
name, err := k.serviceOwner.KeybaseService().ResolveImplicitTeamByID(
ctx, teamID)
if err != nil {
return idutil.ImplicitTeamInfo{}, err
}
assertions, suffix, err := tlf.SplitExtension(name)
if err != nil {
return idutil.ImplicitTeamInfo{}, err
}
return k.serviceOwner.KeybaseService().ResolveIdentifyImplicitTeam(
ctx, assertions, suffix, tlfType, false, "", offline)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"ResolveImplicitTeamByID",
"(",
"ctx",
"context",
".",
"Context",
",",
"teamID",
"keybase1",
".",
"TeamID",
",",
"tlfType",
"tlf",
".",
"Type",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"idutil",
".",
"ImplicitTeamInfo",
",",
"error",
")",
"{",
"name",
",",
"err",
":=",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"ResolveImplicitTeamByID",
"(",
"ctx",
",",
"teamID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"idutil",
".",
"ImplicitTeamInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"assertions",
",",
"suffix",
",",
"err",
":=",
"tlf",
".",
"SplitExtension",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"idutil",
".",
"ImplicitTeamInfo",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"ResolveIdentifyImplicitTeam",
"(",
"ctx",
",",
"assertions",
",",
"suffix",
",",
"tlfType",
",",
"false",
",",
"\"",
"\"",
",",
"offline",
")",
"\n",
"}"
] | // ResolveImplicitTeamByID implements the KBPKI interface for KBPKIClient. | [
"ResolveImplicitTeamByID",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L83-L100 |
158,990 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | ResolveTeamTLFID | func (k *KBPKIClient) ResolveTeamTLFID(
ctx context.Context, teamID keybase1.TeamID,
offline keybase1.OfflineAvailability) (tlf.ID, error) {
settings, err := k.serviceOwner.KeybaseService().GetTeamSettings(
ctx, teamID, offline)
if err != nil {
return tlf.NullID, err
}
if settings.TlfID.IsNil() {
return tlf.NullID, err
}
tlfID, err := tlf.ParseID(settings.TlfID.String())
if err != nil {
return tlf.NullID, err
}
return tlfID, nil
} | go | func (k *KBPKIClient) ResolveTeamTLFID(
ctx context.Context, teamID keybase1.TeamID,
offline keybase1.OfflineAvailability) (tlf.ID, error) {
settings, err := k.serviceOwner.KeybaseService().GetTeamSettings(
ctx, teamID, offline)
if err != nil {
return tlf.NullID, err
}
if settings.TlfID.IsNil() {
return tlf.NullID, err
}
tlfID, err := tlf.ParseID(settings.TlfID.String())
if err != nil {
return tlf.NullID, err
}
return tlfID, nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"ResolveTeamTLFID",
"(",
"ctx",
"context",
".",
"Context",
",",
"teamID",
"keybase1",
".",
"TeamID",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"tlf",
".",
"ID",
",",
"error",
")",
"{",
"settings",
",",
"err",
":=",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"GetTeamSettings",
"(",
"ctx",
",",
"teamID",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tlf",
".",
"NullID",
",",
"err",
"\n",
"}",
"\n",
"if",
"settings",
".",
"TlfID",
".",
"IsNil",
"(",
")",
"{",
"return",
"tlf",
".",
"NullID",
",",
"err",
"\n",
"}",
"\n",
"tlfID",
",",
"err",
":=",
"tlf",
".",
"ParseID",
"(",
"settings",
".",
"TlfID",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tlf",
".",
"NullID",
",",
"err",
"\n",
"}",
"\n",
"return",
"tlfID",
",",
"nil",
"\n",
"}"
] | // ResolveTeamTLFID implements the KBPKI interface for KBPKIClient. | [
"ResolveTeamTLFID",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L103-L119 |
158,991 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | GetNormalizedUsername | func (k *KBPKIClient) GetNormalizedUsername(
ctx context.Context, id keybase1.UserOrTeamID,
offline keybase1.OfflineAvailability) (
kbname.NormalizedUsername, error) {
var assertion string
if id.IsUser() {
assertion = fmt.Sprintf("uid:%s", id)
} else {
assertion = fmt.Sprintf("tid:%s", id)
}
username, _, err := k.Resolve(ctx, assertion, offline)
if err != nil {
return kbname.NormalizedUsername(""), err
}
return username, nil
} | go | func (k *KBPKIClient) GetNormalizedUsername(
ctx context.Context, id keybase1.UserOrTeamID,
offline keybase1.OfflineAvailability) (
kbname.NormalizedUsername, error) {
var assertion string
if id.IsUser() {
assertion = fmt.Sprintf("uid:%s", id)
} else {
assertion = fmt.Sprintf("tid:%s", id)
}
username, _, err := k.Resolve(ctx, assertion, offline)
if err != nil {
return kbname.NormalizedUsername(""), err
}
return username, nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"GetNormalizedUsername",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"keybase1",
".",
"UserOrTeamID",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"kbname",
".",
"NormalizedUsername",
",",
"error",
")",
"{",
"var",
"assertion",
"string",
"\n",
"if",
"id",
".",
"IsUser",
"(",
")",
"{",
"assertion",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"else",
"{",
"assertion",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n",
"username",
",",
"_",
",",
"err",
":=",
"k",
".",
"Resolve",
"(",
"ctx",
",",
"assertion",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"kbname",
".",
"NormalizedUsername",
"(",
"\"",
"\"",
")",
",",
"err",
"\n",
"}",
"\n",
"return",
"username",
",",
"nil",
"\n",
"}"
] | // GetNormalizedUsername implements the KBPKI interface for
// KBPKIClient. | [
"GetNormalizedUsername",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L133-L148 |
158,992 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | HasVerifyingKey | func (k *KBPKIClient) HasVerifyingKey(
ctx context.Context, uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey,
atServerTime time.Time, offline keybase1.OfflineAvailability) error {
ok, err := k.hasVerifyingKey(ctx, uid, verifyingKey, atServerTime, offline)
if err != nil {
return err
}
if ok {
return nil
}
// If the first attempt couldn't find the key, try again after
// clearing our local cache. We might have stale info if the
// service hasn't learned of the users' new key yet.
k.serviceOwner.KeybaseService().FlushUserFromLocalCache(ctx, uid)
ok, err = k.hasVerifyingKey(ctx, uid, verifyingKey, atServerTime, offline)
if err != nil {
return err
}
if !ok {
return VerifyingKeyNotFoundError{verifyingKey}
}
return nil
} | go | func (k *KBPKIClient) HasVerifyingKey(
ctx context.Context, uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey,
atServerTime time.Time, offline keybase1.OfflineAvailability) error {
ok, err := k.hasVerifyingKey(ctx, uid, verifyingKey, atServerTime, offline)
if err != nil {
return err
}
if ok {
return nil
}
// If the first attempt couldn't find the key, try again after
// clearing our local cache. We might have stale info if the
// service hasn't learned of the users' new key yet.
k.serviceOwner.KeybaseService().FlushUserFromLocalCache(ctx, uid)
ok, err = k.hasVerifyingKey(ctx, uid, verifyingKey, atServerTime, offline)
if err != nil {
return err
}
if !ok {
return VerifyingKeyNotFoundError{verifyingKey}
}
return nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"HasVerifyingKey",
"(",
"ctx",
"context",
".",
"Context",
",",
"uid",
"keybase1",
".",
"UID",
",",
"verifyingKey",
"kbfscrypto",
".",
"VerifyingKey",
",",
"atServerTime",
"time",
".",
"Time",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"error",
"{",
"ok",
",",
"err",
":=",
"k",
".",
"hasVerifyingKey",
"(",
"ctx",
",",
"uid",
",",
"verifyingKey",
",",
"atServerTime",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// If the first attempt couldn't find the key, try again after",
"// clearing our local cache. We might have stale info if the",
"// service hasn't learned of the users' new key yet.",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"FlushUserFromLocalCache",
"(",
"ctx",
",",
"uid",
")",
"\n\n",
"ok",
",",
"err",
"=",
"k",
".",
"hasVerifyingKey",
"(",
"ctx",
",",
"uid",
",",
"verifyingKey",
",",
"atServerTime",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"return",
"VerifyingKeyNotFoundError",
"{",
"verifyingKey",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // HasVerifyingKey implements the KBPKI interface for KBPKIClient. | [
"HasVerifyingKey",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L192-L216 |
158,993 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | GetCryptPublicKeys | func (k *KBPKIClient) GetCryptPublicKeys(
ctx context.Context, uid keybase1.UID,
offline keybase1.OfflineAvailability) (
keys []kbfscrypto.CryptPublicKey, err error) {
userInfo, err := k.loadUserPlusKeys(ctx, uid, "", offline)
if err != nil {
return nil, err
}
return userInfo.CryptPublicKeys, nil
} | go | func (k *KBPKIClient) GetCryptPublicKeys(
ctx context.Context, uid keybase1.UID,
offline keybase1.OfflineAvailability) (
keys []kbfscrypto.CryptPublicKey, err error) {
userInfo, err := k.loadUserPlusKeys(ctx, uid, "", offline)
if err != nil {
return nil, err
}
return userInfo.CryptPublicKeys, nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"GetCryptPublicKeys",
"(",
"ctx",
"context",
".",
"Context",
",",
"uid",
"keybase1",
".",
"UID",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"keys",
"[",
"]",
"kbfscrypto",
".",
"CryptPublicKey",
",",
"err",
"error",
")",
"{",
"userInfo",
",",
"err",
":=",
"k",
".",
"loadUserPlusKeys",
"(",
"ctx",
",",
"uid",
",",
"\"",
"\"",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"userInfo",
".",
"CryptPublicKeys",
",",
"nil",
"\n",
"}"
] | // GetCryptPublicKeys implements the KBPKI interface for KBPKIClient. | [
"GetCryptPublicKeys",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L226-L235 |
158,994 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | GetTeamTLFCryptKeys | func (k *KBPKIClient) GetTeamTLFCryptKeys(
ctx context.Context, tid keybase1.TeamID, desiredKeyGen kbfsmd.KeyGen,
offline keybase1.OfflineAvailability) (
map[kbfsmd.KeyGen]kbfscrypto.TLFCryptKey, kbfsmd.KeyGen, error) {
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlf.Unknown, desiredKeyGen, keybase1.UserVersion{},
kbfscrypto.VerifyingKey{}, keybase1.TeamRole_NONE, offline)
if err != nil {
return nil, 0, err
}
return teamInfo.CryptKeys, teamInfo.LatestKeyGen, nil
} | go | func (k *KBPKIClient) GetTeamTLFCryptKeys(
ctx context.Context, tid keybase1.TeamID, desiredKeyGen kbfsmd.KeyGen,
offline keybase1.OfflineAvailability) (
map[kbfsmd.KeyGen]kbfscrypto.TLFCryptKey, kbfsmd.KeyGen, error) {
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlf.Unknown, desiredKeyGen, keybase1.UserVersion{},
kbfscrypto.VerifyingKey{}, keybase1.TeamRole_NONE, offline)
if err != nil {
return nil, 0, err
}
return teamInfo.CryptKeys, teamInfo.LatestKeyGen, nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"GetTeamTLFCryptKeys",
"(",
"ctx",
"context",
".",
"Context",
",",
"tid",
"keybase1",
".",
"TeamID",
",",
"desiredKeyGen",
"kbfsmd",
".",
"KeyGen",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"map",
"[",
"kbfsmd",
".",
"KeyGen",
"]",
"kbfscrypto",
".",
"TLFCryptKey",
",",
"kbfsmd",
".",
"KeyGen",
",",
"error",
")",
"{",
"teamInfo",
",",
"err",
":=",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"LoadTeamPlusKeys",
"(",
"ctx",
",",
"tid",
",",
"tlf",
".",
"Unknown",
",",
"desiredKeyGen",
",",
"keybase1",
".",
"UserVersion",
"{",
"}",
",",
"kbfscrypto",
".",
"VerifyingKey",
"{",
"}",
",",
"keybase1",
".",
"TeamRole_NONE",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"teamInfo",
".",
"CryptKeys",
",",
"teamInfo",
".",
"LatestKeyGen",
",",
"nil",
"\n",
"}"
] | // GetTeamTLFCryptKeys implements the KBPKI interface for KBPKIClient. | [
"GetTeamTLFCryptKeys",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L238-L249 |
158,995 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | GetCurrentMerkleRoot | func (k *KBPKIClient) GetCurrentMerkleRoot(ctx context.Context) (
keybase1.MerkleRootV2, time.Time, error) {
return k.serviceOwner.KeybaseService().GetCurrentMerkleRoot(ctx)
} | go | func (k *KBPKIClient) GetCurrentMerkleRoot(ctx context.Context) (
keybase1.MerkleRootV2, time.Time, error) {
return k.serviceOwner.KeybaseService().GetCurrentMerkleRoot(ctx)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"GetCurrentMerkleRoot",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"keybase1",
".",
"MerkleRootV2",
",",
"time",
".",
"Time",
",",
"error",
")",
"{",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"GetCurrentMerkleRoot",
"(",
"ctx",
")",
"\n",
"}"
] | // GetCurrentMerkleRoot implements the KBPKI interface for KBPKIClient. | [
"GetCurrentMerkleRoot",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L252-L255 |
158,996 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | VerifyMerkleRoot | func (k *KBPKIClient) VerifyMerkleRoot(
ctx context.Context, root keybase1.MerkleRootV2,
kbfsRoot keybase1.KBFSRoot) error {
return k.serviceOwner.KeybaseService().VerifyMerkleRoot(
ctx, root, kbfsRoot)
} | go | func (k *KBPKIClient) VerifyMerkleRoot(
ctx context.Context, root keybase1.MerkleRootV2,
kbfsRoot keybase1.KBFSRoot) error {
return k.serviceOwner.KeybaseService().VerifyMerkleRoot(
ctx, root, kbfsRoot)
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"VerifyMerkleRoot",
"(",
"ctx",
"context",
".",
"Context",
",",
"root",
"keybase1",
".",
"MerkleRootV2",
",",
"kbfsRoot",
"keybase1",
".",
"KBFSRoot",
")",
"error",
"{",
"return",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"VerifyMerkleRoot",
"(",
"ctx",
",",
"root",
",",
"kbfsRoot",
")",
"\n",
"}"
] | // VerifyMerkleRoot implements the KBPKI interface for KBPKIClient. | [
"VerifyMerkleRoot",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L258-L263 |
158,997 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | IsTeamWriter | func (k *KBPKIClient) IsTeamWriter(
ctx context.Context, tid keybase1.TeamID, uid keybase1.UID,
verifyingKey kbfscrypto.VerifyingKey,
offline keybase1.OfflineAvailability) (bool, error) {
if uid.IsNil() || verifyingKey.IsNil() {
// A sessionless user can never be a writer.
return false, nil
}
// Use the verifying key to find out the eldest seqno of the user.
userInfo, err := k.loadUserPlusKeys(ctx, uid, verifyingKey.KID(), offline)
if err != nil {
return false, err
}
found := false
for _, key := range userInfo.VerifyingKeys {
if verifyingKey.KID().Equal(key.KID()) {
found = true
break
}
}
if !found {
// For the purposes of finding the eldest seqno, we need to
// check the verified key against the list of revoked keys as
// well. (The caller should use `HasVerifyingKey` later to
// check whether the revoked key was valid at the time of the
// update or not.)
_, found = userInfo.RevokedVerifyingKeys[verifyingKey]
}
if !found {
// The user doesn't currently have this KID, therefore they
// shouldn't be treated as a writer. The caller should check
// historical device records and team membership.
k.log.CDebugf(ctx, "User %s doesn't currently have verifying key %s",
uid, verifyingKey.KID())
return false, nil
}
desiredUser := keybase1.UserVersion{
Uid: uid,
EldestSeqno: userInfo.EldestSeqno,
}
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlf.Unknown, kbfsmd.UnspecifiedKeyGen, desiredUser,
kbfscrypto.VerifyingKey{}, keybase1.TeamRole_WRITER, offline)
if err != nil {
if tid.IsPublic() {
if _, notFound := err.(libkb.NotFoundError); notFound {
// We are probably just not a writer of this public team.
k.log.CDebugf(ctx,
"Ignoring not found error for public team: %+v", err)
return false, nil
}
}
return false, err
}
return teamInfo.Writers[uid], nil
} | go | func (k *KBPKIClient) IsTeamWriter(
ctx context.Context, tid keybase1.TeamID, uid keybase1.UID,
verifyingKey kbfscrypto.VerifyingKey,
offline keybase1.OfflineAvailability) (bool, error) {
if uid.IsNil() || verifyingKey.IsNil() {
// A sessionless user can never be a writer.
return false, nil
}
// Use the verifying key to find out the eldest seqno of the user.
userInfo, err := k.loadUserPlusKeys(ctx, uid, verifyingKey.KID(), offline)
if err != nil {
return false, err
}
found := false
for _, key := range userInfo.VerifyingKeys {
if verifyingKey.KID().Equal(key.KID()) {
found = true
break
}
}
if !found {
// For the purposes of finding the eldest seqno, we need to
// check the verified key against the list of revoked keys as
// well. (The caller should use `HasVerifyingKey` later to
// check whether the revoked key was valid at the time of the
// update or not.)
_, found = userInfo.RevokedVerifyingKeys[verifyingKey]
}
if !found {
// The user doesn't currently have this KID, therefore they
// shouldn't be treated as a writer. The caller should check
// historical device records and team membership.
k.log.CDebugf(ctx, "User %s doesn't currently have verifying key %s",
uid, verifyingKey.KID())
return false, nil
}
desiredUser := keybase1.UserVersion{
Uid: uid,
EldestSeqno: userInfo.EldestSeqno,
}
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlf.Unknown, kbfsmd.UnspecifiedKeyGen, desiredUser,
kbfscrypto.VerifyingKey{}, keybase1.TeamRole_WRITER, offline)
if err != nil {
if tid.IsPublic() {
if _, notFound := err.(libkb.NotFoundError); notFound {
// We are probably just not a writer of this public team.
k.log.CDebugf(ctx,
"Ignoring not found error for public team: %+v", err)
return false, nil
}
}
return false, err
}
return teamInfo.Writers[uid], nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"IsTeamWriter",
"(",
"ctx",
"context",
".",
"Context",
",",
"tid",
"keybase1",
".",
"TeamID",
",",
"uid",
"keybase1",
".",
"UID",
",",
"verifyingKey",
"kbfscrypto",
".",
"VerifyingKey",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"uid",
".",
"IsNil",
"(",
")",
"||",
"verifyingKey",
".",
"IsNil",
"(",
")",
"{",
"// A sessionless user can never be a writer.",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"// Use the verifying key to find out the eldest seqno of the user.",
"userInfo",
",",
"err",
":=",
"k",
".",
"loadUserPlusKeys",
"(",
"ctx",
",",
"uid",
",",
"verifyingKey",
".",
"KID",
"(",
")",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"userInfo",
".",
"VerifyingKeys",
"{",
"if",
"verifyingKey",
".",
"KID",
"(",
")",
".",
"Equal",
"(",
"key",
".",
"KID",
"(",
")",
")",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"// For the purposes of finding the eldest seqno, we need to",
"// check the verified key against the list of revoked keys as",
"// well. (The caller should use `HasVerifyingKey` later to",
"// check whether the revoked key was valid at the time of the",
"// update or not.)",
"_",
",",
"found",
"=",
"userInfo",
".",
"RevokedVerifyingKeys",
"[",
"verifyingKey",
"]",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"// The user doesn't currently have this KID, therefore they",
"// shouldn't be treated as a writer. The caller should check",
"// historical device records and team membership.",
"k",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"uid",
",",
"verifyingKey",
".",
"KID",
"(",
")",
")",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"desiredUser",
":=",
"keybase1",
".",
"UserVersion",
"{",
"Uid",
":",
"uid",
",",
"EldestSeqno",
":",
"userInfo",
".",
"EldestSeqno",
",",
"}",
"\n",
"teamInfo",
",",
"err",
":=",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"LoadTeamPlusKeys",
"(",
"ctx",
",",
"tid",
",",
"tlf",
".",
"Unknown",
",",
"kbfsmd",
".",
"UnspecifiedKeyGen",
",",
"desiredUser",
",",
"kbfscrypto",
".",
"VerifyingKey",
"{",
"}",
",",
"keybase1",
".",
"TeamRole_WRITER",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"tid",
".",
"IsPublic",
"(",
")",
"{",
"if",
"_",
",",
"notFound",
":=",
"err",
".",
"(",
"libkb",
".",
"NotFoundError",
")",
";",
"notFound",
"{",
"// We are probably just not a writer of this public team.",
"k",
".",
"log",
".",
"CDebugf",
"(",
"ctx",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"teamInfo",
".",
"Writers",
"[",
"uid",
"]",
",",
"nil",
"\n",
"}"
] | // IsTeamWriter implements the KBPKI interface for KBPKIClient. | [
"IsTeamWriter",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L266-L324 |
158,998 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | NoLongerTeamWriter | func (k *KBPKIClient) NoLongerTeamWriter(
ctx context.Context, tid keybase1.TeamID, tlfType tlf.Type,
uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey,
offline keybase1.OfflineAvailability) (keybase1.MerkleRootV2, error) {
if uid.IsNil() || verifyingKey.IsNil() {
// A sessionless user can never be a writer.
return keybase1.MerkleRootV2{}, nil
}
// We don't need the eldest seqno when we look up an older writer,
// the service takes care of that for us.
desiredUser := keybase1.UserVersion{
Uid: uid,
}
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlfType, kbfsmd.UnspecifiedKeyGen, desiredUser,
verifyingKey, keybase1.TeamRole_WRITER, offline)
if err != nil {
return keybase1.MerkleRootV2{}, err
}
return teamInfo.LastWriters[verifyingKey], nil
} | go | func (k *KBPKIClient) NoLongerTeamWriter(
ctx context.Context, tid keybase1.TeamID, tlfType tlf.Type,
uid keybase1.UID, verifyingKey kbfscrypto.VerifyingKey,
offline keybase1.OfflineAvailability) (keybase1.MerkleRootV2, error) {
if uid.IsNil() || verifyingKey.IsNil() {
// A sessionless user can never be a writer.
return keybase1.MerkleRootV2{}, nil
}
// We don't need the eldest seqno when we look up an older writer,
// the service takes care of that for us.
desiredUser := keybase1.UserVersion{
Uid: uid,
}
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlfType, kbfsmd.UnspecifiedKeyGen, desiredUser,
verifyingKey, keybase1.TeamRole_WRITER, offline)
if err != nil {
return keybase1.MerkleRootV2{}, err
}
return teamInfo.LastWriters[verifyingKey], nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"NoLongerTeamWriter",
"(",
"ctx",
"context",
".",
"Context",
",",
"tid",
"keybase1",
".",
"TeamID",
",",
"tlfType",
"tlf",
".",
"Type",
",",
"uid",
"keybase1",
".",
"UID",
",",
"verifyingKey",
"kbfscrypto",
".",
"VerifyingKey",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"keybase1",
".",
"MerkleRootV2",
",",
"error",
")",
"{",
"if",
"uid",
".",
"IsNil",
"(",
")",
"||",
"verifyingKey",
".",
"IsNil",
"(",
")",
"{",
"// A sessionless user can never be a writer.",
"return",
"keybase1",
".",
"MerkleRootV2",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"// We don't need the eldest seqno when we look up an older writer,",
"// the service takes care of that for us.",
"desiredUser",
":=",
"keybase1",
".",
"UserVersion",
"{",
"Uid",
":",
"uid",
",",
"}",
"\n\n",
"teamInfo",
",",
"err",
":=",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"LoadTeamPlusKeys",
"(",
"ctx",
",",
"tid",
",",
"tlfType",
",",
"kbfsmd",
".",
"UnspecifiedKeyGen",
",",
"desiredUser",
",",
"verifyingKey",
",",
"keybase1",
".",
"TeamRole_WRITER",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"keybase1",
".",
"MerkleRootV2",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"return",
"teamInfo",
".",
"LastWriters",
"[",
"verifyingKey",
"]",
",",
"nil",
"\n",
"}"
] | // NoLongerTeamWriter implements the KBPKI interface for KBPKIClient. | [
"NoLongerTeamWriter",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L327-L349 |
158,999 | keybase/client | go/kbfs/libkbfs/kbpki_client.go | IsTeamReader | func (k *KBPKIClient) IsTeamReader(
ctx context.Context, tid keybase1.TeamID, uid keybase1.UID,
offline keybase1.OfflineAvailability) (bool, error) {
desiredUser := keybase1.UserVersion{Uid: uid}
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlf.Unknown, kbfsmd.UnspecifiedKeyGen, desiredUser,
kbfscrypto.VerifyingKey{}, keybase1.TeamRole_READER, offline)
if err != nil {
return false, err
}
return tid.IsPublic() || teamInfo.Writers[uid] || teamInfo.Readers[uid], nil
} | go | func (k *KBPKIClient) IsTeamReader(
ctx context.Context, tid keybase1.TeamID, uid keybase1.UID,
offline keybase1.OfflineAvailability) (bool, error) {
desiredUser := keybase1.UserVersion{Uid: uid}
teamInfo, err := k.serviceOwner.KeybaseService().LoadTeamPlusKeys(
ctx, tid, tlf.Unknown, kbfsmd.UnspecifiedKeyGen, desiredUser,
kbfscrypto.VerifyingKey{}, keybase1.TeamRole_READER, offline)
if err != nil {
return false, err
}
return tid.IsPublic() || teamInfo.Writers[uid] || teamInfo.Readers[uid], nil
} | [
"func",
"(",
"k",
"*",
"KBPKIClient",
")",
"IsTeamReader",
"(",
"ctx",
"context",
".",
"Context",
",",
"tid",
"keybase1",
".",
"TeamID",
",",
"uid",
"keybase1",
".",
"UID",
",",
"offline",
"keybase1",
".",
"OfflineAvailability",
")",
"(",
"bool",
",",
"error",
")",
"{",
"desiredUser",
":=",
"keybase1",
".",
"UserVersion",
"{",
"Uid",
":",
"uid",
"}",
"\n",
"teamInfo",
",",
"err",
":=",
"k",
".",
"serviceOwner",
".",
"KeybaseService",
"(",
")",
".",
"LoadTeamPlusKeys",
"(",
"ctx",
",",
"tid",
",",
"tlf",
".",
"Unknown",
",",
"kbfsmd",
".",
"UnspecifiedKeyGen",
",",
"desiredUser",
",",
"kbfscrypto",
".",
"VerifyingKey",
"{",
"}",
",",
"keybase1",
".",
"TeamRole_READER",
",",
"offline",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"tid",
".",
"IsPublic",
"(",
")",
"||",
"teamInfo",
".",
"Writers",
"[",
"uid",
"]",
"||",
"teamInfo",
".",
"Readers",
"[",
"uid",
"]",
",",
"nil",
"\n",
"}"
] | // IsTeamReader implements the KBPKI interface for KBPKIClient. | [
"IsTeamReader",
"implements",
"the",
"KBPKI",
"interface",
"for",
"KBPKIClient",
"."
] | b352622cd8cc94798cfacbcb56ada203c18e519e | https://github.com/keybase/client/blob/b352622cd8cc94798cfacbcb56ada203c18e519e/go/kbfs/libkbfs/kbpki_client.go#L352-L363 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.