repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
google/codesearch | index/write.go | AddPaths | func (ix *IndexWriter) AddPaths(paths []string) {
ix.paths = append(ix.paths, paths...)
} | go | func (ix *IndexWriter) AddPaths(paths []string) {
ix.paths = append(ix.paths, paths...)
} | [
"func",
"(",
"ix",
"*",
"IndexWriter",
")",
"AddPaths",
"(",
"paths",
"[",
"]",
"string",
")",
"{",
"ix",
".",
"paths",
"=",
"append",
"(",
"ix",
".",
"paths",
",",
"paths",
"...",
")",
"\n",
"}"
] | // AddPaths adds the given paths to the index's list of paths. | [
"AddPaths",
"adds",
"the",
"given",
"paths",
"to",
"the",
"index",
"s",
"list",
"of",
"paths",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L100-L102 | train |
google/codesearch | index/write.go | Add | func (ix *IndexWriter) Add(name string, f io.Reader) {
ix.trigram.Reset()
var (
c = byte(0)
i = 0
buf = ix.inbuf[:0]
tv = uint32(0)
n = int64(0)
linelen = 0
)
for {
tv = (tv << 8) & (1<<24 - 1)
if i >= len(buf) {
n, err := f.Read(buf[:cap(buf)])
if n == 0 {
if err != nil {
if err == io.EOF {
break
}
log.Printf("%s: %v\n", name, err)
return
}
log.Printf("%s: 0-length read\n", name)
return
}
buf = buf[:n]
i = 0
}
c = buf[i]
i++
tv |= uint32(c)
if n++; n >= 3 {
ix.trigram.Add(tv)
}
if !validUTF8((tv>>8)&0xFF, tv&0xFF) {
if ix.LogSkip {
log.Printf("%s: invalid UTF-8, ignoring\n", name)
}
return
}
if n > maxFileLen {
if ix.LogSkip {
log.Printf("%s: too long, ignoring\n", name)
}
return
}
if linelen++; linelen > maxLineLen {
if ix.LogSkip {
log.Printf("%s: very long lines, ignoring\n", name)
}
return
}
if c == '\n' {
linelen = 0
}
}
if ix.trigram.Len() > maxTextTrigrams {
if ix.LogSkip {
log.Printf("%s: too many trigrams, probably not text, ignoring\n", name)
}
return
}
ix.totalBytes += n
if ix.Verbose {
log.Printf("%d %d %s\n", n, ix.trigram.Len(), name)
}
fileid := ix.addName(name)
for _, trigram := range ix.trigram.Dense() {
if len(ix.post) >= cap(ix.post) {
ix.flushPost()
}
ix.post = append(ix.post, makePostEntry(trigram, fileid))
}
} | go | func (ix *IndexWriter) Add(name string, f io.Reader) {
ix.trigram.Reset()
var (
c = byte(0)
i = 0
buf = ix.inbuf[:0]
tv = uint32(0)
n = int64(0)
linelen = 0
)
for {
tv = (tv << 8) & (1<<24 - 1)
if i >= len(buf) {
n, err := f.Read(buf[:cap(buf)])
if n == 0 {
if err != nil {
if err == io.EOF {
break
}
log.Printf("%s: %v\n", name, err)
return
}
log.Printf("%s: 0-length read\n", name)
return
}
buf = buf[:n]
i = 0
}
c = buf[i]
i++
tv |= uint32(c)
if n++; n >= 3 {
ix.trigram.Add(tv)
}
if !validUTF8((tv>>8)&0xFF, tv&0xFF) {
if ix.LogSkip {
log.Printf("%s: invalid UTF-8, ignoring\n", name)
}
return
}
if n > maxFileLen {
if ix.LogSkip {
log.Printf("%s: too long, ignoring\n", name)
}
return
}
if linelen++; linelen > maxLineLen {
if ix.LogSkip {
log.Printf("%s: very long lines, ignoring\n", name)
}
return
}
if c == '\n' {
linelen = 0
}
}
if ix.trigram.Len() > maxTextTrigrams {
if ix.LogSkip {
log.Printf("%s: too many trigrams, probably not text, ignoring\n", name)
}
return
}
ix.totalBytes += n
if ix.Verbose {
log.Printf("%d %d %s\n", n, ix.trigram.Len(), name)
}
fileid := ix.addName(name)
for _, trigram := range ix.trigram.Dense() {
if len(ix.post) >= cap(ix.post) {
ix.flushPost()
}
ix.post = append(ix.post, makePostEntry(trigram, fileid))
}
} | [
"func",
"(",
"ix",
"*",
"IndexWriter",
")",
"Add",
"(",
"name",
"string",
",",
"f",
"io",
".",
"Reader",
")",
"{",
"ix",
".",
"trigram",
".",
"Reset",
"(",
")",
"\n",
"var",
"(",
"c",
"=",
"byte",
"(",
"0",
")",
"\n",
"i",
"=",
"0",
"\n",
"buf",
"=",
"ix",
".",
"inbuf",
"[",
":",
"0",
"]",
"\n",
"tv",
"=",
"uint32",
"(",
"0",
")",
"\n",
"n",
"=",
"int64",
"(",
"0",
")",
"\n",
"linelen",
"=",
"0",
"\n",
")",
"\n",
"for",
"{",
"tv",
"=",
"(",
"tv",
"<<",
"8",
")",
"&",
"(",
"1",
"<<",
"24",
"-",
"1",
")",
"\n",
"if",
"i",
">=",
"len",
"(",
"buf",
")",
"{",
"n",
",",
"err",
":=",
"f",
".",
"Read",
"(",
"buf",
"[",
":",
"cap",
"(",
"buf",
")",
"]",
")",
"\n",
"if",
"n",
"==",
"0",
"{",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"\n",
"log",
".",
"Printf",
"(",
"\"%s: %v\\n\"",
",",
"\\n",
",",
"name",
")",
"\n",
"err",
"\n",
"}",
"\n",
"return",
"\n",
"log",
".",
"Printf",
"(",
"\"%s: 0-length read\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"name",
"\n",
"return",
"\n",
"}",
"\n",
"buf",
"=",
"buf",
"[",
":",
"n",
"]",
"\n",
"i",
"=",
"0",
"\n",
"c",
"=",
"buf",
"[",
"i",
"]",
"\n",
"i",
"++",
"\n",
"tv",
"|=",
"uint32",
"(",
"c",
")",
"\n",
"if",
"n",
"++",
";",
"n",
">=",
"3",
"{",
"ix",
".",
"trigram",
".",
"Add",
"(",
"tv",
")",
"\n",
"}",
"\n",
"if",
"!",
"validUTF8",
"(",
"(",
"tv",
">>",
"8",
")",
"&",
"0xFF",
",",
"tv",
"&",
"0xFF",
")",
"{",
"if",
"ix",
".",
"LogSkip",
"{",
"log",
".",
"Printf",
"(",
"\"%s: invalid UTF-8, ignoring\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"name",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"n",
">",
"maxFileLen",
"{",
"if",
"ix",
".",
"LogSkip",
"{",
"log",
".",
"Printf",
"(",
"\"%s: too long, ignoring\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"name",
"\n",
"}",
"\n",
"return",
"\n",
"if",
"linelen",
"++",
";",
"linelen",
">",
"maxLineLen",
"{",
"if",
"ix",
".",
"LogSkip",
"{",
"log",
".",
"Printf",
"(",
"\"%s: very long lines, ignoring\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"name",
"\n",
"}",
"\n",
"return",
"\n",
"if",
"c",
"==",
"'\\n'",
"{",
"linelen",
"=",
"0",
"\n",
"}",
"\n",
"}"
] | // Add adds the file f to the index under the given name.
// It logs errors using package log. | [
"Add",
"adds",
"the",
"file",
"f",
"to",
"the",
"index",
"under",
"the",
"given",
"name",
".",
"It",
"logs",
"errors",
"using",
"package",
"log",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L118-L193 | train |
google/codesearch | index/write.go | Flush | func (ix *IndexWriter) Flush() {
ix.addName("")
var off [5]uint32
ix.main.writeString(magic)
off[0] = ix.main.offset()
for _, p := range ix.paths {
ix.main.writeString(p)
ix.main.writeString("\x00")
}
ix.main.writeString("\x00")
off[1] = ix.main.offset()
copyFile(ix.main, ix.nameData)
off[2] = ix.main.offset()
ix.mergePost(ix.main)
off[3] = ix.main.offset()
copyFile(ix.main, ix.nameIndex)
off[4] = ix.main.offset()
copyFile(ix.main, ix.postIndex)
for _, v := range off {
ix.main.writeUint32(v)
}
ix.main.writeString(trailerMagic)
os.Remove(ix.nameData.name)
for _, f := range ix.postFile {
os.Remove(f.Name())
}
os.Remove(ix.nameIndex.name)
os.Remove(ix.postIndex.name)
log.Printf("%d data bytes, %d index bytes", ix.totalBytes, ix.main.offset())
ix.main.flush()
} | go | func (ix *IndexWriter) Flush() {
ix.addName("")
var off [5]uint32
ix.main.writeString(magic)
off[0] = ix.main.offset()
for _, p := range ix.paths {
ix.main.writeString(p)
ix.main.writeString("\x00")
}
ix.main.writeString("\x00")
off[1] = ix.main.offset()
copyFile(ix.main, ix.nameData)
off[2] = ix.main.offset()
ix.mergePost(ix.main)
off[3] = ix.main.offset()
copyFile(ix.main, ix.nameIndex)
off[4] = ix.main.offset()
copyFile(ix.main, ix.postIndex)
for _, v := range off {
ix.main.writeUint32(v)
}
ix.main.writeString(trailerMagic)
os.Remove(ix.nameData.name)
for _, f := range ix.postFile {
os.Remove(f.Name())
}
os.Remove(ix.nameIndex.name)
os.Remove(ix.postIndex.name)
log.Printf("%d data bytes, %d index bytes", ix.totalBytes, ix.main.offset())
ix.main.flush()
} | [
"func",
"(",
"ix",
"*",
"IndexWriter",
")",
"Flush",
"(",
")",
"{",
"ix",
".",
"addName",
"(",
"\"\"",
")",
"\n",
"var",
"off",
"[",
"5",
"]",
"uint32",
"\n",
"ix",
".",
"main",
".",
"writeString",
"(",
"magic",
")",
"\n",
"off",
"[",
"0",
"]",
"=",
"ix",
".",
"main",
".",
"offset",
"(",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"ix",
".",
"paths",
"{",
"ix",
".",
"main",
".",
"writeString",
"(",
"p",
")",
"\n",
"ix",
".",
"main",
".",
"writeString",
"(",
"\"\\x00\"",
")",
"\n",
"}",
"\n",
"\\x00",
"\n",
"ix",
".",
"main",
".",
"writeString",
"(",
"\"\\x00\"",
")",
"\n",
"\\x00",
"\n",
"off",
"[",
"1",
"]",
"=",
"ix",
".",
"main",
".",
"offset",
"(",
")",
"\n",
"copyFile",
"(",
"ix",
".",
"main",
",",
"ix",
".",
"nameData",
")",
"\n",
"off",
"[",
"2",
"]",
"=",
"ix",
".",
"main",
".",
"offset",
"(",
")",
"\n",
"ix",
".",
"mergePost",
"(",
"ix",
".",
"main",
")",
"\n",
"off",
"[",
"3",
"]",
"=",
"ix",
".",
"main",
".",
"offset",
"(",
")",
"\n",
"copyFile",
"(",
"ix",
".",
"main",
",",
"ix",
".",
"nameIndex",
")",
"\n",
"off",
"[",
"4",
"]",
"=",
"ix",
".",
"main",
".",
"offset",
"(",
")",
"\n",
"copyFile",
"(",
"ix",
".",
"main",
",",
"ix",
".",
"postIndex",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"off",
"{",
"ix",
".",
"main",
".",
"writeUint32",
"(",
"v",
")",
"\n",
"}",
"\n",
"ix",
".",
"main",
".",
"writeString",
"(",
"trailerMagic",
")",
"\n",
"os",
".",
"Remove",
"(",
"ix",
".",
"nameData",
".",
"name",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"ix",
".",
"postFile",
"{",
"os",
".",
"Remove",
"(",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"os",
".",
"Remove",
"(",
"ix",
".",
"nameIndex",
".",
"name",
")",
"\n",
"os",
".",
"Remove",
"(",
"ix",
".",
"postIndex",
".",
"name",
")",
"\n",
"}"
] | // Flush flushes the index entry to the target file. | [
"Flush",
"flushes",
"the",
"index",
"entry",
"to",
"the",
"target",
"file",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L196-L230 | train |
google/codesearch | index/write.go | addName | func (ix *IndexWriter) addName(name string) uint32 {
if strings.Contains(name, "\x00") {
log.Fatalf("%q: file has NUL byte in name", name)
}
ix.nameIndex.writeUint32(ix.nameData.offset())
ix.nameData.writeString(name)
ix.nameData.writeByte(0)
id := ix.numName
ix.numName++
return uint32(id)
} | go | func (ix *IndexWriter) addName(name string) uint32 {
if strings.Contains(name, "\x00") {
log.Fatalf("%q: file has NUL byte in name", name)
}
ix.nameIndex.writeUint32(ix.nameData.offset())
ix.nameData.writeString(name)
ix.nameData.writeByte(0)
id := ix.numName
ix.numName++
return uint32(id)
} | [
"func",
"(",
"ix",
"*",
"IndexWriter",
")",
"addName",
"(",
"name",
"string",
")",
"uint32",
"{",
"if",
"strings",
".",
"Contains",
"(",
"name",
",",
"\"\\x00\"",
")",
"\\x00",
"\n",
"{",
"log",
".",
"Fatalf",
"(",
"\"%q: file has NUL byte in name\"",
",",
"name",
")",
"\n",
"}",
"\n",
"ix",
".",
"nameIndex",
".",
"writeUint32",
"(",
"ix",
".",
"nameData",
".",
"offset",
"(",
")",
")",
"\n",
"ix",
".",
"nameData",
".",
"writeString",
"(",
"name",
")",
"\n",
"ix",
".",
"nameData",
".",
"writeByte",
"(",
"0",
")",
"\n",
"id",
":=",
"ix",
".",
"numName",
"\n",
"ix",
".",
"numName",
"++",
"\n",
"}"
] | // addName adds the file with the given name to the index.
// It returns the assigned file ID number. | [
"addName",
"adds",
"the",
"file",
"with",
"the",
"given",
"name",
"to",
"the",
"index",
".",
"It",
"returns",
"the",
"assigned",
"file",
"ID",
"number",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L242-L253 | train |
google/codesearch | index/write.go | flushPost | func (ix *IndexWriter) flushPost() {
w, err := ioutil.TempFile("", "csearch-index")
if err != nil {
log.Fatal(err)
}
if ix.Verbose {
log.Printf("flush %d entries to %s", len(ix.post), w.Name())
}
sortPost(ix.post)
// Write the raw ix.post array to disk as is.
// This process is the one reading it back in, so byte order is not a concern.
data := (*[npost * 8]byte)(unsafe.Pointer(&ix.post[0]))[:len(ix.post)*8]
if n, err := w.Write(data); err != nil || n < len(data) {
if err != nil {
log.Fatal(err)
}
log.Fatalf("short write writing %s", w.Name())
}
ix.post = ix.post[:0]
w.Seek(0, 0)
ix.postFile = append(ix.postFile, w)
} | go | func (ix *IndexWriter) flushPost() {
w, err := ioutil.TempFile("", "csearch-index")
if err != nil {
log.Fatal(err)
}
if ix.Verbose {
log.Printf("flush %d entries to %s", len(ix.post), w.Name())
}
sortPost(ix.post)
// Write the raw ix.post array to disk as is.
// This process is the one reading it back in, so byte order is not a concern.
data := (*[npost * 8]byte)(unsafe.Pointer(&ix.post[0]))[:len(ix.post)*8]
if n, err := w.Write(data); err != nil || n < len(data) {
if err != nil {
log.Fatal(err)
}
log.Fatalf("short write writing %s", w.Name())
}
ix.post = ix.post[:0]
w.Seek(0, 0)
ix.postFile = append(ix.postFile, w)
} | [
"func",
"(",
"ix",
"*",
"IndexWriter",
")",
"flushPost",
"(",
")",
"{",
"w",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"\"\"",
",",
"\"csearch-index\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ix",
".",
"Verbose",
"{",
"log",
".",
"Printf",
"(",
"\"flush %d entries to %s\"",
",",
"len",
"(",
"ix",
".",
"post",
")",
",",
"w",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"sortPost",
"(",
"ix",
".",
"post",
")",
"\n",
"data",
":=",
"(",
"*",
"[",
"npost",
"*",
"8",
"]",
"byte",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"ix",
".",
"post",
"[",
"0",
"]",
")",
")",
"[",
":",
"len",
"(",
"ix",
".",
"post",
")",
"*",
"8",
"]",
"\n",
"if",
"n",
",",
"err",
":=",
"w",
".",
"Write",
"(",
"data",
")",
";",
"err",
"!=",
"nil",
"||",
"n",
"<",
"len",
"(",
"data",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Fatalf",
"(",
"\"short write writing %s\"",
",",
"w",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"ix",
".",
"post",
"=",
"ix",
".",
"post",
"[",
":",
"0",
"]",
"\n",
"w",
".",
"Seek",
"(",
"0",
",",
"0",
")",
"\n",
"ix",
".",
"postFile",
"=",
"append",
"(",
"ix",
".",
"postFile",
",",
"w",
")",
"\n",
"}"
] | // flushPost writes ix.post to a new temporary file and
// clears the slice. | [
"flushPost",
"writes",
"ix",
".",
"post",
"to",
"a",
"new",
"temporary",
"file",
"and",
"clears",
"the",
"slice",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L257-L280 | train |
google/codesearch | index/write.go | mergePost | func (ix *IndexWriter) mergePost(out *bufWriter) {
var h postHeap
log.Printf("merge %d files + mem", len(ix.postFile))
for _, f := range ix.postFile {
h.addFile(f)
}
sortPost(ix.post)
h.addMem(ix.post)
npost := 0
e := h.next()
offset0 := out.offset()
for {
npost++
offset := out.offset() - offset0
trigram := e.trigram()
ix.buf[0] = byte(trigram >> 16)
ix.buf[1] = byte(trigram >> 8)
ix.buf[2] = byte(trigram)
// posting list
fileid := ^uint32(0)
nfile := uint32(0)
out.write(ix.buf[:3])
for ; e.trigram() == trigram && trigram != 1<<24-1; e = h.next() {
out.writeUvarint(e.fileid() - fileid)
fileid = e.fileid()
nfile++
}
out.writeUvarint(0)
// index entry
ix.postIndex.write(ix.buf[:3])
ix.postIndex.writeUint32(nfile)
ix.postIndex.writeUint32(offset)
if trigram == 1<<24-1 {
break
}
}
} | go | func (ix *IndexWriter) mergePost(out *bufWriter) {
var h postHeap
log.Printf("merge %d files + mem", len(ix.postFile))
for _, f := range ix.postFile {
h.addFile(f)
}
sortPost(ix.post)
h.addMem(ix.post)
npost := 0
e := h.next()
offset0 := out.offset()
for {
npost++
offset := out.offset() - offset0
trigram := e.trigram()
ix.buf[0] = byte(trigram >> 16)
ix.buf[1] = byte(trigram >> 8)
ix.buf[2] = byte(trigram)
// posting list
fileid := ^uint32(0)
nfile := uint32(0)
out.write(ix.buf[:3])
for ; e.trigram() == trigram && trigram != 1<<24-1; e = h.next() {
out.writeUvarint(e.fileid() - fileid)
fileid = e.fileid()
nfile++
}
out.writeUvarint(0)
// index entry
ix.postIndex.write(ix.buf[:3])
ix.postIndex.writeUint32(nfile)
ix.postIndex.writeUint32(offset)
if trigram == 1<<24-1 {
break
}
}
} | [
"func",
"(",
"ix",
"*",
"IndexWriter",
")",
"mergePost",
"(",
"out",
"*",
"bufWriter",
")",
"{",
"var",
"h",
"postHeap",
"\n",
"log",
".",
"Printf",
"(",
"\"merge %d files + mem\"",
",",
"len",
"(",
"ix",
".",
"postFile",
")",
")",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"ix",
".",
"postFile",
"{",
"h",
".",
"addFile",
"(",
"f",
")",
"\n",
"}",
"\n",
"sortPost",
"(",
"ix",
".",
"post",
")",
"\n",
"h",
".",
"addMem",
"(",
"ix",
".",
"post",
")",
"\n",
"npost",
":=",
"0",
"\n",
"e",
":=",
"h",
".",
"next",
"(",
")",
"\n",
"offset0",
":=",
"out",
".",
"offset",
"(",
")",
"\n",
"for",
"{",
"npost",
"++",
"\n",
"offset",
":=",
"out",
".",
"offset",
"(",
")",
"-",
"offset0",
"\n",
"trigram",
":=",
"e",
".",
"trigram",
"(",
")",
"\n",
"ix",
".",
"buf",
"[",
"0",
"]",
"=",
"byte",
"(",
"trigram",
">>",
"16",
")",
"\n",
"ix",
".",
"buf",
"[",
"1",
"]",
"=",
"byte",
"(",
"trigram",
">>",
"8",
")",
"\n",
"ix",
".",
"buf",
"[",
"2",
"]",
"=",
"byte",
"(",
"trigram",
")",
"\n",
"fileid",
":=",
"^",
"uint32",
"(",
"0",
")",
"\n",
"nfile",
":=",
"uint32",
"(",
"0",
")",
"\n",
"out",
".",
"write",
"(",
"ix",
".",
"buf",
"[",
":",
"3",
"]",
")",
"\n",
"for",
";",
"e",
".",
"trigram",
"(",
")",
"==",
"trigram",
"&&",
"trigram",
"!=",
"1",
"<<",
"24",
"-",
"1",
";",
"e",
"=",
"h",
".",
"next",
"(",
")",
"{",
"out",
".",
"writeUvarint",
"(",
"e",
".",
"fileid",
"(",
")",
"-",
"fileid",
")",
"\n",
"fileid",
"=",
"e",
".",
"fileid",
"(",
")",
"\n",
"nfile",
"++",
"\n",
"}",
"\n",
"out",
".",
"writeUvarint",
"(",
"0",
")",
"\n",
"ix",
".",
"postIndex",
".",
"write",
"(",
"ix",
".",
"buf",
"[",
":",
"3",
"]",
")",
"\n",
"ix",
".",
"postIndex",
".",
"writeUint32",
"(",
"nfile",
")",
"\n",
"ix",
".",
"postIndex",
".",
"writeUint32",
"(",
"offset",
")",
"\n",
"if",
"trigram",
"==",
"1",
"<<",
"24",
"-",
"1",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // mergePost reads the flushed index entries and merges them
// into posting lists, writing the resulting lists to out. | [
"mergePost",
"reads",
"the",
"flushed",
"index",
"entries",
"and",
"merges",
"them",
"into",
"posting",
"lists",
"writing",
"the",
"resulting",
"lists",
"to",
"out",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L284-L325 | train |
google/codesearch | index/write.go | step | func (h *postHeap) step(ch *postChunk) bool {
old := ch.e
m := ch.m
if len(m) == 0 {
return false
}
ch.e = postEntry(m[0])
m = m[1:]
ch.m = m
if old >= ch.e {
panic("bad sort")
}
return true
} | go | func (h *postHeap) step(ch *postChunk) bool {
old := ch.e
m := ch.m
if len(m) == 0 {
return false
}
ch.e = postEntry(m[0])
m = m[1:]
ch.m = m
if old >= ch.e {
panic("bad sort")
}
return true
} | [
"func",
"(",
"h",
"*",
"postHeap",
")",
"step",
"(",
"ch",
"*",
"postChunk",
")",
"bool",
"{",
"old",
":=",
"ch",
".",
"e",
"\n",
"m",
":=",
"ch",
".",
"m",
"\n",
"if",
"len",
"(",
"m",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n",
"ch",
".",
"e",
"=",
"postEntry",
"(",
"m",
"[",
"0",
"]",
")",
"\n",
"m",
"=",
"m",
"[",
"1",
":",
"]",
"\n",
"ch",
".",
"m",
"=",
"m",
"\n",
"if",
"old",
">=",
"ch",
".",
"e",
"{",
"panic",
"(",
"\"bad sort\"",
")",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // step reads the next entry from ch and saves it in ch.e.
// It returns false if ch is over. | [
"step",
"reads",
"the",
"next",
"entry",
"from",
"ch",
"and",
"saves",
"it",
"in",
"ch",
".",
"e",
".",
"It",
"returns",
"false",
"if",
"ch",
"is",
"over",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L353-L366 | train |
google/codesearch | index/write.go | add | func (h *postHeap) add(ch *postChunk) {
if len(ch.m) > 0 {
ch.e = ch.m[0]
ch.m = ch.m[1:]
h.push(ch)
}
} | go | func (h *postHeap) add(ch *postChunk) {
if len(ch.m) > 0 {
ch.e = ch.m[0]
ch.m = ch.m[1:]
h.push(ch)
}
} | [
"func",
"(",
"h",
"*",
"postHeap",
")",
"add",
"(",
"ch",
"*",
"postChunk",
")",
"{",
"if",
"len",
"(",
"ch",
".",
"m",
")",
">",
"0",
"{",
"ch",
".",
"e",
"=",
"ch",
".",
"m",
"[",
"0",
"]",
"\n",
"ch",
".",
"m",
"=",
"ch",
".",
"m",
"[",
"1",
":",
"]",
"\n",
"h",
".",
"push",
"(",
"ch",
")",
"\n",
"}",
"\n",
"}"
] | // add adds the chunk to the postHeap.
// All adds must be called before the first call to next. | [
"add",
"adds",
"the",
"chunk",
"to",
"the",
"postHeap",
".",
"All",
"adds",
"must",
"be",
"called",
"before",
"the",
"first",
"call",
"to",
"next",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L370-L376 | train |
google/codesearch | index/write.go | next | func (h *postHeap) next() postEntry {
if len(h.ch) == 0 {
return makePostEntry(1<<24-1, 0)
}
ch := h.ch[0]
e := ch.e
m := ch.m
if len(m) == 0 {
h.pop()
} else {
ch.e = m[0]
ch.m = m[1:]
h.siftDown(0)
}
return e
} | go | func (h *postHeap) next() postEntry {
if len(h.ch) == 0 {
return makePostEntry(1<<24-1, 0)
}
ch := h.ch[0]
e := ch.e
m := ch.m
if len(m) == 0 {
h.pop()
} else {
ch.e = m[0]
ch.m = m[1:]
h.siftDown(0)
}
return e
} | [
"func",
"(",
"h",
"*",
"postHeap",
")",
"next",
"(",
")",
"postEntry",
"{",
"if",
"len",
"(",
"h",
".",
"ch",
")",
"==",
"0",
"{",
"return",
"makePostEntry",
"(",
"1",
"<<",
"24",
"-",
"1",
",",
"0",
")",
"\n",
"}",
"\n",
"ch",
":=",
"h",
".",
"ch",
"[",
"0",
"]",
"\n",
"e",
":=",
"ch",
".",
"e",
"\n",
"m",
":=",
"ch",
".",
"m",
"\n",
"if",
"len",
"(",
"m",
")",
"==",
"0",
"{",
"h",
".",
"pop",
"(",
")",
"\n",
"}",
"else",
"{",
"ch",
".",
"e",
"=",
"m",
"[",
"0",
"]",
"\n",
"ch",
".",
"m",
"=",
"m",
"[",
"1",
":",
"]",
"\n",
"h",
".",
"siftDown",
"(",
"0",
")",
"\n",
"}",
"\n",
"return",
"e",
"\n",
"}"
] | // next returns the next entry from the postHeap.
// It returns a postEntry with trigram == 1<<24 - 1 if h is empty. | [
"next",
"returns",
"the",
"next",
"entry",
"from",
"the",
"postHeap",
".",
"It",
"returns",
"a",
"postEntry",
"with",
"trigram",
"==",
"1<<24",
"-",
"1",
"if",
"h",
"is",
"empty",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L385-L400 | train |
google/codesearch | index/write.go | bufCreate | func bufCreate(name string) *bufWriter {
var (
f *os.File
err error
)
if name != "" {
f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
} else {
f, err = ioutil.TempFile("", "csearch")
}
if err != nil {
log.Fatal(err)
}
return &bufWriter{
name: f.Name(),
buf: make([]byte, 0, 256<<10),
file: f,
}
} | go | func bufCreate(name string) *bufWriter {
var (
f *os.File
err error
)
if name != "" {
f, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
} else {
f, err = ioutil.TempFile("", "csearch")
}
if err != nil {
log.Fatal(err)
}
return &bufWriter{
name: f.Name(),
buf: make([]byte, 0, 256<<10),
file: f,
}
} | [
"func",
"bufCreate",
"(",
"name",
"string",
")",
"*",
"bufWriter",
"{",
"var",
"(",
"f",
"*",
"os",
".",
"File",
"\n",
"err",
"error",
"\n",
")",
"\n",
"if",
"name",
"!=",
"\"\"",
"{",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"name",
",",
"os",
".",
"O_RDWR",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
",",
"0600",
")",
"\n",
"}",
"else",
"{",
"f",
",",
"err",
"=",
"ioutil",
".",
"TempFile",
"(",
"\"\"",
",",
"\"csearch\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"bufWriter",
"{",
"name",
":",
"f",
".",
"Name",
"(",
")",
",",
"buf",
":",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"256",
"<<",
"10",
")",
",",
"file",
":",
"f",
",",
"}",
"\n",
"}"
] | // bufCreate creates a new file with the given name and returns a
// corresponding bufWriter. If name is empty, bufCreate uses a
// temporary file. | [
"bufCreate",
"creates",
"a",
"new",
"file",
"with",
"the",
"given",
"name",
"and",
"returns",
"a",
"corresponding",
"bufWriter",
".",
"If",
"name",
"is",
"empty",
"bufCreate",
"uses",
"a",
"temporary",
"file",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L463-L481 | train |
google/codesearch | index/write.go | offset | func (b *bufWriter) offset() uint32 {
off, _ := b.file.Seek(0, 1)
off += int64(len(b.buf))
if int64(uint32(off)) != off {
log.Fatalf("index is larger than 4GB")
}
return uint32(off)
} | go | func (b *bufWriter) offset() uint32 {
off, _ := b.file.Seek(0, 1)
off += int64(len(b.buf))
if int64(uint32(off)) != off {
log.Fatalf("index is larger than 4GB")
}
return uint32(off)
} | [
"func",
"(",
"b",
"*",
"bufWriter",
")",
"offset",
"(",
")",
"uint32",
"{",
"off",
",",
"_",
":=",
"b",
".",
"file",
".",
"Seek",
"(",
"0",
",",
"1",
")",
"\n",
"off",
"+=",
"int64",
"(",
"len",
"(",
"b",
".",
"buf",
")",
")",
"\n",
"if",
"int64",
"(",
"uint32",
"(",
"off",
")",
")",
"!=",
"off",
"{",
"log",
".",
"Fatalf",
"(",
"\"index is larger than 4GB\"",
")",
"\n",
"}",
"\n",
"return",
"uint32",
"(",
"off",
")",
"\n",
"}"
] | // offset returns the current write offset. | [
"offset",
"returns",
"the",
"current",
"write",
"offset",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L519-L526 | train |
google/codesearch | index/write.go | finish | func (b *bufWriter) finish() *os.File {
b.flush()
f := b.file
f.Seek(0, 0)
return f
} | go | func (b *bufWriter) finish() *os.File {
b.flush()
f := b.file
f.Seek(0, 0)
return f
} | [
"func",
"(",
"b",
"*",
"bufWriter",
")",
"finish",
"(",
")",
"*",
"os",
".",
"File",
"{",
"b",
".",
"flush",
"(",
")",
"\n",
"f",
":=",
"b",
".",
"file",
"\n",
"f",
".",
"Seek",
"(",
"0",
",",
"0",
")",
"\n",
"return",
"f",
"\n",
"}"
] | // finish flushes the file to disk and returns an open file ready for reading. | [
"finish",
"flushes",
"the",
"file",
"to",
"disk",
"and",
"returns",
"an",
"open",
"file",
"ready",
"for",
"reading",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L540-L545 | train |
google/codesearch | index/write.go | validUTF8 | func validUTF8(c1, c2 uint32) bool {
switch {
case c1 < 0x80:
// 1-byte, must be followed by 1-byte or first of multi-byte
return c2 < 0x80 || 0xc0 <= c2 && c2 < 0xf8
case c1 < 0xc0:
// continuation byte, can be followed by nearly anything
return c2 < 0xf8
case c1 < 0xf8:
// first of multi-byte, must be followed by continuation byte
return 0x80 <= c2 && c2 < 0xc0
}
return false
} | go | func validUTF8(c1, c2 uint32) bool {
switch {
case c1 < 0x80:
// 1-byte, must be followed by 1-byte or first of multi-byte
return c2 < 0x80 || 0xc0 <= c2 && c2 < 0xf8
case c1 < 0xc0:
// continuation byte, can be followed by nearly anything
return c2 < 0xf8
case c1 < 0xf8:
// first of multi-byte, must be followed by continuation byte
return 0x80 <= c2 && c2 < 0xc0
}
return false
} | [
"func",
"validUTF8",
"(",
"c1",
",",
"c2",
"uint32",
")",
"bool",
"{",
"switch",
"{",
"case",
"c1",
"<",
"0x80",
":",
"return",
"c2",
"<",
"0x80",
"||",
"0xc0",
"<=",
"c2",
"&&",
"c2",
"<",
"0xf8",
"\n",
"case",
"c1",
"<",
"0xc0",
":",
"return",
"c2",
"<",
"0xf8",
"\n",
"case",
"c1",
"<",
"0xf8",
":",
"return",
"0x80",
"<=",
"c2",
"&&",
"c2",
"<",
"0xc0",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // validUTF8 reports whether the byte pair can appear in a
// valid sequence of UTF-8-encoded code points. | [
"validUTF8",
"reports",
"whether",
"the",
"byte",
"pair",
"can",
"appear",
"in",
"a",
"valid",
"sequence",
"of",
"UTF",
"-",
"8",
"-",
"encoded",
"code",
"points",
"."
] | 4fe90b597ae534f90238f82c7b5b1bb6d6d52dff | https://github.com/google/codesearch/blob/4fe90b597ae534f90238f82c7b5b1bb6d6d52dff/index/write.go#L581-L594 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/dynamicselection/ccpolicyprovider.go | newCCPolicyProvider | func newCCPolicyProvider(ctx context.Client, discovery fab.DiscoveryService, channelID string) (CCPolicyProvider, error) {
if channelID == "" {
return nil, errors.New("Must provide channel ID for cc policy provider")
}
cpp := ccPolicyProvider{
context: ctx,
channelID: channelID,
discovery: discovery,
ccDataMap: make(map[string]*ccprovider.ChaincodeData),
}
return &cpp, nil
} | go | func newCCPolicyProvider(ctx context.Client, discovery fab.DiscoveryService, channelID string) (CCPolicyProvider, error) {
if channelID == "" {
return nil, errors.New("Must provide channel ID for cc policy provider")
}
cpp := ccPolicyProvider{
context: ctx,
channelID: channelID,
discovery: discovery,
ccDataMap: make(map[string]*ccprovider.ChaincodeData),
}
return &cpp, nil
} | [
"func",
"newCCPolicyProvider",
"(",
"ctx",
"context",
".",
"Client",
",",
"discovery",
"fab",
".",
"DiscoveryService",
",",
"channelID",
"string",
")",
"(",
"CCPolicyProvider",
",",
"error",
")",
"{",
"if",
"channelID",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"Must provide channel ID for cc policy provider\"",
")",
"\n",
"}",
"\n",
"cpp",
":=",
"ccPolicyProvider",
"{",
"context",
":",
"ctx",
",",
"channelID",
":",
"channelID",
",",
"discovery",
":",
"discovery",
",",
"ccDataMap",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"ccprovider",
".",
"ChaincodeData",
")",
",",
"}",
"\n",
"return",
"&",
"cpp",
",",
"nil",
"\n",
"}"
] | // NewCCPolicyProvider creates new chaincode policy data provider | [
"NewCCPolicyProvider",
"creates",
"new",
"chaincode",
"policy",
"data",
"provider"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/dynamicselection/ccpolicyprovider.go#L43-L56 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockidentity.go | NewMockIdentity | func NewMockIdentity(err error) (msp.Identity, error) {
return &MockIdentity{Err: err}, nil
} | go | func NewMockIdentity(err error) (msp.Identity, error) {
return &MockIdentity{Err: err}, nil
} | [
"func",
"NewMockIdentity",
"(",
"err",
"error",
")",
"(",
"msp",
".",
"Identity",
",",
"error",
")",
"{",
"return",
"&",
"MockIdentity",
"{",
"Err",
":",
"err",
"}",
",",
"nil",
"\n",
"}"
] | // NewMockIdentity creates new mock identity | [
"NewMockIdentity",
"creates",
"new",
"mock",
"identity"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockidentity.go#L24-L26 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockidentity.go | Validate | func (id *MockIdentity) Validate() error {
if id.Err != nil && id.Err.Error() == "Validate" {
return id.Err
}
return nil
} | go | func (id *MockIdentity) Validate() error {
if id.Err != nil && id.Err.Error() == "Validate" {
return id.Err
}
return nil
} | [
"func",
"(",
"id",
"*",
"MockIdentity",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"id",
".",
"Err",
"!=",
"nil",
"&&",
"id",
".",
"Err",
".",
"Error",
"(",
")",
"==",
"\"Validate\"",
"{",
"return",
"id",
".",
"Err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate returns nil if this instance is a valid identity or an error otherwise | [
"Validate",
"returns",
"nil",
"if",
"this",
"instance",
"is",
"a",
"valid",
"identity",
"or",
"an",
"error",
"otherwise"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockidentity.go#L49-L54 | train |
hyperledger/fabric-sdk-go | pkg/fab/comm/streamconnection.go | NewStreamConnection | func NewStreamConnection(ctx fabcontext.Client, chConfig fab.ChannelCfg, streamProvider StreamProvider, url string, opts ...options.Opt) (*StreamConnection, error) {
conn, err := NewConnection(ctx, url, opts...)
if err != nil {
return nil, err
}
stream, err := streamProvider(conn.conn)
if err != nil {
conn.commManager.ReleaseConn(conn.conn)
return nil, errors.Wrapf(err, "could not create stream to %s", url)
}
if stream == nil {
return nil, errors.New("unexpected nil stream received from provider")
}
peer, ok := peer.FromContext(stream.Context())
if !ok || peer == nil {
//return error - certificate is not available
return nil, errors.Wrap(err, "No peer cert in GRPC stream")
}
if peer.AuthInfo != nil {
tlsInfo := peer.AuthInfo.(credentials.TLSInfo)
for _, peercert := range tlsInfo.State.PeerCertificates {
err := verifier.ValidateCertificateDates(peercert)
if err != nil {
logger.Error(err)
return nil, errors.Wrapf(err, "error validating certificate dates for [%v]", peercert.Subject)
}
}
}
return &StreamConnection{
GRPCConnection: conn,
chConfig: chConfig,
stream: stream,
}, nil
} | go | func NewStreamConnection(ctx fabcontext.Client, chConfig fab.ChannelCfg, streamProvider StreamProvider, url string, opts ...options.Opt) (*StreamConnection, error) {
conn, err := NewConnection(ctx, url, opts...)
if err != nil {
return nil, err
}
stream, err := streamProvider(conn.conn)
if err != nil {
conn.commManager.ReleaseConn(conn.conn)
return nil, errors.Wrapf(err, "could not create stream to %s", url)
}
if stream == nil {
return nil, errors.New("unexpected nil stream received from provider")
}
peer, ok := peer.FromContext(stream.Context())
if !ok || peer == nil {
//return error - certificate is not available
return nil, errors.Wrap(err, "No peer cert in GRPC stream")
}
if peer.AuthInfo != nil {
tlsInfo := peer.AuthInfo.(credentials.TLSInfo)
for _, peercert := range tlsInfo.State.PeerCertificates {
err := verifier.ValidateCertificateDates(peercert)
if err != nil {
logger.Error(err)
return nil, errors.Wrapf(err, "error validating certificate dates for [%v]", peercert.Subject)
}
}
}
return &StreamConnection{
GRPCConnection: conn,
chConfig: chConfig,
stream: stream,
}, nil
} | [
"func",
"NewStreamConnection",
"(",
"ctx",
"fabcontext",
".",
"Client",
",",
"chConfig",
"fab",
".",
"ChannelCfg",
",",
"streamProvider",
"StreamProvider",
",",
"url",
"string",
",",
"opts",
"...",
"options",
".",
"Opt",
")",
"(",
"*",
"StreamConnection",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"NewConnection",
"(",
"ctx",
",",
"url",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"stream",
",",
"err",
":=",
"streamProvider",
"(",
"conn",
".",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"conn",
".",
"commManager",
".",
"ReleaseConn",
"(",
"conn",
".",
"conn",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"could not create stream to %s\"",
",",
"url",
")",
"\n",
"}",
"\n",
"if",
"stream",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"unexpected nil stream received from provider\"",
")",
"\n",
"}",
"\n",
"peer",
",",
"ok",
":=",
"peer",
".",
"FromContext",
"(",
"stream",
".",
"Context",
"(",
")",
")",
"\n",
"if",
"!",
"ok",
"||",
"peer",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"No peer cert in GRPC stream\"",
")",
"\n",
"}",
"\n",
"if",
"peer",
".",
"AuthInfo",
"!=",
"nil",
"{",
"tlsInfo",
":=",
"peer",
".",
"AuthInfo",
".",
"(",
"credentials",
".",
"TLSInfo",
")",
"\n",
"for",
"_",
",",
"peercert",
":=",
"range",
"tlsInfo",
".",
"State",
".",
"PeerCertificates",
"{",
"err",
":=",
"verifier",
".",
"ValidateCertificateDates",
"(",
"peercert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"error validating certificate dates for [%v]\"",
",",
"peercert",
".",
"Subject",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"StreamConnection",
"{",
"GRPCConnection",
":",
"conn",
",",
"chConfig",
":",
"chConfig",
",",
"stream",
":",
"stream",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewStreamConnection creates a new connection with stream | [
"NewStreamConnection",
"creates",
"a",
"new",
"connection",
"with",
"stream"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/comm/streamconnection.go#L35-L74 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/config.go | CreateConfigSignature | func CreateConfigSignature(ctx context.Client, config []byte) (*common.ConfigSignature, error) {
cfd, e := GetConfigSignatureData(ctx, config)
if e != nil {
return nil, e
}
signingMgr := ctx.SigningManager()
signature, err := signingMgr.Sign(cfd.SigningBytes, ctx.PrivateKey())
if err != nil {
return nil, errors.WithMessage(err, "signing of channel config failed")
}
// build the return object
configSignature := common.ConfigSignature{
SignatureHeader: cfd.SignatureHeaderBytes,
Signature: signature,
}
return &configSignature, nil
} | go | func CreateConfigSignature(ctx context.Client, config []byte) (*common.ConfigSignature, error) {
cfd, e := GetConfigSignatureData(ctx, config)
if e != nil {
return nil, e
}
signingMgr := ctx.SigningManager()
signature, err := signingMgr.Sign(cfd.SigningBytes, ctx.PrivateKey())
if err != nil {
return nil, errors.WithMessage(err, "signing of channel config failed")
}
// build the return object
configSignature := common.ConfigSignature{
SignatureHeader: cfd.SignatureHeaderBytes,
Signature: signature,
}
return &configSignature, nil
} | [
"func",
"CreateConfigSignature",
"(",
"ctx",
"context",
".",
"Client",
",",
"config",
"[",
"]",
"byte",
")",
"(",
"*",
"common",
".",
"ConfigSignature",
",",
"error",
")",
"{",
"cfd",
",",
"e",
":=",
"GetConfigSignatureData",
"(",
"ctx",
",",
"config",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"nil",
",",
"e",
"\n",
"}",
"\n",
"signingMgr",
":=",
"ctx",
".",
"SigningManager",
"(",
")",
"\n",
"signature",
",",
"err",
":=",
"signingMgr",
".",
"Sign",
"(",
"cfd",
".",
"SigningBytes",
",",
"ctx",
".",
"PrivateKey",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"signing of channel config failed\"",
")",
"\n",
"}",
"\n",
"configSignature",
":=",
"common",
".",
"ConfigSignature",
"{",
"SignatureHeader",
":",
"cfd",
".",
"SignatureHeaderBytes",
",",
"Signature",
":",
"signature",
",",
"}",
"\n",
"return",
"&",
"configSignature",
",",
"nil",
"\n",
"}"
] | // CreateConfigSignature creates a ConfigSignature for the current context | [
"CreateConfigSignature",
"creates",
"a",
"ConfigSignature",
"for",
"the",
"current",
"context"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/config.go#L20-L38 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/config.go | ExtractChannelConfig | func ExtractChannelConfig(configEnvelope []byte) ([]byte, error) {
envelope := &common.Envelope{}
err := proto.Unmarshal(configEnvelope, envelope)
if err != nil {
return nil, errors.Wrap(err, "unmarshal config envelope failed")
}
payload := &common.Payload{}
err = proto.Unmarshal(envelope.Payload, payload)
if err != nil {
return nil, errors.Wrap(err, "unmarshal envelope payload failed")
}
configUpdateEnvelope := &common.ConfigUpdateEnvelope{}
err = proto.Unmarshal(payload.Data, configUpdateEnvelope)
if err != nil {
return nil, errors.Wrap(err, "unmarshal config update envelope")
}
return configUpdateEnvelope.ConfigUpdate, nil
} | go | func ExtractChannelConfig(configEnvelope []byte) ([]byte, error) {
envelope := &common.Envelope{}
err := proto.Unmarshal(configEnvelope, envelope)
if err != nil {
return nil, errors.Wrap(err, "unmarshal config envelope failed")
}
payload := &common.Payload{}
err = proto.Unmarshal(envelope.Payload, payload)
if err != nil {
return nil, errors.Wrap(err, "unmarshal envelope payload failed")
}
configUpdateEnvelope := &common.ConfigUpdateEnvelope{}
err = proto.Unmarshal(payload.Data, configUpdateEnvelope)
if err != nil {
return nil, errors.Wrap(err, "unmarshal config update envelope")
}
return configUpdateEnvelope.ConfigUpdate, nil
} | [
"func",
"ExtractChannelConfig",
"(",
"configEnvelope",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"envelope",
":=",
"&",
"common",
".",
"Envelope",
"{",
"}",
"\n",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"configEnvelope",
",",
"envelope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal config envelope failed\"",
")",
"\n",
"}",
"\n",
"payload",
":=",
"&",
"common",
".",
"Payload",
"{",
"}",
"\n",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"envelope",
".",
"Payload",
",",
"payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal envelope payload failed\"",
")",
"\n",
"}",
"\n",
"configUpdateEnvelope",
":=",
"&",
"common",
".",
"ConfigUpdateEnvelope",
"{",
"}",
"\n",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"payload",
".",
"Data",
",",
"configUpdateEnvelope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal config update envelope\"",
")",
"\n",
"}",
"\n",
"return",
"configUpdateEnvelope",
".",
"ConfigUpdate",
",",
"nil",
"\n",
"}"
] | // ExtractChannelConfig extracts the protobuf 'ConfigUpdate' object out of the 'ConfigEnvelope'. | [
"ExtractChannelConfig",
"extracts",
"the",
"protobuf",
"ConfigUpdate",
"object",
"out",
"of",
"the",
"ConfigEnvelope",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/config.go#L90-L111 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/config.go | CreateConfigEnvelope | func CreateConfigEnvelope(data []byte) (*common.ConfigEnvelope, error) {
envelope := &common.Envelope{}
if err := proto.Unmarshal(data, envelope); err != nil {
return nil, errors.Wrap(err, "unmarshal envelope from config block failed")
}
payload := &common.Payload{}
if err := proto.Unmarshal(envelope.Payload, payload); err != nil {
return nil, errors.Wrap(err, "unmarshal payload from envelope failed")
}
channelHeader := &common.ChannelHeader{}
if err := proto.Unmarshal(payload.Header.ChannelHeader, channelHeader); err != nil {
return nil, errors.Wrap(err, "unmarshal payload from envelope failed")
}
if common.HeaderType(channelHeader.Type) != common.HeaderType_CONFIG {
return nil, errors.New("block must be of type 'CONFIG'")
}
configEnvelope := &common.ConfigEnvelope{}
if err := proto.Unmarshal(payload.Data, configEnvelope); err != nil {
return nil, errors.Wrap(err, "unmarshal config envelope failed")
}
return configEnvelope, nil
} | go | func CreateConfigEnvelope(data []byte) (*common.ConfigEnvelope, error) {
envelope := &common.Envelope{}
if err := proto.Unmarshal(data, envelope); err != nil {
return nil, errors.Wrap(err, "unmarshal envelope from config block failed")
}
payload := &common.Payload{}
if err := proto.Unmarshal(envelope.Payload, payload); err != nil {
return nil, errors.Wrap(err, "unmarshal payload from envelope failed")
}
channelHeader := &common.ChannelHeader{}
if err := proto.Unmarshal(payload.Header.ChannelHeader, channelHeader); err != nil {
return nil, errors.Wrap(err, "unmarshal payload from envelope failed")
}
if common.HeaderType(channelHeader.Type) != common.HeaderType_CONFIG {
return nil, errors.New("block must be of type 'CONFIG'")
}
configEnvelope := &common.ConfigEnvelope{}
if err := proto.Unmarshal(payload.Data, configEnvelope); err != nil {
return nil, errors.Wrap(err, "unmarshal config envelope failed")
}
return configEnvelope, nil
} | [
"func",
"CreateConfigEnvelope",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"*",
"common",
".",
"ConfigEnvelope",
",",
"error",
")",
"{",
"envelope",
":=",
"&",
"common",
".",
"Envelope",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"data",
",",
"envelope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal envelope from config block failed\"",
")",
"\n",
"}",
"\n",
"payload",
":=",
"&",
"common",
".",
"Payload",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"envelope",
".",
"Payload",
",",
"payload",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal payload from envelope failed\"",
")",
"\n",
"}",
"\n",
"channelHeader",
":=",
"&",
"common",
".",
"ChannelHeader",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"payload",
".",
"Header",
".",
"ChannelHeader",
",",
"channelHeader",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal payload from envelope failed\"",
")",
"\n",
"}",
"\n",
"if",
"common",
".",
"HeaderType",
"(",
"channelHeader",
".",
"Type",
")",
"!=",
"common",
".",
"HeaderType_CONFIG",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"block must be of type 'CONFIG'\"",
")",
"\n",
"}",
"\n",
"configEnvelope",
":=",
"&",
"common",
".",
"ConfigEnvelope",
"{",
"}",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"payload",
".",
"Data",
",",
"configEnvelope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal config envelope failed\"",
")",
"\n",
"}",
"\n",
"return",
"configEnvelope",
",",
"nil",
"\n",
"}"
] | // CreateConfigEnvelope creates configuration envelope proto | [
"CreateConfigEnvelope",
"creates",
"configuration",
"envelope",
"proto"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/config.go#L114-L137 | train |
hyperledger/fabric-sdk-go | pkg/fab/resource/config.go | GetLastConfigFromBlock | func GetLastConfigFromBlock(block *common.Block) (*common.LastConfig, error) {
if block.Metadata == nil {
return nil, errors.New("block metadata is nil")
}
metadata := &common.Metadata{}
err := proto.Unmarshal(block.Metadata.Metadata[common.BlockMetadataIndex_LAST_CONFIG], metadata)
if err != nil {
return nil, errors.Wrap(err, "unmarshal block metadata failed")
}
lastConfig := &common.LastConfig{}
err = proto.Unmarshal(metadata.Value, lastConfig)
if err != nil {
return nil, errors.Wrap(err, "unmarshal last config from metadata failed")
}
return lastConfig, err
} | go | func GetLastConfigFromBlock(block *common.Block) (*common.LastConfig, error) {
if block.Metadata == nil {
return nil, errors.New("block metadata is nil")
}
metadata := &common.Metadata{}
err := proto.Unmarshal(block.Metadata.Metadata[common.BlockMetadataIndex_LAST_CONFIG], metadata)
if err != nil {
return nil, errors.Wrap(err, "unmarshal block metadata failed")
}
lastConfig := &common.LastConfig{}
err = proto.Unmarshal(metadata.Value, lastConfig)
if err != nil {
return nil, errors.Wrap(err, "unmarshal last config from metadata failed")
}
return lastConfig, err
} | [
"func",
"GetLastConfigFromBlock",
"(",
"block",
"*",
"common",
".",
"Block",
")",
"(",
"*",
"common",
".",
"LastConfig",
",",
"error",
")",
"{",
"if",
"block",
".",
"Metadata",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"block metadata is nil\"",
")",
"\n",
"}",
"\n",
"metadata",
":=",
"&",
"common",
".",
"Metadata",
"{",
"}",
"\n",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"block",
".",
"Metadata",
".",
"Metadata",
"[",
"common",
".",
"BlockMetadataIndex_LAST_CONFIG",
"]",
",",
"metadata",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal block metadata failed\"",
")",
"\n",
"}",
"\n",
"lastConfig",
":=",
"&",
"common",
".",
"LastConfig",
"{",
"}",
"\n",
"err",
"=",
"proto",
".",
"Unmarshal",
"(",
"metadata",
".",
"Value",
",",
"lastConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"unmarshal last config from metadata failed\"",
")",
"\n",
"}",
"\n",
"return",
"lastConfig",
",",
"err",
"\n",
"}"
] | // GetLastConfigFromBlock returns the LastConfig data from the given block | [
"GetLastConfigFromBlock",
"returns",
"the",
"LastConfig",
"data",
"from",
"the",
"given",
"block"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/resource/config.go#L166-L183 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | ConfigFromBackend | func ConfigFromBackend(coreBackend ...core.ConfigBackend) core.CryptoSuiteConfig {
return &Config{backend: lookup.New(coreBackend...)}
} | go | func ConfigFromBackend(coreBackend ...core.ConfigBackend) core.CryptoSuiteConfig {
return &Config{backend: lookup.New(coreBackend...)}
} | [
"func",
"ConfigFromBackend",
"(",
"coreBackend",
"...",
"core",
".",
"ConfigBackend",
")",
"core",
".",
"CryptoSuiteConfig",
"{",
"return",
"&",
"Config",
"{",
"backend",
":",
"lookup",
".",
"New",
"(",
"coreBackend",
"...",
")",
"}",
"\n",
"}"
] | //ConfigFromBackend returns CryptoSuite config implementation for given backend | [
"ConfigFromBackend",
"returns",
"CryptoSuite",
"config",
"implementation",
"for",
"given",
"backend"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L29-L31 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | IsSecurityEnabled | func (c *Config) IsSecurityEnabled() bool {
val, ok := c.backend.Lookup("client.BCCSP.security.enabled")
if !ok {
return defEnabled
}
return cast.ToBool(val)
} | go | func (c *Config) IsSecurityEnabled() bool {
val, ok := c.backend.Lookup("client.BCCSP.security.enabled")
if !ok {
return defEnabled
}
return cast.ToBool(val)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"IsSecurityEnabled",
"(",
")",
"bool",
"{",
"val",
",",
"ok",
":=",
"c",
".",
"backend",
".",
"Lookup",
"(",
"\"client.BCCSP.security.enabled\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"defEnabled",
"\n",
"}",
"\n",
"return",
"cast",
".",
"ToBool",
"(",
"val",
")",
"\n",
"}"
] | // IsSecurityEnabled config used enable and disable security in cryptosuite | [
"IsSecurityEnabled",
"config",
"used",
"enable",
"and",
"disable",
"security",
"in",
"cryptosuite"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L39-L45 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | SecurityAlgorithm | func (c *Config) SecurityAlgorithm() string {
val, ok := c.backend.Lookup("client.BCCSP.security.hashAlgorithm")
if !ok {
return defHashAlgorithm
}
return cast.ToString(val)
} | go | func (c *Config) SecurityAlgorithm() string {
val, ok := c.backend.Lookup("client.BCCSP.security.hashAlgorithm")
if !ok {
return defHashAlgorithm
}
return cast.ToString(val)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"SecurityAlgorithm",
"(",
")",
"string",
"{",
"val",
",",
"ok",
":=",
"c",
".",
"backend",
".",
"Lookup",
"(",
"\"client.BCCSP.security.hashAlgorithm\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"defHashAlgorithm",
"\n",
"}",
"\n",
"return",
"cast",
".",
"ToString",
"(",
"val",
")",
"\n",
"}"
] | // SecurityAlgorithm returns cryptoSuite config hash algorithm | [
"SecurityAlgorithm",
"returns",
"cryptoSuite",
"config",
"hash",
"algorithm"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L48-L54 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | SecurityLevel | func (c *Config) SecurityLevel() int {
val, ok := c.backend.Lookup("client.BCCSP.security.level")
if !ok {
return defLevel
}
return cast.ToInt(val)
} | go | func (c *Config) SecurityLevel() int {
val, ok := c.backend.Lookup("client.BCCSP.security.level")
if !ok {
return defLevel
}
return cast.ToInt(val)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"SecurityLevel",
"(",
")",
"int",
"{",
"val",
",",
"ok",
":=",
"c",
".",
"backend",
".",
"Lookup",
"(",
"\"client.BCCSP.security.level\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"defLevel",
"\n",
"}",
"\n",
"return",
"cast",
".",
"ToInt",
"(",
"val",
")",
"\n",
"}"
] | // SecurityLevel returns cryptSuite config security level | [
"SecurityLevel",
"returns",
"cryptSuite",
"config",
"security",
"level"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L57-L63 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | SecurityProvider | func (c *Config) SecurityProvider() string {
val, ok := c.backend.Lookup("client.BCCSP.security.default.provider")
if !ok {
return strings.ToLower(defProvider)
}
return strings.ToLower(cast.ToString(val))
} | go | func (c *Config) SecurityProvider() string {
val, ok := c.backend.Lookup("client.BCCSP.security.default.provider")
if !ok {
return strings.ToLower(defProvider)
}
return strings.ToLower(cast.ToString(val))
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"SecurityProvider",
"(",
")",
"string",
"{",
"val",
",",
"ok",
":=",
"c",
".",
"backend",
".",
"Lookup",
"(",
"\"client.BCCSP.security.default.provider\"",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"strings",
".",
"ToLower",
"(",
"defProvider",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"ToLower",
"(",
"cast",
".",
"ToString",
"(",
"val",
")",
")",
"\n",
"}"
] | //SecurityProvider provider SW or PKCS11 | [
"SecurityProvider",
"provider",
"SW",
"or",
"PKCS11"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L66-L72 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | SecurityProviderLibPath | func (c *Config) SecurityProviderLibPath() string {
configuredLibs := c.backend.GetString("client.BCCSP.security.library")
libPaths := strings.Split(configuredLibs, ",")
logger.Debugf("Configured BCCSP Lib Paths %s", libPaths)
var lib string
for _, path := range libPaths {
if _, err := os.Stat(strings.TrimSpace(path)); !os.IsNotExist(err) {
lib = strings.TrimSpace(path)
break
}
}
if lib != "" {
logger.Debugf("Found softhsm library: %s", lib)
} else {
logger.Debug("Softhsm library was not found")
}
return lib
} | go | func (c *Config) SecurityProviderLibPath() string {
configuredLibs := c.backend.GetString("client.BCCSP.security.library")
libPaths := strings.Split(configuredLibs, ",")
logger.Debugf("Configured BCCSP Lib Paths %s", libPaths)
var lib string
for _, path := range libPaths {
if _, err := os.Stat(strings.TrimSpace(path)); !os.IsNotExist(err) {
lib = strings.TrimSpace(path)
break
}
}
if lib != "" {
logger.Debugf("Found softhsm library: %s", lib)
} else {
logger.Debug("Softhsm library was not found")
}
return lib
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"SecurityProviderLibPath",
"(",
")",
"string",
"{",
"configuredLibs",
":=",
"c",
".",
"backend",
".",
"GetString",
"(",
"\"client.BCCSP.security.library\"",
")",
"\n",
"libPaths",
":=",
"strings",
".",
"Split",
"(",
"configuredLibs",
",",
"\",\"",
")",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Configured BCCSP Lib Paths %s\"",
",",
"libPaths",
")",
"\n",
"var",
"lib",
"string",
"\n",
"for",
"_",
",",
"path",
":=",
"range",
"libPaths",
"{",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"strings",
".",
"TrimSpace",
"(",
"path",
")",
")",
";",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"lib",
"=",
"strings",
".",
"TrimSpace",
"(",
"path",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"lib",
"!=",
"\"\"",
"{",
"logger",
".",
"Debugf",
"(",
"\"Found softhsm library: %s\"",
",",
"lib",
")",
"\n",
"}",
"else",
"{",
"logger",
".",
"Debug",
"(",
"\"Softhsm library was not found\"",
")",
"\n",
"}",
"\n",
"return",
"lib",
"\n",
"}"
] | //SecurityProviderLibPath will be set only if provider is PKCS11 | [
"SecurityProviderLibPath",
"will",
"be",
"set",
"only",
"if",
"provider",
"is",
"PKCS11"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L84-L101 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/cryptoconfig.go | KeyStorePath | func (c *Config) KeyStorePath() string {
keystorePath := pathvar.Subst(c.backend.GetString("client.credentialStore.cryptoStore.path"))
return filepath.Join(keystorePath, "keystore")
} | go | func (c *Config) KeyStorePath() string {
keystorePath := pathvar.Subst(c.backend.GetString("client.credentialStore.cryptoStore.path"))
return filepath.Join(keystorePath, "keystore")
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"KeyStorePath",
"(",
")",
"string",
"{",
"keystorePath",
":=",
"pathvar",
".",
"Subst",
"(",
"c",
".",
"backend",
".",
"GetString",
"(",
"\"client.credentialStore.cryptoStore.path\"",
")",
")",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"keystorePath",
",",
"\"keystore\"",
")",
"\n",
"}"
] | // KeyStorePath returns the keystore path used by BCCSP | [
"KeyStorePath",
"returns",
"the",
"keystore",
"path",
"used",
"by",
"BCCSP"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/cryptoconfig.go#L114-L117 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/discoveryfilter.go | NewDiscoveryFilterService | func NewDiscoveryFilterService(discoveryService fab.DiscoveryService, targetFilter fab.TargetFilter) fab.DiscoveryService {
return &filterService{discoveryService: discoveryService, targetFilter: targetFilter}
} | go | func NewDiscoveryFilterService(discoveryService fab.DiscoveryService, targetFilter fab.TargetFilter) fab.DiscoveryService {
return &filterService{discoveryService: discoveryService, targetFilter: targetFilter}
} | [
"func",
"NewDiscoveryFilterService",
"(",
"discoveryService",
"fab",
".",
"DiscoveryService",
",",
"targetFilter",
"fab",
".",
"TargetFilter",
")",
"fab",
".",
"DiscoveryService",
"{",
"return",
"&",
"filterService",
"{",
"discoveryService",
":",
"discoveryService",
",",
"targetFilter",
":",
"targetFilter",
"}",
"\n",
"}"
] | // NewDiscoveryFilterService return discovery service with filter | [
"NewDiscoveryFilterService",
"return",
"discovery",
"service",
"with",
"filter"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/discoveryfilter.go#L20-L22 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/discoveryfilter.go | GetPeers | func (fs *filterService) GetPeers() ([]fab.Peer, error) {
peers, err := fs.discoveryService.GetPeers()
if err != nil {
return nil, err
}
targets := filterTargets(peers, fs.targetFilter)
return targets, nil
} | go | func (fs *filterService) GetPeers() ([]fab.Peer, error) {
peers, err := fs.discoveryService.GetPeers()
if err != nil {
return nil, err
}
targets := filterTargets(peers, fs.targetFilter)
return targets, nil
} | [
"func",
"(",
"fs",
"*",
"filterService",
")",
"GetPeers",
"(",
")",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"peers",
",",
"err",
":=",
"fs",
".",
"discoveryService",
".",
"GetPeers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"targets",
":=",
"filterTargets",
"(",
"peers",
",",
"fs",
".",
"targetFilter",
")",
"\n",
"return",
"targets",
",",
"nil",
"\n",
"}"
] | // GetPeers is used to get peers | [
"GetPeers",
"is",
"used",
"to",
"get",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/discoveryfilter.go#L25-L32 | train |
hyperledger/fabric-sdk-go | pkg/client/common/discovery/discoveryfilter.go | filterTargets | func filterTargets(peers []fab.Peer, filter fab.TargetFilter) []fab.Peer {
if filter == nil {
return peers
}
filteredPeers := []fab.Peer{}
for _, peer := range peers {
if filter.Accept(peer) {
filteredPeers = append(filteredPeers, peer)
}
}
return filteredPeers
} | go | func filterTargets(peers []fab.Peer, filter fab.TargetFilter) []fab.Peer {
if filter == nil {
return peers
}
filteredPeers := []fab.Peer{}
for _, peer := range peers {
if filter.Accept(peer) {
filteredPeers = append(filteredPeers, peer)
}
}
return filteredPeers
} | [
"func",
"filterTargets",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
",",
"filter",
"fab",
".",
"TargetFilter",
")",
"[",
"]",
"fab",
".",
"Peer",
"{",
"if",
"filter",
"==",
"nil",
"{",
"return",
"peers",
"\n",
"}",
"\n",
"filteredPeers",
":=",
"[",
"]",
"fab",
".",
"Peer",
"{",
"}",
"\n",
"for",
"_",
",",
"peer",
":=",
"range",
"peers",
"{",
"if",
"filter",
".",
"Accept",
"(",
"peer",
")",
"{",
"filteredPeers",
"=",
"append",
"(",
"filteredPeers",
",",
"peer",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"filteredPeers",
"\n",
"}"
] | // filterTargets is helper method to filter peers | [
"filterTargets",
"is",
"helper",
"method",
"to",
"filter",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/discovery/discoveryfilter.go#L35-L49 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchprovider.go | NewMockChannelProvider | func NewMockChannelProvider(ctx core.Providers) (*MockChannelProvider, error) {
// Create a mock client with the mock channel
cp := MockChannelProvider{
ctx: ctx,
}
return &cp, nil
} | go | func NewMockChannelProvider(ctx core.Providers) (*MockChannelProvider, error) {
// Create a mock client with the mock channel
cp := MockChannelProvider{
ctx: ctx,
}
return &cp, nil
} | [
"func",
"NewMockChannelProvider",
"(",
"ctx",
"core",
".",
"Providers",
")",
"(",
"*",
"MockChannelProvider",
",",
"error",
")",
"{",
"cp",
":=",
"MockChannelProvider",
"{",
"ctx",
":",
"ctx",
",",
"}",
"\n",
"return",
"&",
"cp",
",",
"nil",
"\n",
"}"
] | // NewMockChannelProvider returns a mock ChannelProvider | [
"NewMockChannelProvider",
"returns",
"a",
"mock",
"ChannelProvider"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchprovider.go#L35-L41 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchprovider.go | ChannelService | func (cp *MockChannelProvider) ChannelService(ctx fab.ClientContext, channelID string) (fab.ChannelService, error) {
if cp.customChannelService != nil {
return cp.customChannelService, nil
}
cs := MockChannelService{
provider: cp,
channelID: channelID,
transactor: &MockTransactor{},
discovery: NewMockDiscoveryService(nil),
selection: NewMockSelectionService(nil),
}
return &cs, nil
} | go | func (cp *MockChannelProvider) ChannelService(ctx fab.ClientContext, channelID string) (fab.ChannelService, error) {
if cp.customChannelService != nil {
return cp.customChannelService, nil
}
cs := MockChannelService{
provider: cp,
channelID: channelID,
transactor: &MockTransactor{},
discovery: NewMockDiscoveryService(nil),
selection: NewMockSelectionService(nil),
}
return &cs, nil
} | [
"func",
"(",
"cp",
"*",
"MockChannelProvider",
")",
"ChannelService",
"(",
"ctx",
"fab",
".",
"ClientContext",
",",
"channelID",
"string",
")",
"(",
"fab",
".",
"ChannelService",
",",
"error",
")",
"{",
"if",
"cp",
".",
"customChannelService",
"!=",
"nil",
"{",
"return",
"cp",
".",
"customChannelService",
",",
"nil",
"\n",
"}",
"\n",
"cs",
":=",
"MockChannelService",
"{",
"provider",
":",
"cp",
",",
"channelID",
":",
"channelID",
",",
"transactor",
":",
"&",
"MockTransactor",
"{",
"}",
",",
"discovery",
":",
"NewMockDiscoveryService",
"(",
"nil",
")",
",",
"selection",
":",
"NewMockSelectionService",
"(",
"nil",
")",
",",
"}",
"\n",
"return",
"&",
"cs",
",",
"nil",
"\n",
"}"
] | // ChannelService returns a mock ChannelService | [
"ChannelService",
"returns",
"a",
"mock",
"ChannelService"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchprovider.go#L44-L58 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchprovider.go | EventService | func (cs *MockChannelService) EventService(opts ...options.Opt) (fab.EventService, error) {
return NewMockEventService(), nil
} | go | func (cs *MockChannelService) EventService(opts ...options.Opt) (fab.EventService, error) {
return NewMockEventService(), nil
} | [
"func",
"(",
"cs",
"*",
"MockChannelService",
")",
"EventService",
"(",
"opts",
"...",
"options",
".",
"Opt",
")",
"(",
"fab",
".",
"EventService",
",",
"error",
")",
"{",
"return",
"NewMockEventService",
"(",
")",
",",
"nil",
"\n",
"}"
] | // EventService returns a mock event service | [
"EventService",
"returns",
"a",
"mock",
"event",
"service"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchprovider.go#L71-L73 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchprovider.go | Transactor | func (cs *MockChannelService) Transactor(reqCtx reqContext.Context) (fab.Transactor, error) {
if cs.transactor != nil {
return cs.transactor, nil
}
return &MockTransactor{ChannelID: cs.channelID, Ctx: reqCtx}, nil
} | go | func (cs *MockChannelService) Transactor(reqCtx reqContext.Context) (fab.Transactor, error) {
if cs.transactor != nil {
return cs.transactor, nil
}
return &MockTransactor{ChannelID: cs.channelID, Ctx: reqCtx}, nil
} | [
"func",
"(",
"cs",
"*",
"MockChannelService",
")",
"Transactor",
"(",
"reqCtx",
"reqContext",
".",
"Context",
")",
"(",
"fab",
".",
"Transactor",
",",
"error",
")",
"{",
"if",
"cs",
".",
"transactor",
"!=",
"nil",
"{",
"return",
"cs",
".",
"transactor",
",",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"MockTransactor",
"{",
"ChannelID",
":",
"cs",
".",
"channelID",
",",
"Ctx",
":",
"reqCtx",
"}",
",",
"nil",
"\n",
"}"
] | // Transactor returns a mock transactor | [
"Transactor",
"returns",
"a",
"mock",
"transactor"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchprovider.go#L81-L86 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchprovider.go | Membership | func (cs *MockChannelService) Membership() (fab.ChannelMembership, error) {
if cs.membership != nil {
return cs.membership, nil
}
return NewMockMembership(), nil
} | go | func (cs *MockChannelService) Membership() (fab.ChannelMembership, error) {
if cs.membership != nil {
return cs.membership, nil
}
return NewMockMembership(), nil
} | [
"func",
"(",
"cs",
"*",
"MockChannelService",
")",
"Membership",
"(",
")",
"(",
"fab",
".",
"ChannelMembership",
",",
"error",
")",
"{",
"if",
"cs",
".",
"membership",
"!=",
"nil",
"{",
"return",
"cs",
".",
"membership",
",",
"nil",
"\n",
"}",
"\n",
"return",
"NewMockMembership",
"(",
")",
",",
"nil",
"\n",
"}"
] | // Membership returns member identification | [
"Membership",
"returns",
"member",
"identification"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchprovider.go#L94-L99 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockchprovider.go | ChannelConfig | func (cs *MockChannelService) ChannelConfig() (fab.ChannelCfg, error) {
return &MockChannelCfg{MockID: cs.channelID, MockOrderers: cs.mockOrderers}, nil
} | go | func (cs *MockChannelService) ChannelConfig() (fab.ChannelCfg, error) {
return &MockChannelCfg{MockID: cs.channelID, MockOrderers: cs.mockOrderers}, nil
} | [
"func",
"(",
"cs",
"*",
"MockChannelService",
")",
"ChannelConfig",
"(",
")",
"(",
"fab",
".",
"ChannelCfg",
",",
"error",
")",
"{",
"return",
"&",
"MockChannelCfg",
"{",
"MockID",
":",
"cs",
".",
"channelID",
",",
"MockOrderers",
":",
"cs",
".",
"mockOrderers",
"}",
",",
"nil",
"\n",
"}"
] | //ChannelConfig returns channel config | [
"ChannelConfig",
"returns",
"channel",
"config"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockchprovider.go#L107-L109 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | NewMockConnection | func NewMockConnection(opts ...Opt) *MockConnection {
copts := &Opts{}
for _, opt := range opts {
opt(copts)
}
operations := copts.Operations
if operations == nil {
operations = make(map[Operation]ResultDesc)
}
if copts.Ledger == nil {
panic("ledger is nil")
}
sourceURL := copts.SourceURL
if sourceURL == "" {
sourceURL = "localhost:9051"
}
producer := servicemocks.NewMockProducer(copts.Ledger)
c := &MockConnection{
producer: producer,
producerch: producer.Register(),
rcvch: make(chan interface{}),
operations: operations,
sourceURL: sourceURL,
}
return c
} | go | func NewMockConnection(opts ...Opt) *MockConnection {
copts := &Opts{}
for _, opt := range opts {
opt(copts)
}
operations := copts.Operations
if operations == nil {
operations = make(map[Operation]ResultDesc)
}
if copts.Ledger == nil {
panic("ledger is nil")
}
sourceURL := copts.SourceURL
if sourceURL == "" {
sourceURL = "localhost:9051"
}
producer := servicemocks.NewMockProducer(copts.Ledger)
c := &MockConnection{
producer: producer,
producerch: producer.Register(),
rcvch: make(chan interface{}),
operations: operations,
sourceURL: sourceURL,
}
return c
} | [
"func",
"NewMockConnection",
"(",
"opts",
"...",
"Opt",
")",
"*",
"MockConnection",
"{",
"copts",
":=",
"&",
"Opts",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"copts",
")",
"\n",
"}",
"\n",
"operations",
":=",
"copts",
".",
"Operations",
"\n",
"if",
"operations",
"==",
"nil",
"{",
"operations",
"=",
"make",
"(",
"map",
"[",
"Operation",
"]",
"ResultDesc",
")",
"\n",
"}",
"\n",
"if",
"copts",
".",
"Ledger",
"==",
"nil",
"{",
"panic",
"(",
"\"ledger is nil\"",
")",
"\n",
"}",
"\n",
"sourceURL",
":=",
"copts",
".",
"SourceURL",
"\n",
"if",
"sourceURL",
"==",
"\"\"",
"{",
"sourceURL",
"=",
"\"localhost:9051\"",
"\n",
"}",
"\n",
"producer",
":=",
"servicemocks",
".",
"NewMockProducer",
"(",
"copts",
".",
"Ledger",
")",
"\n",
"c",
":=",
"&",
"MockConnection",
"{",
"producer",
":",
"producer",
",",
"producerch",
":",
"producer",
".",
"Register",
"(",
")",
",",
"rcvch",
":",
"make",
"(",
"chan",
"interface",
"{",
"}",
")",
",",
"operations",
":",
"operations",
",",
"sourceURL",
":",
"sourceURL",
",",
"}",
"\n",
"return",
"c",
"\n",
"}"
] | // NewMockConnection returns a new MockConnection using the given options | [
"NewMockConnection",
"returns",
"a",
"new",
"MockConnection",
"using",
"the",
"given",
"options"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L108-L138 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | Close | func (c *MockConnection) Close() {
if !atomic.CompareAndSwapInt32(&c.closed, 0, 1) {
// Already closed
return
}
c.producer.Close()
close(c.rcvch)
} | go | func (c *MockConnection) Close() {
if !atomic.CompareAndSwapInt32(&c.closed, 0, 1) {
// Already closed
return
}
c.producer.Close()
close(c.rcvch)
} | [
"func",
"(",
"c",
"*",
"MockConnection",
")",
"Close",
"(",
")",
"{",
"if",
"!",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"c",
".",
"closed",
",",
"0",
",",
"1",
")",
"{",
"return",
"\n",
"}",
"\n",
"c",
".",
"producer",
".",
"Close",
"(",
")",
"\n",
"close",
"(",
"c",
".",
"rcvch",
")",
"\n",
"}"
] | // Close implements the MockConnection interface | [
"Close",
"implements",
"the",
"MockConnection",
"interface"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L141-L149 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | Result | func (c *MockConnection) Result(operation Operation) (ResultDesc, bool) {
op, ok := c.operations[operation]
return op, ok
} | go | func (c *MockConnection) Result(operation Operation) (ResultDesc, bool) {
op, ok := c.operations[operation]
return op, ok
} | [
"func",
"(",
"c",
"*",
"MockConnection",
")",
"Result",
"(",
"operation",
"Operation",
")",
"(",
"ResultDesc",
",",
"bool",
")",
"{",
"op",
",",
"ok",
":=",
"c",
".",
"operations",
"[",
"operation",
"]",
"\n",
"return",
"op",
",",
"ok",
"\n",
"}"
] | // Result returns the result for the given operation | [
"Result",
"returns",
"the",
"result",
"for",
"the",
"given",
"operation"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L182-L185 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | Connection | func (cp *ProviderFactory) Connection() Connection {
cp.mtx.RLock()
defer cp.mtx.RUnlock()
return cp.connection
} | go | func (cp *ProviderFactory) Connection() Connection {
cp.mtx.RLock()
defer cp.mtx.RUnlock()
return cp.connection
} | [
"func",
"(",
"cp",
"*",
"ProviderFactory",
")",
"Connection",
"(",
")",
"Connection",
"{",
"cp",
".",
"mtx",
".",
"RLock",
"(",
")",
"\n",
"defer",
"cp",
".",
"mtx",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"cp",
".",
"connection",
"\n",
"}"
] | // Connection returns the connection | [
"Connection",
"returns",
"the",
"connection"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L209-L213 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | Provider | func (cp *ProviderFactory) Provider(conn Connection) api.ConnectionProvider {
return func(context.Client, fab.ChannelCfg, fab.Peer) (api.Connection, error) {
return conn, nil
}
} | go | func (cp *ProviderFactory) Provider(conn Connection) api.ConnectionProvider {
return func(context.Client, fab.ChannelCfg, fab.Peer) (api.Connection, error) {
return conn, nil
}
} | [
"func",
"(",
"cp",
"*",
"ProviderFactory",
")",
"Provider",
"(",
"conn",
"Connection",
")",
"api",
".",
"ConnectionProvider",
"{",
"return",
"func",
"(",
"context",
".",
"Client",
",",
"fab",
".",
"ChannelCfg",
",",
"fab",
".",
"Peer",
")",
"(",
"api",
".",
"Connection",
",",
"error",
")",
"{",
"return",
"conn",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Provider returns a connection provider that always returns the given connection | [
"Provider",
"returns",
"a",
"connection",
"provider",
"that",
"always",
"returns",
"the",
"given",
"connection"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L216-L220 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | FlakeyProvider | func (cp *ProviderFactory) FlakeyProvider(connAttemptResults ConnectAttemptResults, opts ...Opt) api.ConnectionProvider {
var connectAttempt Attempt
return func(ctx context.Client, cfg fab.ChannelCfg, peer fab.Peer) (api.Connection, error) {
connectAttempt++
result, ok := connAttemptResults[connectAttempt]
if !ok {
return nil, errors.New("simulating failed connection attempt")
}
cp.mtx.Lock()
defer cp.mtx.Unlock()
cp.connection = result.ConnFactory(opts...)
return cp.connection, nil
}
} | go | func (cp *ProviderFactory) FlakeyProvider(connAttemptResults ConnectAttemptResults, opts ...Opt) api.ConnectionProvider {
var connectAttempt Attempt
return func(ctx context.Client, cfg fab.ChannelCfg, peer fab.Peer) (api.Connection, error) {
connectAttempt++
result, ok := connAttemptResults[connectAttempt]
if !ok {
return nil, errors.New("simulating failed connection attempt")
}
cp.mtx.Lock()
defer cp.mtx.Unlock()
cp.connection = result.ConnFactory(opts...)
return cp.connection, nil
}
} | [
"func",
"(",
"cp",
"*",
"ProviderFactory",
")",
"FlakeyProvider",
"(",
"connAttemptResults",
"ConnectAttemptResults",
",",
"opts",
"...",
"Opt",
")",
"api",
".",
"ConnectionProvider",
"{",
"var",
"connectAttempt",
"Attempt",
"\n",
"return",
"func",
"(",
"ctx",
"context",
".",
"Client",
",",
"cfg",
"fab",
".",
"ChannelCfg",
",",
"peer",
"fab",
".",
"Peer",
")",
"(",
"api",
".",
"Connection",
",",
"error",
")",
"{",
"connectAttempt",
"++",
"\n",
"result",
",",
"ok",
":=",
"connAttemptResults",
"[",
"connectAttempt",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"simulating failed connection attempt\"",
")",
"\n",
"}",
"\n",
"cp",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cp",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"cp",
".",
"connection",
"=",
"result",
".",
"ConnFactory",
"(",
"opts",
"...",
")",
"\n",
"return",
"cp",
".",
"connection",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // FlakeyProvider creates a connection provider that returns a connection according to the given
// connection attempt results. The results tell the connection provider whether or not to fail,
// to return a connection, what authorization to give the connection, etc. | [
"FlakeyProvider",
"creates",
"a",
"connection",
"provider",
"that",
"returns",
"a",
"connection",
"according",
"to",
"the",
"given",
"connection",
"attempt",
"results",
".",
"The",
"results",
"tell",
"the",
"connection",
"provider",
"whether",
"or",
"not",
"to",
"fail",
"to",
"return",
"a",
"connection",
"what",
"authorization",
"to",
"give",
"the",
"connection",
"etc",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L225-L242 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | NewConnectResult | func NewConnectResult(attempt Attempt, connFactory ConnectionFactory) ConnectResult {
return ConnectResult{Attempt: attempt, ConnFactory: connFactory}
} | go | func NewConnectResult(attempt Attempt, connFactory ConnectionFactory) ConnectResult {
return ConnectResult{Attempt: attempt, ConnFactory: connFactory}
} | [
"func",
"NewConnectResult",
"(",
"attempt",
"Attempt",
",",
"connFactory",
"ConnectionFactory",
")",
"ConnectResult",
"{",
"return",
"ConnectResult",
"{",
"Attempt",
":",
"attempt",
",",
"ConnFactory",
":",
"connFactory",
"}",
"\n",
"}"
] | // NewConnectResult returns a new ConnectResult | [
"NewConnectResult",
"returns",
"a",
"new",
"ConnectResult"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L251-L253 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | NewConnectResults | func NewConnectResults(results ...ConnectResult) ConnectAttemptResults {
mapResults := make(map[Attempt]ConnectResult)
for _, r := range results {
mapResults[r.Attempt] = r
}
return mapResults
} | go | func NewConnectResults(results ...ConnectResult) ConnectAttemptResults {
mapResults := make(map[Attempt]ConnectResult)
for _, r := range results {
mapResults[r.Attempt] = r
}
return mapResults
} | [
"func",
"NewConnectResults",
"(",
"results",
"...",
"ConnectResult",
")",
"ConnectAttemptResults",
"{",
"mapResults",
":=",
"make",
"(",
"map",
"[",
"Attempt",
"]",
"ConnectResult",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"results",
"{",
"mapResults",
"[",
"r",
".",
"Attempt",
"]",
"=",
"r",
"\n",
"}",
"\n",
"return",
"mapResults",
"\n",
"}"
] | // NewConnectResults returns a new ConnectAttemptResults | [
"NewConnectResults",
"returns",
"a",
"new",
"ConnectAttemptResults"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L259-L265 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | NewResult | func NewResult(operation Operation, result Result, errMsg ...string) *OperationResult {
msg := ""
if len(errMsg) > 0 {
msg = errMsg[0]
}
return &OperationResult{
Operation: operation,
Result: result,
ErrMessage: msg,
}
} | go | func NewResult(operation Operation, result Result, errMsg ...string) *OperationResult {
msg := ""
if len(errMsg) > 0 {
msg = errMsg[0]
}
return &OperationResult{
Operation: operation,
Result: result,
ErrMessage: msg,
}
} | [
"func",
"NewResult",
"(",
"operation",
"Operation",
",",
"result",
"Result",
",",
"errMsg",
"...",
"string",
")",
"*",
"OperationResult",
"{",
"msg",
":=",
"\"\"",
"\n",
"if",
"len",
"(",
"errMsg",
")",
">",
"0",
"{",
"msg",
"=",
"errMsg",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"&",
"OperationResult",
"{",
"Operation",
":",
"operation",
",",
"Result",
":",
"result",
",",
"ErrMessage",
":",
"msg",
",",
"}",
"\n",
"}"
] | // NewResult returns a new OperationResult | [
"NewResult",
"returns",
"a",
"new",
"OperationResult"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L287-L297 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | WithLedger | func WithLedger(ledger servicemocks.Ledger) Opt {
return func(opts *Opts) {
opts.Ledger = ledger
}
} | go | func WithLedger(ledger servicemocks.Ledger) Opt {
return func(opts *Opts) {
opts.Ledger = ledger
}
} | [
"func",
"WithLedger",
"(",
"ledger",
"servicemocks",
".",
"Ledger",
")",
"Opt",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"{",
"opts",
".",
"Ledger",
"=",
"ledger",
"\n",
"}",
"\n",
"}"
] | // WithLedger provides the mock connection with a ledger | [
"WithLedger",
"provides",
"the",
"mock",
"connection",
"with",
"a",
"ledger"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L307-L311 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/client/mocks/mockconnection.go | WithResults | func WithResults(funcResults ...*OperationResult) Opt {
return func(opts *Opts) {
opts.Operations = make(map[Operation]ResultDesc)
for _, fr := range funcResults {
opts.Operations[fr.Operation] = ResultDesc{Result: fr.Result, ErrMsg: fr.ErrMessage}
}
}
} | go | func WithResults(funcResults ...*OperationResult) Opt {
return func(opts *Opts) {
opts.Operations = make(map[Operation]ResultDesc)
for _, fr := range funcResults {
opts.Operations[fr.Operation] = ResultDesc{Result: fr.Result, ErrMsg: fr.ErrMessage}
}
}
} | [
"func",
"WithResults",
"(",
"funcResults",
"...",
"*",
"OperationResult",
")",
"Opt",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"{",
"opts",
".",
"Operations",
"=",
"make",
"(",
"map",
"[",
"Operation",
"]",
"ResultDesc",
")",
"\n",
"for",
"_",
",",
"fr",
":=",
"range",
"funcResults",
"{",
"opts",
".",
"Operations",
"[",
"fr",
".",
"Operation",
"]",
"=",
"ResultDesc",
"{",
"Result",
":",
"fr",
".",
"Result",
",",
"ErrMsg",
":",
"fr",
".",
"ErrMessage",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // WithResults specifies the results for one or more operations | [
"WithResults",
"specifies",
"the",
"results",
"for",
"one",
"or",
"more",
"operations"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/client/mocks/mockconnection.go#L314-L321 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | LoadPKCS11ContextHandle | func LoadPKCS11ContextHandle(lib, label, pin string, opts ...Options) (*ContextHandle, error) {
return getInstance(&pkcs11CtxCacheKey{lib: lib, label: label, pin: pin, opts: getCtxOpts(opts...)}, false)
} | go | func LoadPKCS11ContextHandle(lib, label, pin string, opts ...Options) (*ContextHandle, error) {
return getInstance(&pkcs11CtxCacheKey{lib: lib, label: label, pin: pin, opts: getCtxOpts(opts...)}, false)
} | [
"func",
"LoadPKCS11ContextHandle",
"(",
"lib",
",",
"label",
",",
"pin",
"string",
",",
"opts",
"...",
"Options",
")",
"(",
"*",
"ContextHandle",
",",
"error",
")",
"{",
"return",
"getInstance",
"(",
"&",
"pkcs11CtxCacheKey",
"{",
"lib",
":",
"lib",
",",
"label",
":",
"label",
",",
"pin",
":",
"pin",
",",
"opts",
":",
"getCtxOpts",
"(",
"opts",
"...",
")",
"}",
",",
"false",
")",
"\n",
"}"
] | //LoadPKCS11ContextHandle loads PKCS11 context handler instance from underlying cache | [
"LoadPKCS11ContextHandle",
"loads",
"PKCS11",
"context",
"handler",
"instance",
"from",
"underlying",
"cache"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L28-L30 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | ReloadPKCS11ContextHandle | func ReloadPKCS11ContextHandle(lib, label, pin string, opts ...Options) (*ContextHandle, error) {
return getInstance(&pkcs11CtxCacheKey{lib: lib, label: label, pin: pin, opts: getCtxOpts(opts...)}, true)
} | go | func ReloadPKCS11ContextHandle(lib, label, pin string, opts ...Options) (*ContextHandle, error) {
return getInstance(&pkcs11CtxCacheKey{lib: lib, label: label, pin: pin, opts: getCtxOpts(opts...)}, true)
} | [
"func",
"ReloadPKCS11ContextHandle",
"(",
"lib",
",",
"label",
",",
"pin",
"string",
",",
"opts",
"...",
"Options",
")",
"(",
"*",
"ContextHandle",
",",
"error",
")",
"{",
"return",
"getInstance",
"(",
"&",
"pkcs11CtxCacheKey",
"{",
"lib",
":",
"lib",
",",
"label",
":",
"label",
",",
"pin",
":",
"pin",
",",
"opts",
":",
"getCtxOpts",
"(",
"opts",
"...",
")",
"}",
",",
"true",
")",
"\n",
"}"
] | //ReloadPKCS11ContextHandle deletes PKCS11 instance from underlying cache and loads new PKCS11 context handler in cache | [
"ReloadPKCS11ContextHandle",
"deletes",
"PKCS11",
"instance",
"from",
"underlying",
"cache",
"and",
"loads",
"new",
"PKCS11",
"context",
"handler",
"in",
"cache"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L33-L35 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | LoadContextAndLogin | func LoadContextAndLogin(lib, pin, label string) (*ContextHandle, error) {
pkcs11Context, err := LoadPKCS11ContextHandle(lib, label, pin)
if err != nil {
return nil, err
}
session, err := pkcs11Context.OpenSession()
if err != nil {
return nil, err
}
err = pkcs11Context.Login(session)
if err != nil {
return nil, err
}
pkcs11Context.ReturnSession(session)
cachebridge.ClearAllSession()
return pkcs11Context, err
} | go | func LoadContextAndLogin(lib, pin, label string) (*ContextHandle, error) {
pkcs11Context, err := LoadPKCS11ContextHandle(lib, label, pin)
if err != nil {
return nil, err
}
session, err := pkcs11Context.OpenSession()
if err != nil {
return nil, err
}
err = pkcs11Context.Login(session)
if err != nil {
return nil, err
}
pkcs11Context.ReturnSession(session)
cachebridge.ClearAllSession()
return pkcs11Context, err
} | [
"func",
"LoadContextAndLogin",
"(",
"lib",
",",
"pin",
",",
"label",
"string",
")",
"(",
"*",
"ContextHandle",
",",
"error",
")",
"{",
"pkcs11Context",
",",
"err",
":=",
"LoadPKCS11ContextHandle",
"(",
"lib",
",",
"label",
",",
"pin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"pkcs11Context",
".",
"OpenSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"pkcs11Context",
".",
"Login",
"(",
"session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"pkcs11Context",
".",
"ReturnSession",
"(",
"session",
")",
"\n",
"cachebridge",
".",
"ClearAllSession",
"(",
")",
"\n",
"return",
"pkcs11Context",
",",
"err",
"\n",
"}"
] | //LoadContextAndLogin loads Context handle and performs login | [
"LoadContextAndLogin",
"loads",
"Context",
"handle",
"and",
"performs",
"login"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L38-L58 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | Login | func (handle *ContextHandle) Login(session mPkcs11.SessionHandle) error {
handle.lock.RLock()
defer handle.lock.RUnlock()
if handle.pin == "" {
return errors.New("No PIN set")
}
err := handle.ctx.Login(session, mPkcs11.CKU_USER, handle.pin)
if err != nil && err != mPkcs11.Error(mPkcs11.CKR_USER_ALREADY_LOGGED_IN) {
return errors.Errorf("Login failed [%s]", err)
}
return nil
} | go | func (handle *ContextHandle) Login(session mPkcs11.SessionHandle) error {
handle.lock.RLock()
defer handle.lock.RUnlock()
if handle.pin == "" {
return errors.New("No PIN set")
}
err := handle.ctx.Login(session, mPkcs11.CKU_USER, handle.pin)
if err != nil && err != mPkcs11.Error(mPkcs11.CKR_USER_ALREADY_LOGGED_IN) {
return errors.Errorf("Login failed [%s]", err)
}
return nil
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"Login",
"(",
"session",
"mPkcs11",
".",
"SessionHandle",
")",
"error",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"handle",
".",
"pin",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"No PIN set\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"handle",
".",
"ctx",
".",
"Login",
"(",
"session",
",",
"mPkcs11",
".",
"CKU_USER",
",",
"handle",
".",
"pin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_USER_ALREADY_LOGGED_IN",
")",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"Login failed [%s]\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Login logs a user into a token | [
"Login",
"logs",
"a",
"user",
"into",
"a",
"token"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L99-L112 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | ReturnSession | func (handle *ContextHandle) ReturnSession(session mPkcs11.SessionHandle) {
handle.lock.RLock()
defer handle.lock.RUnlock()
_, e := handle.ctx.GetSessionInfo(session)
if e != nil {
logger.Warnf("not returning session [%d], due to error [%s]. Discarding it", session, e)
e = handle.ctx.CloseSession(session)
if e != nil {
logger.Warn("unable to close session:", e)
}
return
}
select {
case handle.sessions <- session:
// returned session back to session cache
default:
// have plenty of sessions in cache, dropping
e = handle.ctx.CloseSession(session)
if e != nil {
logger.Warn("unable to close session: ", e)
}
}
} | go | func (handle *ContextHandle) ReturnSession(session mPkcs11.SessionHandle) {
handle.lock.RLock()
defer handle.lock.RUnlock()
_, e := handle.ctx.GetSessionInfo(session)
if e != nil {
logger.Warnf("not returning session [%d], due to error [%s]. Discarding it", session, e)
e = handle.ctx.CloseSession(session)
if e != nil {
logger.Warn("unable to close session:", e)
}
return
}
select {
case handle.sessions <- session:
// returned session back to session cache
default:
// have plenty of sessions in cache, dropping
e = handle.ctx.CloseSession(session)
if e != nil {
logger.Warn("unable to close session: ", e)
}
}
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"ReturnSession",
"(",
"session",
"mPkcs11",
".",
"SessionHandle",
")",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"_",
",",
"e",
":=",
"handle",
".",
"ctx",
".",
"GetSessionInfo",
"(",
"session",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"not returning session [%d], due to error [%s]. Discarding it\"",
",",
"session",
",",
"e",
")",
"\n",
"e",
"=",
"handle",
".",
"ctx",
".",
"CloseSession",
"(",
"session",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"unable to close session:\"",
",",
"e",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"select",
"{",
"case",
"handle",
".",
"sessions",
"<-",
"session",
":",
"default",
":",
"e",
"=",
"handle",
".",
"ctx",
".",
"CloseSession",
"(",
"session",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"unable to close session: \"",
",",
"e",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | //ReturnSession returns session back into the session pool
//if pool is pull or session is invalid then discards session | [
"ReturnSession",
"returns",
"session",
"back",
"into",
"the",
"session",
"pool",
"if",
"pool",
"is",
"pull",
"or",
"session",
"is",
"invalid",
"then",
"discards",
"session"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L116-L141 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | GetSession | func (handle *ContextHandle) GetSession() (session mPkcs11.SessionHandle) {
handle.lock.RLock()
select {
case session = <-handle.sessions:
logger.Debugf("Reusing existing pkcs11 session %+v on slot %d\n", session, handle.slot)
default:
// cache is empty (or completely in use), create a new session
s, err := handle.OpenSession()
if err != nil {
handle.lock.RUnlock()
panic(fmt.Errorf("OpenSession failed [%s]", err))
}
logger.Debugf("Created new pkcs11 session %+v on slot %d\n", s, handle.slot)
session = s
cachebridge.ClearSession(fmt.Sprintf("%d", session))
}
handle.lock.RUnlock()
return handle.validateSession(session)
} | go | func (handle *ContextHandle) GetSession() (session mPkcs11.SessionHandle) {
handle.lock.RLock()
select {
case session = <-handle.sessions:
logger.Debugf("Reusing existing pkcs11 session %+v on slot %d\n", session, handle.slot)
default:
// cache is empty (or completely in use), create a new session
s, err := handle.OpenSession()
if err != nil {
handle.lock.RUnlock()
panic(fmt.Errorf("OpenSession failed [%s]", err))
}
logger.Debugf("Created new pkcs11 session %+v on slot %d\n", s, handle.slot)
session = s
cachebridge.ClearSession(fmt.Sprintf("%d", session))
}
handle.lock.RUnlock()
return handle.validateSession(session)
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"GetSession",
"(",
")",
"(",
"session",
"mPkcs11",
".",
"SessionHandle",
")",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"select",
"{",
"case",
"session",
"=",
"<-",
"handle",
".",
"sessions",
":",
"logger",
".",
"Debugf",
"(",
"\"Reusing existing pkcs11 session %+v on slot %d\\n\"",
",",
"\\n",
",",
"session",
")",
"\n",
"handle",
".",
"slot",
"}",
"\n",
"default",
":",
"s",
",",
"err",
":=",
"handle",
".",
"OpenSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"OpenSession failed [%s]\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Created new pkcs11 session %+v on slot %d\\n\"",
",",
"\\n",
",",
"s",
")",
"\n",
"handle",
".",
"slot",
"\n",
"session",
"=",
"s",
"\n",
"\n",
"cachebridge",
".",
"ClearSession",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%d\"",
",",
"session",
")",
")",
"\n",
"}"
] | //GetSession returns session from session pool
//if pool is empty or completely in use, creates new session
//if new session is invalid recreates one after reloading ctx and re-login | [
"GetSession",
"returns",
"session",
"from",
"session",
"pool",
"if",
"pool",
"is",
"empty",
"or",
"completely",
"in",
"use",
"creates",
"new",
"session",
"if",
"new",
"session",
"is",
"invalid",
"recreates",
"one",
"after",
"reloading",
"ctx",
"and",
"re",
"-",
"login"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L146-L166 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | FindObjects | func (handle *ContextHandle) FindObjects(session mPkcs11.SessionHandle, max int) ([]mPkcs11.ObjectHandle, bool, error) {
handle.lock.RLock()
defer handle.lock.RUnlock()
return handle.ctx.FindObjects(session, max)
} | go | func (handle *ContextHandle) FindObjects(session mPkcs11.SessionHandle, max int) ([]mPkcs11.ObjectHandle, bool, error) {
handle.lock.RLock()
defer handle.lock.RUnlock()
return handle.ctx.FindObjects(session, max)
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"FindObjects",
"(",
"session",
"mPkcs11",
".",
"SessionHandle",
",",
"max",
"int",
")",
"(",
"[",
"]",
"mPkcs11",
".",
"ObjectHandle",
",",
"bool",
",",
"error",
")",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"handle",
".",
"ctx",
".",
"FindObjects",
"(",
"session",
",",
"max",
")",
"\n",
"}"
] | // FindObjects continues a search for token and session objects that match a template, obtaining additional object
// handles. The returned boolean indicates if the list would have been larger than max. | [
"FindObjects",
"continues",
"a",
"search",
"for",
"token",
"and",
"session",
"objects",
"that",
"match",
"a",
"template",
"obtaining",
"additional",
"object",
"handles",
".",
"The",
"returned",
"boolean",
"indicates",
"if",
"the",
"list",
"would",
"have",
"been",
"larger",
"than",
"max",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L215-L221 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | CopyObject | func (handle *ContextHandle) CopyObject(sh mPkcs11.SessionHandle, o mPkcs11.ObjectHandle, temp []*mPkcs11.Attribute) (mPkcs11.ObjectHandle, error) {
handle.lock.RLock()
defer handle.lock.RUnlock()
return handle.ctx.CopyObject(sh, o, temp)
} | go | func (handle *ContextHandle) CopyObject(sh mPkcs11.SessionHandle, o mPkcs11.ObjectHandle, temp []*mPkcs11.Attribute) (mPkcs11.ObjectHandle, error) {
handle.lock.RLock()
defer handle.lock.RUnlock()
return handle.ctx.CopyObject(sh, o, temp)
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"CopyObject",
"(",
"sh",
"mPkcs11",
".",
"SessionHandle",
",",
"o",
"mPkcs11",
".",
"ObjectHandle",
",",
"temp",
"[",
"]",
"*",
"mPkcs11",
".",
"Attribute",
")",
"(",
"mPkcs11",
".",
"ObjectHandle",
",",
"error",
")",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"handle",
".",
"ctx",
".",
"CopyObject",
"(",
"sh",
",",
"o",
",",
"temp",
")",
"\n",
"}"
] | // CopyObject creates a copy of an object. | [
"CopyObject",
"creates",
"a",
"copy",
"of",
"an",
"object",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L316-L321 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | FindKeyPairFromSKI | func (handle *ContextHandle) FindKeyPairFromSKI(session mPkcs11.SessionHandle, ski []byte, keyType bool) (*mPkcs11.ObjectHandle, error) {
handle.lock.RLock()
defer handle.lock.RUnlock()
return cachebridge.GetKeyPairFromSessionSKI(&cachebridge.KeyPairCacheKey{Mod: handle.ctx, Session: session, SKI: ski, KeyType: keyType})
} | go | func (handle *ContextHandle) FindKeyPairFromSKI(session mPkcs11.SessionHandle, ski []byte, keyType bool) (*mPkcs11.ObjectHandle, error) {
handle.lock.RLock()
defer handle.lock.RUnlock()
return cachebridge.GetKeyPairFromSessionSKI(&cachebridge.KeyPairCacheKey{Mod: handle.ctx, Session: session, SKI: ski, KeyType: keyType})
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"FindKeyPairFromSKI",
"(",
"session",
"mPkcs11",
".",
"SessionHandle",
",",
"ski",
"[",
"]",
"byte",
",",
"keyType",
"bool",
")",
"(",
"*",
"mPkcs11",
".",
"ObjectHandle",
",",
"error",
")",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"cachebridge",
".",
"GetKeyPairFromSessionSKI",
"(",
"&",
"cachebridge",
".",
"KeyPairCacheKey",
"{",
"Mod",
":",
"handle",
".",
"ctx",
",",
"Session",
":",
"session",
",",
"SKI",
":",
"ski",
",",
"KeyType",
":",
"keyType",
"}",
")",
"\n",
"}"
] | //FindKeyPairFromSKI finds key pair by SKI | [
"FindKeyPairFromSKI",
"finds",
"key",
"pair",
"by",
"SKI"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L332-L337 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | validateSession | func (handle *ContextHandle) validateSession(currentSession mPkcs11.SessionHandle) mPkcs11.SessionHandle {
handle.lock.RLock()
e := handle.detectErrorCondition(currentSession)
switch e {
case errSlotIDChanged,
mPkcs11.Error(mPkcs11.CKR_OBJECT_HANDLE_INVALID),
mPkcs11.Error(mPkcs11.CKR_SESSION_HANDLE_INVALID),
mPkcs11.Error(mPkcs11.CKR_SESSION_CLOSED),
mPkcs11.Error(mPkcs11.CKR_TOKEN_NOT_PRESENT),
mPkcs11.Error(mPkcs11.CKR_DEVICE_ERROR),
mPkcs11.Error(mPkcs11.CKR_GENERAL_ERROR),
mPkcs11.Error(mPkcs11.CKR_USER_NOT_LOGGED_IN):
logger.Warnf("Found error condition [%s], attempting to recreate pkcs11 context and re-login....", e)
handle.lock.RUnlock()
handle.lock.Lock()
defer handle.lock.Unlock()
handle.disposePKCS11Ctx()
//create new context
newCtx := handle.createNewPKCS11Ctx()
if newCtx == nil {
logger.Warn("Failed to recreate new pkcs11 context for given library")
return 0
}
//find slot
slot, found := handle.findSlot(newCtx)
if !found {
logger.Warnf("Unable to find slot for label :%s", handle.label)
return 0
}
logger.Debug("got the slot ", slot)
//open new session for given slot
newSession, err := createNewSession(newCtx, slot)
if err != nil {
logger.Fatalf("OpenSession [%s]\n", err)
return 0
}
logger.Debugf("Recreated new pkcs11 session %+v on slot %d\n", newSession, slot)
//login with new session
err = newCtx.Login(newSession, mPkcs11.CKU_USER, handle.pin)
if err != nil && err != mPkcs11.Error(mPkcs11.CKR_USER_ALREADY_LOGGED_IN) {
logger.Warnf("Unable to login with new session :%s", newSession)
return 0
}
handle.sendNotification()
handle.ctx = newCtx
handle.slot = slot
handle.sessions = make(chan mPkcs11.SessionHandle, handle.opts.sessionCacheSize)
logger.Infof("Able to login with recreated session successfully")
return newSession
case mPkcs11.Error(mPkcs11.CKR_DEVICE_MEMORY),
mPkcs11.Error(mPkcs11.CKR_DEVICE_REMOVED):
handle.lock.RUnlock()
panic(fmt.Sprintf("PKCS11 Session failure: [%s]", e))
default:
handle.lock.RUnlock()
// default should be a valid session or valid error, return session as it is
return currentSession
}
} | go | func (handle *ContextHandle) validateSession(currentSession mPkcs11.SessionHandle) mPkcs11.SessionHandle {
handle.lock.RLock()
e := handle.detectErrorCondition(currentSession)
switch e {
case errSlotIDChanged,
mPkcs11.Error(mPkcs11.CKR_OBJECT_HANDLE_INVALID),
mPkcs11.Error(mPkcs11.CKR_SESSION_HANDLE_INVALID),
mPkcs11.Error(mPkcs11.CKR_SESSION_CLOSED),
mPkcs11.Error(mPkcs11.CKR_TOKEN_NOT_PRESENT),
mPkcs11.Error(mPkcs11.CKR_DEVICE_ERROR),
mPkcs11.Error(mPkcs11.CKR_GENERAL_ERROR),
mPkcs11.Error(mPkcs11.CKR_USER_NOT_LOGGED_IN):
logger.Warnf("Found error condition [%s], attempting to recreate pkcs11 context and re-login....", e)
handle.lock.RUnlock()
handle.lock.Lock()
defer handle.lock.Unlock()
handle.disposePKCS11Ctx()
//create new context
newCtx := handle.createNewPKCS11Ctx()
if newCtx == nil {
logger.Warn("Failed to recreate new pkcs11 context for given library")
return 0
}
//find slot
slot, found := handle.findSlot(newCtx)
if !found {
logger.Warnf("Unable to find slot for label :%s", handle.label)
return 0
}
logger.Debug("got the slot ", slot)
//open new session for given slot
newSession, err := createNewSession(newCtx, slot)
if err != nil {
logger.Fatalf("OpenSession [%s]\n", err)
return 0
}
logger.Debugf("Recreated new pkcs11 session %+v on slot %d\n", newSession, slot)
//login with new session
err = newCtx.Login(newSession, mPkcs11.CKU_USER, handle.pin)
if err != nil && err != mPkcs11.Error(mPkcs11.CKR_USER_ALREADY_LOGGED_IN) {
logger.Warnf("Unable to login with new session :%s", newSession)
return 0
}
handle.sendNotification()
handle.ctx = newCtx
handle.slot = slot
handle.sessions = make(chan mPkcs11.SessionHandle, handle.opts.sessionCacheSize)
logger.Infof("Able to login with recreated session successfully")
return newSession
case mPkcs11.Error(mPkcs11.CKR_DEVICE_MEMORY),
mPkcs11.Error(mPkcs11.CKR_DEVICE_REMOVED):
handle.lock.RUnlock()
panic(fmt.Sprintf("PKCS11 Session failure: [%s]", e))
default:
handle.lock.RUnlock()
// default should be a valid session or valid error, return session as it is
return currentSession
}
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"validateSession",
"(",
"currentSession",
"mPkcs11",
".",
"SessionHandle",
")",
"mPkcs11",
".",
"SessionHandle",
"{",
"handle",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"e",
":=",
"handle",
".",
"detectErrorCondition",
"(",
"currentSession",
")",
"\n",
"switch",
"e",
"{",
"case",
"errSlotIDChanged",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_OBJECT_HANDLE_INVALID",
")",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_SESSION_HANDLE_INVALID",
")",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_SESSION_CLOSED",
")",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_TOKEN_NOT_PRESENT",
")",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_DEVICE_ERROR",
")",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_GENERAL_ERROR",
")",
",",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_USER_NOT_LOGGED_IN",
")",
":",
"logger",
".",
"Warnf",
"(",
"\"Found error condition [%s], attempting to recreate pkcs11 context and re-login....\"",
",",
"e",
")",
"\n",
"handle",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"handle",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"handle",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"handle",
".",
"disposePKCS11Ctx",
"(",
")",
"\n",
"newCtx",
":=",
"handle",
".",
"createNewPKCS11Ctx",
"(",
")",
"\n",
"if",
"newCtx",
"==",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"Failed to recreate new pkcs11 context for given library\"",
")",
"\n",
"return",
"0",
"\n",
"}",
"\n",
"slot",
",",
"found",
":=",
"handle",
".",
"findSlot",
"(",
"newCtx",
")",
"\n",
"if",
"!",
"found",
"{",
"logger",
".",
"Warnf",
"(",
"\"Unable to find slot for label :%s\"",
",",
"handle",
".",
"label",
")",
"\n",
"return",
"0",
"\n",
"}",
"\n",
"logger",
".",
"Debug",
"(",
"\"got the slot \"",
",",
"slot",
")",
"\n",
"newSession",
",",
"err",
":=",
"createNewSession",
"(",
"newCtx",
",",
"slot",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Fatalf",
"(",
"\"OpenSession [%s]\\n\"",
",",
"\\n",
")",
"\n",
"err",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Recreated new pkcs11 session %+v on slot %d\\n\"",
",",
"\\n",
",",
"newSession",
")",
"\n",
"slot",
"\n",
"err",
"=",
"newCtx",
".",
"Login",
"(",
"newSession",
",",
"mPkcs11",
".",
"CKU_USER",
",",
"handle",
".",
"pin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_USER_ALREADY_LOGGED_IN",
")",
"{",
"logger",
".",
"Warnf",
"(",
"\"Unable to login with new session :%s\"",
",",
"newSession",
")",
"\n",
"return",
"0",
"\n",
"}",
"\n",
"handle",
".",
"sendNotification",
"(",
")",
"\n",
"handle",
".",
"ctx",
"=",
"newCtx",
"\n",
"handle",
".",
"slot",
"=",
"slot",
"\n",
"handle",
".",
"sessions",
"=",
"make",
"(",
"chan",
"mPkcs11",
".",
"SessionHandle",
",",
"handle",
".",
"opts",
".",
"sessionCacheSize",
")",
"\n",
"logger",
".",
"Infof",
"(",
"\"Able to login with recreated session successfully\"",
")",
"return",
"newSession",
"}",
"\n",
"}"
] | //validateSession validates given session
//if session is invalid recreates one after reloading ctx and re-login
//care should be taken since handle.lock should be read locked before calling this function | [
"validateSession",
"validates",
"given",
"session",
"if",
"session",
"is",
"invalid",
"recreates",
"one",
"after",
"reloading",
"ctx",
"and",
"re",
"-",
"login",
"care",
"should",
"be",
"taken",
"since",
"handle",
".",
"lock",
"should",
"be",
"read",
"locked",
"before",
"calling",
"this",
"function"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L342-L415 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | detectErrorCondition | func (handle *ContextHandle) detectErrorCondition(currentSession mPkcs11.SessionHandle) error {
var e error
slot, ok := handle.findSlot(handle.ctx)
if !ok || slot != handle.slot {
e = errSlotIDChanged
}
if e == nil {
_, e = handle.ctx.GetSessionInfo(currentSession)
if e == nil {
_, e = handle.ctx.GetOperationState(currentSession)
}
}
return e
} | go | func (handle *ContextHandle) detectErrorCondition(currentSession mPkcs11.SessionHandle) error {
var e error
slot, ok := handle.findSlot(handle.ctx)
if !ok || slot != handle.slot {
e = errSlotIDChanged
}
if e == nil {
_, e = handle.ctx.GetSessionInfo(currentSession)
if e == nil {
_, e = handle.ctx.GetOperationState(currentSession)
}
}
return e
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"detectErrorCondition",
"(",
"currentSession",
"mPkcs11",
".",
"SessionHandle",
")",
"error",
"{",
"var",
"e",
"error",
"\n",
"slot",
",",
"ok",
":=",
"handle",
".",
"findSlot",
"(",
"handle",
".",
"ctx",
")",
"\n",
"if",
"!",
"ok",
"||",
"slot",
"!=",
"handle",
".",
"slot",
"{",
"e",
"=",
"errSlotIDChanged",
"\n",
"}",
"\n",
"if",
"e",
"==",
"nil",
"{",
"_",
",",
"e",
"=",
"handle",
".",
"ctx",
".",
"GetSessionInfo",
"(",
"currentSession",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"_",
",",
"e",
"=",
"handle",
".",
"ctx",
".",
"GetOperationState",
"(",
"currentSession",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"e",
"\n",
"}"
] | //detectErrorCondition checks if given session handle has errors | [
"detectErrorCondition",
"checks",
"if",
"given",
"session",
"handle",
"has",
"errors"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L418-L433 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | sendNotification | func (handle *ContextHandle) sendNotification() {
if handle.reloadNotification != nil {
select {
case handle.reloadNotification <- struct{}{}:
logger.Info("Notification sent for recreated pkcs11 ctx")
default:
logger.Warn("Unable to send notification for recreated pkcs11 ctx")
}
}
} | go | func (handle *ContextHandle) sendNotification() {
if handle.reloadNotification != nil {
select {
case handle.reloadNotification <- struct{}{}:
logger.Info("Notification sent for recreated pkcs11 ctx")
default:
logger.Warn("Unable to send notification for recreated pkcs11 ctx")
}
}
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"sendNotification",
"(",
")",
"{",
"if",
"handle",
".",
"reloadNotification",
"!=",
"nil",
"{",
"select",
"{",
"case",
"handle",
".",
"reloadNotification",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"logger",
".",
"Info",
"(",
"\"Notification sent for recreated pkcs11 ctx\"",
")",
"\n",
"default",
":",
"logger",
".",
"Warn",
"(",
"\"Unable to send notification for recreated pkcs11 ctx\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | //sendNotification sends ctx reload notificatin if channel available | [
"sendNotification",
"sends",
"ctx",
"reload",
"notificatin",
"if",
"channel",
"available"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L436-L445 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | disposePKCS11Ctx | func (handle *ContextHandle) disposePKCS11Ctx() {
//ignore error on close all sessions
err := handle.ctx.CloseAllSessions(handle.slot)
if err != nil {
logger.Warnf("Unable to close session", err)
}
//clear cache
cachebridge.ClearAllSession()
//Initialize context
err = handle.ctx.Finalize()
if err != nil {
logger.Warnf("unable to finalize pkcs11 ctx for [%s, %s] : %s", handle.lib, handle.label, err)
}
//Destroy context
handle.ctx.Destroy()
} | go | func (handle *ContextHandle) disposePKCS11Ctx() {
//ignore error on close all sessions
err := handle.ctx.CloseAllSessions(handle.slot)
if err != nil {
logger.Warnf("Unable to close session", err)
}
//clear cache
cachebridge.ClearAllSession()
//Initialize context
err = handle.ctx.Finalize()
if err != nil {
logger.Warnf("unable to finalize pkcs11 ctx for [%s, %s] : %s", handle.lib, handle.label, err)
}
//Destroy context
handle.ctx.Destroy()
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"disposePKCS11Ctx",
"(",
")",
"{",
"err",
":=",
"handle",
".",
"ctx",
".",
"CloseAllSessions",
"(",
"handle",
".",
"slot",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"Unable to close session\"",
",",
"err",
")",
"\n",
"}",
"\n",
"cachebridge",
".",
"ClearAllSession",
"(",
")",
"\n",
"err",
"=",
"handle",
".",
"ctx",
".",
"Finalize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"unable to finalize pkcs11 ctx for [%s, %s] : %s\"",
",",
"handle",
".",
"lib",
",",
"handle",
".",
"label",
",",
"err",
")",
"\n",
"}",
"\n",
"handle",
".",
"ctx",
".",
"Destroy",
"(",
")",
"\n",
"}"
] | //disposePKCS11Ctx disposes mPkcs11.Ctx object | [
"disposePKCS11Ctx",
"disposes",
"mPkcs11",
".",
"Ctx",
"object"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L448-L466 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | createNewPKCS11Ctx | func (handle *ContextHandle) createNewPKCS11Ctx() *mPkcs11.Ctx {
newCtx := mPkcs11.New(handle.lib)
if newCtx == nil {
logger.Warn("Failed to recreate new context for given library")
return nil
}
//initialize new context
err := newCtx.Initialize()
if err != nil {
if err != mPkcs11.Error(mPkcs11.CKR_CRYPTOKI_ALREADY_INITIALIZED) {
logger.Warn("Failed to initialize context:", err)
return nil
}
}
return newCtx
} | go | func (handle *ContextHandle) createNewPKCS11Ctx() *mPkcs11.Ctx {
newCtx := mPkcs11.New(handle.lib)
if newCtx == nil {
logger.Warn("Failed to recreate new context for given library")
return nil
}
//initialize new context
err := newCtx.Initialize()
if err != nil {
if err != mPkcs11.Error(mPkcs11.CKR_CRYPTOKI_ALREADY_INITIALIZED) {
logger.Warn("Failed to initialize context:", err)
return nil
}
}
return newCtx
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"createNewPKCS11Ctx",
"(",
")",
"*",
"mPkcs11",
".",
"Ctx",
"{",
"newCtx",
":=",
"mPkcs11",
".",
"New",
"(",
"handle",
".",
"lib",
")",
"\n",
"if",
"newCtx",
"==",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"Failed to recreate new context for given library\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"err",
":=",
"newCtx",
".",
"Initialize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_CRYPTOKI_ALREADY_INITIALIZED",
")",
"{",
"logger",
".",
"Warn",
"(",
"\"Failed to initialize context:\"",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"newCtx",
"\n",
"}"
] | //createNewPKCS11Ctx creates new mPkcs11.Ctx | [
"createNewPKCS11Ctx",
"creates",
"new",
"mPkcs11",
".",
"Ctx"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L469-L486 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | findSlot | func (handle *ContextHandle) findSlot(ctx *mPkcs11.Ctx) (uint, bool) {
var found bool
var slot uint
//get all slots
slots, err := ctx.GetSlotList(true)
if err != nil {
logger.Warn("Failed to get slot list for recreated context:", err)
return slot, found
}
//find slot matching label
for _, s := range slots {
info, err := ctx.GetTokenInfo(s)
if err != nil {
continue
}
logger.Debugf("Looking for %s, found label %s\n", handle.label, info.Label)
if handle.label == info.Label {
found = true
slot = s
break
}
}
return slot, found
} | go | func (handle *ContextHandle) findSlot(ctx *mPkcs11.Ctx) (uint, bool) {
var found bool
var slot uint
//get all slots
slots, err := ctx.GetSlotList(true)
if err != nil {
logger.Warn("Failed to get slot list for recreated context:", err)
return slot, found
}
//find slot matching label
for _, s := range slots {
info, err := ctx.GetTokenInfo(s)
if err != nil {
continue
}
logger.Debugf("Looking for %s, found label %s\n", handle.label, info.Label)
if handle.label == info.Label {
found = true
slot = s
break
}
}
return slot, found
} | [
"func",
"(",
"handle",
"*",
"ContextHandle",
")",
"findSlot",
"(",
"ctx",
"*",
"mPkcs11",
".",
"Ctx",
")",
"(",
"uint",
",",
"bool",
")",
"{",
"var",
"found",
"bool",
"\n",
"var",
"slot",
"uint",
"\n",
"slots",
",",
"err",
":=",
"ctx",
".",
"GetSlotList",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"Failed to get slot list for recreated context:\"",
",",
"err",
")",
"\n",
"return",
"slot",
",",
"found",
"\n",
"}",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"slots",
"{",
"info",
",",
"err",
":=",
"ctx",
".",
"GetTokenInfo",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Looking for %s, found label %s\\n\"",
",",
"\\n",
",",
"handle",
".",
"label",
")",
"\n",
"info",
".",
"Label",
"\n",
"}",
"\n",
"if",
"handle",
".",
"label",
"==",
"info",
".",
"Label",
"{",
"found",
"=",
"true",
"\n",
"slot",
"=",
"s",
"\n",
"break",
"\n",
"}",
"\n",
"}"
] | //findSlot finds slot for given pkcs11 ctx and label | [
"findSlot",
"finds",
"slot",
"for",
"given",
"pkcs11",
"ctx",
"and",
"label"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L489-L516 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | String | func (key *pkcs11CtxCacheKey) String() string {
return fmt.Sprintf("%x_%s_%s_%d_%d", key.lib, key.label, key.opts.connectionName, key.opts.sessionCacheSize, key.opts.openSessionRetry)
} | go | func (key *pkcs11CtxCacheKey) String() string {
return fmt.Sprintf("%x_%s_%s_%d_%d", key.lib, key.label, key.opts.connectionName, key.opts.sessionCacheSize, key.opts.openSessionRetry)
} | [
"func",
"(",
"key",
"*",
"pkcs11CtxCacheKey",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%x_%s_%s_%d_%d\"",
",",
"key",
".",
"lib",
",",
"key",
".",
"label",
",",
"key",
".",
"opts",
".",
"connectionName",
",",
"key",
".",
"opts",
".",
"sessionCacheSize",
",",
"key",
".",
"opts",
".",
"openSessionRetry",
")",
"\n",
"}"
] | //String return string value for pkcs11CtxCacheKey | [
"String",
"return",
"string",
"value",
"for",
"pkcs11CtxCacheKey"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L541-L543 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | getInstance | func getInstance(key lazycache.Key, reload bool) (*ContextHandle, error) {
once.Do(func() {
ctxCache = newCtxCache()
//anyway, loading first time, no need to reload
reload = false
})
if reload {
ctxCache.Delete(key)
}
ref, err := ctxCache.Get(key)
if err != nil {
return nil, errors.WithMessage(err, "failed to get pkcs11 ctx cache for given key")
}
return ref.(*ContextHandle), nil
} | go | func getInstance(key lazycache.Key, reload bool) (*ContextHandle, error) {
once.Do(func() {
ctxCache = newCtxCache()
//anyway, loading first time, no need to reload
reload = false
})
if reload {
ctxCache.Delete(key)
}
ref, err := ctxCache.Get(key)
if err != nil {
return nil, errors.WithMessage(err, "failed to get pkcs11 ctx cache for given key")
}
return ref.(*ContextHandle), nil
} | [
"func",
"getInstance",
"(",
"key",
"lazycache",
".",
"Key",
",",
"reload",
"bool",
")",
"(",
"*",
"ContextHandle",
",",
"error",
")",
"{",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"ctxCache",
"=",
"newCtxCache",
"(",
")",
"\n",
"reload",
"=",
"false",
"\n",
"}",
")",
"\n",
"if",
"reload",
"{",
"ctxCache",
".",
"Delete",
"(",
"key",
")",
"\n",
"}",
"\n",
"ref",
",",
"err",
":=",
"ctxCache",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"failed to get pkcs11 ctx cache for given key\"",
")",
"\n",
"}",
"\n",
"return",
"ref",
".",
"(",
"*",
"ContextHandle",
")",
",",
"nil",
"\n",
"}"
] | //getInstance loads ContextHandle instance from cache
//key - cache key
//reload - if true then deletes the existing cache instance and recreates one | [
"getInstance",
"loads",
"ContextHandle",
"instance",
"from",
"cache",
"key",
"-",
"cache",
"key",
"reload",
"-",
"if",
"true",
"then",
"deletes",
"the",
"existing",
"cache",
"instance",
"and",
"recreates",
"one"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L548-L566 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | finalizer | func finalizer() lazyref.Finalizer {
return func(v interface{}) {
if handle, ok := v.(*ContextHandle); ok {
err := handle.ctx.CloseAllSessions(handle.slot)
if err != nil {
logger.Warnf("unable to close all sessions in finalizer for [%s, %s] : %s", handle.lib, handle.label, err)
}
err = handle.ctx.Finalize()
if err != nil {
logger.Warnf("unable to finalize pkcs11 ctx in finalizer for [%s, %s] : %s", handle.lib, handle.label, err)
}
handle.ctx.Destroy()
cachebridge.ClearAllSession()
}
}
} | go | func finalizer() lazyref.Finalizer {
return func(v interface{}) {
if handle, ok := v.(*ContextHandle); ok {
err := handle.ctx.CloseAllSessions(handle.slot)
if err != nil {
logger.Warnf("unable to close all sessions in finalizer for [%s, %s] : %s", handle.lib, handle.label, err)
}
err = handle.ctx.Finalize()
if err != nil {
logger.Warnf("unable to finalize pkcs11 ctx in finalizer for [%s, %s] : %s", handle.lib, handle.label, err)
}
handle.ctx.Destroy()
cachebridge.ClearAllSession()
}
}
} | [
"func",
"finalizer",
"(",
")",
"lazyref",
".",
"Finalizer",
"{",
"return",
"func",
"(",
"v",
"interface",
"{",
"}",
")",
"{",
"if",
"handle",
",",
"ok",
":=",
"v",
".",
"(",
"*",
"ContextHandle",
")",
";",
"ok",
"{",
"err",
":=",
"handle",
".",
"ctx",
".",
"CloseAllSessions",
"(",
"handle",
".",
"slot",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"unable to close all sessions in finalizer for [%s, %s] : %s\"",
",",
"handle",
".",
"lib",
",",
"handle",
".",
"label",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"handle",
".",
"ctx",
".",
"Finalize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warnf",
"(",
"\"unable to finalize pkcs11 ctx in finalizer for [%s, %s] : %s\"",
",",
"handle",
".",
"lib",
",",
"handle",
".",
"label",
",",
"err",
")",
"\n",
"}",
"\n",
"handle",
".",
"ctx",
".",
"Destroy",
"(",
")",
"\n",
"cachebridge",
".",
"ClearAllSession",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | //finalizer finalizer for context handler cache | [
"finalizer",
"finalizer",
"for",
"context",
"handler",
"cache"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L578-L593 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/common/pkcs11/contextHandle.go | loadLibInitializer | func loadLibInitializer() lazycache.EntryInitializer {
return func(key lazycache.Key) (interface{}, error) {
ctxKey := key.(*pkcs11CtxCacheKey)
var slot uint
logger.Debugf("Loading pkcs11 library [%s]\n", ctxKey.lib)
if ctxKey.lib == "" {
return &ContextHandle{}, errors.New("No PKCS11 library default")
}
ctx := mPkcs11.New(ctxKey.lib)
if ctx == nil {
return &ContextHandle{}, errors.Errorf("Instantiate failed [%s]", ctxKey.lib)
}
err := ctx.Initialize()
if err != nil && err != mPkcs11.Error(mPkcs11.CKR_CRYPTOKI_ALREADY_INITIALIZED) {
logger.Warn("Failed to initialize context:", err)
return &ContextHandle{}, errors.WithMessage(err, "Failed to initialize pkcs11 ctx")
}
slots, err := ctx.GetSlotList(true)
if err != nil {
return &ContextHandle{}, errors.WithMessage(err, "Could not get Slot List")
}
found := false
for _, s := range slots {
info, errToken := ctx.GetTokenInfo(s)
if errToken != nil {
continue
}
logger.Debugf("Looking for %s, found label %s\n", ctxKey.label, info.Label)
if ctxKey.label == info.Label {
found = true
slot = s
break
}
}
if !found {
return &ContextHandle{}, errors.Errorf("Could not find token with label %s", ctxKey.label)
}
sessions := make(chan mPkcs11.SessionHandle, ctxKey.opts.sessionCacheSize)
return &ContextHandle{ctx: ctx, slot: slot, pin: ctxKey.pin, lib: ctxKey.lib, label: ctxKey.label, sessions: sessions, opts: ctxKey.opts}, nil
}
} | go | func loadLibInitializer() lazycache.EntryInitializer {
return func(key lazycache.Key) (interface{}, error) {
ctxKey := key.(*pkcs11CtxCacheKey)
var slot uint
logger.Debugf("Loading pkcs11 library [%s]\n", ctxKey.lib)
if ctxKey.lib == "" {
return &ContextHandle{}, errors.New("No PKCS11 library default")
}
ctx := mPkcs11.New(ctxKey.lib)
if ctx == nil {
return &ContextHandle{}, errors.Errorf("Instantiate failed [%s]", ctxKey.lib)
}
err := ctx.Initialize()
if err != nil && err != mPkcs11.Error(mPkcs11.CKR_CRYPTOKI_ALREADY_INITIALIZED) {
logger.Warn("Failed to initialize context:", err)
return &ContextHandle{}, errors.WithMessage(err, "Failed to initialize pkcs11 ctx")
}
slots, err := ctx.GetSlotList(true)
if err != nil {
return &ContextHandle{}, errors.WithMessage(err, "Could not get Slot List")
}
found := false
for _, s := range slots {
info, errToken := ctx.GetTokenInfo(s)
if errToken != nil {
continue
}
logger.Debugf("Looking for %s, found label %s\n", ctxKey.label, info.Label)
if ctxKey.label == info.Label {
found = true
slot = s
break
}
}
if !found {
return &ContextHandle{}, errors.Errorf("Could not find token with label %s", ctxKey.label)
}
sessions := make(chan mPkcs11.SessionHandle, ctxKey.opts.sessionCacheSize)
return &ContextHandle{ctx: ctx, slot: slot, pin: ctxKey.pin, lib: ctxKey.lib, label: ctxKey.label, sessions: sessions, opts: ctxKey.opts}, nil
}
} | [
"func",
"loadLibInitializer",
"(",
")",
"lazycache",
".",
"EntryInitializer",
"{",
"return",
"func",
"(",
"key",
"lazycache",
".",
"Key",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ctxKey",
":=",
"key",
".",
"(",
"*",
"pkcs11CtxCacheKey",
")",
"\n",
"var",
"slot",
"uint",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Loading pkcs11 library [%s]\\n\"",
",",
"\\n",
")",
"\n",
"ctxKey",
".",
"lib",
"\n",
"if",
"ctxKey",
".",
"lib",
"==",
"\"\"",
"{",
"return",
"&",
"ContextHandle",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"No PKCS11 library default\"",
")",
"\n",
"}",
"\n",
"ctx",
":=",
"mPkcs11",
".",
"New",
"(",
"ctxKey",
".",
"lib",
")",
"\n",
"if",
"ctx",
"==",
"nil",
"{",
"return",
"&",
"ContextHandle",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"Instantiate failed [%s]\"",
",",
"ctxKey",
".",
"lib",
")",
"\n",
"}",
"\n",
"err",
":=",
"ctx",
".",
"Initialize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"mPkcs11",
".",
"Error",
"(",
"mPkcs11",
".",
"CKR_CRYPTOKI_ALREADY_INITIALIZED",
")",
"{",
"logger",
".",
"Warn",
"(",
"\"Failed to initialize context:\"",
",",
"err",
")",
"\n",
"return",
"&",
"ContextHandle",
"{",
"}",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"Failed to initialize pkcs11 ctx\"",
")",
"\n",
"}",
"\n",
"slots",
",",
"err",
":=",
"ctx",
".",
"GetSlotList",
"(",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"ContextHandle",
"{",
"}",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"Could not get Slot List\"",
")",
"\n",
"}",
"\n",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"slots",
"{",
"info",
",",
"errToken",
":=",
"ctx",
".",
"GetTokenInfo",
"(",
"s",
")",
"\n",
"if",
"errToken",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Looking for %s, found label %s\\n\"",
",",
"\\n",
",",
"ctxKey",
".",
"label",
")",
"\n",
"info",
".",
"Label",
"\n",
"}",
"\n",
"if",
"ctxKey",
".",
"label",
"==",
"info",
".",
"Label",
"{",
"found",
"=",
"true",
"\n",
"slot",
"=",
"s",
"\n",
"break",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"return",
"&",
"ContextHandle",
"{",
"}",
",",
"errors",
".",
"Errorf",
"(",
"\"Could not find token with label %s\"",
",",
"ctxKey",
".",
"label",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | //loadLibInitializer initializer for context handler cache | [
"loadLibInitializer",
"initializer",
"for",
"context",
"handler",
"cache"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/common/pkcs11/contextHandle.go#L596-L640 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | New | func New(channelID string, options ...Option) (*ChannelConfig, error) {
opts, err := prepareOpts(options...)
if err != nil {
return nil, err
}
return &ChannelConfig{channelID: channelID, opts: opts}, nil
} | go | func New(channelID string, options ...Option) (*ChannelConfig, error) {
opts, err := prepareOpts(options...)
if err != nil {
return nil, err
}
return &ChannelConfig{channelID: channelID, opts: opts}, nil
} | [
"func",
"New",
"(",
"channelID",
"string",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"ChannelConfig",
",",
"error",
")",
"{",
"opts",
",",
"err",
":=",
"prepareOpts",
"(",
"options",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ChannelConfig",
"{",
"channelID",
":",
"channelID",
",",
"opts",
":",
"opts",
"}",
",",
"nil",
"\n",
"}"
] | // New channel config implementation | [
"New",
"channel",
"config",
"implementation"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L132-L139 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | Query | func (c *ChannelConfig) Query(reqCtx reqContext.Context) (fab.ChannelCfg, error) {
if c.opts.Orderer != nil {
return c.queryOrderer(reqCtx)
}
return c.queryPeers(reqCtx)
} | go | func (c *ChannelConfig) Query(reqCtx reqContext.Context) (fab.ChannelCfg, error) {
if c.opts.Orderer != nil {
return c.queryOrderer(reqCtx)
}
return c.queryPeers(reqCtx)
} | [
"func",
"(",
"c",
"*",
"ChannelConfig",
")",
"Query",
"(",
"reqCtx",
"reqContext",
".",
"Context",
")",
"(",
"fab",
".",
"ChannelCfg",
",",
"error",
")",
"{",
"if",
"c",
".",
"opts",
".",
"Orderer",
"!=",
"nil",
"{",
"return",
"c",
".",
"queryOrderer",
"(",
"reqCtx",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"queryPeers",
"(",
"reqCtx",
")",
"\n",
"}"
] | // Query returns channel configuration | [
"Query",
"returns",
"channel",
"configuration"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L142-L149 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | WithPeers | func WithPeers(peers []fab.Peer) Option {
return func(opts *Opts) error {
opts.Targets = peers
return nil
}
} | go | func WithPeers(peers []fab.Peer) Option {
return func(opts *Opts) error {
opts.Targets = peers
return nil
}
} | [
"func",
"WithPeers",
"(",
"peers",
"[",
"]",
"fab",
".",
"Peer",
")",
"Option",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"error",
"{",
"opts",
".",
"Targets",
"=",
"peers",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithPeers encapsulates peers to Option | [
"WithPeers",
"encapsulates",
"peers",
"to",
"Option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L290-L295 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | WithMinResponses | func WithMinResponses(min int) Option {
return func(opts *Opts) error {
opts.MinResponses = min
return nil
}
} | go | func WithMinResponses(min int) Option {
return func(opts *Opts) error {
opts.MinResponses = min
return nil
}
} | [
"func",
"WithMinResponses",
"(",
"min",
"int",
")",
"Option",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"error",
"{",
"opts",
".",
"MinResponses",
"=",
"min",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithMinResponses encapsulates minimum responses to Option | [
"WithMinResponses",
"encapsulates",
"minimum",
"responses",
"to",
"Option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L298-L303 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | WithOrderer | func WithOrderer(orderer fab.Orderer) Option {
return func(opts *Opts) error {
opts.Orderer = orderer
return nil
}
} | go | func WithOrderer(orderer fab.Orderer) Option {
return func(opts *Opts) error {
opts.Orderer = orderer
return nil
}
} | [
"func",
"WithOrderer",
"(",
"orderer",
"fab",
".",
"Orderer",
")",
"Option",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"error",
"{",
"opts",
".",
"Orderer",
"=",
"orderer",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithOrderer encapsulates orderer to Option | [
"WithOrderer",
"encapsulates",
"orderer",
"to",
"Option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L306-L311 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | WithMaxTargets | func WithMaxTargets(maxTargets int) Option {
return func(opts *Opts) error {
opts.MaxTargets = maxTargets
return nil
}
} | go | func WithMaxTargets(maxTargets int) Option {
return func(opts *Opts) error {
opts.MaxTargets = maxTargets
return nil
}
} | [
"func",
"WithMaxTargets",
"(",
"maxTargets",
"int",
")",
"Option",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"error",
"{",
"opts",
".",
"MaxTargets",
"=",
"maxTargets",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithMaxTargets encapsulates minTargets to Option | [
"WithMaxTargets",
"encapsulates",
"minTargets",
"to",
"Option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L314-L319 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | WithRetryOpts | func WithRetryOpts(retryOpts retry.Opts) Option {
return func(opts *Opts) error {
opts.RetryOpts = retryOpts
return nil
}
} | go | func WithRetryOpts(retryOpts retry.Opts) Option {
return func(opts *Opts) error {
opts.RetryOpts = retryOpts
return nil
}
} | [
"func",
"WithRetryOpts",
"(",
"retryOpts",
"retry",
".",
"Opts",
")",
"Option",
"{",
"return",
"func",
"(",
"opts",
"*",
"Opts",
")",
"error",
"{",
"opts",
".",
"RetryOpts",
"=",
"retryOpts",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithRetryOpts encapsulates retry opts to Option | [
"WithRetryOpts",
"encapsulates",
"retry",
"opts",
"to",
"Option"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L322-L327 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | prepareOpts | func prepareOpts(options ...Option) (Opts, error) {
opts := Opts{}
for _, option := range options {
err := option(&opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read query config opts")
}
}
return opts, nil
} | go | func prepareOpts(options ...Option) (Opts, error) {
opts := Opts{}
for _, option := range options {
err := option(&opts)
if err != nil {
return opts, errors.WithMessage(err, "Failed to read query config opts")
}
}
return opts, nil
} | [
"func",
"prepareOpts",
"(",
"options",
"...",
"Option",
")",
"(",
"Opts",
",",
"error",
")",
"{",
"opts",
":=",
"Opts",
"{",
"}",
"\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"err",
":=",
"option",
"(",
"&",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"opts",
",",
"errors",
".",
"WithMessage",
"(",
"err",
",",
"\"Failed to read query config opts\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"opts",
",",
"nil",
"\n",
"}"
] | // prepareOpts Reads channel config options from Option array | [
"prepareOpts",
"Reads",
"channel",
"config",
"options",
"from",
"Option",
"array"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L330-L340 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/chconfig.go | randomMaxTargets | func randomMaxTargets(targets []fab.ProposalProcessor, max int) []fab.ProposalProcessor {
if len(targets) <= max {
return targets
}
for i := range targets {
j := rand.Intn(i + 1)
targets[i], targets[j] = targets[j], targets[i]
}
return targets[:max]
} | go | func randomMaxTargets(targets []fab.ProposalProcessor, max int) []fab.ProposalProcessor {
if len(targets) <= max {
return targets
}
for i := range targets {
j := rand.Intn(i + 1)
targets[i], targets[j] = targets[j], targets[i]
}
return targets[:max]
} | [
"func",
"randomMaxTargets",
"(",
"targets",
"[",
"]",
"fab",
".",
"ProposalProcessor",
",",
"max",
"int",
")",
"[",
"]",
"fab",
".",
"ProposalProcessor",
"{",
"if",
"len",
"(",
"targets",
")",
"<=",
"max",
"{",
"return",
"targets",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"targets",
"{",
"j",
":=",
"rand",
".",
"Intn",
"(",
"i",
"+",
"1",
")",
"\n",
"targets",
"[",
"i",
"]",
",",
"targets",
"[",
"j",
"]",
"=",
"targets",
"[",
"j",
"]",
",",
"targets",
"[",
"i",
"]",
"\n",
"}",
"\n",
"return",
"targets",
"[",
":",
"max",
"]",
"\n",
"}"
] | //randomMaxTargets returns random sub set of max length targets | [
"randomMaxTargets",
"returns",
"random",
"sub",
"set",
"of",
"max",
"length",
"targets"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/chconfig.go#L623-L632 | train |
hyperledger/fabric-sdk-go | pkg/core/cryptosuite/bccsp/pkcs11/cryptosuiteimpl.go | getOptsByConfig | func getOptsByConfig(c core.CryptoSuiteConfig) *pkcs11.PKCS11Opts {
pkks := pkcs11.FileKeystoreOpts{KeyStorePath: c.KeyStorePath()}
opts := &pkcs11.PKCS11Opts{
SecLevel: c.SecurityLevel(),
HashFamily: c.SecurityAlgorithm(),
FileKeystore: &pkks,
Library: c.SecurityProviderLibPath(),
Pin: c.SecurityProviderPin(),
Label: c.SecurityProviderLabel(),
SoftVerify: c.SoftVerify(),
}
logger.Debug("Initialized PKCS11 cryptosuite")
return opts
} | go | func getOptsByConfig(c core.CryptoSuiteConfig) *pkcs11.PKCS11Opts {
pkks := pkcs11.FileKeystoreOpts{KeyStorePath: c.KeyStorePath()}
opts := &pkcs11.PKCS11Opts{
SecLevel: c.SecurityLevel(),
HashFamily: c.SecurityAlgorithm(),
FileKeystore: &pkks,
Library: c.SecurityProviderLibPath(),
Pin: c.SecurityProviderPin(),
Label: c.SecurityProviderLabel(),
SoftVerify: c.SoftVerify(),
}
logger.Debug("Initialized PKCS11 cryptosuite")
return opts
} | [
"func",
"getOptsByConfig",
"(",
"c",
"core",
".",
"CryptoSuiteConfig",
")",
"*",
"pkcs11",
".",
"PKCS11Opts",
"{",
"pkks",
":=",
"pkcs11",
".",
"FileKeystoreOpts",
"{",
"KeyStorePath",
":",
"c",
".",
"KeyStorePath",
"(",
")",
"}",
"\n",
"opts",
":=",
"&",
"pkcs11",
".",
"PKCS11Opts",
"{",
"SecLevel",
":",
"c",
".",
"SecurityLevel",
"(",
")",
",",
"HashFamily",
":",
"c",
".",
"SecurityAlgorithm",
"(",
")",
",",
"FileKeystore",
":",
"&",
"pkks",
",",
"Library",
":",
"c",
".",
"SecurityProviderLibPath",
"(",
")",
",",
"Pin",
":",
"c",
".",
"SecurityProviderPin",
"(",
")",
",",
"Label",
":",
"c",
".",
"SecurityProviderLabel",
"(",
")",
",",
"SoftVerify",
":",
"c",
".",
"SoftVerify",
"(",
")",
",",
"}",
"\n",
"logger",
".",
"Debug",
"(",
"\"Initialized PKCS11 cryptosuite\"",
")",
"\n",
"return",
"opts",
"\n",
"}"
] | //getOptsByConfig Returns Factory opts for given SDK config | [
"getOptsByConfig",
"Returns",
"Factory",
"opts",
"for",
"given",
"SDK",
"config"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/core/cryptosuite/bccsp/pkcs11/cryptosuiteimpl.go#L48-L62 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/deliverclient/dispatcher/events.go | NewSeekEvent | func NewSeekEvent(seekInfo *ab.SeekInfo, errch chan<- error) *SeekEvent {
return &SeekEvent{
SeekInfo: seekInfo,
ErrCh: errch,
}
} | go | func NewSeekEvent(seekInfo *ab.SeekInfo, errch chan<- error) *SeekEvent {
return &SeekEvent{
SeekInfo: seekInfo,
ErrCh: errch,
}
} | [
"func",
"NewSeekEvent",
"(",
"seekInfo",
"*",
"ab",
".",
"SeekInfo",
",",
"errch",
"chan",
"<-",
"error",
")",
"*",
"SeekEvent",
"{",
"return",
"&",
"SeekEvent",
"{",
"SeekInfo",
":",
"seekInfo",
",",
"ErrCh",
":",
"errch",
",",
"}",
"\n",
"}"
] | // NewSeekEvent returns a new SeekRequestEvent | [
"NewSeekEvent",
"returns",
"a",
"new",
"SeekRequestEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/deliverclient/dispatcher/events.go#L20-L25 | train |
hyperledger/fabric-sdk-go | pkg/fab/chconfig/cache.go | NewRefCache | func NewRefCache(opts ...options.Opt) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(ck.Context(), ck.Provider(), ck.ChannelID(), opts...), nil
}
return lazycache.New("Channel_Cfg_Cache", initializer)
} | go | func NewRefCache(opts ...options.Opt) *lazycache.Cache {
initializer := func(key lazycache.Key) (interface{}, error) {
ck, ok := key.(CacheKey)
if !ok {
return nil, errors.New("unexpected cache key")
}
return NewRef(ck.Context(), ck.Provider(), ck.ChannelID(), opts...), nil
}
return lazycache.New("Channel_Cfg_Cache", initializer)
} | [
"func",
"NewRefCache",
"(",
"opts",
"...",
"options",
".",
"Opt",
")",
"*",
"lazycache",
".",
"Cache",
"{",
"initializer",
":=",
"func",
"(",
"key",
"lazycache",
".",
"Key",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ck",
",",
"ok",
":=",
"key",
".",
"(",
"CacheKey",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"unexpected cache key\"",
")",
"\n",
"}",
"\n",
"return",
"NewRef",
"(",
"ck",
".",
"Context",
"(",
")",
",",
"ck",
".",
"Provider",
"(",
")",
",",
"ck",
".",
"ChannelID",
"(",
")",
",",
"opts",
"...",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"lazycache",
".",
"New",
"(",
"\"Channel_Cfg_Cache\"",
",",
"initializer",
")",
"\n",
"}"
] | // NewRefCache a cache of channel config references that refreshed with the
// given interval | [
"NewRefCache",
"a",
"cache",
"of",
"channel",
"config",
"references",
"that",
"refreshed",
"with",
"the",
"given",
"interval"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/chconfig/cache.go#L47-L57 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/endpoint/endpoint.go | BlockHeight | func (e *EventEndpoint) BlockHeight() uint64 {
peerState, ok := e.Peer.(fab.PeerState)
if !ok {
return 0
}
return peerState.BlockHeight()
} | go | func (e *EventEndpoint) BlockHeight() uint64 {
peerState, ok := e.Peer.(fab.PeerState)
if !ok {
return 0
}
return peerState.BlockHeight()
} | [
"func",
"(",
"e",
"*",
"EventEndpoint",
")",
"BlockHeight",
"(",
")",
"uint64",
"{",
"peerState",
",",
"ok",
":=",
"e",
".",
"Peer",
".",
"(",
"fab",
".",
"PeerState",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"peerState",
".",
"BlockHeight",
"(",
")",
"\n",
"}"
] | // BlockHeight returns the block height of the peer. If the peer doesn't contain any state info then 0 is returned. | [
"BlockHeight",
"returns",
"the",
"block",
"height",
"of",
"the",
"peer",
".",
"If",
"the",
"peer",
"doesn",
"t",
"contain",
"any",
"state",
"info",
"then",
"0",
"is",
"returned",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/endpoint/endpoint.go#L30-L36 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/endpoint/endpoint.go | FromPeerConfig | func FromPeerConfig(config fab.EndpointConfig, peer fab.Peer, peerCfg *fab.PeerConfig) *EventEndpoint {
opts := comm.OptsFromPeerConfig(peerCfg)
opts = append(opts, comm.WithConnectTimeout(config.Timeout(fab.PeerConnection)))
return &EventEndpoint{
Peer: peer,
opts: opts,
}
} | go | func FromPeerConfig(config fab.EndpointConfig, peer fab.Peer, peerCfg *fab.PeerConfig) *EventEndpoint {
opts := comm.OptsFromPeerConfig(peerCfg)
opts = append(opts, comm.WithConnectTimeout(config.Timeout(fab.PeerConnection)))
return &EventEndpoint{
Peer: peer,
opts: opts,
}
} | [
"func",
"FromPeerConfig",
"(",
"config",
"fab",
".",
"EndpointConfig",
",",
"peer",
"fab",
".",
"Peer",
",",
"peerCfg",
"*",
"fab",
".",
"PeerConfig",
")",
"*",
"EventEndpoint",
"{",
"opts",
":=",
"comm",
".",
"OptsFromPeerConfig",
"(",
"peerCfg",
")",
"\n",
"opts",
"=",
"append",
"(",
"opts",
",",
"comm",
".",
"WithConnectTimeout",
"(",
"config",
".",
"Timeout",
"(",
"fab",
".",
"PeerConnection",
")",
")",
")",
"\n",
"return",
"&",
"EventEndpoint",
"{",
"Peer",
":",
"peer",
",",
"opts",
":",
"opts",
",",
"}",
"\n",
"}"
] | // FromPeerConfig creates a new EventEndpoint from the given config | [
"FromPeerConfig",
"creates",
"a",
"new",
"EventEndpoint",
"from",
"the",
"given",
"config"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/endpoint/endpoint.go#L39-L47 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdata.go | NewSimpleMockBlock | func NewSimpleMockBlock() *common.Block {
return &common.Block{
Data: &common.BlockData{
Data: [][]byte{[]byte("test")},
},
Header: &common.BlockHeader{
DataHash: []byte(""),
PreviousHash: []byte(""),
Number: 1,
},
Metadata: &common.BlockMetadata{
Metadata: [][]byte{[]byte("test")},
},
}
} | go | func NewSimpleMockBlock() *common.Block {
return &common.Block{
Data: &common.BlockData{
Data: [][]byte{[]byte("test")},
},
Header: &common.BlockHeader{
DataHash: []byte(""),
PreviousHash: []byte(""),
Number: 1,
},
Metadata: &common.BlockMetadata{
Metadata: [][]byte{[]byte("test")},
},
}
} | [
"func",
"NewSimpleMockBlock",
"(",
")",
"*",
"common",
".",
"Block",
"{",
"return",
"&",
"common",
".",
"Block",
"{",
"Data",
":",
"&",
"common",
".",
"BlockData",
"{",
"Data",
":",
"[",
"]",
"[",
"]",
"byte",
"{",
"[",
"]",
"byte",
"(",
"\"test\"",
")",
"}",
",",
"}",
",",
"Header",
":",
"&",
"common",
".",
"BlockHeader",
"{",
"DataHash",
":",
"[",
"]",
"byte",
"(",
"\"\"",
")",
",",
"PreviousHash",
":",
"[",
"]",
"byte",
"(",
"\"\"",
")",
",",
"Number",
":",
"1",
",",
"}",
",",
"Metadata",
":",
"&",
"common",
".",
"BlockMetadata",
"{",
"Metadata",
":",
"[",
"]",
"[",
"]",
"byte",
"{",
"[",
"]",
"byte",
"(",
"\"test\"",
")",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewSimpleMockBlock returns a simple mock block | [
"NewSimpleMockBlock",
"returns",
"a",
"simple",
"mock",
"block"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdata.go#L30-L44 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdata.go | Build | func (b *MockConfigBlockBuilder) Build() *common.Block {
return &common.Block{
Header: &common.BlockHeader{
Number: b.Index,
},
Metadata: b.buildBlockMetadata(),
Data: &common.BlockData{
Data: b.buildBlockEnvelopeBytes(),
},
}
} | go | func (b *MockConfigBlockBuilder) Build() *common.Block {
return &common.Block{
Header: &common.BlockHeader{
Number: b.Index,
},
Metadata: b.buildBlockMetadata(),
Data: &common.BlockData{
Data: b.buildBlockEnvelopeBytes(),
},
}
} | [
"func",
"(",
"b",
"*",
"MockConfigBlockBuilder",
")",
"Build",
"(",
")",
"*",
"common",
".",
"Block",
"{",
"return",
"&",
"common",
".",
"Block",
"{",
"Header",
":",
"&",
"common",
".",
"BlockHeader",
"{",
"Number",
":",
"b",
".",
"Index",
",",
"}",
",",
"Metadata",
":",
"b",
".",
"buildBlockMetadata",
"(",
")",
",",
"Data",
":",
"&",
"common",
".",
"BlockData",
"{",
"Data",
":",
"b",
".",
"buildBlockEnvelopeBytes",
"(",
")",
",",
"}",
",",
"}",
"\n",
"}"
] | // Build creates a mock Chain configuration Block | [
"Build",
"creates",
"a",
"mock",
"Chain",
"configuration",
"Block"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdata.go#L83-L93 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdata.go | Build | func (b *MockConfigUpdateEnvelopeBuilder) Build() *common.Envelope {
return &common.Envelope{
Payload: marshalOrPanic(b.buildPayload()),
}
} | go | func (b *MockConfigUpdateEnvelopeBuilder) Build() *common.Envelope {
return &common.Envelope{
Payload: marshalOrPanic(b.buildPayload()),
}
} | [
"func",
"(",
"b",
"*",
"MockConfigUpdateEnvelopeBuilder",
")",
"Build",
"(",
")",
"*",
"common",
".",
"Envelope",
"{",
"return",
"&",
"common",
".",
"Envelope",
"{",
"Payload",
":",
"marshalOrPanic",
"(",
"b",
".",
"buildPayload",
"(",
")",
")",
",",
"}",
"\n",
"}"
] | // Build builds an Envelope that contains a mock ConfigUpdateEnvelope | [
"Build",
"builds",
"an",
"Envelope",
"that",
"contains",
"a",
"mock",
"ConfigUpdateEnvelope"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdata.go#L443-L447 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdata.go | CreateBlockWithCCEvent | func CreateBlockWithCCEvent(events *pp.ChaincodeEvent, txID string,
channelID string) (*common.Block, error) {
return CreateBlockWithCCEventAndTxStatus(events, txID, channelID, pp.TxValidationCode_VALID)
} | go | func CreateBlockWithCCEvent(events *pp.ChaincodeEvent, txID string,
channelID string) (*common.Block, error) {
return CreateBlockWithCCEventAndTxStatus(events, txID, channelID, pp.TxValidationCode_VALID)
} | [
"func",
"CreateBlockWithCCEvent",
"(",
"events",
"*",
"pp",
".",
"ChaincodeEvent",
",",
"txID",
"string",
",",
"channelID",
"string",
")",
"(",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"return",
"CreateBlockWithCCEventAndTxStatus",
"(",
"events",
",",
"txID",
",",
"channelID",
",",
"pp",
".",
"TxValidationCode_VALID",
")",
"\n",
"}"
] | // CreateBlockWithCCEvent creates a mock block | [
"CreateBlockWithCCEvent",
"creates",
"a",
"mock",
"block"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdata.go#L499-L502 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdata.go | CreateBlockWithCCEventAndTxStatus | func CreateBlockWithCCEventAndTxStatus(events *pp.ChaincodeEvent, txID string,
channelID string, txValidationCode pp.TxValidationCode) (*common.Block, error) {
chdr := &common.ChannelHeader{
Type: int32(common.HeaderType_ENDORSER_TRANSACTION),
Version: 1,
Timestamp: ×tamp.Timestamp{
Seconds: time.Now().Unix(),
Nanos: 0,
},
ChannelId: channelID,
TxId: txID}
hdr := &common.Header{ChannelHeader: protoutil.MarshalOrPanic(chdr)}
payload := &common.Payload{Header: hdr}
cea := &pp.ChaincodeEndorsedAction{}
ccaPayload := &pp.ChaincodeActionPayload{Action: cea}
env := &common.Envelope{}
taa := &pp.TransactionAction{}
taas := make([]*pp.TransactionAction, 1)
taas[0] = taa
tx := &pp.Transaction{Actions: taas}
pHashBytes := []byte("proposal_hash")
pResponse := &pp.Response{Status: 200}
results := []byte("results")
eventBytes, err := protoutil.GetBytesChaincodeEvent(events)
if err != nil {
return nil, err
}
ccaPayload.Action.ProposalResponsePayload, err = protoutil.GetBytesProposalResponsePayload(pHashBytes, pResponse, results, eventBytes, nil)
if err != nil {
return nil, err
}
tx.Actions[0].Payload, err = protoutil.GetBytesChaincodeActionPayload(ccaPayload)
if err != nil {
return nil, err
}
payload.Data, err = protoutil.GetBytesTransaction(tx)
if err != nil {
return nil, err
}
env.Payload, err = protoutil.GetBytesPayload(payload)
if err != nil {
return nil, err
}
ebytes, err := protoutil.GetBytesEnvelope(env)
if err != nil {
return nil, err
}
block := newBlock(1, []byte{})
block.Data.Data = append(block.Data.Data, ebytes)
blockbytes := cutil.ConcatenateBytes(block.Data.Data...)
block.Header.DataHash = computeSHA256(blockbytes)
txsfltr := ledger_util.NewTxValidationFlags(len(block.Data.Data))
for i := 0; i < len(block.Data.Data); i++ {
txsfltr[i] = uint8(txValidationCode)
}
block.Metadata.Metadata[common.BlockMetadataIndex_TRANSACTIONS_FILTER] = txsfltr
return block, nil
} | go | func CreateBlockWithCCEventAndTxStatus(events *pp.ChaincodeEvent, txID string,
channelID string, txValidationCode pp.TxValidationCode) (*common.Block, error) {
chdr := &common.ChannelHeader{
Type: int32(common.HeaderType_ENDORSER_TRANSACTION),
Version: 1,
Timestamp: ×tamp.Timestamp{
Seconds: time.Now().Unix(),
Nanos: 0,
},
ChannelId: channelID,
TxId: txID}
hdr := &common.Header{ChannelHeader: protoutil.MarshalOrPanic(chdr)}
payload := &common.Payload{Header: hdr}
cea := &pp.ChaincodeEndorsedAction{}
ccaPayload := &pp.ChaincodeActionPayload{Action: cea}
env := &common.Envelope{}
taa := &pp.TransactionAction{}
taas := make([]*pp.TransactionAction, 1)
taas[0] = taa
tx := &pp.Transaction{Actions: taas}
pHashBytes := []byte("proposal_hash")
pResponse := &pp.Response{Status: 200}
results := []byte("results")
eventBytes, err := protoutil.GetBytesChaincodeEvent(events)
if err != nil {
return nil, err
}
ccaPayload.Action.ProposalResponsePayload, err = protoutil.GetBytesProposalResponsePayload(pHashBytes, pResponse, results, eventBytes, nil)
if err != nil {
return nil, err
}
tx.Actions[0].Payload, err = protoutil.GetBytesChaincodeActionPayload(ccaPayload)
if err != nil {
return nil, err
}
payload.Data, err = protoutil.GetBytesTransaction(tx)
if err != nil {
return nil, err
}
env.Payload, err = protoutil.GetBytesPayload(payload)
if err != nil {
return nil, err
}
ebytes, err := protoutil.GetBytesEnvelope(env)
if err != nil {
return nil, err
}
block := newBlock(1, []byte{})
block.Data.Data = append(block.Data.Data, ebytes)
blockbytes := cutil.ConcatenateBytes(block.Data.Data...)
block.Header.DataHash = computeSHA256(blockbytes)
txsfltr := ledger_util.NewTxValidationFlags(len(block.Data.Data))
for i := 0; i < len(block.Data.Data); i++ {
txsfltr[i] = uint8(txValidationCode)
}
block.Metadata.Metadata[common.BlockMetadataIndex_TRANSACTIONS_FILTER] = txsfltr
return block, nil
} | [
"func",
"CreateBlockWithCCEventAndTxStatus",
"(",
"events",
"*",
"pp",
".",
"ChaincodeEvent",
",",
"txID",
"string",
",",
"channelID",
"string",
",",
"txValidationCode",
"pp",
".",
"TxValidationCode",
")",
"(",
"*",
"common",
".",
"Block",
",",
"error",
")",
"{",
"chdr",
":=",
"&",
"common",
".",
"ChannelHeader",
"{",
"Type",
":",
"int32",
"(",
"common",
".",
"HeaderType_ENDORSER_TRANSACTION",
")",
",",
"Version",
":",
"1",
",",
"Timestamp",
":",
"&",
"timestamp",
".",
"Timestamp",
"{",
"Seconds",
":",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
",",
"Nanos",
":",
"0",
",",
"}",
",",
"ChannelId",
":",
"channelID",
",",
"TxId",
":",
"txID",
"}",
"\n",
"hdr",
":=",
"&",
"common",
".",
"Header",
"{",
"ChannelHeader",
":",
"protoutil",
".",
"MarshalOrPanic",
"(",
"chdr",
")",
"}",
"\n",
"payload",
":=",
"&",
"common",
".",
"Payload",
"{",
"Header",
":",
"hdr",
"}",
"\n",
"cea",
":=",
"&",
"pp",
".",
"ChaincodeEndorsedAction",
"{",
"}",
"\n",
"ccaPayload",
":=",
"&",
"pp",
".",
"ChaincodeActionPayload",
"{",
"Action",
":",
"cea",
"}",
"\n",
"env",
":=",
"&",
"common",
".",
"Envelope",
"{",
"}",
"\n",
"taa",
":=",
"&",
"pp",
".",
"TransactionAction",
"{",
"}",
"\n",
"taas",
":=",
"make",
"(",
"[",
"]",
"*",
"pp",
".",
"TransactionAction",
",",
"1",
")",
"\n",
"taas",
"[",
"0",
"]",
"=",
"taa",
"\n",
"tx",
":=",
"&",
"pp",
".",
"Transaction",
"{",
"Actions",
":",
"taas",
"}",
"\n",
"pHashBytes",
":=",
"[",
"]",
"byte",
"(",
"\"proposal_hash\"",
")",
"\n",
"pResponse",
":=",
"&",
"pp",
".",
"Response",
"{",
"Status",
":",
"200",
"}",
"\n",
"results",
":=",
"[",
"]",
"byte",
"(",
"\"results\"",
")",
"\n",
"eventBytes",
",",
"err",
":=",
"protoutil",
".",
"GetBytesChaincodeEvent",
"(",
"events",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ccaPayload",
".",
"Action",
".",
"ProposalResponsePayload",
",",
"err",
"=",
"protoutil",
".",
"GetBytesProposalResponsePayload",
"(",
"pHashBytes",
",",
"pResponse",
",",
"results",
",",
"eventBytes",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"tx",
".",
"Actions",
"[",
"0",
"]",
".",
"Payload",
",",
"err",
"=",
"protoutil",
".",
"GetBytesChaincodeActionPayload",
"(",
"ccaPayload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"payload",
".",
"Data",
",",
"err",
"=",
"protoutil",
".",
"GetBytesTransaction",
"(",
"tx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"env",
".",
"Payload",
",",
"err",
"=",
"protoutil",
".",
"GetBytesPayload",
"(",
"payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ebytes",
",",
"err",
":=",
"protoutil",
".",
"GetBytesEnvelope",
"(",
"env",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"block",
":=",
"newBlock",
"(",
"1",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"block",
".",
"Data",
".",
"Data",
"=",
"append",
"(",
"block",
".",
"Data",
".",
"Data",
",",
"ebytes",
")",
"\n",
"blockbytes",
":=",
"cutil",
".",
"ConcatenateBytes",
"(",
"block",
".",
"Data",
".",
"Data",
"...",
")",
"\n",
"block",
".",
"Header",
".",
"DataHash",
"=",
"computeSHA256",
"(",
"blockbytes",
")",
"\n",
"txsfltr",
":=",
"ledger_util",
".",
"NewTxValidationFlags",
"(",
"len",
"(",
"block",
".",
"Data",
".",
"Data",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"block",
".",
"Data",
".",
"Data",
")",
";",
"i",
"++",
"{",
"txsfltr",
"[",
"i",
"]",
"=",
"uint8",
"(",
"txValidationCode",
")",
"\n",
"}",
"\n",
"block",
".",
"Metadata",
".",
"Metadata",
"[",
"common",
".",
"BlockMetadataIndex_TRANSACTIONS_FILTER",
"]",
"=",
"txsfltr",
"\n",
"return",
"block",
",",
"nil",
"\n",
"}"
] | // CreateBlockWithCCEventAndTxStatus creates a mock block with the given CC event and TX validation code | [
"CreateBlockWithCCEventAndTxStatus",
"creates",
"a",
"mock",
"block",
"with",
"the",
"given",
"CC",
"event",
"and",
"TX",
"validation",
"code"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdata.go#L505-L568 | train |
hyperledger/fabric-sdk-go | pkg/fab/mocks/mockdata.go | newBlock | func newBlock(seqNum uint64, previousHash []byte) *common.Block {
block := &common.Block{}
block.Header = &common.BlockHeader{}
block.Header.Number = seqNum
block.Header.PreviousHash = previousHash
block.Data = &common.BlockData{}
var metadataContents [][]byte
for i := 0; i < len(common.BlockMetadataIndex_name); i++ {
metadataContents = append(metadataContents, []byte{})
}
block.Metadata = &common.BlockMetadata{Metadata: metadataContents}
return block
} | go | func newBlock(seqNum uint64, previousHash []byte) *common.Block {
block := &common.Block{}
block.Header = &common.BlockHeader{}
block.Header.Number = seqNum
block.Header.PreviousHash = previousHash
block.Data = &common.BlockData{}
var metadataContents [][]byte
for i := 0; i < len(common.BlockMetadataIndex_name); i++ {
metadataContents = append(metadataContents, []byte{})
}
block.Metadata = &common.BlockMetadata{Metadata: metadataContents}
return block
} | [
"func",
"newBlock",
"(",
"seqNum",
"uint64",
",",
"previousHash",
"[",
"]",
"byte",
")",
"*",
"common",
".",
"Block",
"{",
"block",
":=",
"&",
"common",
".",
"Block",
"{",
"}",
"\n",
"block",
".",
"Header",
"=",
"&",
"common",
".",
"BlockHeader",
"{",
"}",
"\n",
"block",
".",
"Header",
".",
"Number",
"=",
"seqNum",
"\n",
"block",
".",
"Header",
".",
"PreviousHash",
"=",
"previousHash",
"\n",
"block",
".",
"Data",
"=",
"&",
"common",
".",
"BlockData",
"{",
"}",
"\n",
"var",
"metadataContents",
"[",
"]",
"[",
"]",
"byte",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"common",
".",
"BlockMetadataIndex_name",
")",
";",
"i",
"++",
"{",
"metadataContents",
"=",
"append",
"(",
"metadataContents",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"}",
"\n",
"block",
".",
"Metadata",
"=",
"&",
"common",
".",
"BlockMetadata",
"{",
"Metadata",
":",
"metadataContents",
"}",
"\n",
"return",
"block",
"\n",
"}"
] | // NewBlock construct a block with no data and no metadata. | [
"NewBlock",
"construct",
"a",
"block",
"with",
"no",
"data",
"and",
"no",
"metadata",
"."
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/mocks/mockdata.go#L571-L585 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/staticselection/staticselection.go | NewService | func NewService(discovery fab.DiscoveryService) (fab.SelectionService, error) {
return &SelectionService{discoveryService: discovery}, nil
} | go | func NewService(discovery fab.DiscoveryService) (fab.SelectionService, error) {
return &SelectionService{discoveryService: discovery}, nil
} | [
"func",
"NewService",
"(",
"discovery",
"fab",
".",
"DiscoveryService",
")",
"(",
"fab",
".",
"SelectionService",
",",
"error",
")",
"{",
"return",
"&",
"SelectionService",
"{",
"discoveryService",
":",
"discovery",
"}",
",",
"nil",
"\n",
"}"
] | // NewService creates a static selection service | [
"NewService",
"creates",
"a",
"static",
"selection",
"service"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/staticselection/staticselection.go#L26-L28 | train |
hyperledger/fabric-sdk-go | pkg/client/common/selection/staticselection/staticselection.go | GetEndorsersForChaincode | func (s *SelectionService) GetEndorsersForChaincode(chaincodes []*fab.ChaincodeCall, opts ...copts.Opt) ([]fab.Peer, error) {
params := options.NewParams(opts)
channelPeers, err := s.discoveryService.GetPeers()
if err != nil {
logger.Errorf("Error retrieving peers from discovery service: %s", err)
return nil, nil
}
// Apply peer filter if provided
if params.PeerFilter != nil {
var peers []fab.Peer
for _, peer := range channelPeers {
if params.PeerFilter(peer) {
peers = append(peers, peer)
}
}
channelPeers = peers
}
if params.PeerSorter != nil {
peers := make([]fab.Peer, len(channelPeers))
copy(peers, channelPeers)
channelPeers = params.PeerSorter(peers)
}
if logging.IsEnabledFor(loggerModule, logging.DEBUG) {
str := ""
for i, peer := range channelPeers {
str += peer.URL()
if i+1 < len(channelPeers) {
str += ","
}
}
logger.Debugf("Available peers: [%s]", str)
}
return channelPeers, nil
} | go | func (s *SelectionService) GetEndorsersForChaincode(chaincodes []*fab.ChaincodeCall, opts ...copts.Opt) ([]fab.Peer, error) {
params := options.NewParams(opts)
channelPeers, err := s.discoveryService.GetPeers()
if err != nil {
logger.Errorf("Error retrieving peers from discovery service: %s", err)
return nil, nil
}
// Apply peer filter if provided
if params.PeerFilter != nil {
var peers []fab.Peer
for _, peer := range channelPeers {
if params.PeerFilter(peer) {
peers = append(peers, peer)
}
}
channelPeers = peers
}
if params.PeerSorter != nil {
peers := make([]fab.Peer, len(channelPeers))
copy(peers, channelPeers)
channelPeers = params.PeerSorter(peers)
}
if logging.IsEnabledFor(loggerModule, logging.DEBUG) {
str := ""
for i, peer := range channelPeers {
str += peer.URL()
if i+1 < len(channelPeers) {
str += ","
}
}
logger.Debugf("Available peers: [%s]", str)
}
return channelPeers, nil
} | [
"func",
"(",
"s",
"*",
"SelectionService",
")",
"GetEndorsersForChaincode",
"(",
"chaincodes",
"[",
"]",
"*",
"fab",
".",
"ChaincodeCall",
",",
"opts",
"...",
"copts",
".",
"Opt",
")",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"error",
")",
"{",
"params",
":=",
"options",
".",
"NewParams",
"(",
"opts",
")",
"\n",
"channelPeers",
",",
"err",
":=",
"s",
".",
"discoveryService",
".",
"GetPeers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Errorf",
"(",
"\"Error retrieving peers from discovery service: %s\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"if",
"params",
".",
"PeerFilter",
"!=",
"nil",
"{",
"var",
"peers",
"[",
"]",
"fab",
".",
"Peer",
"\n",
"for",
"_",
",",
"peer",
":=",
"range",
"channelPeers",
"{",
"if",
"params",
".",
"PeerFilter",
"(",
"peer",
")",
"{",
"peers",
"=",
"append",
"(",
"peers",
",",
"peer",
")",
"\n",
"}",
"\n",
"}",
"\n",
"channelPeers",
"=",
"peers",
"\n",
"}",
"\n",
"if",
"params",
".",
"PeerSorter",
"!=",
"nil",
"{",
"peers",
":=",
"make",
"(",
"[",
"]",
"fab",
".",
"Peer",
",",
"len",
"(",
"channelPeers",
")",
")",
"\n",
"copy",
"(",
"peers",
",",
"channelPeers",
")",
"\n",
"channelPeers",
"=",
"params",
".",
"PeerSorter",
"(",
"peers",
")",
"\n",
"}",
"\n",
"if",
"logging",
".",
"IsEnabledFor",
"(",
"loggerModule",
",",
"logging",
".",
"DEBUG",
")",
"{",
"str",
":=",
"\"\"",
"\n",
"for",
"i",
",",
"peer",
":=",
"range",
"channelPeers",
"{",
"str",
"+=",
"peer",
".",
"URL",
"(",
")",
"\n",
"if",
"i",
"+",
"1",
"<",
"len",
"(",
"channelPeers",
")",
"{",
"str",
"+=",
"\",\"",
"\n",
"}",
"\n",
"}",
"\n",
"logger",
".",
"Debugf",
"(",
"\"Available peers: [%s]\"",
",",
"str",
")",
"\n",
"}",
"\n",
"return",
"channelPeers",
",",
"nil",
"\n",
"}"
] | // GetEndorsersForChaincode returns a set of endorsing peers | [
"GetEndorsersForChaincode",
"returns",
"a",
"set",
"of",
"endorsing",
"peers"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/client/common/selection/staticselection/staticselection.go#L31-L69 | train |
hyperledger/fabric-sdk-go | pkg/msp/memory_user_store.go | Store | func (s *MemoryUserStore) Store(user *msp.UserData) error {
s.store[user.ID+"@"+user.MSPID] = user.EnrollmentCertificate
return nil
} | go | func (s *MemoryUserStore) Store(user *msp.UserData) error {
s.store[user.ID+"@"+user.MSPID] = user.EnrollmentCertificate
return nil
} | [
"func",
"(",
"s",
"*",
"MemoryUserStore",
")",
"Store",
"(",
"user",
"*",
"msp",
".",
"UserData",
")",
"error",
"{",
"s",
".",
"store",
"[",
"user",
".",
"ID",
"+",
"\"@\"",
"+",
"user",
".",
"MSPID",
"]",
"=",
"user",
".",
"EnrollmentCertificate",
"\n",
"return",
"nil",
"\n",
"}"
] | // Store stores a user into store | [
"Store",
"stores",
"a",
"user",
"into",
"store"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/memory_user_store.go#L25-L28 | train |
hyperledger/fabric-sdk-go | pkg/msp/memory_user_store.go | Load | func (s *MemoryUserStore) Load(id msp.IdentityIdentifier) (*msp.UserData, error) {
cert, ok := s.store[id.ID+"@"+id.MSPID]
if !ok {
return nil, msp.ErrUserNotFound
}
userData := msp.UserData{
ID: id.ID,
MSPID: id.MSPID,
EnrollmentCertificate: cert,
}
return &userData, nil
} | go | func (s *MemoryUserStore) Load(id msp.IdentityIdentifier) (*msp.UserData, error) {
cert, ok := s.store[id.ID+"@"+id.MSPID]
if !ok {
return nil, msp.ErrUserNotFound
}
userData := msp.UserData{
ID: id.ID,
MSPID: id.MSPID,
EnrollmentCertificate: cert,
}
return &userData, nil
} | [
"func",
"(",
"s",
"*",
"MemoryUserStore",
")",
"Load",
"(",
"id",
"msp",
".",
"IdentityIdentifier",
")",
"(",
"*",
"msp",
".",
"UserData",
",",
"error",
")",
"{",
"cert",
",",
"ok",
":=",
"s",
".",
"store",
"[",
"id",
".",
"ID",
"+",
"\"@\"",
"+",
"id",
".",
"MSPID",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"msp",
".",
"ErrUserNotFound",
"\n",
"}",
"\n",
"userData",
":=",
"msp",
".",
"UserData",
"{",
"ID",
":",
"id",
".",
"ID",
",",
"MSPID",
":",
"id",
".",
"MSPID",
",",
"EnrollmentCertificate",
":",
"cert",
",",
"}",
"\n",
"return",
"&",
"userData",
",",
"nil",
"\n",
"}"
] | // Load loads a user from store | [
"Load",
"loads",
"a",
"user",
"from",
"store"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/memory_user_store.go#L31-L42 | train |
hyperledger/fabric-sdk-go | pkg/msp/memory_key_store.go | NewMemoryKeyStore | func NewMemoryKeyStore(password []byte) *MemoryKeyStore {
store := make(map[string]bccsp.Key)
return &MemoryKeyStore{store: store, password: password}
} | go | func NewMemoryKeyStore(password []byte) *MemoryKeyStore {
store := make(map[string]bccsp.Key)
return &MemoryKeyStore{store: store, password: password}
} | [
"func",
"NewMemoryKeyStore",
"(",
"password",
"[",
"]",
"byte",
")",
"*",
"MemoryKeyStore",
"{",
"store",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bccsp",
".",
"Key",
")",
"\n",
"return",
"&",
"MemoryKeyStore",
"{",
"store",
":",
"store",
",",
"password",
":",
"password",
"}",
"\n",
"}"
] | // NewMemoryKeyStore creates a new MemoryKeyStore instance | [
"NewMemoryKeyStore",
"creates",
"a",
"new",
"MemoryKeyStore",
"instance"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/memory_key_store.go#L24-L27 | train |
hyperledger/fabric-sdk-go | pkg/msp/memory_key_store.go | GetKey | func (s *MemoryKeyStore) GetKey(ski []byte) (bccsp.Key, error) {
key, ok := s.store[hex.EncodeToString(ski)]
if !ok {
return nil, fmt.Errorf("Key not found [%s]", ski)
}
return key, nil
} | go | func (s *MemoryKeyStore) GetKey(ski []byte) (bccsp.Key, error) {
key, ok := s.store[hex.EncodeToString(ski)]
if !ok {
return nil, fmt.Errorf("Key not found [%s]", ski)
}
return key, nil
} | [
"func",
"(",
"s",
"*",
"MemoryKeyStore",
")",
"GetKey",
"(",
"ski",
"[",
"]",
"byte",
")",
"(",
"bccsp",
".",
"Key",
",",
"error",
")",
"{",
"key",
",",
"ok",
":=",
"s",
".",
"store",
"[",
"hex",
".",
"EncodeToString",
"(",
"ski",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Key not found [%s]\"",
",",
"ski",
")",
"\n",
"}",
"\n",
"return",
"key",
",",
"nil",
"\n",
"}"
] | // GetKey returns a key for the provided SKI | [
"GetKey",
"returns",
"a",
"key",
"for",
"the",
"provided",
"SKI"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/memory_key_store.go#L35-L41 | train |
hyperledger/fabric-sdk-go | pkg/msp/memory_key_store.go | StoreKey | func (s *MemoryKeyStore) StoreKey(key bccsp.Key) error {
ski := hex.EncodeToString(key.SKI())
s.store[ski] = key
return nil
} | go | func (s *MemoryKeyStore) StoreKey(key bccsp.Key) error {
ski := hex.EncodeToString(key.SKI())
s.store[ski] = key
return nil
} | [
"func",
"(",
"s",
"*",
"MemoryKeyStore",
")",
"StoreKey",
"(",
"key",
"bccsp",
".",
"Key",
")",
"error",
"{",
"ski",
":=",
"hex",
".",
"EncodeToString",
"(",
"key",
".",
"SKI",
"(",
")",
")",
"\n",
"s",
".",
"store",
"[",
"ski",
"]",
"=",
"key",
"\n",
"return",
"nil",
"\n",
"}"
] | // StoreKey stores a key | [
"StoreKey",
"stores",
"a",
"key"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/msp/memory_key_store.go#L44-L48 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/dispatcher/events.go | NewRegisterBlockEvent | func NewRegisterBlockEvent(filter fab.BlockFilter, eventch chan<- *fab.BlockEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterBlockEvent {
return &RegisterBlockEvent{
Reg: &BlockReg{Filter: filter, Eventch: eventch},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | go | func NewRegisterBlockEvent(filter fab.BlockFilter, eventch chan<- *fab.BlockEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterBlockEvent {
return &RegisterBlockEvent{
Reg: &BlockReg{Filter: filter, Eventch: eventch},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | [
"func",
"NewRegisterBlockEvent",
"(",
"filter",
"fab",
".",
"BlockFilter",
",",
"eventch",
"chan",
"<-",
"*",
"fab",
".",
"BlockEvent",
",",
"respch",
"chan",
"<-",
"fab",
".",
"Registration",
",",
"errCh",
"chan",
"<-",
"error",
")",
"*",
"RegisterBlockEvent",
"{",
"return",
"&",
"RegisterBlockEvent",
"{",
"Reg",
":",
"&",
"BlockReg",
"{",
"Filter",
":",
"filter",
",",
"Eventch",
":",
"eventch",
"}",
",",
"RegisterEvent",
":",
"NewRegisterEvent",
"(",
"respch",
",",
"errCh",
")",
",",
"}",
"\n",
"}"
] | // NewRegisterBlockEvent creates a new RegisterBlockEvent | [
"NewRegisterBlockEvent",
"creates",
"a",
"new",
"RegisterBlockEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/dispatcher/events.go#L88-L93 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/dispatcher/events.go | NewRegisterFilteredBlockEvent | func NewRegisterFilteredBlockEvent(eventch chan<- *fab.FilteredBlockEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterFilteredBlockEvent {
return &RegisterFilteredBlockEvent{
Reg: &FilteredBlockReg{Eventch: eventch},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | go | func NewRegisterFilteredBlockEvent(eventch chan<- *fab.FilteredBlockEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterFilteredBlockEvent {
return &RegisterFilteredBlockEvent{
Reg: &FilteredBlockReg{Eventch: eventch},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | [
"func",
"NewRegisterFilteredBlockEvent",
"(",
"eventch",
"chan",
"<-",
"*",
"fab",
".",
"FilteredBlockEvent",
",",
"respch",
"chan",
"<-",
"fab",
".",
"Registration",
",",
"errCh",
"chan",
"<-",
"error",
")",
"*",
"RegisterFilteredBlockEvent",
"{",
"return",
"&",
"RegisterFilteredBlockEvent",
"{",
"Reg",
":",
"&",
"FilteredBlockReg",
"{",
"Eventch",
":",
"eventch",
"}",
",",
"RegisterEvent",
":",
"NewRegisterEvent",
"(",
"respch",
",",
"errCh",
")",
",",
"}",
"\n",
"}"
] | // NewRegisterFilteredBlockEvent creates a new RegisterFilterBlockEvent | [
"NewRegisterFilteredBlockEvent",
"creates",
"a",
"new",
"RegisterFilterBlockEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/dispatcher/events.go#L96-L101 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/dispatcher/events.go | NewRegisterChaincodeEvent | func NewRegisterChaincodeEvent(ccID, eventFilter string, eventch chan<- *fab.CCEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterChaincodeEvent {
return &RegisterChaincodeEvent{
Reg: &ChaincodeReg{
ChaincodeID: ccID,
EventFilter: eventFilter,
Eventch: eventch,
},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | go | func NewRegisterChaincodeEvent(ccID, eventFilter string, eventch chan<- *fab.CCEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterChaincodeEvent {
return &RegisterChaincodeEvent{
Reg: &ChaincodeReg{
ChaincodeID: ccID,
EventFilter: eventFilter,
Eventch: eventch,
},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | [
"func",
"NewRegisterChaincodeEvent",
"(",
"ccID",
",",
"eventFilter",
"string",
",",
"eventch",
"chan",
"<-",
"*",
"fab",
".",
"CCEvent",
",",
"respch",
"chan",
"<-",
"fab",
".",
"Registration",
",",
"errCh",
"chan",
"<-",
"error",
")",
"*",
"RegisterChaincodeEvent",
"{",
"return",
"&",
"RegisterChaincodeEvent",
"{",
"Reg",
":",
"&",
"ChaincodeReg",
"{",
"ChaincodeID",
":",
"ccID",
",",
"EventFilter",
":",
"eventFilter",
",",
"Eventch",
":",
"eventch",
",",
"}",
",",
"RegisterEvent",
":",
"NewRegisterEvent",
"(",
"respch",
",",
"errCh",
")",
",",
"}",
"\n",
"}"
] | // NewRegisterChaincodeEvent creates a new RegisterChaincodeEvent | [
"NewRegisterChaincodeEvent",
"creates",
"a",
"new",
"RegisterChaincodeEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/dispatcher/events.go#L111-L120 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/dispatcher/events.go | NewRegisterTxStatusEvent | func NewRegisterTxStatusEvent(txID string, eventch chan<- *fab.TxStatusEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterTxStatusEvent {
return &RegisterTxStatusEvent{
Reg: &TxStatusReg{TxID: txID, Eventch: eventch},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | go | func NewRegisterTxStatusEvent(txID string, eventch chan<- *fab.TxStatusEvent, respch chan<- fab.Registration, errCh chan<- error) *RegisterTxStatusEvent {
return &RegisterTxStatusEvent{
Reg: &TxStatusReg{TxID: txID, Eventch: eventch},
RegisterEvent: NewRegisterEvent(respch, errCh),
}
} | [
"func",
"NewRegisterTxStatusEvent",
"(",
"txID",
"string",
",",
"eventch",
"chan",
"<-",
"*",
"fab",
".",
"TxStatusEvent",
",",
"respch",
"chan",
"<-",
"fab",
".",
"Registration",
",",
"errCh",
"chan",
"<-",
"error",
")",
"*",
"RegisterTxStatusEvent",
"{",
"return",
"&",
"RegisterTxStatusEvent",
"{",
"Reg",
":",
"&",
"TxStatusReg",
"{",
"TxID",
":",
"txID",
",",
"Eventch",
":",
"eventch",
"}",
",",
"RegisterEvent",
":",
"NewRegisterEvent",
"(",
"respch",
",",
"errCh",
")",
",",
"}",
"\n",
"}"
] | // NewRegisterTxStatusEvent creates a new RegisterTxStatusEvent | [
"NewRegisterTxStatusEvent",
"creates",
"a",
"new",
"RegisterTxStatusEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/dispatcher/events.go#L123-L128 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/dispatcher/events.go | NewRegisterEvent | func NewRegisterEvent(respch chan<- fab.Registration, errCh chan<- error) RegisterEvent {
return RegisterEvent{
RegCh: respch,
ErrCh: errCh,
}
} | go | func NewRegisterEvent(respch chan<- fab.Registration, errCh chan<- error) RegisterEvent {
return RegisterEvent{
RegCh: respch,
ErrCh: errCh,
}
} | [
"func",
"NewRegisterEvent",
"(",
"respch",
"chan",
"<-",
"fab",
".",
"Registration",
",",
"errCh",
"chan",
"<-",
"error",
")",
"RegisterEvent",
"{",
"return",
"RegisterEvent",
"{",
"RegCh",
":",
"respch",
",",
"ErrCh",
":",
"errCh",
",",
"}",
"\n",
"}"
] | // NewRegisterEvent creates a new RgisterEvent | [
"NewRegisterEvent",
"creates",
"a",
"new",
"RgisterEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/dispatcher/events.go#L131-L136 | train |
hyperledger/fabric-sdk-go | pkg/fab/events/service/dispatcher/events.go | NewBlockEvent | func NewBlockEvent(block *cb.Block, sourceURL string) *fab.BlockEvent {
return &fab.BlockEvent{
Block: block,
SourceURL: sourceURL,
}
} | go | func NewBlockEvent(block *cb.Block, sourceURL string) *fab.BlockEvent {
return &fab.BlockEvent{
Block: block,
SourceURL: sourceURL,
}
} | [
"func",
"NewBlockEvent",
"(",
"block",
"*",
"cb",
".",
"Block",
",",
"sourceURL",
"string",
")",
"*",
"fab",
".",
"BlockEvent",
"{",
"return",
"&",
"fab",
".",
"BlockEvent",
"{",
"Block",
":",
"block",
",",
"SourceURL",
":",
"sourceURL",
",",
"}",
"\n",
"}"
] | // NewBlockEvent creates a new BlockEvent | [
"NewBlockEvent",
"creates",
"a",
"new",
"BlockEvent"
] | 48bb0d199e2cee03ad3af0a413bdfc064fc69bfe | https://github.com/hyperledger/fabric-sdk-go/blob/48bb0d199e2cee03ad3af0a413bdfc064fc69bfe/pkg/fab/events/service/dispatcher/events.go#L139-L144 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.