id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
143,200 |
uber/ringpop-go
|
swim/node.go
|
SetIdentity
|
func (n *Node) SetIdentity(identity string) error {
return n.memberlist.SetLocalLabel(membership.IdentityLabelKey, identity)
}
|
go
|
func (n *Node) SetIdentity(identity string) error {
return n.memberlist.SetLocalLabel(membership.IdentityLabelKey, identity)
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"SetIdentity",
"(",
"identity",
"string",
")",
"error",
"{",
"return",
"n",
".",
"memberlist",
".",
"SetLocalLabel",
"(",
"membership",
".",
"IdentityLabelKey",
",",
"identity",
")",
"\n",
"}"
] |
// SetIdentity changes the identity of the local node. This will change the
// state of the local node and will be gossiped around in the network.
|
[
"SetIdentity",
"changes",
"the",
"identity",
"of",
"the",
"local",
"node",
".",
"This",
"will",
"change",
"the",
"state",
"of",
"the",
"local",
"node",
"and",
"will",
"be",
"gossiped",
"around",
"in",
"the",
"network",
"."
] |
6475220d53092c8264fc6ce9416a351c960fe9fc
|
https://github.com/uber/ringpop-go/blob/6475220d53092c8264fc6ce9416a351c960fe9fc/swim/node.go#L579-L581
|
143,201 |
uber/ringpop-go
|
events/events.go
|
AddListener
|
func (a *sharedEventEmitter) AddListener(l EventListener) bool {
if l == nil {
// do not register nil listener, will cause nil pointer dereference during
// event emitting
return false
}
a.listenersLock.Lock()
defer a.listenersLock.Unlock()
// Check if listener is already registered
for _, listener := range a.listeners {
if listener == l {
return false
}
}
// by making a copy the backing array will never be changed after its creation.
// this allowes to copy the slice while locked but iterate while not locked
// preventing deadlocks when listeners are added/removed in the handler of a
// listener
listenersCopy := make([]EventListener, 0, len(a.listeners)+1)
listenersCopy = append(listenersCopy, a.listeners...)
listenersCopy = append(listenersCopy, l)
a.listeners = listenersCopy
return true
}
|
go
|
func (a *sharedEventEmitter) AddListener(l EventListener) bool {
if l == nil {
// do not register nil listener, will cause nil pointer dereference during
// event emitting
return false
}
a.listenersLock.Lock()
defer a.listenersLock.Unlock()
// Check if listener is already registered
for _, listener := range a.listeners {
if listener == l {
return false
}
}
// by making a copy the backing array will never be changed after its creation.
// this allowes to copy the slice while locked but iterate while not locked
// preventing deadlocks when listeners are added/removed in the handler of a
// listener
listenersCopy := make([]EventListener, 0, len(a.listeners)+1)
listenersCopy = append(listenersCopy, a.listeners...)
listenersCopy = append(listenersCopy, l)
a.listeners = listenersCopy
return true
}
|
[
"func",
"(",
"a",
"*",
"sharedEventEmitter",
")",
"AddListener",
"(",
"l",
"EventListener",
")",
"bool",
"{",
"if",
"l",
"==",
"nil",
"{",
"// do not register nil listener, will cause nil pointer dereference during",
"// event emitting",
"return",
"false",
"\n",
"}",
"\n\n",
"a",
".",
"listenersLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"listenersLock",
".",
"Unlock",
"(",
")",
"\n\n",
"// Check if listener is already registered",
"for",
"_",
",",
"listener",
":=",
"range",
"a",
".",
"listeners",
"{",
"if",
"listener",
"==",
"l",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"// by making a copy the backing array will never be changed after its creation.",
"// this allowes to copy the slice while locked but iterate while not locked",
"// preventing deadlocks when listeners are added/removed in the handler of a",
"// listener",
"listenersCopy",
":=",
"make",
"(",
"[",
"]",
"EventListener",
",",
"0",
",",
"len",
"(",
"a",
".",
"listeners",
")",
"+",
"1",
")",
"\n",
"listenersCopy",
"=",
"append",
"(",
"listenersCopy",
",",
"a",
".",
"listeners",
"...",
")",
"\n",
"listenersCopy",
"=",
"append",
"(",
"listenersCopy",
",",
"l",
")",
"\n\n",
"a",
".",
"listeners",
"=",
"listenersCopy",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// AddListener adds a listener to the EventEmitter. Events emitted on this
// emitter will be invoked on the listener. The return value indicates if the
// listener has been added or not. It can't be added if it is already added and
// therefore registered to receive events
|
[
"AddListener",
"adds",
"a",
"listener",
"to",
"the",
"EventEmitter",
".",
"Events",
"emitted",
"on",
"this",
"emitter",
"will",
"be",
"invoked",
"on",
"the",
"listener",
".",
"The",
"return",
"value",
"indicates",
"if",
"the",
"listener",
"has",
"been",
"added",
"or",
"not",
".",
"It",
"can",
"t",
"be",
"added",
"if",
"it",
"is",
"already",
"added",
"and",
"therefore",
"registered",
"to",
"receive",
"events"
] |
6475220d53092c8264fc6ce9416a351c960fe9fc
|
https://github.com/uber/ringpop-go/blob/6475220d53092c8264fc6ce9416a351c960fe9fc/events/events.go#L70-L98
|
143,202 |
uber/ringpop-go
|
events/events.go
|
RemoveListener
|
func (a *sharedEventEmitter) RemoveListener(l EventListener) bool {
a.listenersLock.Lock()
defer a.listenersLock.Unlock()
for i := range a.listeners {
if a.listeners[i] == l {
// create a new list excluding the listener that needs removal
listenersCopy := make([]EventListener, 0, len(a.listeners)-1)
listenersCopy = append(listenersCopy, a.listeners[:i]...)
listenersCopy = append(listenersCopy, a.listeners[i+1:]...)
a.listeners = listenersCopy
return true
}
}
return false
}
|
go
|
func (a *sharedEventEmitter) RemoveListener(l EventListener) bool {
a.listenersLock.Lock()
defer a.listenersLock.Unlock()
for i := range a.listeners {
if a.listeners[i] == l {
// create a new list excluding the listener that needs removal
listenersCopy := make([]EventListener, 0, len(a.listeners)-1)
listenersCopy = append(listenersCopy, a.listeners[:i]...)
listenersCopy = append(listenersCopy, a.listeners[i+1:]...)
a.listeners = listenersCopy
return true
}
}
return false
}
|
[
"func",
"(",
"a",
"*",
"sharedEventEmitter",
")",
"RemoveListener",
"(",
"l",
"EventListener",
")",
"bool",
"{",
"a",
".",
"listenersLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"listenersLock",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"i",
":=",
"range",
"a",
".",
"listeners",
"{",
"if",
"a",
".",
"listeners",
"[",
"i",
"]",
"==",
"l",
"{",
"// create a new list excluding the listener that needs removal",
"listenersCopy",
":=",
"make",
"(",
"[",
"]",
"EventListener",
",",
"0",
",",
"len",
"(",
"a",
".",
"listeners",
")",
"-",
"1",
")",
"\n",
"listenersCopy",
"=",
"append",
"(",
"listenersCopy",
",",
"a",
".",
"listeners",
"[",
":",
"i",
"]",
"...",
")",
"\n",
"listenersCopy",
"=",
"append",
"(",
"listenersCopy",
",",
"a",
".",
"listeners",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"a",
".",
"listeners",
"=",
"listenersCopy",
"\n\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
"\n",
"}"
] |
// RemoveListener removes a listener from the EventEmitter. Subsequent calls to
// EmitEvent will not cause HandleEvent to be called on this listener. The
// return value indicates if a listener has been removed or not. The listener
// can't be removed if it was not present before.
|
[
"RemoveListener",
"removes",
"a",
"listener",
"from",
"the",
"EventEmitter",
".",
"Subsequent",
"calls",
"to",
"EmitEvent",
"will",
"not",
"cause",
"HandleEvent",
"to",
"be",
"called",
"on",
"this",
"listener",
".",
"The",
"return",
"value",
"indicates",
"if",
"a",
"listener",
"has",
"been",
"removed",
"or",
"not",
".",
"The",
"listener",
"can",
"t",
"be",
"removed",
"if",
"it",
"was",
"not",
"present",
"before",
"."
] |
6475220d53092c8264fc6ce9416a351c960fe9fc
|
https://github.com/uber/ringpop-go/blob/6475220d53092c8264fc6ce9416a351c960fe9fc/events/events.go#L104-L121
|
143,203 |
uber/ringpop-go
|
events/events.go
|
EmitEvent
|
func (a *AsyncEventEmitter) EmitEvent(event Event) {
a.listenersLock.RLock()
for _, listener := range a.listeners {
go listener.HandleEvent(event)
}
a.listenersLock.RUnlock()
}
|
go
|
func (a *AsyncEventEmitter) EmitEvent(event Event) {
a.listenersLock.RLock()
for _, listener := range a.listeners {
go listener.HandleEvent(event)
}
a.listenersLock.RUnlock()
}
|
[
"func",
"(",
"a",
"*",
"AsyncEventEmitter",
")",
"EmitEvent",
"(",
"event",
"Event",
")",
"{",
"a",
".",
"listenersLock",
".",
"RLock",
"(",
")",
"\n",
"for",
"_",
",",
"listener",
":=",
"range",
"a",
".",
"listeners",
"{",
"go",
"listener",
".",
"HandleEvent",
"(",
"event",
")",
"\n",
"}",
"\n",
"a",
".",
"listenersLock",
".",
"RUnlock",
"(",
")",
"\n",
"}"
] |
// EmitEvent will send the event to all registered listeners
|
[
"EmitEvent",
"will",
"send",
"the",
"event",
"to",
"all",
"registered",
"listeners"
] |
6475220d53092c8264fc6ce9416a351c960fe9fc
|
https://github.com/uber/ringpop-go/blob/6475220d53092c8264fc6ce9416a351c960fe9fc/events/events.go#L130-L136
|
143,204 |
uber/ringpop-go
|
swim/memberlist_iter.go
|
newMemberlistIter
|
func newMemberlistIter(m *memberlist) *memberlistIter {
iter := &memberlistIter{
m: m,
currentIndex: -1,
currentRound: 0,
}
iter.m.Shuffle()
return iter
}
|
go
|
func newMemberlistIter(m *memberlist) *memberlistIter {
iter := &memberlistIter{
m: m,
currentIndex: -1,
currentRound: 0,
}
iter.m.Shuffle()
return iter
}
|
[
"func",
"newMemberlistIter",
"(",
"m",
"*",
"memberlist",
")",
"*",
"memberlistIter",
"{",
"iter",
":=",
"&",
"memberlistIter",
"{",
"m",
":",
"m",
",",
"currentIndex",
":",
"-",
"1",
",",
"currentRound",
":",
"0",
",",
"}",
"\n\n",
"iter",
".",
"m",
".",
"Shuffle",
"(",
")",
"\n\n",
"return",
"iter",
"\n",
"}"
] |
// NewMemberlistIter returns a new MemberlistIter
|
[
"NewMemberlistIter",
"returns",
"a",
"new",
"MemberlistIter"
] |
6475220d53092c8264fc6ce9416a351c960fe9fc
|
https://github.com/uber/ringpop-go/blob/6475220d53092c8264fc6ce9416a351c960fe9fc/swim/memberlist_iter.go#L36-L46
|
143,205 |
uber/ringpop-go
|
swim/memberlist_iter.go
|
Next
|
func (i *memberlistIter) Next() (*Member, bool) {
maxToVisit := i.m.NumMembers()
visited := make(map[string]bool)
for len(visited) < maxToVisit {
i.currentIndex++
if i.currentIndex >= i.m.NumMembers() {
i.currentIndex = 0
i.currentRound++
i.m.Shuffle()
}
member := i.m.MemberAt(i.currentIndex)
visited[member.Address] = true
if i.m.Pingable(*member) {
return member, true
}
}
return nil, false
}
|
go
|
func (i *memberlistIter) Next() (*Member, bool) {
maxToVisit := i.m.NumMembers()
visited := make(map[string]bool)
for len(visited) < maxToVisit {
i.currentIndex++
if i.currentIndex >= i.m.NumMembers() {
i.currentIndex = 0
i.currentRound++
i.m.Shuffle()
}
member := i.m.MemberAt(i.currentIndex)
visited[member.Address] = true
if i.m.Pingable(*member) {
return member, true
}
}
return nil, false
}
|
[
"func",
"(",
"i",
"*",
"memberlistIter",
")",
"Next",
"(",
")",
"(",
"*",
"Member",
",",
"bool",
")",
"{",
"maxToVisit",
":=",
"i",
".",
"m",
".",
"NumMembers",
"(",
")",
"\n",
"visited",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n\n",
"for",
"len",
"(",
"visited",
")",
"<",
"maxToVisit",
"{",
"i",
".",
"currentIndex",
"++",
"\n\n",
"if",
"i",
".",
"currentIndex",
">=",
"i",
".",
"m",
".",
"NumMembers",
"(",
")",
"{",
"i",
".",
"currentIndex",
"=",
"0",
"\n",
"i",
".",
"currentRound",
"++",
"\n",
"i",
".",
"m",
".",
"Shuffle",
"(",
")",
"\n",
"}",
"\n\n",
"member",
":=",
"i",
".",
"m",
".",
"MemberAt",
"(",
"i",
".",
"currentIndex",
")",
"\n",
"visited",
"[",
"member",
".",
"Address",
"]",
"=",
"true",
"\n\n",
"if",
"i",
".",
"m",
".",
"Pingable",
"(",
"*",
"member",
")",
"{",
"return",
"member",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] |
// Next returns the next pingable member in the member list, if it
// visits all members but none are pingable returns nil, false
|
[
"Next",
"returns",
"the",
"next",
"pingable",
"member",
"in",
"the",
"member",
"list",
"if",
"it",
"visits",
"all",
"members",
"but",
"none",
"are",
"pingable",
"returns",
"nil",
"false"
] |
6475220d53092c8264fc6ce9416a351c960fe9fc
|
https://github.com/uber/ringpop-go/blob/6475220d53092c8264fc6ce9416a351c960fe9fc/swim/memberlist_iter.go#L50-L72
|
143,206 |
beanstalkd/go-beanstalk
|
conn.go
|
Dial
|
func Dial(network, addr string) (*Conn, error) {
return DialTimeout(network, addr, DefaultDialTimeout)
}
|
go
|
func Dial(network, addr string) (*Conn, error) {
return DialTimeout(network, addr, DefaultDialTimeout)
}
|
[
"func",
"Dial",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"return",
"DialTimeout",
"(",
"network",
",",
"addr",
",",
"DefaultDialTimeout",
")",
"\n",
"}"
] |
// Dial connects addr on the given network using net.DialTimeout
// with a default timeout of 10s and then returns a new Conn for the connection.
|
[
"Dial",
"connects",
"addr",
"on",
"the",
"given",
"network",
"using",
"net",
".",
"DialTimeout",
"with",
"a",
"default",
"timeout",
"of",
"10s",
"and",
"then",
"returns",
"a",
"new",
"Conn",
"for",
"the",
"connection",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L52-L54
|
143,207 |
beanstalkd/go-beanstalk
|
conn.go
|
DialTimeout
|
func DialTimeout(network, addr string, timeout time.Duration) (*Conn, error) {
dialer := &net.Dialer{
Timeout: timeout,
KeepAlive: DefaultKeepAlivePeriod,
}
c, err := dialer.Dial(network, addr)
if err != nil {
return nil, err
}
return NewConn(c), nil
}
|
go
|
func DialTimeout(network, addr string, timeout time.Duration) (*Conn, error) {
dialer := &net.Dialer{
Timeout: timeout,
KeepAlive: DefaultKeepAlivePeriod,
}
c, err := dialer.Dial(network, addr)
if err != nil {
return nil, err
}
return NewConn(c), nil
}
|
[
"func",
"DialTimeout",
"(",
"network",
",",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"dialer",
":=",
"&",
"net",
".",
"Dialer",
"{",
"Timeout",
":",
"timeout",
",",
"KeepAlive",
":",
"DefaultKeepAlivePeriod",
",",
"}",
"\n",
"c",
",",
"err",
":=",
"dialer",
".",
"Dial",
"(",
"network",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewConn",
"(",
"c",
")",
",",
"nil",
"\n",
"}"
] |
// DialTimeout connects addr on the given network using net.DialTimeout
// with a supplied timeout and then returns a new Conn for the connection.
|
[
"DialTimeout",
"connects",
"addr",
"on",
"the",
"given",
"network",
"using",
"net",
".",
"DialTimeout",
"with",
"a",
"supplied",
"timeout",
"and",
"then",
"returns",
"a",
"new",
"Conn",
"for",
"the",
"connection",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L58-L68
|
143,208 |
beanstalkd/go-beanstalk
|
conn.go
|
printLine
|
func (c *Conn) printLine(cmd string, args ...interface{}) {
io.WriteString(c.c.W, cmd)
for _, a := range args {
c.c.W.Write(space)
fmt.Fprint(c.c.W, a)
}
c.c.W.Write(crnl)
}
|
go
|
func (c *Conn) printLine(cmd string, args ...interface{}) {
io.WriteString(c.c.W, cmd)
for _, a := range args {
c.c.W.Write(space)
fmt.Fprint(c.c.W, a)
}
c.c.W.Write(crnl)
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"printLine",
"(",
"cmd",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"io",
".",
"WriteString",
"(",
"c",
".",
"c",
".",
"W",
",",
"cmd",
")",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"args",
"{",
"c",
".",
"c",
".",
"W",
".",
"Write",
"(",
"space",
")",
"\n",
"fmt",
".",
"Fprint",
"(",
"c",
".",
"c",
".",
"W",
",",
"a",
")",
"\n",
"}",
"\n",
"c",
".",
"c",
".",
"W",
".",
"Write",
"(",
"crnl",
")",
"\n",
"}"
] |
// does not flush
|
[
"does",
"not",
"flush"
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L129-L136
|
143,209 |
beanstalkd/go-beanstalk
|
conn.go
|
Delete
|
func (c *Conn) Delete(id uint64) error {
r, err := c.cmd(nil, nil, nil, "delete", id)
if err != nil {
return err
}
_, err = c.readResp(r, false, "DELETED")
return err
}
|
go
|
func (c *Conn) Delete(id uint64) error {
r, err := c.cmd(nil, nil, nil, "delete", id)
if err != nil {
return err
}
_, err = c.readResp(r, false, "DELETED")
return err
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"Delete",
"(",
"id",
"uint64",
")",
"error",
"{",
"r",
",",
"err",
":=",
"c",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"readResp",
"(",
"r",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Delete deletes the given job.
|
[
"Delete",
"deletes",
"the",
"given",
"job",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L171-L178
|
143,210 |
beanstalkd/go-beanstalk
|
conn.go
|
Bury
|
func (c *Conn) Bury(id uint64, pri uint32) error {
r, err := c.cmd(nil, nil, nil, "bury", id, pri)
if err != nil {
return err
}
_, err = c.readResp(r, false, "BURIED")
return err
}
|
go
|
func (c *Conn) Bury(id uint64, pri uint32) error {
r, err := c.cmd(nil, nil, nil, "bury", id, pri)
if err != nil {
return err
}
_, err = c.readResp(r, false, "BURIED")
return err
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"Bury",
"(",
"id",
"uint64",
",",
"pri",
"uint32",
")",
"error",
"{",
"r",
",",
"err",
":=",
"c",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"id",
",",
"pri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"readResp",
"(",
"r",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Bury places the given job in a holding area in the job's tube and
// sets its priority to pri. The job will not be scheduled again until it
// has been kicked; see also the documentation of Kick.
|
[
"Bury",
"places",
"the",
"given",
"job",
"in",
"a",
"holding",
"area",
"in",
"the",
"job",
"s",
"tube",
"and",
"sets",
"its",
"priority",
"to",
"pri",
".",
"The",
"job",
"will",
"not",
"be",
"scheduled",
"again",
"until",
"it",
"has",
"been",
"kicked",
";",
"see",
"also",
"the",
"documentation",
"of",
"Kick",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L196-L203
|
143,211 |
beanstalkd/go-beanstalk
|
conn.go
|
Peek
|
func (c *Conn) Peek(id uint64) (body []byte, err error) {
r, err := c.cmd(nil, nil, nil, "peek", id)
if err != nil {
return nil, err
}
return c.readResp(r, true, "FOUND %d", &id)
}
|
go
|
func (c *Conn) Peek(id uint64) (body []byte, err error) {
r, err := c.cmd(nil, nil, nil, "peek", id)
if err != nil {
return nil, err
}
return c.readResp(r, true, "FOUND %d", &id)
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"Peek",
"(",
"id",
"uint64",
")",
"(",
"body",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"r",
",",
"err",
":=",
"c",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
",",
"&",
"id",
")",
"\n",
"}"
] |
// Peek gets a copy of the specified job from the server.
|
[
"Peek",
"gets",
"a",
"copy",
"of",
"the",
"specified",
"job",
"from",
"the",
"server",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L229-L235
|
143,212 |
beanstalkd/go-beanstalk
|
conn.go
|
Stats
|
func (c *Conn) Stats() (map[string]string, error) {
r, err := c.cmd(nil, nil, nil, "stats")
if err != nil {
return nil, err
}
body, err := c.readResp(r, true, "OK")
return parseDict(body), err
}
|
go
|
func (c *Conn) Stats() (map[string]string, error) {
r, err := c.cmd(nil, nil, nil, "stats")
if err != nil {
return nil, err
}
body, err := c.readResp(r, true, "OK")
return parseDict(body), err
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"Stats",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"c",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"c",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
")",
"\n",
"return",
"parseDict",
"(",
"body",
")",
",",
"err",
"\n",
"}"
] |
// Stats retrieves global statistics from the server.
|
[
"Stats",
"retrieves",
"global",
"statistics",
"from",
"the",
"server",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L238-L245
|
143,213 |
beanstalkd/go-beanstalk
|
conn.go
|
StatsJob
|
func (c *Conn) StatsJob(id uint64) (map[string]string, error) {
r, err := c.cmd(nil, nil, nil, "stats-job", id)
if err != nil {
return nil, err
}
body, err := c.readResp(r, true, "OK")
return parseDict(body), err
}
|
go
|
func (c *Conn) StatsJob(id uint64) (map[string]string, error) {
r, err := c.cmd(nil, nil, nil, "stats-job", id)
if err != nil {
return nil, err
}
body, err := c.readResp(r, true, "OK")
return parseDict(body), err
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"StatsJob",
"(",
"id",
"uint64",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"c",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"c",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
")",
"\n",
"return",
"parseDict",
"(",
"body",
")",
",",
"err",
"\n",
"}"
] |
// StatsJob retrieves statistics about the given job.
|
[
"StatsJob",
"retrieves",
"statistics",
"about",
"the",
"given",
"job",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L248-L255
|
143,214 |
beanstalkd/go-beanstalk
|
conn.go
|
ListTubes
|
func (c *Conn) ListTubes() ([]string, error) {
r, err := c.cmd(nil, nil, nil, "list-tubes")
if err != nil {
return nil, err
}
body, err := c.readResp(r, true, "OK")
return parseList(body), err
}
|
go
|
func (c *Conn) ListTubes() ([]string, error) {
r, err := c.cmd(nil, nil, nil, "list-tubes")
if err != nil {
return nil, err
}
body, err := c.readResp(r, true, "OK")
return parseList(body), err
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"ListTubes",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"c",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"c",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
")",
"\n",
"return",
"parseList",
"(",
"body",
")",
",",
"err",
"\n",
"}"
] |
// ListTubes returns the names of the tubes that currently
// exist on the server.
|
[
"ListTubes",
"returns",
"the",
"names",
"of",
"the",
"tubes",
"that",
"currently",
"exist",
"on",
"the",
"server",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/conn.go#L259-L266
|
143,215 |
beanstalkd/go-beanstalk
|
tubeset.go
|
NewTubeSet
|
func NewTubeSet(c *Conn, name ...string) *TubeSet {
ts := &TubeSet{c, make(map[string]bool)}
for _, s := range name {
ts.Name[s] = true
}
return ts
}
|
go
|
func NewTubeSet(c *Conn, name ...string) *TubeSet {
ts := &TubeSet{c, make(map[string]bool)}
for _, s := range name {
ts.Name[s] = true
}
return ts
}
|
[
"func",
"NewTubeSet",
"(",
"c",
"*",
"Conn",
",",
"name",
"...",
"string",
")",
"*",
"TubeSet",
"{",
"ts",
":=",
"&",
"TubeSet",
"{",
"c",
",",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"}",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"name",
"{",
"ts",
".",
"Name",
"[",
"s",
"]",
"=",
"true",
"\n",
"}",
"\n",
"return",
"ts",
"\n",
"}"
] |
// NewTubeSet returns a new TubeSet representing the given names.
|
[
"NewTubeSet",
"returns",
"a",
"new",
"TubeSet",
"representing",
"the",
"given",
"names",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tubeset.go#L15-L21
|
143,216 |
beanstalkd/go-beanstalk
|
tubeset.go
|
Reserve
|
func (t *TubeSet) Reserve(timeout time.Duration) (id uint64, body []byte, err error) {
r, err := t.Conn.cmd(nil, t, nil, "reserve-with-timeout", dur(timeout))
if err != nil {
return 0, nil, err
}
body, err = t.Conn.readResp(r, true, "RESERVED %d", &id)
if err != nil {
return 0, nil, err
}
return id, body, nil
}
|
go
|
func (t *TubeSet) Reserve(timeout time.Duration) (id uint64, body []byte, err error) {
r, err := t.Conn.cmd(nil, t, nil, "reserve-with-timeout", dur(timeout))
if err != nil {
return 0, nil, err
}
body, err = t.Conn.readResp(r, true, "RESERVED %d", &id)
if err != nil {
return 0, nil, err
}
return id, body, nil
}
|
[
"func",
"(",
"t",
"*",
"TubeSet",
")",
"Reserve",
"(",
"timeout",
"time",
".",
"Duration",
")",
"(",
"id",
"uint64",
",",
"body",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"r",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"cmd",
"(",
"nil",
",",
"t",
",",
"nil",
",",
"\"",
"\"",
",",
"dur",
"(",
"timeout",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
"=",
"t",
".",
"Conn",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
",",
"&",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"id",
",",
"body",
",",
"nil",
"\n",
"}"
] |
// Reserve reserves and returns a job from one of the tubes in t. If no
// job is available before time timeout has passed, Reserve returns a
// ConnError recording ErrTimeout.
//
// Typically, a client will reserve a job, perform some work, then delete
// the job with Conn.Delete.
|
[
"Reserve",
"reserves",
"and",
"returns",
"a",
"job",
"from",
"one",
"of",
"the",
"tubes",
"in",
"t",
".",
"If",
"no",
"job",
"is",
"available",
"before",
"time",
"timeout",
"has",
"passed",
"Reserve",
"returns",
"a",
"ConnError",
"recording",
"ErrTimeout",
".",
"Typically",
"a",
"client",
"will",
"reserve",
"a",
"job",
"perform",
"some",
"work",
"then",
"delete",
"the",
"job",
"with",
"Conn",
".",
"Delete",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tubeset.go#L29-L39
|
143,217 |
beanstalkd/go-beanstalk
|
tube.go
|
Put
|
func (t *Tube) Put(body []byte, pri uint32, delay, ttr time.Duration) (id uint64, err error) {
r, err := t.Conn.cmd(t, nil, body, "put", pri, dur(delay), dur(ttr))
if err != nil {
return 0, err
}
_, err = t.Conn.readResp(r, false, "INSERTED %d", &id)
if err != nil {
return 0, err
}
return id, nil
}
|
go
|
func (t *Tube) Put(body []byte, pri uint32, delay, ttr time.Duration) (id uint64, err error) {
r, err := t.Conn.cmd(t, nil, body, "put", pri, dur(delay), dur(ttr))
if err != nil {
return 0, err
}
_, err = t.Conn.readResp(r, false, "INSERTED %d", &id)
if err != nil {
return 0, err
}
return id, nil
}
|
[
"func",
"(",
"t",
"*",
"Tube",
")",
"Put",
"(",
"body",
"[",
"]",
"byte",
",",
"pri",
"uint32",
",",
"delay",
",",
"ttr",
"time",
".",
"Duration",
")",
"(",
"id",
"uint64",
",",
"err",
"error",
")",
"{",
"r",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"cmd",
"(",
"t",
",",
"nil",
",",
"body",
",",
"\"",
"\"",
",",
"pri",
",",
"dur",
"(",
"delay",
")",
",",
"dur",
"(",
"ttr",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"t",
".",
"Conn",
".",
"readResp",
"(",
"r",
",",
"false",
",",
"\"",
"\"",
",",
"&",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] |
// Put puts a job into tube t with priority pri and TTR ttr, and returns
// the id of the newly-created job. If delay is nonzero, the server will
// wait the given amount of time after returning to the client and before
// putting the job into the ready queue.
|
[
"Put",
"puts",
"a",
"job",
"into",
"tube",
"t",
"with",
"priority",
"pri",
"and",
"TTR",
"ttr",
"and",
"returns",
"the",
"id",
"of",
"the",
"newly",
"-",
"created",
"job",
".",
"If",
"delay",
"is",
"nonzero",
"the",
"server",
"will",
"wait",
"the",
"given",
"amount",
"of",
"time",
"after",
"returning",
"to",
"the",
"client",
"and",
"before",
"putting",
"the",
"job",
"into",
"the",
"ready",
"queue",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tube.go#L18-L28
|
143,218 |
beanstalkd/go-beanstalk
|
tube.go
|
PeekDelayed
|
func (t *Tube) PeekDelayed() (id uint64, body []byte, err error) {
r, err := t.Conn.cmd(t, nil, nil, "peek-delayed")
if err != nil {
return 0, nil, err
}
body, err = t.Conn.readResp(r, true, "FOUND %d", &id)
if err != nil {
return 0, nil, err
}
return id, body, nil
}
|
go
|
func (t *Tube) PeekDelayed() (id uint64, body []byte, err error) {
r, err := t.Conn.cmd(t, nil, nil, "peek-delayed")
if err != nil {
return 0, nil, err
}
body, err = t.Conn.readResp(r, true, "FOUND %d", &id)
if err != nil {
return 0, nil, err
}
return id, body, nil
}
|
[
"func",
"(",
"t",
"*",
"Tube",
")",
"PeekDelayed",
"(",
")",
"(",
"id",
"uint64",
",",
"body",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"r",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"cmd",
"(",
"t",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
"=",
"t",
".",
"Conn",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
",",
"&",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"id",
",",
"body",
",",
"nil",
"\n",
"}"
] |
// PeekDelayed gets a copy of the delayed job that is next to be
// put in t's ready queue.
|
[
"PeekDelayed",
"gets",
"a",
"copy",
"of",
"the",
"delayed",
"job",
"that",
"is",
"next",
"to",
"be",
"put",
"in",
"t",
"s",
"ready",
"queue",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tube.go#L45-L55
|
143,219 |
beanstalkd/go-beanstalk
|
tube.go
|
Kick
|
func (t *Tube) Kick(bound int) (n int, err error) {
r, err := t.Conn.cmd(t, nil, nil, "kick", bound)
if err != nil {
return 0, err
}
_, err = t.Conn.readResp(r, false, "KICKED %d", &n)
if err != nil {
return 0, err
}
return n, nil
}
|
go
|
func (t *Tube) Kick(bound int) (n int, err error) {
r, err := t.Conn.cmd(t, nil, nil, "kick", bound)
if err != nil {
return 0, err
}
_, err = t.Conn.readResp(r, false, "KICKED %d", &n)
if err != nil {
return 0, err
}
return n, nil
}
|
[
"func",
"(",
"t",
"*",
"Tube",
")",
"Kick",
"(",
"bound",
"int",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"r",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"cmd",
"(",
"t",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"bound",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"t",
".",
"Conn",
".",
"readResp",
"(",
"r",
",",
"false",
",",
"\"",
"\"",
",",
"&",
"n",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] |
// Kick takes up to bound jobs from the holding area and moves them into
// the ready queue, then returns the number of jobs moved. Jobs will be
// taken in the order in which they were last buried.
|
[
"Kick",
"takes",
"up",
"to",
"bound",
"jobs",
"from",
"the",
"holding",
"area",
"and",
"moves",
"them",
"into",
"the",
"ready",
"queue",
"then",
"returns",
"the",
"number",
"of",
"jobs",
"moved",
".",
"Jobs",
"will",
"be",
"taken",
"in",
"the",
"order",
"in",
"which",
"they",
"were",
"last",
"buried",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tube.go#L74-L84
|
143,220 |
beanstalkd/go-beanstalk
|
tube.go
|
Stats
|
func (t *Tube) Stats() (map[string]string, error) {
r, err := t.Conn.cmd(nil, nil, nil, "stats-tube", t.Name)
if err != nil {
return nil, err
}
body, err := t.Conn.readResp(r, true, "OK")
return parseDict(body), err
}
|
go
|
func (t *Tube) Stats() (map[string]string, error) {
r, err := t.Conn.cmd(nil, nil, nil, "stats-tube", t.Name)
if err != nil {
return nil, err
}
body, err := t.Conn.readResp(r, true, "OK")
return parseDict(body), err
}
|
[
"func",
"(",
"t",
"*",
"Tube",
")",
"Stats",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"r",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"t",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"readResp",
"(",
"r",
",",
"true",
",",
"\"",
"\"",
")",
"\n",
"return",
"parseDict",
"(",
"body",
")",
",",
"err",
"\n",
"}"
] |
// Stats retrieves statistics about tube t.
|
[
"Stats",
"retrieves",
"statistics",
"about",
"tube",
"t",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tube.go#L87-L94
|
143,221 |
beanstalkd/go-beanstalk
|
tube.go
|
Pause
|
func (t *Tube) Pause(d time.Duration) error {
r, err := t.Conn.cmd(nil, nil, nil, "pause-tube", t.Name, dur(d))
if err != nil {
return err
}
_, err = t.Conn.readResp(r, false, "PAUSED")
if err != nil {
return err
}
return nil
}
|
go
|
func (t *Tube) Pause(d time.Duration) error {
r, err := t.Conn.cmd(nil, nil, nil, "pause-tube", t.Name, dur(d))
if err != nil {
return err
}
_, err = t.Conn.readResp(r, false, "PAUSED")
if err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"Tube",
")",
"Pause",
"(",
"d",
"time",
".",
"Duration",
")",
"error",
"{",
"r",
",",
"err",
":=",
"t",
".",
"Conn",
".",
"cmd",
"(",
"nil",
",",
"nil",
",",
"nil",
",",
"\"",
"\"",
",",
"t",
".",
"Name",
",",
"dur",
"(",
"d",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"t",
".",
"Conn",
".",
"readResp",
"(",
"r",
",",
"false",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Pause pauses new reservations in t for time d.
|
[
"Pause",
"pauses",
"new",
"reservations",
"in",
"t",
"for",
"time",
"d",
"."
] |
7a112881e6c4f85f0d98f8929536e775d31fb4de
|
https://github.com/beanstalkd/go-beanstalk/blob/7a112881e6c4f85f0d98f8929536e775d31fb4de/tube.go#L97-L107
|
143,222 |
hashicorp/go-immutable-radix
|
iradix.go
|
Txn
|
func (t *Tree) Txn() *Txn {
txn := &Txn{
root: t.root,
snap: t.root,
size: t.size,
}
return txn
}
|
go
|
func (t *Tree) Txn() *Txn {
txn := &Txn{
root: t.root,
snap: t.root,
size: t.size,
}
return txn
}
|
[
"func",
"(",
"t",
"*",
"Tree",
")",
"Txn",
"(",
")",
"*",
"Txn",
"{",
"txn",
":=",
"&",
"Txn",
"{",
"root",
":",
"t",
".",
"root",
",",
"snap",
":",
"t",
".",
"root",
",",
"size",
":",
"t",
".",
"size",
",",
"}",
"\n",
"return",
"txn",
"\n",
"}"
] |
// Txn starts a new transaction that can be used to mutate the tree
|
[
"Txn",
"starts",
"a",
"new",
"transaction",
"that",
"can",
"be",
"used",
"to",
"mutate",
"the",
"tree"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L80-L87
|
143,223 |
hashicorp/go-immutable-radix
|
iradix.go
|
trackChannel
|
func (t *Txn) trackChannel(ch chan struct{}) {
// In overflow, make sure we don't store any more objects.
if t.trackOverflow {
return
}
// If this would overflow the state we reject it and set the flag (since
// we aren't tracking everything that's required any longer).
if len(t.trackChannels) >= defaultModifiedCache {
// Mark that we are in the overflow state
t.trackOverflow = true
// Clear the map so that the channels can be garbage collected. It is
// safe to do this since we have already overflowed and will be using
// the slow notify algorithm.
t.trackChannels = nil
return
}
// Create the map on the fly when we need it.
if t.trackChannels == nil {
t.trackChannels = make(map[chan struct{}]struct{})
}
// Otherwise we are good to track it.
t.trackChannels[ch] = struct{}{}
}
|
go
|
func (t *Txn) trackChannel(ch chan struct{}) {
// In overflow, make sure we don't store any more objects.
if t.trackOverflow {
return
}
// If this would overflow the state we reject it and set the flag (since
// we aren't tracking everything that's required any longer).
if len(t.trackChannels) >= defaultModifiedCache {
// Mark that we are in the overflow state
t.trackOverflow = true
// Clear the map so that the channels can be garbage collected. It is
// safe to do this since we have already overflowed and will be using
// the slow notify algorithm.
t.trackChannels = nil
return
}
// Create the map on the fly when we need it.
if t.trackChannels == nil {
t.trackChannels = make(map[chan struct{}]struct{})
}
// Otherwise we are good to track it.
t.trackChannels[ch] = struct{}{}
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"trackChannel",
"(",
"ch",
"chan",
"struct",
"{",
"}",
")",
"{",
"// In overflow, make sure we don't store any more objects.",
"if",
"t",
".",
"trackOverflow",
"{",
"return",
"\n",
"}",
"\n\n",
"// If this would overflow the state we reject it and set the flag (since",
"// we aren't tracking everything that's required any longer).",
"if",
"len",
"(",
"t",
".",
"trackChannels",
")",
">=",
"defaultModifiedCache",
"{",
"// Mark that we are in the overflow state",
"t",
".",
"trackOverflow",
"=",
"true",
"\n\n",
"// Clear the map so that the channels can be garbage collected. It is",
"// safe to do this since we have already overflowed and will be using",
"// the slow notify algorithm.",
"t",
".",
"trackChannels",
"=",
"nil",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Create the map on the fly when we need it.",
"if",
"t",
".",
"trackChannels",
"==",
"nil",
"{",
"t",
".",
"trackChannels",
"=",
"make",
"(",
"map",
"[",
"chan",
"struct",
"{",
"}",
"]",
"struct",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"// Otherwise we are good to track it.",
"t",
".",
"trackChannels",
"[",
"ch",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}"
] |
// trackChannel safely attempts to track the given mutation channel, setting the
// overflow flag if we can no longer track any more. This limits the amount of
// state that will accumulate during a transaction and we have a slower algorithm
// to switch to if we overflow.
|
[
"trackChannel",
"safely",
"attempts",
"to",
"track",
"the",
"given",
"mutation",
"channel",
"setting",
"the",
"overflow",
"flag",
"if",
"we",
"can",
"no",
"longer",
"track",
"any",
"more",
".",
"This",
"limits",
"the",
"amount",
"of",
"state",
"that",
"will",
"accumulate",
"during",
"a",
"transaction",
"and",
"we",
"have",
"a",
"slower",
"algorithm",
"to",
"switch",
"to",
"if",
"we",
"overflow",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L100-L126
|
143,224 |
hashicorp/go-immutable-radix
|
iradix.go
|
writeNode
|
func (t *Txn) writeNode(n *Node, forLeafUpdate bool) *Node {
// Ensure the writable set exists.
if t.writable == nil {
lru, err := simplelru.NewLRU(defaultModifiedCache, nil)
if err != nil {
panic(err)
}
t.writable = lru
}
// If this node has already been modified, we can continue to use it
// during this transaction. We know that we don't need to track it for
// a node update since the node is writable, but if this is for a leaf
// update we track it, in case the initial write to this node didn't
// update the leaf.
if _, ok := t.writable.Get(n); ok {
if t.trackMutate && forLeafUpdate && n.leaf != nil {
t.trackChannel(n.leaf.mutateCh)
}
return n
}
// Mark this node as being mutated.
if t.trackMutate {
t.trackChannel(n.mutateCh)
}
// Mark its leaf as being mutated, if appropriate.
if t.trackMutate && forLeafUpdate && n.leaf != nil {
t.trackChannel(n.leaf.mutateCh)
}
// Copy the existing node. If you have set forLeafUpdate it will be
// safe to replace this leaf with another after you get your node for
// writing. You MUST replace it, because the channel associated with
// this leaf will be closed when this transaction is committed.
nc := &Node{
mutateCh: make(chan struct{}),
leaf: n.leaf,
}
if n.prefix != nil {
nc.prefix = make([]byte, len(n.prefix))
copy(nc.prefix, n.prefix)
}
if len(n.edges) != 0 {
nc.edges = make([]edge, len(n.edges))
copy(nc.edges, n.edges)
}
// Mark this node as writable.
t.writable.Add(nc, nil)
return nc
}
|
go
|
func (t *Txn) writeNode(n *Node, forLeafUpdate bool) *Node {
// Ensure the writable set exists.
if t.writable == nil {
lru, err := simplelru.NewLRU(defaultModifiedCache, nil)
if err != nil {
panic(err)
}
t.writable = lru
}
// If this node has already been modified, we can continue to use it
// during this transaction. We know that we don't need to track it for
// a node update since the node is writable, but if this is for a leaf
// update we track it, in case the initial write to this node didn't
// update the leaf.
if _, ok := t.writable.Get(n); ok {
if t.trackMutate && forLeafUpdate && n.leaf != nil {
t.trackChannel(n.leaf.mutateCh)
}
return n
}
// Mark this node as being mutated.
if t.trackMutate {
t.trackChannel(n.mutateCh)
}
// Mark its leaf as being mutated, if appropriate.
if t.trackMutate && forLeafUpdate && n.leaf != nil {
t.trackChannel(n.leaf.mutateCh)
}
// Copy the existing node. If you have set forLeafUpdate it will be
// safe to replace this leaf with another after you get your node for
// writing. You MUST replace it, because the channel associated with
// this leaf will be closed when this transaction is committed.
nc := &Node{
mutateCh: make(chan struct{}),
leaf: n.leaf,
}
if n.prefix != nil {
nc.prefix = make([]byte, len(n.prefix))
copy(nc.prefix, n.prefix)
}
if len(n.edges) != 0 {
nc.edges = make([]edge, len(n.edges))
copy(nc.edges, n.edges)
}
// Mark this node as writable.
t.writable.Add(nc, nil)
return nc
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"writeNode",
"(",
"n",
"*",
"Node",
",",
"forLeafUpdate",
"bool",
")",
"*",
"Node",
"{",
"// Ensure the writable set exists.",
"if",
"t",
".",
"writable",
"==",
"nil",
"{",
"lru",
",",
"err",
":=",
"simplelru",
".",
"NewLRU",
"(",
"defaultModifiedCache",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"t",
".",
"writable",
"=",
"lru",
"\n",
"}",
"\n\n",
"// If this node has already been modified, we can continue to use it",
"// during this transaction. We know that we don't need to track it for",
"// a node update since the node is writable, but if this is for a leaf",
"// update we track it, in case the initial write to this node didn't",
"// update the leaf.",
"if",
"_",
",",
"ok",
":=",
"t",
".",
"writable",
".",
"Get",
"(",
"n",
")",
";",
"ok",
"{",
"if",
"t",
".",
"trackMutate",
"&&",
"forLeafUpdate",
"&&",
"n",
".",
"leaf",
"!=",
"nil",
"{",
"t",
".",
"trackChannel",
"(",
"n",
".",
"leaf",
".",
"mutateCh",
")",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}",
"\n\n",
"// Mark this node as being mutated.",
"if",
"t",
".",
"trackMutate",
"{",
"t",
".",
"trackChannel",
"(",
"n",
".",
"mutateCh",
")",
"\n",
"}",
"\n\n",
"// Mark its leaf as being mutated, if appropriate.",
"if",
"t",
".",
"trackMutate",
"&&",
"forLeafUpdate",
"&&",
"n",
".",
"leaf",
"!=",
"nil",
"{",
"t",
".",
"trackChannel",
"(",
"n",
".",
"leaf",
".",
"mutateCh",
")",
"\n",
"}",
"\n\n",
"// Copy the existing node. If you have set forLeafUpdate it will be",
"// safe to replace this leaf with another after you get your node for",
"// writing. You MUST replace it, because the channel associated with",
"// this leaf will be closed when this transaction is committed.",
"nc",
":=",
"&",
"Node",
"{",
"mutateCh",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"leaf",
":",
"n",
".",
"leaf",
",",
"}",
"\n",
"if",
"n",
".",
"prefix",
"!=",
"nil",
"{",
"nc",
".",
"prefix",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"n",
".",
"prefix",
")",
")",
"\n",
"copy",
"(",
"nc",
".",
"prefix",
",",
"n",
".",
"prefix",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"n",
".",
"edges",
")",
"!=",
"0",
"{",
"nc",
".",
"edges",
"=",
"make",
"(",
"[",
"]",
"edge",
",",
"len",
"(",
"n",
".",
"edges",
")",
")",
"\n",
"copy",
"(",
"nc",
".",
"edges",
",",
"n",
".",
"edges",
")",
"\n",
"}",
"\n\n",
"// Mark this node as writable.",
"t",
".",
"writable",
".",
"Add",
"(",
"nc",
",",
"nil",
")",
"\n",
"return",
"nc",
"\n",
"}"
] |
// writeNode returns a node to be modified, if the current node has already been
// modified during the course of the transaction, it is used in-place. Set
// forLeafUpdate to true if you are getting a write node to update the leaf,
// which will set leaf mutation tracking appropriately as well.
|
[
"writeNode",
"returns",
"a",
"node",
"to",
"be",
"modified",
"if",
"the",
"current",
"node",
"has",
"already",
"been",
"modified",
"during",
"the",
"course",
"of",
"the",
"transaction",
"it",
"is",
"used",
"in",
"-",
"place",
".",
"Set",
"forLeafUpdate",
"to",
"true",
"if",
"you",
"are",
"getting",
"a",
"write",
"node",
"to",
"update",
"the",
"leaf",
"which",
"will",
"set",
"leaf",
"mutation",
"tracking",
"appropriately",
"as",
"well",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L132-L184
|
143,225 |
hashicorp/go-immutable-radix
|
iradix.go
|
trackChannelsAndCount
|
func (t *Txn) trackChannelsAndCount(n *Node) int {
// Count only leaf nodes
leaves := 0
if n.leaf != nil {
leaves = 1
}
// Mark this node as being mutated.
if t.trackMutate {
t.trackChannel(n.mutateCh)
}
// Mark its leaf as being mutated, if appropriate.
if t.trackMutate && n.leaf != nil {
t.trackChannel(n.leaf.mutateCh)
}
// Recurse on the children
for _, e := range n.edges {
leaves += t.trackChannelsAndCount(e.node)
}
return leaves
}
|
go
|
func (t *Txn) trackChannelsAndCount(n *Node) int {
// Count only leaf nodes
leaves := 0
if n.leaf != nil {
leaves = 1
}
// Mark this node as being mutated.
if t.trackMutate {
t.trackChannel(n.mutateCh)
}
// Mark its leaf as being mutated, if appropriate.
if t.trackMutate && n.leaf != nil {
t.trackChannel(n.leaf.mutateCh)
}
// Recurse on the children
for _, e := range n.edges {
leaves += t.trackChannelsAndCount(e.node)
}
return leaves
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"trackChannelsAndCount",
"(",
"n",
"*",
"Node",
")",
"int",
"{",
"// Count only leaf nodes",
"leaves",
":=",
"0",
"\n",
"if",
"n",
".",
"leaf",
"!=",
"nil",
"{",
"leaves",
"=",
"1",
"\n",
"}",
"\n",
"// Mark this node as being mutated.",
"if",
"t",
".",
"trackMutate",
"{",
"t",
".",
"trackChannel",
"(",
"n",
".",
"mutateCh",
")",
"\n",
"}",
"\n\n",
"// Mark its leaf as being mutated, if appropriate.",
"if",
"t",
".",
"trackMutate",
"&&",
"n",
".",
"leaf",
"!=",
"nil",
"{",
"t",
".",
"trackChannel",
"(",
"n",
".",
"leaf",
".",
"mutateCh",
")",
"\n",
"}",
"\n\n",
"// Recurse on the children",
"for",
"_",
",",
"e",
":=",
"range",
"n",
".",
"edges",
"{",
"leaves",
"+=",
"t",
".",
"trackChannelsAndCount",
"(",
"e",
".",
"node",
")",
"\n",
"}",
"\n",
"return",
"leaves",
"\n",
"}"
] |
// Visit all the nodes in the tree under n, and add their mutateChannels to the transaction
// Returns the size of the subtree visited
|
[
"Visit",
"all",
"the",
"nodes",
"in",
"the",
"tree",
"under",
"n",
"and",
"add",
"their",
"mutateChannels",
"to",
"the",
"transaction",
"Returns",
"the",
"size",
"of",
"the",
"subtree",
"visited"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L188-L209
|
143,226 |
hashicorp/go-immutable-radix
|
iradix.go
|
mergeChild
|
func (t *Txn) mergeChild(n *Node) {
// Mark the child node as being mutated since we are about to abandon
// it. We don't need to mark the leaf since we are retaining it if it
// is there.
e := n.edges[0]
child := e.node
if t.trackMutate {
t.trackChannel(child.mutateCh)
}
// Merge the nodes.
n.prefix = concat(n.prefix, child.prefix)
n.leaf = child.leaf
if len(child.edges) != 0 {
n.edges = make([]edge, len(child.edges))
copy(n.edges, child.edges)
} else {
n.edges = nil
}
}
|
go
|
func (t *Txn) mergeChild(n *Node) {
// Mark the child node as being mutated since we are about to abandon
// it. We don't need to mark the leaf since we are retaining it if it
// is there.
e := n.edges[0]
child := e.node
if t.trackMutate {
t.trackChannel(child.mutateCh)
}
// Merge the nodes.
n.prefix = concat(n.prefix, child.prefix)
n.leaf = child.leaf
if len(child.edges) != 0 {
n.edges = make([]edge, len(child.edges))
copy(n.edges, child.edges)
} else {
n.edges = nil
}
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"mergeChild",
"(",
"n",
"*",
"Node",
")",
"{",
"// Mark the child node as being mutated since we are about to abandon",
"// it. We don't need to mark the leaf since we are retaining it if it",
"// is there.",
"e",
":=",
"n",
".",
"edges",
"[",
"0",
"]",
"\n",
"child",
":=",
"e",
".",
"node",
"\n",
"if",
"t",
".",
"trackMutate",
"{",
"t",
".",
"trackChannel",
"(",
"child",
".",
"mutateCh",
")",
"\n",
"}",
"\n\n",
"// Merge the nodes.",
"n",
".",
"prefix",
"=",
"concat",
"(",
"n",
".",
"prefix",
",",
"child",
".",
"prefix",
")",
"\n",
"n",
".",
"leaf",
"=",
"child",
".",
"leaf",
"\n",
"if",
"len",
"(",
"child",
".",
"edges",
")",
"!=",
"0",
"{",
"n",
".",
"edges",
"=",
"make",
"(",
"[",
"]",
"edge",
",",
"len",
"(",
"child",
".",
"edges",
")",
")",
"\n",
"copy",
"(",
"n",
".",
"edges",
",",
"child",
".",
"edges",
")",
"\n",
"}",
"else",
"{",
"n",
".",
"edges",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] |
// mergeChild is called to collapse the given node with its child. This is only
// called when the given node is not a leaf and has a single edge.
|
[
"mergeChild",
"is",
"called",
"to",
"collapse",
"the",
"given",
"node",
"with",
"its",
"child",
".",
"This",
"is",
"only",
"called",
"when",
"the",
"given",
"node",
"is",
"not",
"a",
"leaf",
"and",
"has",
"a",
"single",
"edge",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L213-L232
|
143,227 |
hashicorp/go-immutable-radix
|
iradix.go
|
delete
|
func (t *Txn) delete(parent, n *Node, search []byte) (*Node, *leafNode) {
// Check for key exhaustion
if len(search) == 0 {
if !n.isLeaf() {
return nil, nil
}
// Copy the pointer in case we are in a transaction that already
// modified this node since the node will be reused. Any changes
// made to the node will not affect returning the original leaf
// value.
oldLeaf := n.leaf
// Remove the leaf node
nc := t.writeNode(n, true)
nc.leaf = nil
// Check if this node should be merged
if n != t.root && len(nc.edges) == 1 {
t.mergeChild(nc)
}
return nc, oldLeaf
}
// Look for an edge
label := search[0]
idx, child := n.getEdge(label)
if child == nil || !bytes.HasPrefix(search, child.prefix) {
return nil, nil
}
// Consume the search prefix
search = search[len(child.prefix):]
newChild, leaf := t.delete(n, child, search)
if newChild == nil {
return nil, nil
}
// Copy this node. WATCH OUT - it's safe to pass "false" here because we
// will only ADD a leaf via nc.mergeChild() if there isn't one due to
// the !nc.isLeaf() check in the logic just below. This is pretty subtle,
// so be careful if you change any of the logic here.
nc := t.writeNode(n, false)
// Delete the edge if the node has no edges
if newChild.leaf == nil && len(newChild.edges) == 0 {
nc.delEdge(label)
if n != t.root && len(nc.edges) == 1 && !nc.isLeaf() {
t.mergeChild(nc)
}
} else {
nc.edges[idx].node = newChild
}
return nc, leaf
}
|
go
|
func (t *Txn) delete(parent, n *Node, search []byte) (*Node, *leafNode) {
// Check for key exhaustion
if len(search) == 0 {
if !n.isLeaf() {
return nil, nil
}
// Copy the pointer in case we are in a transaction that already
// modified this node since the node will be reused. Any changes
// made to the node will not affect returning the original leaf
// value.
oldLeaf := n.leaf
// Remove the leaf node
nc := t.writeNode(n, true)
nc.leaf = nil
// Check if this node should be merged
if n != t.root && len(nc.edges) == 1 {
t.mergeChild(nc)
}
return nc, oldLeaf
}
// Look for an edge
label := search[0]
idx, child := n.getEdge(label)
if child == nil || !bytes.HasPrefix(search, child.prefix) {
return nil, nil
}
// Consume the search prefix
search = search[len(child.prefix):]
newChild, leaf := t.delete(n, child, search)
if newChild == nil {
return nil, nil
}
// Copy this node. WATCH OUT - it's safe to pass "false" here because we
// will only ADD a leaf via nc.mergeChild() if there isn't one due to
// the !nc.isLeaf() check in the logic just below. This is pretty subtle,
// so be careful if you change any of the logic here.
nc := t.writeNode(n, false)
// Delete the edge if the node has no edges
if newChild.leaf == nil && len(newChild.edges) == 0 {
nc.delEdge(label)
if n != t.root && len(nc.edges) == 1 && !nc.isLeaf() {
t.mergeChild(nc)
}
} else {
nc.edges[idx].node = newChild
}
return nc, leaf
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"delete",
"(",
"parent",
",",
"n",
"*",
"Node",
",",
"search",
"[",
"]",
"byte",
")",
"(",
"*",
"Node",
",",
"*",
"leafNode",
")",
"{",
"// Check for key exhaustion",
"if",
"len",
"(",
"search",
")",
"==",
"0",
"{",
"if",
"!",
"n",
".",
"isLeaf",
"(",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"// Copy the pointer in case we are in a transaction that already",
"// modified this node since the node will be reused. Any changes",
"// made to the node will not affect returning the original leaf",
"// value.",
"oldLeaf",
":=",
"n",
".",
"leaf",
"\n\n",
"// Remove the leaf node",
"nc",
":=",
"t",
".",
"writeNode",
"(",
"n",
",",
"true",
")",
"\n",
"nc",
".",
"leaf",
"=",
"nil",
"\n\n",
"// Check if this node should be merged",
"if",
"n",
"!=",
"t",
".",
"root",
"&&",
"len",
"(",
"nc",
".",
"edges",
")",
"==",
"1",
"{",
"t",
".",
"mergeChild",
"(",
"nc",
")",
"\n",
"}",
"\n",
"return",
"nc",
",",
"oldLeaf",
"\n",
"}",
"\n\n",
"// Look for an edge",
"label",
":=",
"search",
"[",
"0",
"]",
"\n",
"idx",
",",
"child",
":=",
"n",
".",
"getEdge",
"(",
"label",
")",
"\n",
"if",
"child",
"==",
"nil",
"||",
"!",
"bytes",
".",
"HasPrefix",
"(",
"search",
",",
"child",
".",
"prefix",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"// Consume the search prefix",
"search",
"=",
"search",
"[",
"len",
"(",
"child",
".",
"prefix",
")",
":",
"]",
"\n",
"newChild",
",",
"leaf",
":=",
"t",
".",
"delete",
"(",
"n",
",",
"child",
",",
"search",
")",
"\n",
"if",
"newChild",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"// Copy this node. WATCH OUT - it's safe to pass \"false\" here because we",
"// will only ADD a leaf via nc.mergeChild() if there isn't one due to",
"// the !nc.isLeaf() check in the logic just below. This is pretty subtle,",
"// so be careful if you change any of the logic here.",
"nc",
":=",
"t",
".",
"writeNode",
"(",
"n",
",",
"false",
")",
"\n\n",
"// Delete the edge if the node has no edges",
"if",
"newChild",
".",
"leaf",
"==",
"nil",
"&&",
"len",
"(",
"newChild",
".",
"edges",
")",
"==",
"0",
"{",
"nc",
".",
"delEdge",
"(",
"label",
")",
"\n",
"if",
"n",
"!=",
"t",
".",
"root",
"&&",
"len",
"(",
"nc",
".",
"edges",
")",
"==",
"1",
"&&",
"!",
"nc",
".",
"isLeaf",
"(",
")",
"{",
"t",
".",
"mergeChild",
"(",
"nc",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"nc",
".",
"edges",
"[",
"idx",
"]",
".",
"node",
"=",
"newChild",
"\n",
"}",
"\n",
"return",
"nc",
",",
"leaf",
"\n",
"}"
] |
// delete does a recursive deletion
|
[
"delete",
"does",
"a",
"recursive",
"deletion"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L335-L388
|
143,228 |
hashicorp/go-immutable-radix
|
iradix.go
|
Insert
|
func (t *Txn) Insert(k []byte, v interface{}) (interface{}, bool) {
newRoot, oldVal, didUpdate := t.insert(t.root, k, k, v)
if newRoot != nil {
t.root = newRoot
}
if !didUpdate {
t.size++
}
return oldVal, didUpdate
}
|
go
|
func (t *Txn) Insert(k []byte, v interface{}) (interface{}, bool) {
newRoot, oldVal, didUpdate := t.insert(t.root, k, k, v)
if newRoot != nil {
t.root = newRoot
}
if !didUpdate {
t.size++
}
return oldVal, didUpdate
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"Insert",
"(",
"k",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"newRoot",
",",
"oldVal",
",",
"didUpdate",
":=",
"t",
".",
"insert",
"(",
"t",
".",
"root",
",",
"k",
",",
"k",
",",
"v",
")",
"\n",
"if",
"newRoot",
"!=",
"nil",
"{",
"t",
".",
"root",
"=",
"newRoot",
"\n",
"}",
"\n",
"if",
"!",
"didUpdate",
"{",
"t",
".",
"size",
"++",
"\n",
"}",
"\n",
"return",
"oldVal",
",",
"didUpdate",
"\n",
"}"
] |
// Insert is used to add or update a given key. The return provides
// the previous value and a bool indicating if any was set.
|
[
"Insert",
"is",
"used",
"to",
"add",
"or",
"update",
"a",
"given",
"key",
".",
"The",
"return",
"provides",
"the",
"previous",
"value",
"and",
"a",
"bool",
"indicating",
"if",
"any",
"was",
"set",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L442-L451
|
143,229 |
hashicorp/go-immutable-radix
|
iradix.go
|
Delete
|
func (t *Txn) Delete(k []byte) (interface{}, bool) {
newRoot, leaf := t.delete(nil, t.root, k)
if newRoot != nil {
t.root = newRoot
}
if leaf != nil {
t.size--
return leaf.val, true
}
return nil, false
}
|
go
|
func (t *Txn) Delete(k []byte) (interface{}, bool) {
newRoot, leaf := t.delete(nil, t.root, k)
if newRoot != nil {
t.root = newRoot
}
if leaf != nil {
t.size--
return leaf.val, true
}
return nil, false
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"Delete",
"(",
"k",
"[",
"]",
"byte",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"newRoot",
",",
"leaf",
":=",
"t",
".",
"delete",
"(",
"nil",
",",
"t",
".",
"root",
",",
"k",
")",
"\n",
"if",
"newRoot",
"!=",
"nil",
"{",
"t",
".",
"root",
"=",
"newRoot",
"\n",
"}",
"\n",
"if",
"leaf",
"!=",
"nil",
"{",
"t",
".",
"size",
"--",
"\n",
"return",
"leaf",
".",
"val",
",",
"true",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] |
// Delete is used to delete a given key. Returns the old value if any,
// and a bool indicating if the key was set.
|
[
"Delete",
"is",
"used",
"to",
"delete",
"a",
"given",
"key",
".",
"Returns",
"the",
"old",
"value",
"if",
"any",
"and",
"a",
"bool",
"indicating",
"if",
"the",
"key",
"was",
"set",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L455-L465
|
143,230 |
hashicorp/go-immutable-radix
|
iradix.go
|
DeletePrefix
|
func (t *Txn) DeletePrefix(prefix []byte) bool {
newRoot, numDeletions := t.deletePrefix(nil, t.root, prefix)
if newRoot != nil {
t.root = newRoot
t.size = t.size - numDeletions
return true
}
return false
}
|
go
|
func (t *Txn) DeletePrefix(prefix []byte) bool {
newRoot, numDeletions := t.deletePrefix(nil, t.root, prefix)
if newRoot != nil {
t.root = newRoot
t.size = t.size - numDeletions
return true
}
return false
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"DeletePrefix",
"(",
"prefix",
"[",
"]",
"byte",
")",
"bool",
"{",
"newRoot",
",",
"numDeletions",
":=",
"t",
".",
"deletePrefix",
"(",
"nil",
",",
"t",
".",
"root",
",",
"prefix",
")",
"\n",
"if",
"newRoot",
"!=",
"nil",
"{",
"t",
".",
"root",
"=",
"newRoot",
"\n",
"t",
".",
"size",
"=",
"t",
".",
"size",
"-",
"numDeletions",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n\n",
"}"
] |
// DeletePrefix is used to delete an entire subtree that matches the prefix
// This will delete all nodes under that prefix
|
[
"DeletePrefix",
"is",
"used",
"to",
"delete",
"an",
"entire",
"subtree",
"that",
"matches",
"the",
"prefix",
"This",
"will",
"delete",
"all",
"nodes",
"under",
"that",
"prefix"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L469-L478
|
143,231 |
hashicorp/go-immutable-radix
|
iradix.go
|
GetWatch
|
func (t *Txn) GetWatch(k []byte) (<-chan struct{}, interface{}, bool) {
return t.root.GetWatch(k)
}
|
go
|
func (t *Txn) GetWatch(k []byte) (<-chan struct{}, interface{}, bool) {
return t.root.GetWatch(k)
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"GetWatch",
"(",
"k",
"[",
"]",
"byte",
")",
"(",
"<-",
"chan",
"struct",
"{",
"}",
",",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"return",
"t",
".",
"root",
".",
"GetWatch",
"(",
"k",
")",
"\n",
"}"
] |
// GetWatch is used to lookup a specific key, returning
// the watch channel, value and if it was found
|
[
"GetWatch",
"is",
"used",
"to",
"lookup",
"a",
"specific",
"key",
"returning",
"the",
"watch",
"channel",
"value",
"and",
"if",
"it",
"was",
"found"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L495-L497
|
143,232 |
hashicorp/go-immutable-radix
|
iradix.go
|
Commit
|
func (t *Txn) Commit() *Tree {
nt := t.CommitOnly()
if t.trackMutate {
t.Notify()
}
return nt
}
|
go
|
func (t *Txn) Commit() *Tree {
nt := t.CommitOnly()
if t.trackMutate {
t.Notify()
}
return nt
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"Commit",
"(",
")",
"*",
"Tree",
"{",
"nt",
":=",
"t",
".",
"CommitOnly",
"(",
")",
"\n",
"if",
"t",
".",
"trackMutate",
"{",
"t",
".",
"Notify",
"(",
")",
"\n",
"}",
"\n",
"return",
"nt",
"\n",
"}"
] |
// Commit is used to finalize the transaction and return a new tree. If mutation
// tracking is turned on then notifications will also be issued.
|
[
"Commit",
"is",
"used",
"to",
"finalize",
"the",
"transaction",
"and",
"return",
"a",
"new",
"tree",
".",
"If",
"mutation",
"tracking",
"is",
"turned",
"on",
"then",
"notifications",
"will",
"also",
"be",
"issued",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L501-L507
|
143,233 |
hashicorp/go-immutable-radix
|
iradix.go
|
CommitOnly
|
func (t *Txn) CommitOnly() *Tree {
nt := &Tree{t.root, t.size}
t.writable = nil
return nt
}
|
go
|
func (t *Txn) CommitOnly() *Tree {
nt := &Tree{t.root, t.size}
t.writable = nil
return nt
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"CommitOnly",
"(",
")",
"*",
"Tree",
"{",
"nt",
":=",
"&",
"Tree",
"{",
"t",
".",
"root",
",",
"t",
".",
"size",
"}",
"\n",
"t",
".",
"writable",
"=",
"nil",
"\n",
"return",
"nt",
"\n",
"}"
] |
// CommitOnly is used to finalize the transaction and return a new tree, but
// does not issue any notifications until Notify is called.
|
[
"CommitOnly",
"is",
"used",
"to",
"finalize",
"the",
"transaction",
"and",
"return",
"a",
"new",
"tree",
"but",
"does",
"not",
"issue",
"any",
"notifications",
"until",
"Notify",
"is",
"called",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L511-L515
|
143,234 |
hashicorp/go-immutable-radix
|
iradix.go
|
slowNotify
|
func (t *Txn) slowNotify() {
snapIter := t.snap.rawIterator()
rootIter := t.root.rawIterator()
for snapIter.Front() != nil || rootIter.Front() != nil {
// If we've exhausted the nodes in the old snapshot, we know
// there's nothing remaining to notify.
if snapIter.Front() == nil {
return
}
snapElem := snapIter.Front()
// If we've exhausted the nodes in the new root, we know we need
// to invalidate everything that remains in the old snapshot. We
// know from the loop condition there's something in the old
// snapshot.
if rootIter.Front() == nil {
close(snapElem.mutateCh)
if snapElem.isLeaf() {
close(snapElem.leaf.mutateCh)
}
snapIter.Next()
continue
}
// Do one string compare so we can check the various conditions
// below without repeating the compare.
cmp := strings.Compare(snapIter.Path(), rootIter.Path())
// If the snapshot is behind the root, then we must have deleted
// this node during the transaction.
if cmp < 0 {
close(snapElem.mutateCh)
if snapElem.isLeaf() {
close(snapElem.leaf.mutateCh)
}
snapIter.Next()
continue
}
// If the snapshot is ahead of the root, then we must have added
// this node during the transaction.
if cmp > 0 {
rootIter.Next()
continue
}
// If we have the same path, then we need to see if we mutated a
// node and possibly the leaf.
rootElem := rootIter.Front()
if snapElem != rootElem {
close(snapElem.mutateCh)
if snapElem.leaf != nil && (snapElem.leaf != rootElem.leaf) {
close(snapElem.leaf.mutateCh)
}
}
snapIter.Next()
rootIter.Next()
}
}
|
go
|
func (t *Txn) slowNotify() {
snapIter := t.snap.rawIterator()
rootIter := t.root.rawIterator()
for snapIter.Front() != nil || rootIter.Front() != nil {
// If we've exhausted the nodes in the old snapshot, we know
// there's nothing remaining to notify.
if snapIter.Front() == nil {
return
}
snapElem := snapIter.Front()
// If we've exhausted the nodes in the new root, we know we need
// to invalidate everything that remains in the old snapshot. We
// know from the loop condition there's something in the old
// snapshot.
if rootIter.Front() == nil {
close(snapElem.mutateCh)
if snapElem.isLeaf() {
close(snapElem.leaf.mutateCh)
}
snapIter.Next()
continue
}
// Do one string compare so we can check the various conditions
// below without repeating the compare.
cmp := strings.Compare(snapIter.Path(), rootIter.Path())
// If the snapshot is behind the root, then we must have deleted
// this node during the transaction.
if cmp < 0 {
close(snapElem.mutateCh)
if snapElem.isLeaf() {
close(snapElem.leaf.mutateCh)
}
snapIter.Next()
continue
}
// If the snapshot is ahead of the root, then we must have added
// this node during the transaction.
if cmp > 0 {
rootIter.Next()
continue
}
// If we have the same path, then we need to see if we mutated a
// node and possibly the leaf.
rootElem := rootIter.Front()
if snapElem != rootElem {
close(snapElem.mutateCh)
if snapElem.leaf != nil && (snapElem.leaf != rootElem.leaf) {
close(snapElem.leaf.mutateCh)
}
}
snapIter.Next()
rootIter.Next()
}
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"slowNotify",
"(",
")",
"{",
"snapIter",
":=",
"t",
".",
"snap",
".",
"rawIterator",
"(",
")",
"\n",
"rootIter",
":=",
"t",
".",
"root",
".",
"rawIterator",
"(",
")",
"\n",
"for",
"snapIter",
".",
"Front",
"(",
")",
"!=",
"nil",
"||",
"rootIter",
".",
"Front",
"(",
")",
"!=",
"nil",
"{",
"// If we've exhausted the nodes in the old snapshot, we know",
"// there's nothing remaining to notify.",
"if",
"snapIter",
".",
"Front",
"(",
")",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"snapElem",
":=",
"snapIter",
".",
"Front",
"(",
")",
"\n\n",
"// If we've exhausted the nodes in the new root, we know we need",
"// to invalidate everything that remains in the old snapshot. We",
"// know from the loop condition there's something in the old",
"// snapshot.",
"if",
"rootIter",
".",
"Front",
"(",
")",
"==",
"nil",
"{",
"close",
"(",
"snapElem",
".",
"mutateCh",
")",
"\n",
"if",
"snapElem",
".",
"isLeaf",
"(",
")",
"{",
"close",
"(",
"snapElem",
".",
"leaf",
".",
"mutateCh",
")",
"\n",
"}",
"\n",
"snapIter",
".",
"Next",
"(",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// Do one string compare so we can check the various conditions",
"// below without repeating the compare.",
"cmp",
":=",
"strings",
".",
"Compare",
"(",
"snapIter",
".",
"Path",
"(",
")",
",",
"rootIter",
".",
"Path",
"(",
")",
")",
"\n\n",
"// If the snapshot is behind the root, then we must have deleted",
"// this node during the transaction.",
"if",
"cmp",
"<",
"0",
"{",
"close",
"(",
"snapElem",
".",
"mutateCh",
")",
"\n",
"if",
"snapElem",
".",
"isLeaf",
"(",
")",
"{",
"close",
"(",
"snapElem",
".",
"leaf",
".",
"mutateCh",
")",
"\n",
"}",
"\n",
"snapIter",
".",
"Next",
"(",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// If the snapshot is ahead of the root, then we must have added",
"// this node during the transaction.",
"if",
"cmp",
">",
"0",
"{",
"rootIter",
".",
"Next",
"(",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// If we have the same path, then we need to see if we mutated a",
"// node and possibly the leaf.",
"rootElem",
":=",
"rootIter",
".",
"Front",
"(",
")",
"\n",
"if",
"snapElem",
"!=",
"rootElem",
"{",
"close",
"(",
"snapElem",
".",
"mutateCh",
")",
"\n",
"if",
"snapElem",
".",
"leaf",
"!=",
"nil",
"&&",
"(",
"snapElem",
".",
"leaf",
"!=",
"rootElem",
".",
"leaf",
")",
"{",
"close",
"(",
"snapElem",
".",
"leaf",
".",
"mutateCh",
")",
"\n",
"}",
"\n",
"}",
"\n",
"snapIter",
".",
"Next",
"(",
")",
"\n",
"rootIter",
".",
"Next",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// slowNotify does a complete comparison of the before and after trees in order
// to trigger notifications. This doesn't require any additional state but it
// is very expensive to compute.
|
[
"slowNotify",
"does",
"a",
"complete",
"comparison",
"of",
"the",
"before",
"and",
"after",
"trees",
"in",
"order",
"to",
"trigger",
"notifications",
".",
"This",
"doesn",
"t",
"require",
"any",
"additional",
"state",
"but",
"it",
"is",
"very",
"expensive",
"to",
"compute",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L520-L578
|
143,235 |
hashicorp/go-immutable-radix
|
iradix.go
|
Notify
|
func (t *Txn) Notify() {
if !t.trackMutate {
return
}
// If we've overflowed the tracking state we can't use it in any way and
// need to do a full tree compare.
if t.trackOverflow {
t.slowNotify()
} else {
for ch := range t.trackChannels {
close(ch)
}
}
// Clean up the tracking state so that a re-notify is safe (will trigger
// the else clause above which will be a no-op).
t.trackChannels = nil
t.trackOverflow = false
}
|
go
|
func (t *Txn) Notify() {
if !t.trackMutate {
return
}
// If we've overflowed the tracking state we can't use it in any way and
// need to do a full tree compare.
if t.trackOverflow {
t.slowNotify()
} else {
for ch := range t.trackChannels {
close(ch)
}
}
// Clean up the tracking state so that a re-notify is safe (will trigger
// the else clause above which will be a no-op).
t.trackChannels = nil
t.trackOverflow = false
}
|
[
"func",
"(",
"t",
"*",
"Txn",
")",
"Notify",
"(",
")",
"{",
"if",
"!",
"t",
".",
"trackMutate",
"{",
"return",
"\n",
"}",
"\n\n",
"// If we've overflowed the tracking state we can't use it in any way and",
"// need to do a full tree compare.",
"if",
"t",
".",
"trackOverflow",
"{",
"t",
".",
"slowNotify",
"(",
")",
"\n",
"}",
"else",
"{",
"for",
"ch",
":=",
"range",
"t",
".",
"trackChannels",
"{",
"close",
"(",
"ch",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Clean up the tracking state so that a re-notify is safe (will trigger",
"// the else clause above which will be a no-op).",
"t",
".",
"trackChannels",
"=",
"nil",
"\n",
"t",
".",
"trackOverflow",
"=",
"false",
"\n",
"}"
] |
// Notify is used along with TrackMutate to trigger notifications. This must
// only be done once a transaction is committed via CommitOnly, and it is called
// automatically by Commit.
|
[
"Notify",
"is",
"used",
"along",
"with",
"TrackMutate",
"to",
"trigger",
"notifications",
".",
"This",
"must",
"only",
"be",
"done",
"once",
"a",
"transaction",
"is",
"committed",
"via",
"CommitOnly",
"and",
"it",
"is",
"called",
"automatically",
"by",
"Commit",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L583-L602
|
143,236 |
hashicorp/go-immutable-radix
|
iradix.go
|
Insert
|
func (t *Tree) Insert(k []byte, v interface{}) (*Tree, interface{}, bool) {
txn := t.Txn()
old, ok := txn.Insert(k, v)
return txn.Commit(), old, ok
}
|
go
|
func (t *Tree) Insert(k []byte, v interface{}) (*Tree, interface{}, bool) {
txn := t.Txn()
old, ok := txn.Insert(k, v)
return txn.Commit(), old, ok
}
|
[
"func",
"(",
"t",
"*",
"Tree",
")",
"Insert",
"(",
"k",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"*",
"Tree",
",",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"txn",
":=",
"t",
".",
"Txn",
"(",
")",
"\n",
"old",
",",
"ok",
":=",
"txn",
".",
"Insert",
"(",
"k",
",",
"v",
")",
"\n",
"return",
"txn",
".",
"Commit",
"(",
")",
",",
"old",
",",
"ok",
"\n",
"}"
] |
// Insert is used to add or update a given key. The return provides
// the new tree, previous value and a bool indicating if any was set.
|
[
"Insert",
"is",
"used",
"to",
"add",
"or",
"update",
"a",
"given",
"key",
".",
"The",
"return",
"provides",
"the",
"new",
"tree",
"previous",
"value",
"and",
"a",
"bool",
"indicating",
"if",
"any",
"was",
"set",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L606-L610
|
143,237 |
hashicorp/go-immutable-radix
|
iradix.go
|
Delete
|
func (t *Tree) Delete(k []byte) (*Tree, interface{}, bool) {
txn := t.Txn()
old, ok := txn.Delete(k)
return txn.Commit(), old, ok
}
|
go
|
func (t *Tree) Delete(k []byte) (*Tree, interface{}, bool) {
txn := t.Txn()
old, ok := txn.Delete(k)
return txn.Commit(), old, ok
}
|
[
"func",
"(",
"t",
"*",
"Tree",
")",
"Delete",
"(",
"k",
"[",
"]",
"byte",
")",
"(",
"*",
"Tree",
",",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"txn",
":=",
"t",
".",
"Txn",
"(",
")",
"\n",
"old",
",",
"ok",
":=",
"txn",
".",
"Delete",
"(",
"k",
")",
"\n",
"return",
"txn",
".",
"Commit",
"(",
")",
",",
"old",
",",
"ok",
"\n",
"}"
] |
// Delete is used to delete a given key. Returns the new tree,
// old value if any, and a bool indicating if the key was set.
|
[
"Delete",
"is",
"used",
"to",
"delete",
"a",
"given",
"key",
".",
"Returns",
"the",
"new",
"tree",
"old",
"value",
"if",
"any",
"and",
"a",
"bool",
"indicating",
"if",
"the",
"key",
"was",
"set",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L614-L618
|
143,238 |
hashicorp/go-immutable-radix
|
iradix.go
|
DeletePrefix
|
func (t *Tree) DeletePrefix(k []byte) (*Tree, bool) {
txn := t.Txn()
ok := txn.DeletePrefix(k)
return txn.Commit(), ok
}
|
go
|
func (t *Tree) DeletePrefix(k []byte) (*Tree, bool) {
txn := t.Txn()
ok := txn.DeletePrefix(k)
return txn.Commit(), ok
}
|
[
"func",
"(",
"t",
"*",
"Tree",
")",
"DeletePrefix",
"(",
"k",
"[",
"]",
"byte",
")",
"(",
"*",
"Tree",
",",
"bool",
")",
"{",
"txn",
":=",
"t",
".",
"Txn",
"(",
")",
"\n",
"ok",
":=",
"txn",
".",
"DeletePrefix",
"(",
"k",
")",
"\n",
"return",
"txn",
".",
"Commit",
"(",
")",
",",
"ok",
"\n",
"}"
] |
// DeletePrefix is used to delete all nodes starting with a given prefix. Returns the new tree,
// and a bool indicating if the prefix matched any nodes
|
[
"DeletePrefix",
"is",
"used",
"to",
"delete",
"all",
"nodes",
"starting",
"with",
"a",
"given",
"prefix",
".",
"Returns",
"the",
"new",
"tree",
"and",
"a",
"bool",
"indicating",
"if",
"the",
"prefix",
"matched",
"any",
"nodes"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L622-L626
|
143,239 |
hashicorp/go-immutable-radix
|
iradix.go
|
longestPrefix
|
func longestPrefix(k1, k2 []byte) int {
max := len(k1)
if l := len(k2); l < max {
max = l
}
var i int
for i = 0; i < max; i++ {
if k1[i] != k2[i] {
break
}
}
return i
}
|
go
|
func longestPrefix(k1, k2 []byte) int {
max := len(k1)
if l := len(k2); l < max {
max = l
}
var i int
for i = 0; i < max; i++ {
if k1[i] != k2[i] {
break
}
}
return i
}
|
[
"func",
"longestPrefix",
"(",
"k1",
",",
"k2",
"[",
"]",
"byte",
")",
"int",
"{",
"max",
":=",
"len",
"(",
"k1",
")",
"\n",
"if",
"l",
":=",
"len",
"(",
"k2",
")",
";",
"l",
"<",
"max",
"{",
"max",
"=",
"l",
"\n",
"}",
"\n",
"var",
"i",
"int",
"\n",
"for",
"i",
"=",
"0",
";",
"i",
"<",
"max",
";",
"i",
"++",
"{",
"if",
"k1",
"[",
"i",
"]",
"!=",
"k2",
"[",
"i",
"]",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"i",
"\n",
"}"
] |
// longestPrefix finds the length of the shared prefix
// of two strings
|
[
"longestPrefix",
"finds",
"the",
"length",
"of",
"the",
"shared",
"prefix",
"of",
"two",
"strings"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L642-L654
|
143,240 |
hashicorp/go-immutable-radix
|
iradix.go
|
concat
|
func concat(a, b []byte) []byte {
c := make([]byte, len(a)+len(b))
copy(c, a)
copy(c[len(a):], b)
return c
}
|
go
|
func concat(a, b []byte) []byte {
c := make([]byte, len(a)+len(b))
copy(c, a)
copy(c[len(a):], b)
return c
}
|
[
"func",
"concat",
"(",
"a",
",",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"c",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
")",
"\n",
"copy",
"(",
"c",
",",
"a",
")",
"\n",
"copy",
"(",
"c",
"[",
"len",
"(",
"a",
")",
":",
"]",
",",
"b",
")",
"\n",
"return",
"c",
"\n",
"}"
] |
// concat two byte slices, returning a third new copy
|
[
"concat",
"two",
"byte",
"slices",
"returning",
"a",
"third",
"new",
"copy"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iradix.go#L657-L662
|
143,241 |
hashicorp/go-immutable-radix
|
node.go
|
LongestPrefix
|
func (n *Node) LongestPrefix(k []byte) ([]byte, interface{}, bool) {
var last *leafNode
search := k
for {
// Look for a leaf node
if n.isLeaf() {
last = n.leaf
}
// Check for key exhaution
if len(search) == 0 {
break
}
// Look for an edge
_, n = n.getEdge(search[0])
if n == nil {
break
}
// Consume the search prefix
if bytes.HasPrefix(search, n.prefix) {
search = search[len(n.prefix):]
} else {
break
}
}
if last != nil {
return last.key, last.val, true
}
return nil, nil, false
}
|
go
|
func (n *Node) LongestPrefix(k []byte) ([]byte, interface{}, bool) {
var last *leafNode
search := k
for {
// Look for a leaf node
if n.isLeaf() {
last = n.leaf
}
// Check for key exhaution
if len(search) == 0 {
break
}
// Look for an edge
_, n = n.getEdge(search[0])
if n == nil {
break
}
// Consume the search prefix
if bytes.HasPrefix(search, n.prefix) {
search = search[len(n.prefix):]
} else {
break
}
}
if last != nil {
return last.key, last.val, true
}
return nil, nil, false
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"LongestPrefix",
"(",
"k",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"var",
"last",
"*",
"leafNode",
"\n",
"search",
":=",
"k",
"\n",
"for",
"{",
"// Look for a leaf node",
"if",
"n",
".",
"isLeaf",
"(",
")",
"{",
"last",
"=",
"n",
".",
"leaf",
"\n",
"}",
"\n\n",
"// Check for key exhaution",
"if",
"len",
"(",
"search",
")",
"==",
"0",
"{",
"break",
"\n",
"}",
"\n\n",
"// Look for an edge",
"_",
",",
"n",
"=",
"n",
".",
"getEdge",
"(",
"search",
"[",
"0",
"]",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"// Consume the search prefix",
"if",
"bytes",
".",
"HasPrefix",
"(",
"search",
",",
"n",
".",
"prefix",
")",
"{",
"search",
"=",
"search",
"[",
"len",
"(",
"n",
".",
"prefix",
")",
":",
"]",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"last",
"!=",
"nil",
"{",
"return",
"last",
".",
"key",
",",
"last",
".",
"val",
",",
"true",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"false",
"\n",
"}"
] |
// LongestPrefix is like Get, but instead of an
// exact match, it will return the longest prefix match.
|
[
"LongestPrefix",
"is",
"like",
"Get",
"but",
"instead",
"of",
"an",
"exact",
"match",
"it",
"will",
"return",
"the",
"longest",
"prefix",
"match",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/node.go#L132-L163
|
143,242 |
hashicorp/go-immutable-radix
|
node.go
|
Minimum
|
func (n *Node) Minimum() ([]byte, interface{}, bool) {
for {
if n.isLeaf() {
return n.leaf.key, n.leaf.val, true
}
if len(n.edges) > 0 {
n = n.edges[0].node
} else {
break
}
}
return nil, nil, false
}
|
go
|
func (n *Node) Minimum() ([]byte, interface{}, bool) {
for {
if n.isLeaf() {
return n.leaf.key, n.leaf.val, true
}
if len(n.edges) > 0 {
n = n.edges[0].node
} else {
break
}
}
return nil, nil, false
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"Minimum",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"for",
"{",
"if",
"n",
".",
"isLeaf",
"(",
")",
"{",
"return",
"n",
".",
"leaf",
".",
"key",
",",
"n",
".",
"leaf",
".",
"val",
",",
"true",
"\n",
"}",
"\n",
"if",
"len",
"(",
"n",
".",
"edges",
")",
">",
"0",
"{",
"n",
"=",
"n",
".",
"edges",
"[",
"0",
"]",
".",
"node",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"false",
"\n",
"}"
] |
// Minimum is used to return the minimum value in the tree
|
[
"Minimum",
"is",
"used",
"to",
"return",
"the",
"minimum",
"value",
"in",
"the",
"tree"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/node.go#L166-L178
|
143,243 |
hashicorp/go-immutable-radix
|
node.go
|
rawIterator
|
func (n *Node) rawIterator() *rawIterator {
iter := &rawIterator{node: n}
iter.Next()
return iter
}
|
go
|
func (n *Node) rawIterator() *rawIterator {
iter := &rawIterator{node: n}
iter.Next()
return iter
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"rawIterator",
"(",
")",
"*",
"rawIterator",
"{",
"iter",
":=",
"&",
"rawIterator",
"{",
"node",
":",
"n",
"}",
"\n",
"iter",
".",
"Next",
"(",
")",
"\n",
"return",
"iter",
"\n",
"}"
] |
// rawIterator is used to return a raw iterator at the given node to walk the
// tree.
|
[
"rawIterator",
"is",
"used",
"to",
"return",
"a",
"raw",
"iterator",
"at",
"the",
"given",
"node",
"to",
"walk",
"the",
"tree",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/node.go#L204-L208
|
143,244 |
hashicorp/go-immutable-radix
|
node.go
|
WalkPrefix
|
func (n *Node) WalkPrefix(prefix []byte, fn WalkFn) {
search := prefix
for {
// Check for key exhaution
if len(search) == 0 {
recursiveWalk(n, fn)
return
}
// Look for an edge
_, n = n.getEdge(search[0])
if n == nil {
break
}
// Consume the search prefix
if bytes.HasPrefix(search, n.prefix) {
search = search[len(n.prefix):]
} else if bytes.HasPrefix(n.prefix, search) {
// Child may be under our search prefix
recursiveWalk(n, fn)
return
} else {
break
}
}
}
|
go
|
func (n *Node) WalkPrefix(prefix []byte, fn WalkFn) {
search := prefix
for {
// Check for key exhaution
if len(search) == 0 {
recursiveWalk(n, fn)
return
}
// Look for an edge
_, n = n.getEdge(search[0])
if n == nil {
break
}
// Consume the search prefix
if bytes.HasPrefix(search, n.prefix) {
search = search[len(n.prefix):]
} else if bytes.HasPrefix(n.prefix, search) {
// Child may be under our search prefix
recursiveWalk(n, fn)
return
} else {
break
}
}
}
|
[
"func",
"(",
"n",
"*",
"Node",
")",
"WalkPrefix",
"(",
"prefix",
"[",
"]",
"byte",
",",
"fn",
"WalkFn",
")",
"{",
"search",
":=",
"prefix",
"\n",
"for",
"{",
"// Check for key exhaution",
"if",
"len",
"(",
"search",
")",
"==",
"0",
"{",
"recursiveWalk",
"(",
"n",
",",
"fn",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Look for an edge",
"_",
",",
"n",
"=",
"n",
".",
"getEdge",
"(",
"search",
"[",
"0",
"]",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n\n",
"// Consume the search prefix",
"if",
"bytes",
".",
"HasPrefix",
"(",
"search",
",",
"n",
".",
"prefix",
")",
"{",
"search",
"=",
"search",
"[",
"len",
"(",
"n",
".",
"prefix",
")",
":",
"]",
"\n\n",
"}",
"else",
"if",
"bytes",
".",
"HasPrefix",
"(",
"n",
".",
"prefix",
",",
"search",
")",
"{",
"// Child may be under our search prefix",
"recursiveWalk",
"(",
"n",
",",
"fn",
")",
"\n",
"return",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// WalkPrefix is used to walk the tree under a prefix
|
[
"WalkPrefix",
"is",
"used",
"to",
"walk",
"the",
"tree",
"under",
"a",
"prefix"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/node.go#L216-L243
|
143,245 |
hashicorp/go-immutable-radix
|
iter.go
|
SeekPrefixWatch
|
func (i *Iterator) SeekPrefixWatch(prefix []byte) (watch <-chan struct{}) {
// Wipe the stack
i.stack = nil
n := i.node
watch = n.mutateCh
search := prefix
for {
// Check for key exhaution
if len(search) == 0 {
i.node = n
return
}
// Look for an edge
_, n = n.getEdge(search[0])
if n == nil {
i.node = nil
return
}
// Update to the finest granularity as the search makes progress
watch = n.mutateCh
// Consume the search prefix
if bytes.HasPrefix(search, n.prefix) {
search = search[len(n.prefix):]
} else if bytes.HasPrefix(n.prefix, search) {
i.node = n
return
} else {
i.node = nil
return
}
}
}
|
go
|
func (i *Iterator) SeekPrefixWatch(prefix []byte) (watch <-chan struct{}) {
// Wipe the stack
i.stack = nil
n := i.node
watch = n.mutateCh
search := prefix
for {
// Check for key exhaution
if len(search) == 0 {
i.node = n
return
}
// Look for an edge
_, n = n.getEdge(search[0])
if n == nil {
i.node = nil
return
}
// Update to the finest granularity as the search makes progress
watch = n.mutateCh
// Consume the search prefix
if bytes.HasPrefix(search, n.prefix) {
search = search[len(n.prefix):]
} else if bytes.HasPrefix(n.prefix, search) {
i.node = n
return
} else {
i.node = nil
return
}
}
}
|
[
"func",
"(",
"i",
"*",
"Iterator",
")",
"SeekPrefixWatch",
"(",
"prefix",
"[",
"]",
"byte",
")",
"(",
"watch",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"// Wipe the stack",
"i",
".",
"stack",
"=",
"nil",
"\n",
"n",
":=",
"i",
".",
"node",
"\n",
"watch",
"=",
"n",
".",
"mutateCh",
"\n",
"search",
":=",
"prefix",
"\n",
"for",
"{",
"// Check for key exhaution",
"if",
"len",
"(",
"search",
")",
"==",
"0",
"{",
"i",
".",
"node",
"=",
"n",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Look for an edge",
"_",
",",
"n",
"=",
"n",
".",
"getEdge",
"(",
"search",
"[",
"0",
"]",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"i",
".",
"node",
"=",
"nil",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Update to the finest granularity as the search makes progress",
"watch",
"=",
"n",
".",
"mutateCh",
"\n\n",
"// Consume the search prefix",
"if",
"bytes",
".",
"HasPrefix",
"(",
"search",
",",
"n",
".",
"prefix",
")",
"{",
"search",
"=",
"search",
"[",
"len",
"(",
"n",
".",
"prefix",
")",
":",
"]",
"\n\n",
"}",
"else",
"if",
"bytes",
".",
"HasPrefix",
"(",
"n",
".",
"prefix",
",",
"search",
")",
"{",
"i",
".",
"node",
"=",
"n",
"\n",
"return",
"\n",
"}",
"else",
"{",
"i",
".",
"node",
"=",
"nil",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// SeekPrefixWatch is used to seek the iterator to a given prefix
// and returns the watch channel of the finest granularity
|
[
"SeekPrefixWatch",
"is",
"used",
"to",
"seek",
"the",
"iterator",
"to",
"a",
"given",
"prefix",
"and",
"returns",
"the",
"watch",
"channel",
"of",
"the",
"finest",
"granularity"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iter.go#L14-L49
|
143,246 |
hashicorp/go-immutable-radix
|
iter.go
|
Next
|
func (i *Iterator) Next() ([]byte, interface{}, bool) {
// Initialize our stack if needed
if i.stack == nil && i.node != nil {
i.stack = []edges{
edges{
edge{node: i.node},
},
}
}
for len(i.stack) > 0 {
// Inspect the last element of the stack
n := len(i.stack)
last := i.stack[n-1]
elem := last[0].node
// Update the stack
if len(last) > 1 {
i.stack[n-1] = last[1:]
} else {
i.stack = i.stack[:n-1]
}
// Push the edges onto the frontier
if len(elem.edges) > 0 {
i.stack = append(i.stack, elem.edges)
}
// Return the leaf values if any
if elem.leaf != nil {
return elem.leaf.key, elem.leaf.val, true
}
}
return nil, nil, false
}
|
go
|
func (i *Iterator) Next() ([]byte, interface{}, bool) {
// Initialize our stack if needed
if i.stack == nil && i.node != nil {
i.stack = []edges{
edges{
edge{node: i.node},
},
}
}
for len(i.stack) > 0 {
// Inspect the last element of the stack
n := len(i.stack)
last := i.stack[n-1]
elem := last[0].node
// Update the stack
if len(last) > 1 {
i.stack[n-1] = last[1:]
} else {
i.stack = i.stack[:n-1]
}
// Push the edges onto the frontier
if len(elem.edges) > 0 {
i.stack = append(i.stack, elem.edges)
}
// Return the leaf values if any
if elem.leaf != nil {
return elem.leaf.key, elem.leaf.val, true
}
}
return nil, nil, false
}
|
[
"func",
"(",
"i",
"*",
"Iterator",
")",
"Next",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"// Initialize our stack if needed",
"if",
"i",
".",
"stack",
"==",
"nil",
"&&",
"i",
".",
"node",
"!=",
"nil",
"{",
"i",
".",
"stack",
"=",
"[",
"]",
"edges",
"{",
"edges",
"{",
"edge",
"{",
"node",
":",
"i",
".",
"node",
"}",
",",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"for",
"len",
"(",
"i",
".",
"stack",
")",
">",
"0",
"{",
"// Inspect the last element of the stack",
"n",
":=",
"len",
"(",
"i",
".",
"stack",
")",
"\n",
"last",
":=",
"i",
".",
"stack",
"[",
"n",
"-",
"1",
"]",
"\n",
"elem",
":=",
"last",
"[",
"0",
"]",
".",
"node",
"\n\n",
"// Update the stack",
"if",
"len",
"(",
"last",
")",
">",
"1",
"{",
"i",
".",
"stack",
"[",
"n",
"-",
"1",
"]",
"=",
"last",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"i",
".",
"stack",
"=",
"i",
".",
"stack",
"[",
":",
"n",
"-",
"1",
"]",
"\n",
"}",
"\n\n",
"// Push the edges onto the frontier",
"if",
"len",
"(",
"elem",
".",
"edges",
")",
">",
"0",
"{",
"i",
".",
"stack",
"=",
"append",
"(",
"i",
".",
"stack",
",",
"elem",
".",
"edges",
")",
"\n",
"}",
"\n\n",
"// Return the leaf values if any",
"if",
"elem",
".",
"leaf",
"!=",
"nil",
"{",
"return",
"elem",
".",
"leaf",
".",
"key",
",",
"elem",
".",
"leaf",
".",
"val",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"false",
"\n",
"}"
] |
// Next returns the next node in order
|
[
"Next",
"returns",
"the",
"next",
"node",
"in",
"order"
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/iter.go#L57-L91
|
143,247 |
hashicorp/go-immutable-radix
|
raw_iter.go
|
Next
|
func (i *rawIterator) Next() {
// Initialize our stack if needed.
if i.stack == nil && i.node != nil {
i.stack = []rawStackEntry{
rawStackEntry{
edges: edges{
edge{node: i.node},
},
},
}
}
for len(i.stack) > 0 {
// Inspect the last element of the stack.
n := len(i.stack)
last := i.stack[n-1]
elem := last.edges[0].node
// Update the stack.
if len(last.edges) > 1 {
i.stack[n-1].edges = last.edges[1:]
} else {
i.stack = i.stack[:n-1]
}
// Push the edges onto the frontier.
if len(elem.edges) > 0 {
path := last.path + string(elem.prefix)
i.stack = append(i.stack, rawStackEntry{path, elem.edges})
}
i.pos = elem
i.path = last.path + string(elem.prefix)
return
}
i.pos = nil
i.path = ""
}
|
go
|
func (i *rawIterator) Next() {
// Initialize our stack if needed.
if i.stack == nil && i.node != nil {
i.stack = []rawStackEntry{
rawStackEntry{
edges: edges{
edge{node: i.node},
},
},
}
}
for len(i.stack) > 0 {
// Inspect the last element of the stack.
n := len(i.stack)
last := i.stack[n-1]
elem := last.edges[0].node
// Update the stack.
if len(last.edges) > 1 {
i.stack[n-1].edges = last.edges[1:]
} else {
i.stack = i.stack[:n-1]
}
// Push the edges onto the frontier.
if len(elem.edges) > 0 {
path := last.path + string(elem.prefix)
i.stack = append(i.stack, rawStackEntry{path, elem.edges})
}
i.pos = elem
i.path = last.path + string(elem.prefix)
return
}
i.pos = nil
i.path = ""
}
|
[
"func",
"(",
"i",
"*",
"rawIterator",
")",
"Next",
"(",
")",
"{",
"// Initialize our stack if needed.",
"if",
"i",
".",
"stack",
"==",
"nil",
"&&",
"i",
".",
"node",
"!=",
"nil",
"{",
"i",
".",
"stack",
"=",
"[",
"]",
"rawStackEntry",
"{",
"rawStackEntry",
"{",
"edges",
":",
"edges",
"{",
"edge",
"{",
"node",
":",
"i",
".",
"node",
"}",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"for",
"len",
"(",
"i",
".",
"stack",
")",
">",
"0",
"{",
"// Inspect the last element of the stack.",
"n",
":=",
"len",
"(",
"i",
".",
"stack",
")",
"\n",
"last",
":=",
"i",
".",
"stack",
"[",
"n",
"-",
"1",
"]",
"\n",
"elem",
":=",
"last",
".",
"edges",
"[",
"0",
"]",
".",
"node",
"\n\n",
"// Update the stack.",
"if",
"len",
"(",
"last",
".",
"edges",
")",
">",
"1",
"{",
"i",
".",
"stack",
"[",
"n",
"-",
"1",
"]",
".",
"edges",
"=",
"last",
".",
"edges",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"i",
".",
"stack",
"=",
"i",
".",
"stack",
"[",
":",
"n",
"-",
"1",
"]",
"\n",
"}",
"\n\n",
"// Push the edges onto the frontier.",
"if",
"len",
"(",
"elem",
".",
"edges",
")",
">",
"0",
"{",
"path",
":=",
"last",
".",
"path",
"+",
"string",
"(",
"elem",
".",
"prefix",
")",
"\n",
"i",
".",
"stack",
"=",
"append",
"(",
"i",
".",
"stack",
",",
"rawStackEntry",
"{",
"path",
",",
"elem",
".",
"edges",
"}",
")",
"\n",
"}",
"\n\n",
"i",
".",
"pos",
"=",
"elem",
"\n",
"i",
".",
"path",
"=",
"last",
".",
"path",
"+",
"string",
"(",
"elem",
".",
"prefix",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"i",
".",
"pos",
"=",
"nil",
"\n",
"i",
".",
"path",
"=",
"\"",
"\"",
"\n",
"}"
] |
// Next advances the iterator to the next node.
|
[
"Next",
"advances",
"the",
"iterator",
"to",
"the",
"next",
"node",
"."
] |
27df80928bb34bb1b0d6d0e01b9e679902e7a6b5
|
https://github.com/hashicorp/go-immutable-radix/blob/27df80928bb34bb1b0d6d0e01b9e679902e7a6b5/raw_iter.go#L40-L78
|
143,248 |
lestrrat-go/jwx
|
jwe/serializer.go
|
Serialize
|
func (s CompactSerialize) Serialize(m *Message) ([]byte, error) {
if len(m.Recipients) != 1 {
return nil, errors.New("wrong number of recipients for compact serialization")
}
recipient := m.Recipients[0]
// The protected header must be a merge between the message-wide
// protected header AND the recipient header
hcopy := NewHeader()
// There's something wrong if m.ProtectedHeader.Header is nil, but
// it could happen
if m.ProtectedHeader == nil || m.ProtectedHeader.Header == nil {
return nil, errors.New("invalid protected header")
}
err := hcopy.Copy(m.ProtectedHeader.Header)
if err != nil {
return nil, errors.Wrap(err, "failed to copy protected header")
}
hcopy, err = hcopy.Merge(m.UnprotectedHeader)
if err != nil {
return nil, errors.Wrap(err, "failed to merge unprotected header")
}
hcopy, err = hcopy.Merge(recipient.Header)
if err != nil {
return nil, errors.Wrap(err, "failed to merge recipient header")
}
protected, err := EncodedHeader{Header: hcopy}.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode header")
}
encryptedKey, err := recipient.EncryptedKey.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode encryption key")
}
iv, err := m.InitializationVector.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode iv")
}
cipher, err := m.CipherText.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode cipher text")
}
tag, err := m.Tag.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode tag")
}
buf := append(append(append(append(append(append(append(append(protected, '.'), encryptedKey...), '.'), iv...), '.'), cipher...), '.'), tag...)
return buf, nil
}
|
go
|
func (s CompactSerialize) Serialize(m *Message) ([]byte, error) {
if len(m.Recipients) != 1 {
return nil, errors.New("wrong number of recipients for compact serialization")
}
recipient := m.Recipients[0]
// The protected header must be a merge between the message-wide
// protected header AND the recipient header
hcopy := NewHeader()
// There's something wrong if m.ProtectedHeader.Header is nil, but
// it could happen
if m.ProtectedHeader == nil || m.ProtectedHeader.Header == nil {
return nil, errors.New("invalid protected header")
}
err := hcopy.Copy(m.ProtectedHeader.Header)
if err != nil {
return nil, errors.Wrap(err, "failed to copy protected header")
}
hcopy, err = hcopy.Merge(m.UnprotectedHeader)
if err != nil {
return nil, errors.Wrap(err, "failed to merge unprotected header")
}
hcopy, err = hcopy.Merge(recipient.Header)
if err != nil {
return nil, errors.Wrap(err, "failed to merge recipient header")
}
protected, err := EncodedHeader{Header: hcopy}.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode header")
}
encryptedKey, err := recipient.EncryptedKey.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode encryption key")
}
iv, err := m.InitializationVector.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode iv")
}
cipher, err := m.CipherText.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode cipher text")
}
tag, err := m.Tag.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode tag")
}
buf := append(append(append(append(append(append(append(append(protected, '.'), encryptedKey...), '.'), iv...), '.'), cipher...), '.'), tag...)
return buf, nil
}
|
[
"func",
"(",
"s",
"CompactSerialize",
")",
"Serialize",
"(",
"m",
"*",
"Message",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"m",
".",
"Recipients",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"recipient",
":=",
"m",
".",
"Recipients",
"[",
"0",
"]",
"\n\n",
"// The protected header must be a merge between the message-wide",
"// protected header AND the recipient header",
"hcopy",
":=",
"NewHeader",
"(",
")",
"\n",
"// There's something wrong if m.ProtectedHeader.Header is nil, but",
"// it could happen",
"if",
"m",
".",
"ProtectedHeader",
"==",
"nil",
"||",
"m",
".",
"ProtectedHeader",
".",
"Header",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"hcopy",
".",
"Copy",
"(",
"m",
".",
"ProtectedHeader",
".",
"Header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"hcopy",
",",
"err",
"=",
"hcopy",
".",
"Merge",
"(",
"m",
".",
"UnprotectedHeader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"hcopy",
",",
"err",
"=",
"hcopy",
".",
"Merge",
"(",
"recipient",
".",
"Header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"protected",
",",
"err",
":=",
"EncodedHeader",
"{",
"Header",
":",
"hcopy",
"}",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"encryptedKey",
",",
"err",
":=",
"recipient",
".",
"EncryptedKey",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"iv",
",",
"err",
":=",
"m",
".",
"InitializationVector",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cipher",
",",
"err",
":=",
"m",
".",
"CipherText",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tag",
",",
"err",
":=",
"m",
".",
"Tag",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"buf",
":=",
"append",
"(",
"append",
"(",
"append",
"(",
"append",
"(",
"append",
"(",
"append",
"(",
"append",
"(",
"append",
"(",
"protected",
",",
"'.'",
")",
",",
"encryptedKey",
"...",
")",
",",
"'.'",
")",
",",
"iv",
"...",
")",
",",
"'.'",
")",
",",
"cipher",
"...",
")",
",",
"'.'",
")",
",",
"tag",
"...",
")",
"\n",
"return",
"buf",
",",
"nil",
"\n",
"}"
] |
// Serialize converts the message into a JWE compact serialize format byte buffer
|
[
"Serialize",
"converts",
"the",
"message",
"into",
"a",
"JWE",
"compact",
"serialize",
"format",
"byte",
"buffer"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/serializer.go#L10-L65
|
143,249 |
lestrrat-go/jwx
|
jwe/serializer.go
|
Serialize
|
func (s JSONSerialize) Serialize(m *Message) ([]byte, error) {
if s.Pretty {
return json.MarshalIndent(m, "", " ")
}
return json.Marshal(m)
}
|
go
|
func (s JSONSerialize) Serialize(m *Message) ([]byte, error) {
if s.Pretty {
return json.MarshalIndent(m, "", " ")
}
return json.Marshal(m)
}
|
[
"func",
"(",
"s",
"JSONSerialize",
")",
"Serialize",
"(",
"m",
"*",
"Message",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"s",
".",
"Pretty",
"{",
"return",
"json",
".",
"MarshalIndent",
"(",
"m",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"m",
")",
"\n",
"}"
] |
// Serialize converts the message into a JWE JSON serialize format byte buffer
|
[
"Serialize",
"converts",
"the",
"message",
"into",
"a",
"JWE",
"JSON",
"serialize",
"format",
"byte",
"buffer"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/serializer.go#L68-L73
|
143,250 |
lestrrat-go/jwx
|
jwe/aescbc/aescbc.go
|
Seal
|
func (c AesCbcHmac) Seal(dst, nonce, plaintext, data []byte) []byte {
ctlen := len(plaintext)
ciphertext := make([]byte, ctlen+c.Overhead())[:ctlen]
copy(ciphertext, plaintext)
ciphertext = padbuf.PadBuffer(ciphertext).Pad(c.blockCipher.BlockSize())
cbc := cipher.NewCBCEncrypter(c.blockCipher, nonce)
cbc.CryptBlocks(ciphertext, ciphertext)
authtag := c.ComputeAuthTag(data, nonce, ciphertext)
retlen := len(dst) + len(ciphertext) + len(authtag)
ret := ensureSize(dst, retlen)
out := ret[len(dst):]
n := copy(out, ciphertext)
n += copy(out[n:], authtag)
if debug.Enabled {
debug.Printf("Seal: ciphertext = %x (%d)\n", ciphertext, len(ciphertext))
debug.Printf("Seal: authtag = %x (%d)\n", authtag, len(authtag))
debug.Printf("Seal: ret = %x (%d)\n", ret, len(ret))
}
return ret
}
|
go
|
func (c AesCbcHmac) Seal(dst, nonce, plaintext, data []byte) []byte {
ctlen := len(plaintext)
ciphertext := make([]byte, ctlen+c.Overhead())[:ctlen]
copy(ciphertext, plaintext)
ciphertext = padbuf.PadBuffer(ciphertext).Pad(c.blockCipher.BlockSize())
cbc := cipher.NewCBCEncrypter(c.blockCipher, nonce)
cbc.CryptBlocks(ciphertext, ciphertext)
authtag := c.ComputeAuthTag(data, nonce, ciphertext)
retlen := len(dst) + len(ciphertext) + len(authtag)
ret := ensureSize(dst, retlen)
out := ret[len(dst):]
n := copy(out, ciphertext)
n += copy(out[n:], authtag)
if debug.Enabled {
debug.Printf("Seal: ciphertext = %x (%d)\n", ciphertext, len(ciphertext))
debug.Printf("Seal: authtag = %x (%d)\n", authtag, len(authtag))
debug.Printf("Seal: ret = %x (%d)\n", ret, len(ret))
}
return ret
}
|
[
"func",
"(",
"c",
"AesCbcHmac",
")",
"Seal",
"(",
"dst",
",",
"nonce",
",",
"plaintext",
",",
"data",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"ctlen",
":=",
"len",
"(",
"plaintext",
")",
"\n",
"ciphertext",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"ctlen",
"+",
"c",
".",
"Overhead",
"(",
")",
")",
"[",
":",
"ctlen",
"]",
"\n",
"copy",
"(",
"ciphertext",
",",
"plaintext",
")",
"\n",
"ciphertext",
"=",
"padbuf",
".",
"PadBuffer",
"(",
"ciphertext",
")",
".",
"Pad",
"(",
"c",
".",
"blockCipher",
".",
"BlockSize",
"(",
")",
")",
"\n\n",
"cbc",
":=",
"cipher",
".",
"NewCBCEncrypter",
"(",
"c",
".",
"blockCipher",
",",
"nonce",
")",
"\n",
"cbc",
".",
"CryptBlocks",
"(",
"ciphertext",
",",
"ciphertext",
")",
"\n\n",
"authtag",
":=",
"c",
".",
"ComputeAuthTag",
"(",
"data",
",",
"nonce",
",",
"ciphertext",
")",
"\n\n",
"retlen",
":=",
"len",
"(",
"dst",
")",
"+",
"len",
"(",
"ciphertext",
")",
"+",
"len",
"(",
"authtag",
")",
"\n\n",
"ret",
":=",
"ensureSize",
"(",
"dst",
",",
"retlen",
")",
"\n",
"out",
":=",
"ret",
"[",
"len",
"(",
"dst",
")",
":",
"]",
"\n",
"n",
":=",
"copy",
"(",
"out",
",",
"ciphertext",
")",
"\n",
"n",
"+=",
"copy",
"(",
"out",
"[",
"n",
":",
"]",
",",
"authtag",
")",
"\n\n",
"if",
"debug",
".",
"Enabled",
"{",
"debug",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"ciphertext",
",",
"len",
"(",
"ciphertext",
")",
")",
"\n",
"debug",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"authtag",
",",
"len",
"(",
"authtag",
")",
")",
"\n",
"debug",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"ret",
",",
"len",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Seal fulfills the crypto.AEAD interface
|
[
"Seal",
"fulfills",
"the",
"crypto",
".",
"AEAD",
"interface"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/aescbc/aescbc.go#L119-L143
|
143,251 |
lestrrat-go/jwx
|
jwe/aescbc/aescbc.go
|
Open
|
func (c AesCbcHmac) Open(dst, nonce, ciphertext, data []byte) ([]byte, error) {
if len(ciphertext) < c.keysize {
return nil, errors.New("invalid ciphertext (too short)")
}
tagOffset := len(ciphertext) - c.tagsize
if tagOffset%c.blockCipher.BlockSize() != 0 {
return nil, fmt.Errorf(
"invalid ciphertext (invalid length: %d %% %d != 0)",
tagOffset,
c.blockCipher.BlockSize(),
)
}
tag := ciphertext[tagOffset:]
ciphertext = ciphertext[:tagOffset]
expectedTag := c.ComputeAuthTag(data, nonce, ciphertext)
if subtle.ConstantTimeCompare(expectedTag, tag) != 1 {
if debug.Enabled {
debug.Printf("provided tag = %x\n", tag)
debug.Printf("expected tag = %x\n", expectedTag)
}
return nil, errors.New("invalid ciphertext (tag mismatch)")
}
cbc := cipher.NewCBCDecrypter(c.blockCipher, nonce)
buf := make([]byte, tagOffset)
cbc.CryptBlocks(buf, ciphertext)
plaintext, err := padbuf.PadBuffer(buf).Unpad(c.blockCipher.BlockSize())
if err != nil {
return nil, errors.Wrap(err, `failed to generate plaintext from decrypted blocks`)
}
ret := ensureSize(dst, len(plaintext))
out := ret[len(dst):]
copy(out, plaintext)
return ret, nil
}
|
go
|
func (c AesCbcHmac) Open(dst, nonce, ciphertext, data []byte) ([]byte, error) {
if len(ciphertext) < c.keysize {
return nil, errors.New("invalid ciphertext (too short)")
}
tagOffset := len(ciphertext) - c.tagsize
if tagOffset%c.blockCipher.BlockSize() != 0 {
return nil, fmt.Errorf(
"invalid ciphertext (invalid length: %d %% %d != 0)",
tagOffset,
c.blockCipher.BlockSize(),
)
}
tag := ciphertext[tagOffset:]
ciphertext = ciphertext[:tagOffset]
expectedTag := c.ComputeAuthTag(data, nonce, ciphertext)
if subtle.ConstantTimeCompare(expectedTag, tag) != 1 {
if debug.Enabled {
debug.Printf("provided tag = %x\n", tag)
debug.Printf("expected tag = %x\n", expectedTag)
}
return nil, errors.New("invalid ciphertext (tag mismatch)")
}
cbc := cipher.NewCBCDecrypter(c.blockCipher, nonce)
buf := make([]byte, tagOffset)
cbc.CryptBlocks(buf, ciphertext)
plaintext, err := padbuf.PadBuffer(buf).Unpad(c.blockCipher.BlockSize())
if err != nil {
return nil, errors.Wrap(err, `failed to generate plaintext from decrypted blocks`)
}
ret := ensureSize(dst, len(plaintext))
out := ret[len(dst):]
copy(out, plaintext)
return ret, nil
}
|
[
"func",
"(",
"c",
"AesCbcHmac",
")",
"Open",
"(",
"dst",
",",
"nonce",
",",
"ciphertext",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"ciphertext",
")",
"<",
"c",
".",
"keysize",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"tagOffset",
":=",
"len",
"(",
"ciphertext",
")",
"-",
"c",
".",
"tagsize",
"\n",
"if",
"tagOffset",
"%",
"c",
".",
"blockCipher",
".",
"BlockSize",
"(",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"tagOffset",
",",
"c",
".",
"blockCipher",
".",
"BlockSize",
"(",
")",
",",
")",
"\n",
"}",
"\n",
"tag",
":=",
"ciphertext",
"[",
"tagOffset",
":",
"]",
"\n",
"ciphertext",
"=",
"ciphertext",
"[",
":",
"tagOffset",
"]",
"\n\n",
"expectedTag",
":=",
"c",
".",
"ComputeAuthTag",
"(",
"data",
",",
"nonce",
",",
"ciphertext",
")",
"\n",
"if",
"subtle",
".",
"ConstantTimeCompare",
"(",
"expectedTag",
",",
"tag",
")",
"!=",
"1",
"{",
"if",
"debug",
".",
"Enabled",
"{",
"debug",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"tag",
")",
"\n",
"debug",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"expectedTag",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cbc",
":=",
"cipher",
".",
"NewCBCDecrypter",
"(",
"c",
".",
"blockCipher",
",",
"nonce",
")",
"\n",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"tagOffset",
")",
"\n",
"cbc",
".",
"CryptBlocks",
"(",
"buf",
",",
"ciphertext",
")",
"\n\n",
"plaintext",
",",
"err",
":=",
"padbuf",
".",
"PadBuffer",
"(",
"buf",
")",
".",
"Unpad",
"(",
"c",
".",
"blockCipher",
".",
"BlockSize",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to generate plaintext from decrypted blocks`",
")",
"\n",
"}",
"\n",
"ret",
":=",
"ensureSize",
"(",
"dst",
",",
"len",
"(",
"plaintext",
")",
")",
"\n",
"out",
":=",
"ret",
"[",
"len",
"(",
"dst",
")",
":",
"]",
"\n",
"copy",
"(",
"out",
",",
"plaintext",
")",
"\n",
"return",
"ret",
",",
"nil",
"\n",
"}"
] |
// Open fulfills the crypto.AEAD interface
|
[
"Open",
"fulfills",
"the",
"crypto",
".",
"AEAD",
"interface"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/aescbc/aescbc.go#L146-L183
|
143,252 |
lestrrat-go/jwx
|
jwk/headers_gen.go
|
PopulateMap
|
func (h StandardHeaders) PopulateMap(m map[string]interface{}) error {
for k, v := range h.privateParams {
m[k] = v
}
if v, ok := h.Get(AlgorithmKey); ok {
m[AlgorithmKey] = v
}
if v, ok := h.Get(KeyIDKey); ok {
m[KeyIDKey] = v
}
if v, ok := h.Get(KeyTypeKey); ok {
m[KeyTypeKey] = v
}
if v, ok := h.Get(KeyUsageKey); ok {
m[KeyUsageKey] = v
}
if v, ok := h.Get(KeyOpsKey); ok {
m[KeyOpsKey] = v
}
if v, ok := h.Get(X509CertChainKey); ok {
m[X509CertChainKey] = v
}
if v, ok := h.Get(X509CertThumbprintKey); ok {
m[X509CertThumbprintKey] = v
}
if v, ok := h.Get(X509CertThumbprintS256Key); ok {
m[X509CertThumbprintS256Key] = v
}
if v, ok := h.Get(X509URLKey); ok {
m[X509URLKey] = v
}
return nil
}
|
go
|
func (h StandardHeaders) PopulateMap(m map[string]interface{}) error {
for k, v := range h.privateParams {
m[k] = v
}
if v, ok := h.Get(AlgorithmKey); ok {
m[AlgorithmKey] = v
}
if v, ok := h.Get(KeyIDKey); ok {
m[KeyIDKey] = v
}
if v, ok := h.Get(KeyTypeKey); ok {
m[KeyTypeKey] = v
}
if v, ok := h.Get(KeyUsageKey); ok {
m[KeyUsageKey] = v
}
if v, ok := h.Get(KeyOpsKey); ok {
m[KeyOpsKey] = v
}
if v, ok := h.Get(X509CertChainKey); ok {
m[X509CertChainKey] = v
}
if v, ok := h.Get(X509CertThumbprintKey); ok {
m[X509CertThumbprintKey] = v
}
if v, ok := h.Get(X509CertThumbprintS256Key); ok {
m[X509CertThumbprintS256Key] = v
}
if v, ok := h.Get(X509URLKey); ok {
m[X509URLKey] = v
}
return nil
}
|
[
"func",
"(",
"h",
"StandardHeaders",
")",
"PopulateMap",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"h",
".",
"privateParams",
"{",
"m",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"AlgorithmKey",
")",
";",
"ok",
"{",
"m",
"[",
"AlgorithmKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"KeyIDKey",
")",
";",
"ok",
"{",
"m",
"[",
"KeyIDKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"KeyTypeKey",
")",
";",
"ok",
"{",
"m",
"[",
"KeyTypeKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"KeyUsageKey",
")",
";",
"ok",
"{",
"m",
"[",
"KeyUsageKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"KeyOpsKey",
")",
";",
"ok",
"{",
"m",
"[",
"KeyOpsKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"X509CertChainKey",
")",
";",
"ok",
"{",
"m",
"[",
"X509CertChainKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"X509CertThumbprintKey",
")",
";",
"ok",
"{",
"m",
"[",
"X509CertThumbprintKey",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"X509CertThumbprintS256Key",
")",
";",
"ok",
"{",
"m",
"[",
"X509CertThumbprintS256Key",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"v",
",",
"ok",
":=",
"h",
".",
"Get",
"(",
"X509URLKey",
")",
";",
"ok",
"{",
"m",
"[",
"X509URLKey",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// PopulateMap populates a map with appropriate values that represent
// the headers as a JSON object. This exists primarily because JWKs are
// represented as flat objects instead of differentiating the different
// parts of the message in separate sub objects.
|
[
"PopulateMap",
"populates",
"a",
"map",
"with",
"appropriate",
"values",
"that",
"represent",
"the",
"headers",
"as",
"a",
"JSON",
"object",
".",
"This",
"exists",
"primarily",
"because",
"JWKs",
"are",
"represented",
"as",
"flat",
"objects",
"instead",
"of",
"differentiating",
"the",
"different",
"parts",
"of",
"the",
"message",
"in",
"separate",
"sub",
"objects",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwk/headers_gen.go#L254-L287
|
143,253 |
lestrrat-go/jwx
|
jwe/encrypt.go
|
NewMultiEncrypt
|
func NewMultiEncrypt(cc ContentEncrypter, kg KeyGenerator, ke ...KeyEncrypter) *MultiEncrypt {
e := &MultiEncrypt{
ContentEncrypter: cc,
KeyGenerator: kg,
KeyEncrypters: ke,
}
return e
}
|
go
|
func NewMultiEncrypt(cc ContentEncrypter, kg KeyGenerator, ke ...KeyEncrypter) *MultiEncrypt {
e := &MultiEncrypt{
ContentEncrypter: cc,
KeyGenerator: kg,
KeyEncrypters: ke,
}
return e
}
|
[
"func",
"NewMultiEncrypt",
"(",
"cc",
"ContentEncrypter",
",",
"kg",
"KeyGenerator",
",",
"ke",
"...",
"KeyEncrypter",
")",
"*",
"MultiEncrypt",
"{",
"e",
":=",
"&",
"MultiEncrypt",
"{",
"ContentEncrypter",
":",
"cc",
",",
"KeyGenerator",
":",
"kg",
",",
"KeyEncrypters",
":",
"ke",
",",
"}",
"\n",
"return",
"e",
"\n",
"}"
] |
// NewMultiEncrypt creates a new Encrypt struct. The caller is responsible
// for instantiating valid inputs for ContentEncrypter, KeyGenerator,
// and KeyEncrypters.
|
[
"NewMultiEncrypt",
"creates",
"a",
"new",
"Encrypt",
"struct",
".",
"The",
"caller",
"is",
"responsible",
"for",
"instantiating",
"valid",
"inputs",
"for",
"ContentEncrypter",
"KeyGenerator",
"and",
"KeyEncrypters",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/encrypt.go#L11-L18
|
143,254 |
lestrrat-go/jwx
|
jwe/jwe.go
|
Decrypt
|
func Decrypt(buf []byte, alg jwa.KeyEncryptionAlgorithm, key interface{}) ([]byte, error) {
msg, err := Parse(buf)
if err != nil {
return nil, errors.Wrap(err, "failed to parse buffer for Decrypt")
}
return msg.Decrypt(alg, key)
}
|
go
|
func Decrypt(buf []byte, alg jwa.KeyEncryptionAlgorithm, key interface{}) ([]byte, error) {
msg, err := Parse(buf)
if err != nil {
return nil, errors.Wrap(err, "failed to parse buffer for Decrypt")
}
return msg.Decrypt(alg, key)
}
|
[
"func",
"Decrypt",
"(",
"buf",
"[",
"]",
"byte",
",",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"key",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"msg",
",",
"err",
":=",
"Parse",
"(",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"msg",
".",
"Decrypt",
"(",
"alg",
",",
"key",
")",
"\n",
"}"
] |
// Decrypt takes the key encryption algorithm and the corresponding
// key to decrypt the JWE message, and returns the decrypted payload.
// The JWE message can be either compact or full JSON format.
|
[
"Decrypt",
"takes",
"the",
"key",
"encryption",
"algorithm",
"and",
"the",
"corresponding",
"key",
"to",
"decrypt",
"the",
"JWE",
"message",
"and",
"returns",
"the",
"decrypted",
"payload",
".",
"The",
"JWE",
"message",
"can",
"be",
"either",
"compact",
"or",
"full",
"JSON",
"format",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/jwe.go#L103-L110
|
143,255 |
lestrrat-go/jwx
|
jwe/jwe.go
|
Parse
|
func Parse(buf []byte) (*Message, error) {
buf = bytes.TrimSpace(buf)
if len(buf) == 0 {
return nil, errors.New("empty buffer")
}
if buf[0] == '{' {
return parseJSON(buf)
}
return parseCompact(buf)
}
|
go
|
func Parse(buf []byte) (*Message, error) {
buf = bytes.TrimSpace(buf)
if len(buf) == 0 {
return nil, errors.New("empty buffer")
}
if buf[0] == '{' {
return parseJSON(buf)
}
return parseCompact(buf)
}
|
[
"func",
"Parse",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"*",
"Message",
",",
"error",
")",
"{",
"buf",
"=",
"bytes",
".",
"TrimSpace",
"(",
"buf",
")",
"\n",
"if",
"len",
"(",
"buf",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"buf",
"[",
"0",
"]",
"==",
"'{'",
"{",
"return",
"parseJSON",
"(",
"buf",
")",
"\n",
"}",
"\n",
"return",
"parseCompact",
"(",
"buf",
")",
"\n",
"}"
] |
// Parse parses the JWE message into a Message object. The JWE message
// can be either compact or full JSON format.
|
[
"Parse",
"parses",
"the",
"JWE",
"message",
"into",
"a",
"Message",
"object",
".",
"The",
"JWE",
"message",
"can",
"be",
"either",
"compact",
"or",
"full",
"JSON",
"format",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/jwe.go#L114-L124
|
143,256 |
lestrrat-go/jwx
|
jwk/jwk.go
|
New
|
func New(key interface{}) (Key, error) {
if key == nil {
return nil, errors.New(`jwk.New requires a non-nil key`)
}
switch v := key.(type) {
case *rsa.PrivateKey:
return newRSAPrivateKey(v)
case *rsa.PublicKey:
return newRSAPublicKey(v)
case *ecdsa.PrivateKey:
return newECDSAPrivateKey(v)
case *ecdsa.PublicKey:
return newECDSAPublicKey(v)
case []byte:
return newSymmetricKey(v)
default:
return nil, errors.Errorf(`invalid key type %T`, key)
}
}
|
go
|
func New(key interface{}) (Key, error) {
if key == nil {
return nil, errors.New(`jwk.New requires a non-nil key`)
}
switch v := key.(type) {
case *rsa.PrivateKey:
return newRSAPrivateKey(v)
case *rsa.PublicKey:
return newRSAPublicKey(v)
case *ecdsa.PrivateKey:
return newECDSAPrivateKey(v)
case *ecdsa.PublicKey:
return newECDSAPublicKey(v)
case []byte:
return newSymmetricKey(v)
default:
return nil, errors.Errorf(`invalid key type %T`, key)
}
}
|
[
"func",
"New",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"Key",
",",
"error",
")",
"{",
"if",
"key",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"`jwk.New requires a non-nil key`",
")",
"\n",
"}",
"\n\n",
"switch",
"v",
":=",
"key",
".",
"(",
"type",
")",
"{",
"case",
"*",
"rsa",
".",
"PrivateKey",
":",
"return",
"newRSAPrivateKey",
"(",
"v",
")",
"\n",
"case",
"*",
"rsa",
".",
"PublicKey",
":",
"return",
"newRSAPublicKey",
"(",
"v",
")",
"\n",
"case",
"*",
"ecdsa",
".",
"PrivateKey",
":",
"return",
"newECDSAPrivateKey",
"(",
"v",
")",
"\n",
"case",
"*",
"ecdsa",
".",
"PublicKey",
":",
"return",
"newECDSAPublicKey",
"(",
"v",
")",
"\n",
"case",
"[",
"]",
"byte",
":",
"return",
"newSymmetricKey",
"(",
"v",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"`invalid key type %T`",
",",
"key",
")",
"\n",
"}",
"\n",
"}"
] |
// New creates a jwk.Key from the given key.
|
[
"New",
"creates",
"a",
"jwk",
".",
"Key",
"from",
"the",
"given",
"key",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwk/jwk.go#L49-L68
|
143,257 |
lestrrat-go/jwx
|
jwk/jwk.go
|
Fetch
|
func Fetch(urlstring string, options ...Option) (*Set, error) {
u, err := url.Parse(urlstring)
if err != nil {
return nil, errors.Wrap(err, `failed to parse url`)
}
switch u.Scheme {
case "http", "https":
return FetchHTTP(urlstring, options...)
case "file":
f, err := os.Open(u.Path)
if err != nil {
return nil, errors.Wrap(err, `failed to open jwk file`)
}
defer f.Close()
buf, err := ioutil.ReadAll(f)
if err != nil {
return nil, errors.Wrap(err, `failed read content from jwk file`)
}
return ParseBytes(buf)
}
return nil, errors.Errorf(`invalid url scheme %s`, u.Scheme)
}
|
go
|
func Fetch(urlstring string, options ...Option) (*Set, error) {
u, err := url.Parse(urlstring)
if err != nil {
return nil, errors.Wrap(err, `failed to parse url`)
}
switch u.Scheme {
case "http", "https":
return FetchHTTP(urlstring, options...)
case "file":
f, err := os.Open(u.Path)
if err != nil {
return nil, errors.Wrap(err, `failed to open jwk file`)
}
defer f.Close()
buf, err := ioutil.ReadAll(f)
if err != nil {
return nil, errors.Wrap(err, `failed read content from jwk file`)
}
return ParseBytes(buf)
}
return nil, errors.Errorf(`invalid url scheme %s`, u.Scheme)
}
|
[
"func",
"Fetch",
"(",
"urlstring",
"string",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"Set",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"urlstring",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to parse url`",
")",
"\n",
"}",
"\n\n",
"switch",
"u",
".",
"Scheme",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"FetchHTTP",
"(",
"urlstring",
",",
"options",
"...",
")",
"\n",
"case",
"\"",
"\"",
":",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"u",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to open jwk file`",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed read content from jwk file`",
")",
"\n",
"}",
"\n",
"return",
"ParseBytes",
"(",
"buf",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"`invalid url scheme %s`",
",",
"u",
".",
"Scheme",
")",
"\n",
"}"
] |
// Fetch fetches a JWK resource specified by a URL
|
[
"Fetch",
"fetches",
"a",
"JWK",
"resource",
"specified",
"by",
"a",
"URL"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwk/jwk.go#L71-L94
|
143,258 |
lestrrat-go/jwx
|
jwk/jwk.go
|
FetchHTTP
|
func FetchHTTP(jwkurl string, options ...Option) (*Set, error) {
var httpcl HTTPClient = http.DefaultClient
for _, option := range options {
switch option.Name() {
case optkeyHTTPClient:
httpcl = option.Value().(HTTPClient)
}
}
res, err := httpcl.Get(jwkurl)
if err != nil {
return nil, errors.Wrap(err, "failed to fetch remote JWK")
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, errors.New("failed to fetch remote JWK (status != 200)")
}
buf, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, errors.Wrap(err, "failed to read JWK HTTP response body")
}
return ParseBytes(buf)
}
|
go
|
func FetchHTTP(jwkurl string, options ...Option) (*Set, error) {
var httpcl HTTPClient = http.DefaultClient
for _, option := range options {
switch option.Name() {
case optkeyHTTPClient:
httpcl = option.Value().(HTTPClient)
}
}
res, err := httpcl.Get(jwkurl)
if err != nil {
return nil, errors.Wrap(err, "failed to fetch remote JWK")
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, errors.New("failed to fetch remote JWK (status != 200)")
}
buf, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, errors.Wrap(err, "failed to read JWK HTTP response body")
}
return ParseBytes(buf)
}
|
[
"func",
"FetchHTTP",
"(",
"jwkurl",
"string",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"Set",
",",
"error",
")",
"{",
"var",
"httpcl",
"HTTPClient",
"=",
"http",
".",
"DefaultClient",
"\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"switch",
"option",
".",
"Name",
"(",
")",
"{",
"case",
"optkeyHTTPClient",
":",
"httpcl",
"=",
"option",
".",
"Value",
"(",
")",
".",
"(",
"HTTPClient",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"res",
",",
"err",
":=",
"httpcl",
".",
"Get",
"(",
"jwkurl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"defer",
"res",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"res",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"res",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"ParseBytes",
"(",
"buf",
")",
"\n",
"}"
] |
// FetchHTTP fetches the remote JWK and parses its contents
|
[
"FetchHTTP",
"fetches",
"the",
"remote",
"JWK",
"and",
"parses",
"its",
"contents"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwk/jwk.go#L97-L122
|
143,259 |
lestrrat-go/jwx
|
jwk/jwk.go
|
Parse
|
func Parse(in io.Reader) (*Set, error) {
m := make(map[string]interface{})
if err := json.NewDecoder(in).Decode(&m); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal JWK")
}
// We must change what the underlying structure that gets decoded
// out of this JSON is based on parameters within the already parsed
// JSON (m). In order to do this, we have to go through the tedious
// task of parsing the contents of this map :/
if _, ok := m["keys"]; ok {
var set Set
if err := set.ExtractMap(m); err != nil {
return nil, errors.Wrap(err, `failed to extract from map`)
}
return &set, nil
}
k, err := constructKey(m)
if err != nil {
return nil, errors.Wrap(err, `failed to construct key from keys`)
}
return &Set{Keys: []Key{k}}, nil
}
|
go
|
func Parse(in io.Reader) (*Set, error) {
m := make(map[string]interface{})
if err := json.NewDecoder(in).Decode(&m); err != nil {
return nil, errors.Wrap(err, "failed to unmarshal JWK")
}
// We must change what the underlying structure that gets decoded
// out of this JSON is based on parameters within the already parsed
// JSON (m). In order to do this, we have to go through the tedious
// task of parsing the contents of this map :/
if _, ok := m["keys"]; ok {
var set Set
if err := set.ExtractMap(m); err != nil {
return nil, errors.Wrap(err, `failed to extract from map`)
}
return &set, nil
}
k, err := constructKey(m)
if err != nil {
return nil, errors.Wrap(err, `failed to construct key from keys`)
}
return &Set{Keys: []Key{k}}, nil
}
|
[
"func",
"Parse",
"(",
"in",
"io",
".",
"Reader",
")",
"(",
"*",
"Set",
",",
"error",
")",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"in",
")",
".",
"Decode",
"(",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// We must change what the underlying structure that gets decoded",
"// out of this JSON is based on parameters within the already parsed",
"// JSON (m). In order to do this, we have to go through the tedious",
"// task of parsing the contents of this map :/",
"if",
"_",
",",
"ok",
":=",
"m",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"var",
"set",
"Set",
"\n",
"if",
"err",
":=",
"set",
".",
"ExtractMap",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to extract from map`",
")",
"\n",
"}",
"\n",
"return",
"&",
"set",
",",
"nil",
"\n",
"}",
"\n\n",
"k",
",",
"err",
":=",
"constructKey",
"(",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to construct key from keys`",
")",
"\n",
"}",
"\n",
"return",
"&",
"Set",
"{",
"Keys",
":",
"[",
"]",
"Key",
"{",
"k",
"}",
"}",
",",
"nil",
"\n",
"}"
] |
// Parse parses JWK from the incoming io.Reader.
|
[
"Parse",
"parses",
"JWK",
"from",
"the",
"incoming",
"io",
".",
"Reader",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwk/jwk.go#L134-L157
|
143,260 |
lestrrat-go/jwx
|
jws/message.go
|
LookupSignature
|
func (m Message) LookupSignature(kid string) []*Signature {
var sigs []*Signature
for _, sig := range m.signatures {
if hdr := sig.PublicHeaders(); hdr != nil {
hdrKeyId, ok := hdr.Get(KeyIDKey)
if ok && hdrKeyId == kid {
sigs = append(sigs, sig)
continue
}
}
if hdr := sig.ProtectedHeaders(); hdr != nil {
hdrKeyId, ok := hdr.Get(KeyIDKey)
if ok && hdrKeyId == kid {
sigs = append(sigs, sig)
continue
}
}
}
return sigs
}
|
go
|
func (m Message) LookupSignature(kid string) []*Signature {
var sigs []*Signature
for _, sig := range m.signatures {
if hdr := sig.PublicHeaders(); hdr != nil {
hdrKeyId, ok := hdr.Get(KeyIDKey)
if ok && hdrKeyId == kid {
sigs = append(sigs, sig)
continue
}
}
if hdr := sig.ProtectedHeaders(); hdr != nil {
hdrKeyId, ok := hdr.Get(KeyIDKey)
if ok && hdrKeyId == kid {
sigs = append(sigs, sig)
continue
}
}
}
return sigs
}
|
[
"func",
"(",
"m",
"Message",
")",
"LookupSignature",
"(",
"kid",
"string",
")",
"[",
"]",
"*",
"Signature",
"{",
"var",
"sigs",
"[",
"]",
"*",
"Signature",
"\n",
"for",
"_",
",",
"sig",
":=",
"range",
"m",
".",
"signatures",
"{",
"if",
"hdr",
":=",
"sig",
".",
"PublicHeaders",
"(",
")",
";",
"hdr",
"!=",
"nil",
"{",
"hdrKeyId",
",",
"ok",
":=",
"hdr",
".",
"Get",
"(",
"KeyIDKey",
")",
"\n",
"if",
"ok",
"&&",
"hdrKeyId",
"==",
"kid",
"{",
"sigs",
"=",
"append",
"(",
"sigs",
",",
"sig",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"hdr",
":=",
"sig",
".",
"ProtectedHeaders",
"(",
")",
";",
"hdr",
"!=",
"nil",
"{",
"hdrKeyId",
",",
"ok",
":=",
"hdr",
".",
"Get",
"(",
"KeyIDKey",
")",
"\n",
"if",
"ok",
"&&",
"hdrKeyId",
"==",
"kid",
"{",
"sigs",
"=",
"append",
"(",
"sigs",
",",
"sig",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"sigs",
"\n",
"}"
] |
// LookupSignature looks up a particular signature entry using
// the `kid` value
|
[
"LookupSignature",
"looks",
"up",
"a",
"particular",
"signature",
"entry",
"using",
"the",
"kid",
"value"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/message.go#L25-L45
|
143,261 |
lestrrat-go/jwx
|
jwe/interface.go
|
NewErrUnsupportedAlgorithm
|
func NewErrUnsupportedAlgorithm(alg, purpose string) errUnsupportedAlgorithm {
return errUnsupportedAlgorithm{alg: alg, purpose: purpose}
}
|
go
|
func NewErrUnsupportedAlgorithm(alg, purpose string) errUnsupportedAlgorithm {
return errUnsupportedAlgorithm{alg: alg, purpose: purpose}
}
|
[
"func",
"NewErrUnsupportedAlgorithm",
"(",
"alg",
",",
"purpose",
"string",
")",
"errUnsupportedAlgorithm",
"{",
"return",
"errUnsupportedAlgorithm",
"{",
"alg",
":",
"alg",
",",
"purpose",
":",
"purpose",
"}",
"\n",
"}"
] |
// NewErrUnsupportedAlgorithm creates a new UnsupportedAlgorithm error
|
[
"NewErrUnsupportedAlgorithm",
"creates",
"a",
"new",
"UnsupportedAlgorithm",
"error"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/interface.go#L31-L33
|
143,262 |
lestrrat-go/jwx
|
jwe/interface.go
|
Error
|
func (e errUnsupportedAlgorithm) Error() string {
return fmt.Sprintf("unsupported algorithm '%s' for %s", e.alg, e.purpose)
}
|
go
|
func (e errUnsupportedAlgorithm) Error() string {
return fmt.Sprintf("unsupported algorithm '%s' for %s", e.alg, e.purpose)
}
|
[
"func",
"(",
"e",
"errUnsupportedAlgorithm",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"alg",
",",
"e",
".",
"purpose",
")",
"\n",
"}"
] |
// Error returns the string representation of the error
|
[
"Error",
"returns",
"the",
"string",
"representation",
"of",
"the",
"error"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/interface.go#L36-L38
|
143,263 |
lestrrat-go/jwx
|
jws/jws.go
|
Sign
|
func Sign(payload []byte, alg jwa.SignatureAlgorithm, key interface{}, options ...Option) ([]byte, error) {
var hdrs Headers = &StandardHeaders{}
for _, o := range options {
switch o.Name() {
case optkeyHeaders:
hdrs = o.Value().(Headers)
}
}
signer, err := sign.New(alg)
if err != nil {
return nil, errors.Wrap(err, `failed to create signer`)
}
hdrs.Set(AlgorithmKey, signer.Algorithm())
hdrbuf, err := json.Marshal(hdrs)
if err != nil {
return nil, errors.Wrap(err, `failed to marshal headers`)
}
var buf bytes.Buffer
enc := base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(hdrbuf); err != nil {
return nil, errors.Wrap(err, `failed to write headers as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing headers as base64`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(payload); err != nil {
return nil, errors.Wrap(err, `failed to write payload as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing payload as base64`)
}
signature, err := signer.Sign(buf.Bytes(), key)
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(signature); err != nil {
return nil, errors.Wrap(err, `failed to write signature as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing signature as base64`)
}
return buf.Bytes(), nil
}
|
go
|
func Sign(payload []byte, alg jwa.SignatureAlgorithm, key interface{}, options ...Option) ([]byte, error) {
var hdrs Headers = &StandardHeaders{}
for _, o := range options {
switch o.Name() {
case optkeyHeaders:
hdrs = o.Value().(Headers)
}
}
signer, err := sign.New(alg)
if err != nil {
return nil, errors.Wrap(err, `failed to create signer`)
}
hdrs.Set(AlgorithmKey, signer.Algorithm())
hdrbuf, err := json.Marshal(hdrs)
if err != nil {
return nil, errors.Wrap(err, `failed to marshal headers`)
}
var buf bytes.Buffer
enc := base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(hdrbuf); err != nil {
return nil, errors.Wrap(err, `failed to write headers as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing headers as base64`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(payload); err != nil {
return nil, errors.Wrap(err, `failed to write payload as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing payload as base64`)
}
signature, err := signer.Sign(buf.Bytes(), key)
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(signature); err != nil {
return nil, errors.Wrap(err, `failed to write signature as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing signature as base64`)
}
return buf.Bytes(), nil
}
|
[
"func",
"Sign",
"(",
"payload",
"[",
"]",
"byte",
",",
"alg",
"jwa",
".",
"SignatureAlgorithm",
",",
"key",
"interface",
"{",
"}",
",",
"options",
"...",
"Option",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"hdrs",
"Headers",
"=",
"&",
"StandardHeaders",
"{",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"options",
"{",
"switch",
"o",
".",
"Name",
"(",
")",
"{",
"case",
"optkeyHeaders",
":",
"hdrs",
"=",
"o",
".",
"Value",
"(",
")",
".",
"(",
"Headers",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"signer",
",",
"err",
":=",
"sign",
".",
"New",
"(",
"alg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to create signer`",
")",
"\n",
"}",
"\n\n",
"hdrs",
".",
"Set",
"(",
"AlgorithmKey",
",",
"signer",
".",
"Algorithm",
"(",
")",
")",
"\n\n",
"hdrbuf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"hdrs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to marshal headers`",
")",
"\n",
"}",
"\n\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"enc",
":=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"RawURLEncoding",
",",
"&",
"buf",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"enc",
".",
"Write",
"(",
"hdrbuf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to write headers as base64`",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"enc",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to finalize writing headers as base64`",
")",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteByte",
"(",
"'.'",
")",
"\n",
"enc",
"=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"RawURLEncoding",
",",
"&",
"buf",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"enc",
".",
"Write",
"(",
"payload",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to write payload as base64`",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"enc",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to finalize writing payload as base64`",
")",
"\n",
"}",
"\n\n",
"signature",
",",
"err",
":=",
"signer",
".",
"Sign",
"(",
"buf",
".",
"Bytes",
"(",
")",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to sign payload`",
")",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteByte",
"(",
"'.'",
")",
"\n",
"enc",
"=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"RawURLEncoding",
",",
"&",
"buf",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"enc",
".",
"Write",
"(",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to write signature as base64`",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"enc",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to finalize writing signature as base64`",
")",
"\n",
"}",
"\n\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// Sign generates a signature for the given payload, and serializes
// it in compact serialization format. In this format you may NOT use
// multiple signers.
//
// If you would like to pass custom headers, use the WithHeaders option.
|
[
"Sign",
"generates",
"a",
"signature",
"for",
"the",
"given",
"payload",
"and",
"serializes",
"it",
"in",
"compact",
"serialization",
"format",
".",
"In",
"this",
"format",
"you",
"may",
"NOT",
"use",
"multiple",
"signers",
".",
"If",
"you",
"would",
"like",
"to",
"pass",
"custom",
"headers",
"use",
"the",
"WithHeaders",
"option",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L87-L141
|
143,264 |
lestrrat-go/jwx
|
jws/jws.go
|
SignLiteral
|
func SignLiteral(payload []byte, alg jwa.SignatureAlgorithm, key interface{}, headers []byte) ([]byte, error) {
signer, err := sign.New(alg)
if err != nil {
return nil, errors.Wrap(err, `failed to create signer`)
}
var buf bytes.Buffer
enc := base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(headers); err != nil {
return nil, errors.Wrap(err, `failed to write headers as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing headers as base64`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(payload); err != nil {
return nil, errors.Wrap(err, `failed to write payload as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing payload as base64`)
}
signature, err := signer.Sign(buf.Bytes(), key)
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(signature); err != nil {
return nil, errors.Wrap(err, `failed to write signature as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing signature as base64`)
}
return buf.Bytes(), nil
}
|
go
|
func SignLiteral(payload []byte, alg jwa.SignatureAlgorithm, key interface{}, headers []byte) ([]byte, error) {
signer, err := sign.New(alg)
if err != nil {
return nil, errors.Wrap(err, `failed to create signer`)
}
var buf bytes.Buffer
enc := base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(headers); err != nil {
return nil, errors.Wrap(err, `failed to write headers as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing headers as base64`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(payload); err != nil {
return nil, errors.Wrap(err, `failed to write payload as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing payload as base64`)
}
signature, err := signer.Sign(buf.Bytes(), key)
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
buf.WriteByte('.')
enc = base64.NewEncoder(base64.RawURLEncoding, &buf)
if _, err := enc.Write(signature); err != nil {
return nil, errors.Wrap(err, `failed to write signature as base64`)
}
if err := enc.Close(); err != nil {
return nil, errors.Wrap(err, `failed to finalize writing signature as base64`)
}
return buf.Bytes(), nil
}
|
[
"func",
"SignLiteral",
"(",
"payload",
"[",
"]",
"byte",
",",
"alg",
"jwa",
".",
"SignatureAlgorithm",
",",
"key",
"interface",
"{",
"}",
",",
"headers",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"signer",
",",
"err",
":=",
"sign",
".",
"New",
"(",
"alg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to create signer`",
")",
"\n",
"}",
"\n\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"enc",
":=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"RawURLEncoding",
",",
"&",
"buf",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"enc",
".",
"Write",
"(",
"headers",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to write headers as base64`",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"enc",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to finalize writing headers as base64`",
")",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteByte",
"(",
"'.'",
")",
"\n",
"enc",
"=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"RawURLEncoding",
",",
"&",
"buf",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"enc",
".",
"Write",
"(",
"payload",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to write payload as base64`",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"enc",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to finalize writing payload as base64`",
")",
"\n",
"}",
"\n\n",
"signature",
",",
"err",
":=",
"signer",
".",
"Sign",
"(",
"buf",
".",
"Bytes",
"(",
")",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to sign payload`",
")",
"\n",
"}",
"\n\n",
"buf",
".",
"WriteByte",
"(",
"'.'",
")",
"\n",
"enc",
"=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"RawURLEncoding",
",",
"&",
"buf",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"enc",
".",
"Write",
"(",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to write signature as base64`",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"enc",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to finalize writing signature as base64`",
")",
"\n",
"}",
"\n\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// SignLiteral generates a signature for the given payload and headers, and serializes
// it in compact serialization format. In this format you may NOT use
// multiple signers.
//
|
[
"SignLiteral",
"generates",
"a",
"signature",
"for",
"the",
"given",
"payload",
"and",
"headers",
"and",
"serializes",
"it",
"in",
"compact",
"serialization",
"format",
".",
"In",
"this",
"format",
"you",
"may",
"NOT",
"use",
"multiple",
"signers",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L147-L187
|
143,265 |
lestrrat-go/jwx
|
jws/jws.go
|
SignMulti
|
func SignMulti(payload []byte, options ...Option) ([]byte, error) {
var signers []PayloadSigner
for _, o := range options {
switch o.Name() {
case optkeyPayloadSigner:
signers = append(signers, o.Value().(PayloadSigner))
}
}
if len(signers) == 0 {
return nil, errors.New(`no signers provided`)
}
var result EncodedMessage
result.Payload = base64.RawURLEncoding.EncodeToString(payload)
for _, signer := range signers {
protected := signer.ProtectedHeader()
if protected == nil {
protected = &StandardHeaders{}
}
protected.Set(AlgorithmKey, signer.Algorithm())
hdrbuf, err := json.Marshal(protected)
if err != nil {
return nil, errors.Wrap(err, `failed to marshal headers`)
}
encodedHeader := base64.RawURLEncoding.EncodeToString(hdrbuf)
var buf bytes.Buffer
buf.WriteString(encodedHeader)
buf.WriteByte('.')
buf.WriteString(result.Payload)
signature, err := signer.Sign(buf.Bytes())
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
result.Signatures = append(result.Signatures, &EncodedSignature{
Headers: signer.PublicHeader(),
Protected: encodedHeader,
Signature: base64.RawURLEncoding.EncodeToString(signature),
})
}
return json.Marshal(result)
}
|
go
|
func SignMulti(payload []byte, options ...Option) ([]byte, error) {
var signers []PayloadSigner
for _, o := range options {
switch o.Name() {
case optkeyPayloadSigner:
signers = append(signers, o.Value().(PayloadSigner))
}
}
if len(signers) == 0 {
return nil, errors.New(`no signers provided`)
}
var result EncodedMessage
result.Payload = base64.RawURLEncoding.EncodeToString(payload)
for _, signer := range signers {
protected := signer.ProtectedHeader()
if protected == nil {
protected = &StandardHeaders{}
}
protected.Set(AlgorithmKey, signer.Algorithm())
hdrbuf, err := json.Marshal(protected)
if err != nil {
return nil, errors.Wrap(err, `failed to marshal headers`)
}
encodedHeader := base64.RawURLEncoding.EncodeToString(hdrbuf)
var buf bytes.Buffer
buf.WriteString(encodedHeader)
buf.WriteByte('.')
buf.WriteString(result.Payload)
signature, err := signer.Sign(buf.Bytes())
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
result.Signatures = append(result.Signatures, &EncodedSignature{
Headers: signer.PublicHeader(),
Protected: encodedHeader,
Signature: base64.RawURLEncoding.EncodeToString(signature),
})
}
return json.Marshal(result)
}
|
[
"func",
"SignMulti",
"(",
"payload",
"[",
"]",
"byte",
",",
"options",
"...",
"Option",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"signers",
"[",
"]",
"PayloadSigner",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"options",
"{",
"switch",
"o",
".",
"Name",
"(",
")",
"{",
"case",
"optkeyPayloadSigner",
":",
"signers",
"=",
"append",
"(",
"signers",
",",
"o",
".",
"Value",
"(",
")",
".",
"(",
"PayloadSigner",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"signers",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"`no signers provided`",
")",
"\n",
"}",
"\n\n",
"var",
"result",
"EncodedMessage",
"\n\n",
"result",
".",
"Payload",
"=",
"base64",
".",
"RawURLEncoding",
".",
"EncodeToString",
"(",
"payload",
")",
"\n\n",
"for",
"_",
",",
"signer",
":=",
"range",
"signers",
"{",
"protected",
":=",
"signer",
".",
"ProtectedHeader",
"(",
")",
"\n",
"if",
"protected",
"==",
"nil",
"{",
"protected",
"=",
"&",
"StandardHeaders",
"{",
"}",
"\n",
"}",
"\n\n",
"protected",
".",
"Set",
"(",
"AlgorithmKey",
",",
"signer",
".",
"Algorithm",
"(",
")",
")",
"\n\n",
"hdrbuf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"protected",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to marshal headers`",
")",
"\n",
"}",
"\n",
"encodedHeader",
":=",
"base64",
".",
"RawURLEncoding",
".",
"EncodeToString",
"(",
"hdrbuf",
")",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"buf",
".",
"WriteString",
"(",
"encodedHeader",
")",
"\n",
"buf",
".",
"WriteByte",
"(",
"'.'",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"result",
".",
"Payload",
")",
"\n",
"signature",
",",
"err",
":=",
"signer",
".",
"Sign",
"(",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to sign payload`",
")",
"\n",
"}",
"\n\n",
"result",
".",
"Signatures",
"=",
"append",
"(",
"result",
".",
"Signatures",
",",
"&",
"EncodedSignature",
"{",
"Headers",
":",
"signer",
".",
"PublicHeader",
"(",
")",
",",
"Protected",
":",
"encodedHeader",
",",
"Signature",
":",
"base64",
".",
"RawURLEncoding",
".",
"EncodeToString",
"(",
"signature",
")",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"json",
".",
"Marshal",
"(",
"result",
")",
"\n",
"}"
] |
// SignMulti accepts multiple signers via the options parameter,
// and creates a JWS in JSON serialization format that contains
// signatures from applying aforementioned signers.
|
[
"SignMulti",
"accepts",
"multiple",
"signers",
"via",
"the",
"options",
"parameter",
"and",
"creates",
"a",
"JWS",
"in",
"JSON",
"serialization",
"format",
"that",
"contains",
"signatures",
"from",
"applying",
"aforementioned",
"signers",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L192-L239
|
143,266 |
lestrrat-go/jwx
|
jws/jws.go
|
VerifyWithJKU
|
func VerifyWithJKU(buf []byte, jwkurl string) ([]byte, error) {
key, err := jwk.FetchHTTP(jwkurl)
if err != nil {
return nil, errors.Wrap(err, `failed to fetch jwk via HTTP`)
}
return VerifyWithJWKSet(buf, key, nil)
}
|
go
|
func VerifyWithJKU(buf []byte, jwkurl string) ([]byte, error) {
key, err := jwk.FetchHTTP(jwkurl)
if err != nil {
return nil, errors.Wrap(err, `failed to fetch jwk via HTTP`)
}
return VerifyWithJWKSet(buf, key, nil)
}
|
[
"func",
"VerifyWithJKU",
"(",
"buf",
"[",
"]",
"byte",
",",
"jwkurl",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"key",
",",
"err",
":=",
"jwk",
".",
"FetchHTTP",
"(",
"jwkurl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to fetch jwk via HTTP`",
")",
"\n",
"}",
"\n\n",
"return",
"VerifyWithJWKSet",
"(",
"buf",
",",
"key",
",",
"nil",
")",
"\n",
"}"
] |
// VerifyWithJKU verifies the JWS message using a remote JWK
// file represented in the url.
|
[
"VerifyWithJKU",
"verifies",
"the",
"JWS",
"message",
"using",
"a",
"remote",
"JWK",
"file",
"represented",
"in",
"the",
"url",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L327-L334
|
143,267 |
lestrrat-go/jwx
|
jws/jws.go
|
VerifyWithJWK
|
func VerifyWithJWK(buf []byte, key jwk.Key) (payload []byte, err error) {
keyval, err := key.Materialize()
if err != nil {
return nil, errors.Wrap(err, `failed to materialize jwk.Key`)
}
payload, err = Verify(buf, jwa.SignatureAlgorithm(key.Algorithm()), keyval)
if err != nil {
return nil, errors.Wrap(err, "failed to verify message")
}
return payload, nil
}
|
go
|
func VerifyWithJWK(buf []byte, key jwk.Key) (payload []byte, err error) {
keyval, err := key.Materialize()
if err != nil {
return nil, errors.Wrap(err, `failed to materialize jwk.Key`)
}
payload, err = Verify(buf, jwa.SignatureAlgorithm(key.Algorithm()), keyval)
if err != nil {
return nil, errors.Wrap(err, "failed to verify message")
}
return payload, nil
}
|
[
"func",
"VerifyWithJWK",
"(",
"buf",
"[",
"]",
"byte",
",",
"key",
"jwk",
".",
"Key",
")",
"(",
"payload",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"keyval",
",",
"err",
":=",
"key",
".",
"Materialize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to materialize jwk.Key`",
")",
"\n",
"}",
"\n\n",
"payload",
",",
"err",
"=",
"Verify",
"(",
"buf",
",",
"jwa",
".",
"SignatureAlgorithm",
"(",
"key",
".",
"Algorithm",
"(",
")",
")",
",",
"keyval",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"payload",
",",
"nil",
"\n",
"}"
] |
// VerifyWithJWK verifies the JWS message using the specified JWK
|
[
"VerifyWithJWK",
"verifies",
"the",
"JWS",
"message",
"using",
"the",
"specified",
"JWK"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L337-L349
|
143,268 |
lestrrat-go/jwx
|
jws/jws.go
|
VerifyWithJWKSet
|
func VerifyWithJWKSet(buf []byte, keyset *jwk.Set, keyaccept JWKAcceptFunc) (payload []byte, err error) {
if keyaccept == nil {
keyaccept = DefaultJWKAcceptor
}
for _, key := range keyset.Keys {
if !keyaccept(key) {
continue
}
payload, err := VerifyWithJWK(buf, key)
if err == nil {
return payload, nil
}
}
return nil, errors.New("failed to verify with any of the keys")
}
|
go
|
func VerifyWithJWKSet(buf []byte, keyset *jwk.Set, keyaccept JWKAcceptFunc) (payload []byte, err error) {
if keyaccept == nil {
keyaccept = DefaultJWKAcceptor
}
for _, key := range keyset.Keys {
if !keyaccept(key) {
continue
}
payload, err := VerifyWithJWK(buf, key)
if err == nil {
return payload, nil
}
}
return nil, errors.New("failed to verify with any of the keys")
}
|
[
"func",
"VerifyWithJWKSet",
"(",
"buf",
"[",
"]",
"byte",
",",
"keyset",
"*",
"jwk",
".",
"Set",
",",
"keyaccept",
"JWKAcceptFunc",
")",
"(",
"payload",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"if",
"keyaccept",
"==",
"nil",
"{",
"keyaccept",
"=",
"DefaultJWKAcceptor",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"key",
":=",
"range",
"keyset",
".",
"Keys",
"{",
"if",
"!",
"keyaccept",
"(",
"key",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"payload",
",",
"err",
":=",
"VerifyWithJWK",
"(",
"buf",
",",
"key",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"payload",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// VerifyWithJWKSet verifies the JWS message using JWK key set.
// By default it will only pick up keys that have the "use" key
// set to either "sig" or "enc", but you can override it by
// providing a keyaccept function.
|
[
"VerifyWithJWKSet",
"verifies",
"the",
"JWS",
"message",
"using",
"JWK",
"key",
"set",
".",
"By",
"default",
"it",
"will",
"only",
"pick",
"up",
"keys",
"that",
"have",
"the",
"use",
"key",
"set",
"to",
"either",
"sig",
"or",
"enc",
"but",
"you",
"can",
"override",
"it",
"by",
"providing",
"a",
"keyaccept",
"function",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L355-L373
|
143,269 |
lestrrat-go/jwx
|
jws/jws.go
|
Parse
|
func Parse(src io.Reader) (m *Message, err error) {
rdr := bufio.NewReader(src)
var first rune
for {
r, _, err := rdr.ReadRune()
if err != nil {
return nil, errors.Wrap(err, `failed to read rune`)
}
if !unicode.IsSpace(r) {
first = r
rdr.UnreadRune()
break
}
}
var parser func(io.Reader) (*Message, error)
if first == '{' {
parser = parseJSON
} else {
parser = parseCompact
}
m, err = parser(rdr)
if err != nil {
return nil, errors.Wrap(err, `failed to parse jws message`)
}
return m, nil
}
|
go
|
func Parse(src io.Reader) (m *Message, err error) {
rdr := bufio.NewReader(src)
var first rune
for {
r, _, err := rdr.ReadRune()
if err != nil {
return nil, errors.Wrap(err, `failed to read rune`)
}
if !unicode.IsSpace(r) {
first = r
rdr.UnreadRune()
break
}
}
var parser func(io.Reader) (*Message, error)
if first == '{' {
parser = parseJSON
} else {
parser = parseCompact
}
m, err = parser(rdr)
if err != nil {
return nil, errors.Wrap(err, `failed to parse jws message`)
}
return m, nil
}
|
[
"func",
"Parse",
"(",
"src",
"io",
".",
"Reader",
")",
"(",
"m",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"rdr",
":=",
"bufio",
".",
"NewReader",
"(",
"src",
")",
"\n",
"var",
"first",
"rune",
"\n",
"for",
"{",
"r",
",",
"_",
",",
"err",
":=",
"rdr",
".",
"ReadRune",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to read rune`",
")",
"\n",
"}",
"\n",
"if",
"!",
"unicode",
".",
"IsSpace",
"(",
"r",
")",
"{",
"first",
"=",
"r",
"\n",
"rdr",
".",
"UnreadRune",
"(",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"var",
"parser",
"func",
"(",
"io",
".",
"Reader",
")",
"(",
"*",
"Message",
",",
"error",
")",
"\n",
"if",
"first",
"==",
"'{'",
"{",
"parser",
"=",
"parseJSON",
"\n",
"}",
"else",
"{",
"parser",
"=",
"parseCompact",
"\n",
"}",
"\n\n",
"m",
",",
"err",
"=",
"parser",
"(",
"rdr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to parse jws message`",
")",
"\n",
"}",
"\n\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// Parse parses contents from the given source and creates a jws.Message
// struct. The input can be in either compact or full JSON serialization.
|
[
"Parse",
"parses",
"contents",
"from",
"the",
"given",
"source",
"and",
"creates",
"a",
"jws",
".",
"Message",
"struct",
".",
"The",
"input",
"can",
"be",
"in",
"either",
"compact",
"or",
"full",
"JSON",
"serialization",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L377-L406
|
143,270 |
lestrrat-go/jwx
|
jws/jws.go
|
parseCompact
|
func parseCompact(rdr io.Reader) (m *Message, err error) {
protected, payload, signature, err := SplitCompact(rdr)
if err != nil {
return nil, errors.Wrap(err, `invalid compact serialization format`)
}
decodedHeader := make([]byte, base64.RawURLEncoding.DecodedLen(len(protected)))
if _, err := base64.RawURLEncoding.Decode(decodedHeader, protected); err != nil {
return nil, errors.Wrap(err, `failed to decode headers`)
}
var hdr StandardHeaders
if err := json.Unmarshal(decodedHeader, &hdr); err != nil {
return nil, errors.Wrap(err, `failed to parse JOSE headers`)
}
decodedPayload := make([]byte, base64.RawURLEncoding.DecodedLen(len(payload)))
if _, err = base64.RawURLEncoding.Decode(decodedPayload, payload); err != nil {
return nil, errors.Wrap(err, `failed to decode payload`)
}
decodedSignature := make([]byte, base64.RawURLEncoding.DecodedLen(len(signature)))
if _, err := base64.RawURLEncoding.Decode(decodedSignature, signature); err != nil {
return nil, errors.Wrap(err, `failed to decode signature`)
}
var msg Message
msg.payload = decodedPayload
msg.signatures = append(msg.signatures, &Signature{
protected: &hdr,
signature: decodedSignature,
})
return &msg, nil
}
|
go
|
func parseCompact(rdr io.Reader) (m *Message, err error) {
protected, payload, signature, err := SplitCompact(rdr)
if err != nil {
return nil, errors.Wrap(err, `invalid compact serialization format`)
}
decodedHeader := make([]byte, base64.RawURLEncoding.DecodedLen(len(protected)))
if _, err := base64.RawURLEncoding.Decode(decodedHeader, protected); err != nil {
return nil, errors.Wrap(err, `failed to decode headers`)
}
var hdr StandardHeaders
if err := json.Unmarshal(decodedHeader, &hdr); err != nil {
return nil, errors.Wrap(err, `failed to parse JOSE headers`)
}
decodedPayload := make([]byte, base64.RawURLEncoding.DecodedLen(len(payload)))
if _, err = base64.RawURLEncoding.Decode(decodedPayload, payload); err != nil {
return nil, errors.Wrap(err, `failed to decode payload`)
}
decodedSignature := make([]byte, base64.RawURLEncoding.DecodedLen(len(signature)))
if _, err := base64.RawURLEncoding.Decode(decodedSignature, signature); err != nil {
return nil, errors.Wrap(err, `failed to decode signature`)
}
var msg Message
msg.payload = decodedPayload
msg.signatures = append(msg.signatures, &Signature{
protected: &hdr,
signature: decodedSignature,
})
return &msg, nil
}
|
[
"func",
"parseCompact",
"(",
"rdr",
"io",
".",
"Reader",
")",
"(",
"m",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"protected",
",",
"payload",
",",
"signature",
",",
"err",
":=",
"SplitCompact",
"(",
"rdr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`invalid compact serialization format`",
")",
"\n",
"}",
"\n\n",
"decodedHeader",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"base64",
".",
"RawURLEncoding",
".",
"DecodedLen",
"(",
"len",
"(",
"protected",
")",
")",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"base64",
".",
"RawURLEncoding",
".",
"Decode",
"(",
"decodedHeader",
",",
"protected",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to decode headers`",
")",
"\n",
"}",
"\n",
"var",
"hdr",
"StandardHeaders",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"decodedHeader",
",",
"&",
"hdr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to parse JOSE headers`",
")",
"\n",
"}",
"\n\n",
"decodedPayload",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"base64",
".",
"RawURLEncoding",
".",
"DecodedLen",
"(",
"len",
"(",
"payload",
")",
")",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"base64",
".",
"RawURLEncoding",
".",
"Decode",
"(",
"decodedPayload",
",",
"payload",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to decode payload`",
")",
"\n",
"}",
"\n\n",
"decodedSignature",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"base64",
".",
"RawURLEncoding",
".",
"DecodedLen",
"(",
"len",
"(",
"signature",
")",
")",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"base64",
".",
"RawURLEncoding",
".",
"Decode",
"(",
"decodedSignature",
",",
"signature",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to decode signature`",
")",
"\n",
"}",
"\n\n",
"var",
"msg",
"Message",
"\n",
"msg",
".",
"payload",
"=",
"decodedPayload",
"\n",
"msg",
".",
"signatures",
"=",
"append",
"(",
"msg",
".",
"signatures",
",",
"&",
"Signature",
"{",
"protected",
":",
"&",
"hdr",
",",
"signature",
":",
"decodedSignature",
",",
"}",
")",
"\n",
"return",
"&",
"msg",
",",
"nil",
"\n",
"}"
] |
// parseCompact parses a JWS value serialized via compact serialization.
|
[
"parseCompact",
"parses",
"a",
"JWS",
"value",
"serialized",
"via",
"compact",
"serialization",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/jws.go#L525-L558
|
143,271 |
lestrrat-go/jwx
|
jws/verify/verify.go
|
New
|
func New(alg jwa.SignatureAlgorithm) (Verifier, error) {
switch alg {
case jwa.RS256, jwa.RS384, jwa.RS512, jwa.PS256, jwa.PS384, jwa.PS512:
return newRSA(alg)
case jwa.ES256, jwa.ES384, jwa.ES512:
return newECDSA(alg)
case jwa.HS256, jwa.HS384, jwa.HS512:
return newHMAC(alg)
default:
return nil, errors.Errorf(`unsupported signature algorithm: %s`, alg)
}
}
|
go
|
func New(alg jwa.SignatureAlgorithm) (Verifier, error) {
switch alg {
case jwa.RS256, jwa.RS384, jwa.RS512, jwa.PS256, jwa.PS384, jwa.PS512:
return newRSA(alg)
case jwa.ES256, jwa.ES384, jwa.ES512:
return newECDSA(alg)
case jwa.HS256, jwa.HS384, jwa.HS512:
return newHMAC(alg)
default:
return nil, errors.Errorf(`unsupported signature algorithm: %s`, alg)
}
}
|
[
"func",
"New",
"(",
"alg",
"jwa",
".",
"SignatureAlgorithm",
")",
"(",
"Verifier",
",",
"error",
")",
"{",
"switch",
"alg",
"{",
"case",
"jwa",
".",
"RS256",
",",
"jwa",
".",
"RS384",
",",
"jwa",
".",
"RS512",
",",
"jwa",
".",
"PS256",
",",
"jwa",
".",
"PS384",
",",
"jwa",
".",
"PS512",
":",
"return",
"newRSA",
"(",
"alg",
")",
"\n",
"case",
"jwa",
".",
"ES256",
",",
"jwa",
".",
"ES384",
",",
"jwa",
".",
"ES512",
":",
"return",
"newECDSA",
"(",
"alg",
")",
"\n",
"case",
"jwa",
".",
"HS256",
",",
"jwa",
".",
"HS384",
",",
"jwa",
".",
"HS512",
":",
"return",
"newHMAC",
"(",
"alg",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"`unsupported signature algorithm: %s`",
",",
"alg",
")",
"\n",
"}",
"\n",
"}"
] |
// New creates a new JWS verifier using the specified algorithm
// and the public key
|
[
"New",
"creates",
"a",
"new",
"JWS",
"verifier",
"using",
"the",
"specified",
"algorithm",
"and",
"the",
"public",
"key"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jws/verify/verify.go#L10-L21
|
143,272 |
lestrrat-go/jwx
|
jwt/jwt.go
|
ParseString
|
func ParseString(s string, options ...Option) (*Token, error) {
return Parse(strings.NewReader(s), options...)
}
|
go
|
func ParseString(s string, options ...Option) (*Token, error) {
return Parse(strings.NewReader(s), options...)
}
|
[
"func",
"ParseString",
"(",
"s",
"string",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"Token",
",",
"error",
")",
"{",
"return",
"Parse",
"(",
"strings",
".",
"NewReader",
"(",
"s",
")",
",",
"options",
"...",
")",
"\n",
"}"
] |
// ParseString calls Parse with the given string
|
[
"ParseString",
"calls",
"Parse",
"with",
"the",
"given",
"string"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwt/jwt.go#L19-L21
|
143,273 |
lestrrat-go/jwx
|
jwt/jwt.go
|
ParseBytes
|
func ParseBytes(s []byte, options ...Option) (*Token, error) {
return Parse(bytes.NewReader(s), options...)
}
|
go
|
func ParseBytes(s []byte, options ...Option) (*Token, error) {
return Parse(bytes.NewReader(s), options...)
}
|
[
"func",
"ParseBytes",
"(",
"s",
"[",
"]",
"byte",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"Token",
",",
"error",
")",
"{",
"return",
"Parse",
"(",
"bytes",
".",
"NewReader",
"(",
"s",
")",
",",
"options",
"...",
")",
"\n",
"}"
] |
// ParseString calls Parse with the given byte sequence
|
[
"ParseString",
"calls",
"Parse",
"with",
"the",
"given",
"byte",
"sequence"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwt/jwt.go#L24-L26
|
143,274 |
lestrrat-go/jwx
|
jwt/jwt.go
|
Sign
|
func (t *Token) Sign(method jwa.SignatureAlgorithm, key interface{}) ([]byte, error) {
buf, err := json.Marshal(t)
if err != nil {
return nil, errors.Wrap(err, `failed to marshal token`)
}
var hdr jws.StandardHeaders
if hdr.Set(`alg`, method.String()) != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
if hdr.Set(`typ`, `JWT`) != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
sign, err := jws.Sign(buf, method, key, jws.WithHeaders(&hdr))
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
return sign, nil
}
|
go
|
func (t *Token) Sign(method jwa.SignatureAlgorithm, key interface{}) ([]byte, error) {
buf, err := json.Marshal(t)
if err != nil {
return nil, errors.Wrap(err, `failed to marshal token`)
}
var hdr jws.StandardHeaders
if hdr.Set(`alg`, method.String()) != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
if hdr.Set(`typ`, `JWT`) != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
sign, err := jws.Sign(buf, method, key, jws.WithHeaders(&hdr))
if err != nil {
return nil, errors.Wrap(err, `failed to sign payload`)
}
return sign, nil
}
|
[
"func",
"(",
"t",
"*",
"Token",
")",
"Sign",
"(",
"method",
"jwa",
".",
"SignatureAlgorithm",
",",
"key",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to marshal token`",
")",
"\n",
"}",
"\n\n",
"var",
"hdr",
"jws",
".",
"StandardHeaders",
"\n",
"if",
"hdr",
".",
"Set",
"(",
"`alg`",
",",
"method",
".",
"String",
"(",
")",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to sign payload`",
")",
"\n",
"}",
"\n",
"if",
"hdr",
".",
"Set",
"(",
"`typ`",
",",
"`JWT`",
")",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to sign payload`",
")",
"\n",
"}",
"\n",
"sign",
",",
"err",
":=",
"jws",
".",
"Sign",
"(",
"buf",
",",
"method",
",",
"key",
",",
"jws",
".",
"WithHeaders",
"(",
"&",
"hdr",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to sign payload`",
")",
"\n",
"}",
"\n\n",
"return",
"sign",
",",
"nil",
"\n",
"}"
] |
// Sign is a convenience function to create a signed JWT token serialized in
// compact form. `key` must match the key type required by the given
// signature method `method`
|
[
"Sign",
"is",
"a",
"convenience",
"function",
"to",
"create",
"a",
"signed",
"JWT",
"token",
"serialized",
"in",
"compact",
"form",
".",
"key",
"must",
"match",
"the",
"key",
"type",
"required",
"by",
"the",
"given",
"signature",
"method",
"method"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwt/jwt.go#L87-L106
|
143,275 |
lestrrat-go/jwx
|
buffer/buffer.go
|
FromUint
|
func FromUint(v uint64) Buffer {
data := make([]byte, 8)
binary.BigEndian.PutUint64(data, v)
i := 0
for ; i < len(data); i++ {
if data[i] != 0x0 {
break
}
}
return Buffer(data[i:])
}
|
go
|
func FromUint(v uint64) Buffer {
data := make([]byte, 8)
binary.BigEndian.PutUint64(data, v)
i := 0
for ; i < len(data); i++ {
if data[i] != 0x0 {
break
}
}
return Buffer(data[i:])
}
|
[
"func",
"FromUint",
"(",
"v",
"uint64",
")",
"Buffer",
"{",
"data",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"data",
",",
"v",
")",
"\n\n",
"i",
":=",
"0",
"\n",
"for",
";",
"i",
"<",
"len",
"(",
"data",
")",
";",
"i",
"++",
"{",
"if",
"data",
"[",
"i",
"]",
"!=",
"0x0",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"Buffer",
"(",
"data",
"[",
"i",
":",
"]",
")",
"\n",
"}"
] |
// FromUint creates a `Buffer` from an unsigned int
|
[
"FromUint",
"creates",
"a",
"Buffer",
"from",
"an",
"unsigned",
"int"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L21-L32
|
143,276 |
lestrrat-go/jwx
|
buffer/buffer.go
|
FromBase64
|
func FromBase64(v []byte) (Buffer, error) {
b := Buffer{}
if err := b.Base64Decode(v); err != nil {
return Buffer(nil), errors.Wrap(err, "failed to decode from base64")
}
return b, nil
}
|
go
|
func FromBase64(v []byte) (Buffer, error) {
b := Buffer{}
if err := b.Base64Decode(v); err != nil {
return Buffer(nil), errors.Wrap(err, "failed to decode from base64")
}
return b, nil
}
|
[
"func",
"FromBase64",
"(",
"v",
"[",
"]",
"byte",
")",
"(",
"Buffer",
",",
"error",
")",
"{",
"b",
":=",
"Buffer",
"{",
"}",
"\n",
"if",
"err",
":=",
"b",
".",
"Base64Decode",
"(",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Buffer",
"(",
"nil",
")",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] |
// FromBase64 constructs a new Buffer from a base64 encoded data
|
[
"FromBase64",
"constructs",
"a",
"new",
"Buffer",
"from",
"a",
"base64",
"encoded",
"data"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L35-L42
|
143,277 |
lestrrat-go/jwx
|
buffer/buffer.go
|
NData
|
func (b Buffer) NData() []byte {
buf := make([]byte, 4+b.Len())
binary.BigEndian.PutUint32(buf, uint32(b.Len()))
copy(buf[4:], b.Bytes())
return buf
}
|
go
|
func (b Buffer) NData() []byte {
buf := make([]byte, 4+b.Len())
binary.BigEndian.PutUint32(buf, uint32(b.Len()))
copy(buf[4:], b.Bytes())
return buf
}
|
[
"func",
"(",
"b",
"Buffer",
")",
"NData",
"(",
")",
"[",
"]",
"byte",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
"+",
"b",
".",
"Len",
"(",
")",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"buf",
",",
"uint32",
"(",
"b",
".",
"Len",
"(",
")",
")",
")",
"\n\n",
"copy",
"(",
"buf",
"[",
"4",
":",
"]",
",",
"b",
".",
"Bytes",
"(",
")",
")",
"\n",
"return",
"buf",
"\n",
"}"
] |
// NData returns Datalen || Data, where Datalen is a 32 bit counter for
// the length of the following data, and Data is the octets that comprise
// the buffer data
|
[
"NData",
"returns",
"Datalen",
"||",
"Data",
"where",
"Datalen",
"is",
"a",
"32",
"bit",
"counter",
"for",
"the",
"length",
"of",
"the",
"following",
"data",
"and",
"Data",
"is",
"the",
"octets",
"that",
"comprise",
"the",
"buffer",
"data"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L61-L67
|
143,278 |
lestrrat-go/jwx
|
buffer/buffer.go
|
Base64Encode
|
func (b Buffer) Base64Encode() ([]byte, error) {
enc := base64.RawURLEncoding
out := make([]byte, enc.EncodedLen(len(b)))
enc.Encode(out, b)
return out, nil
}
|
go
|
func (b Buffer) Base64Encode() ([]byte, error) {
enc := base64.RawURLEncoding
out := make([]byte, enc.EncodedLen(len(b)))
enc.Encode(out, b)
return out, nil
}
|
[
"func",
"(",
"b",
"Buffer",
")",
"Base64Encode",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"enc",
":=",
"base64",
".",
"RawURLEncoding",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"enc",
".",
"EncodedLen",
"(",
"len",
"(",
"b",
")",
")",
")",
"\n",
"enc",
".",
"Encode",
"(",
"out",
",",
"b",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// Base64Encode encodes the contents of the Buffer using base64.RawURLEncoding
|
[
"Base64Encode",
"encodes",
"the",
"contents",
"of",
"the",
"Buffer",
"using",
"base64",
".",
"RawURLEncoding"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L80-L85
|
143,279 |
lestrrat-go/jwx
|
buffer/buffer.go
|
Base64Decode
|
func (b *Buffer) Base64Decode(v []byte) error {
enc := base64.RawURLEncoding
out := make([]byte, enc.DecodedLen(len(v)))
n, err := enc.Decode(out, v)
if err != nil {
return errors.Wrap(err, "failed to decode from base64")
}
out = out[:n]
*b = Buffer(out)
return nil
}
|
go
|
func (b *Buffer) Base64Decode(v []byte) error {
enc := base64.RawURLEncoding
out := make([]byte, enc.DecodedLen(len(v)))
n, err := enc.Decode(out, v)
if err != nil {
return errors.Wrap(err, "failed to decode from base64")
}
out = out[:n]
*b = Buffer(out)
return nil
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"Base64Decode",
"(",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"enc",
":=",
"base64",
".",
"RawURLEncoding",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"enc",
".",
"DecodedLen",
"(",
"len",
"(",
"v",
")",
")",
")",
"\n",
"n",
",",
"err",
":=",
"enc",
".",
"Decode",
"(",
"out",
",",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"out",
"=",
"out",
"[",
":",
"n",
"]",
"\n",
"*",
"b",
"=",
"Buffer",
"(",
"out",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Base64Decode decodes the contents of the Buffer using base64.RawURLEncoding
|
[
"Base64Decode",
"decodes",
"the",
"contents",
"of",
"the",
"Buffer",
"using",
"base64",
".",
"RawURLEncoding"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L88-L98
|
143,280 |
lestrrat-go/jwx
|
buffer/buffer.go
|
MarshalJSON
|
func (b Buffer) MarshalJSON() ([]byte, error) {
v, err := b.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode to base64")
}
return json.Marshal(string(v))
}
|
go
|
func (b Buffer) MarshalJSON() ([]byte, error) {
v, err := b.Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to encode to base64")
}
return json.Marshal(string(v))
}
|
[
"func",
"(",
"b",
"Buffer",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"b",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"string",
"(",
"v",
")",
")",
"\n",
"}"
] |
// MarshalJSON marshals the buffer into JSON format after encoding the buffer
// with base64.RawURLEncoding
|
[
"MarshalJSON",
"marshals",
"the",
"buffer",
"into",
"JSON",
"format",
"after",
"encoding",
"the",
"buffer",
"with",
"base64",
".",
"RawURLEncoding"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L102-L108
|
143,281 |
lestrrat-go/jwx
|
buffer/buffer.go
|
UnmarshalJSON
|
func (b *Buffer) UnmarshalJSON(data []byte) error {
var x string
if err := json.Unmarshal(data, &x); err != nil {
return errors.Wrap(err, "failed to unmarshal JSON")
}
return b.Base64Decode([]byte(x))
}
|
go
|
func (b *Buffer) UnmarshalJSON(data []byte) error {
var x string
if err := json.Unmarshal(data, &x); err != nil {
return errors.Wrap(err, "failed to unmarshal JSON")
}
return b.Base64Decode([]byte(x))
}
|
[
"func",
"(",
"b",
"*",
"Buffer",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"x",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"x",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"b",
".",
"Base64Decode",
"(",
"[",
"]",
"byte",
"(",
"x",
")",
")",
"\n",
"}"
] |
// UnmarshalJSON unmarshals from a JSON string into a Buffer, after decoding it
// with base64.RawURLEncoding
|
[
"UnmarshalJSON",
"unmarshals",
"from",
"a",
"JSON",
"string",
"into",
"a",
"Buffer",
"after",
"decoding",
"it",
"with",
"base64",
".",
"RawURLEncoding"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/buffer/buffer.go#L112-L118
|
143,282 |
lestrrat-go/jwx
|
jwe/key_generate.go
|
KeyGenerate
|
func (g StaticKeyGenerate) KeyGenerate() (ByteSource, error) {
buf := make([]byte, g.KeySize())
copy(buf, g)
return ByteKey(buf), nil
}
|
go
|
func (g StaticKeyGenerate) KeyGenerate() (ByteSource, error) {
buf := make([]byte, g.KeySize())
copy(buf, g)
return ByteKey(buf), nil
}
|
[
"func",
"(",
"g",
"StaticKeyGenerate",
")",
"KeyGenerate",
"(",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"g",
".",
"KeySize",
"(",
")",
")",
"\n",
"copy",
"(",
"buf",
",",
"g",
")",
"\n",
"return",
"ByteKey",
"(",
"buf",
")",
",",
"nil",
"\n",
"}"
] |
// KeyGenerate returns the key
|
[
"KeyGenerate",
"returns",
"the",
"key"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_generate.go#L27-L31
|
143,283 |
lestrrat-go/jwx
|
jwe/key_generate.go
|
KeyGenerate
|
func (g RandomKeyGenerate) KeyGenerate() (ByteSource, error) {
buf := make([]byte, g.keysize)
if _, err := io.ReadFull(rand.Reader, buf); err != nil {
return nil, errors.Wrap(err, "failed to read from rand.Reader")
}
return ByteKey(buf), nil
}
|
go
|
func (g RandomKeyGenerate) KeyGenerate() (ByteSource, error) {
buf := make([]byte, g.keysize)
if _, err := io.ReadFull(rand.Reader, buf); err != nil {
return nil, errors.Wrap(err, "failed to read from rand.Reader")
}
return ByteKey(buf), nil
}
|
[
"func",
"(",
"g",
"RandomKeyGenerate",
")",
"KeyGenerate",
"(",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"g",
".",
"keysize",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"rand",
".",
"Reader",
",",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"ByteKey",
"(",
"buf",
")",
",",
"nil",
"\n",
"}"
] |
// KeyGenerate generates a random new key
|
[
"KeyGenerate",
"generates",
"a",
"random",
"new",
"key"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_generate.go#L45-L51
|
143,284 |
lestrrat-go/jwx
|
jwe/key_generate.go
|
NewEcdhesKeyGenerate
|
func NewEcdhesKeyGenerate(alg jwa.KeyEncryptionAlgorithm, pubkey *ecdsa.PublicKey) (*EcdhesKeyGenerate, error) {
var keysize int
switch alg {
case jwa.ECDH_ES:
return nil, errors.New("unimplemented")
case jwa.ECDH_ES_A128KW:
keysize = 16
case jwa.ECDH_ES_A192KW:
keysize = 24
case jwa.ECDH_ES_A256KW:
keysize = 32
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid ECDH-ES key generation algorithm")
}
return &EcdhesKeyGenerate{
algorithm: alg,
keysize: keysize,
pubkey: pubkey,
}, nil
}
|
go
|
func NewEcdhesKeyGenerate(alg jwa.KeyEncryptionAlgorithm, pubkey *ecdsa.PublicKey) (*EcdhesKeyGenerate, error) {
var keysize int
switch alg {
case jwa.ECDH_ES:
return nil, errors.New("unimplemented")
case jwa.ECDH_ES_A128KW:
keysize = 16
case jwa.ECDH_ES_A192KW:
keysize = 24
case jwa.ECDH_ES_A256KW:
keysize = 32
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid ECDH-ES key generation algorithm")
}
return &EcdhesKeyGenerate{
algorithm: alg,
keysize: keysize,
pubkey: pubkey,
}, nil
}
|
[
"func",
"NewEcdhesKeyGenerate",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"pubkey",
"*",
"ecdsa",
".",
"PublicKey",
")",
"(",
"*",
"EcdhesKeyGenerate",
",",
"error",
")",
"{",
"var",
"keysize",
"int",
"\n",
"switch",
"alg",
"{",
"case",
"jwa",
".",
"ECDH_ES",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"case",
"jwa",
".",
"ECDH_ES_A128KW",
":",
"keysize",
"=",
"16",
"\n",
"case",
"jwa",
".",
"ECDH_ES_A192KW",
":",
"keysize",
"=",
"24",
"\n",
"case",
"jwa",
".",
"ECDH_ES_A256KW",
":",
"keysize",
"=",
"32",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"ErrUnsupportedAlgorithm",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"EcdhesKeyGenerate",
"{",
"algorithm",
":",
"alg",
",",
"keysize",
":",
"keysize",
",",
"pubkey",
":",
"pubkey",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewEcdhesKeyGenerate creates a new key generator using ECDH-ES
|
[
"NewEcdhesKeyGenerate",
"creates",
"a",
"new",
"key",
"generator",
"using",
"ECDH",
"-",
"ES"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_generate.go#L54-L74
|
143,285 |
lestrrat-go/jwx
|
jwe/key_generate.go
|
KeyGenerate
|
func (g EcdhesKeyGenerate) KeyGenerate() (ByteSource, error) {
priv, err := ecdsa.GenerateKey(g.pubkey.Curve, rand.Reader)
if err != nil {
return nil, errors.Wrap(err, "failed to generate key for ECDH-ES")
}
pubinfo := make([]byte, 4)
binary.BigEndian.PutUint32(pubinfo, uint32(g.keysize)*8)
z, _ := priv.PublicKey.Curve.ScalarMult(g.pubkey.X, g.pubkey.Y, priv.D.Bytes())
kdf := concatkdf.New(crypto.SHA256, []byte(g.algorithm.String()), z.Bytes(), []byte{}, []byte{}, pubinfo, []byte{})
kek := make([]byte, g.keysize)
kdf.Read(kek)
return ByteWithECPrivateKey{
PrivateKey: priv,
ByteKey: ByteKey(kek),
}, nil
}
|
go
|
func (g EcdhesKeyGenerate) KeyGenerate() (ByteSource, error) {
priv, err := ecdsa.GenerateKey(g.pubkey.Curve, rand.Reader)
if err != nil {
return nil, errors.Wrap(err, "failed to generate key for ECDH-ES")
}
pubinfo := make([]byte, 4)
binary.BigEndian.PutUint32(pubinfo, uint32(g.keysize)*8)
z, _ := priv.PublicKey.Curve.ScalarMult(g.pubkey.X, g.pubkey.Y, priv.D.Bytes())
kdf := concatkdf.New(crypto.SHA256, []byte(g.algorithm.String()), z.Bytes(), []byte{}, []byte{}, pubinfo, []byte{})
kek := make([]byte, g.keysize)
kdf.Read(kek)
return ByteWithECPrivateKey{
PrivateKey: priv,
ByteKey: ByteKey(kek),
}, nil
}
|
[
"func",
"(",
"g",
"EcdhesKeyGenerate",
")",
"KeyGenerate",
"(",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"priv",
",",
"err",
":=",
"ecdsa",
".",
"GenerateKey",
"(",
"g",
".",
"pubkey",
".",
"Curve",
",",
"rand",
".",
"Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"pubinfo",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"pubinfo",
",",
"uint32",
"(",
"g",
".",
"keysize",
")",
"*",
"8",
")",
"\n\n",
"z",
",",
"_",
":=",
"priv",
".",
"PublicKey",
".",
"Curve",
".",
"ScalarMult",
"(",
"g",
".",
"pubkey",
".",
"X",
",",
"g",
".",
"pubkey",
".",
"Y",
",",
"priv",
".",
"D",
".",
"Bytes",
"(",
")",
")",
"\n",
"kdf",
":=",
"concatkdf",
".",
"New",
"(",
"crypto",
".",
"SHA256",
",",
"[",
"]",
"byte",
"(",
"g",
".",
"algorithm",
".",
"String",
"(",
")",
")",
",",
"z",
".",
"Bytes",
"(",
")",
",",
"[",
"]",
"byte",
"{",
"}",
",",
"[",
"]",
"byte",
"{",
"}",
",",
"pubinfo",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"kek",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"g",
".",
"keysize",
")",
"\n",
"kdf",
".",
"Read",
"(",
"kek",
")",
"\n\n",
"return",
"ByteWithECPrivateKey",
"{",
"PrivateKey",
":",
"priv",
",",
"ByteKey",
":",
"ByteKey",
"(",
"kek",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// KeyGenerate generates new keys using ECDH-ES
|
[
"KeyGenerate",
"generates",
"new",
"keys",
"using",
"ECDH",
"-",
"ES"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_generate.go#L82-L100
|
143,286 |
lestrrat-go/jwx
|
jwe/message.go
|
Get
|
func (h *Header) Get(key string) (interface{}, error) {
switch key {
case "alg":
return h.Algorithm, nil
case "apu":
return h.AgreementPartyUInfo, nil
case "apv":
return h.AgreementPartyVInfo, nil
case "enc":
return h.ContentEncryption, nil
case "epk":
return h.EphemeralPublicKey, nil
case "cty":
return h.ContentType, nil
case "kid":
return h.KeyID, nil
case "typ":
return h.Type, nil
case "x5t":
return h.X509CertThumbprint, nil
case "x5t#256":
return h.X509CertThumbprintS256, nil
case "x5c":
return h.X509CertChain, nil
case "crit":
return h.Critical, nil
case "jku":
return h.JwkSetURL, nil
case "x5u":
return h.X509Url, nil
default:
v, ok := h.PrivateParams[key]
if !ok {
return nil, errors.New("invalid header name")
}
return v, nil
}
}
|
go
|
func (h *Header) Get(key string) (interface{}, error) {
switch key {
case "alg":
return h.Algorithm, nil
case "apu":
return h.AgreementPartyUInfo, nil
case "apv":
return h.AgreementPartyVInfo, nil
case "enc":
return h.ContentEncryption, nil
case "epk":
return h.EphemeralPublicKey, nil
case "cty":
return h.ContentType, nil
case "kid":
return h.KeyID, nil
case "typ":
return h.Type, nil
case "x5t":
return h.X509CertThumbprint, nil
case "x5t#256":
return h.X509CertThumbprintS256, nil
case "x5c":
return h.X509CertChain, nil
case "crit":
return h.Critical, nil
case "jku":
return h.JwkSetURL, nil
case "x5u":
return h.X509Url, nil
default:
v, ok := h.PrivateParams[key]
if !ok {
return nil, errors.New("invalid header name")
}
return v, nil
}
}
|
[
"func",
"(",
"h",
"*",
"Header",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"switch",
"key",
"{",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"Algorithm",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"AgreementPartyUInfo",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"AgreementPartyVInfo",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"ContentEncryption",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"EphemeralPublicKey",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"ContentType",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"KeyID",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"Type",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"X509CertThumbprint",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"X509CertThumbprintS256",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"X509CertChain",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"Critical",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"JwkSetURL",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"h",
".",
"X509Url",
",",
"nil",
"\n",
"default",
":",
"v",
",",
"ok",
":=",
"h",
".",
"PrivateParams",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// Get returns the header key
|
[
"Get",
"returns",
"the",
"header",
"key"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/message.go#L39-L76
|
143,287 |
lestrrat-go/jwx
|
jwe/message.go
|
Base64Encode
|
func (e EncodedHeader) Base64Encode() ([]byte, error) {
buf, err := json.Marshal(e.Header)
if err != nil {
return nil, errors.Wrap(err, "failed to marshal encoded header into JSON")
}
buf, err = buffer.Buffer(buf).Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to base64 encode encoded header")
}
return buf, nil
}
|
go
|
func (e EncodedHeader) Base64Encode() ([]byte, error) {
buf, err := json.Marshal(e.Header)
if err != nil {
return nil, errors.Wrap(err, "failed to marshal encoded header into JSON")
}
buf, err = buffer.Buffer(buf).Base64Encode()
if err != nil {
return nil, errors.Wrap(err, "failed to base64 encode encoded header")
}
return buf, nil
}
|
[
"func",
"(",
"e",
"EncodedHeader",
")",
"Base64Encode",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"e",
".",
"Header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"buf",
",",
"err",
"=",
"buffer",
".",
"Buffer",
"(",
"buf",
")",
".",
"Base64Encode",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"buf",
",",
"nil",
"\n",
"}"
] |
// Base64Encode creates the base64 encoded version of the JSON
// representation of this header
|
[
"Base64Encode",
"creates",
"the",
"base64",
"encoded",
"version",
"of",
"the",
"JSON",
"representation",
"of",
"this",
"header"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/message.go#L395-L407
|
143,288 |
lestrrat-go/jwx
|
jwt/token_gen.go
|
UnmarshalJSON
|
func (t *Token) UnmarshalJSON(data []byte) error {
var m map[string]interface{}
if err := json.Unmarshal(data, &m); err != nil {
return errors.Wrap(err, `failed to unmarshal token`)
}
for name, value := range m {
if err := t.Set(name, value); err != nil {
return errors.Wrapf(err, `failed to set value for %s`, name)
}
}
return nil
}
|
go
|
func (t *Token) UnmarshalJSON(data []byte) error {
var m map[string]interface{}
if err := json.Unmarshal(data, &m); err != nil {
return errors.Wrap(err, `failed to unmarshal token`)
}
for name, value := range m {
if err := t.Set(name, value); err != nil {
return errors.Wrapf(err, `failed to set value for %s`, name)
}
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"Token",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to unmarshal token`",
")",
"\n",
"}",
"\n",
"for",
"name",
",",
"value",
":=",
"range",
"m",
"{",
"if",
"err",
":=",
"t",
".",
"Set",
"(",
"name",
",",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"`failed to set value for %s`",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UnmarshalJSON deserializes data from a JSON data buffer into a Token
|
[
"UnmarshalJSON",
"deserializes",
"data",
"from",
"a",
"JSON",
"data",
"buffer",
"into",
"a",
"Token"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwt/token_gen.go#L311-L322
|
143,289 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewKeyWrapEncrypt
|
func NewKeyWrapEncrypt(alg jwa.KeyEncryptionAlgorithm, sharedkey []byte) (KeyWrapEncrypt, error) {
return KeyWrapEncrypt{
alg: alg,
sharedkey: sharedkey,
}, nil
}
|
go
|
func NewKeyWrapEncrypt(alg jwa.KeyEncryptionAlgorithm, sharedkey []byte) (KeyWrapEncrypt, error) {
return KeyWrapEncrypt{
alg: alg,
sharedkey: sharedkey,
}, nil
}
|
[
"func",
"NewKeyWrapEncrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"sharedkey",
"[",
"]",
"byte",
")",
"(",
"KeyWrapEncrypt",
",",
"error",
")",
"{",
"return",
"KeyWrapEncrypt",
"{",
"alg",
":",
"alg",
",",
"sharedkey",
":",
"sharedkey",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewKeyWrapEncrypt creates a key-wrap encrypter using AES-CGM.
// Although the name suggests otherwise, this does the decryption as well.
|
[
"NewKeyWrapEncrypt",
"creates",
"a",
"key",
"-",
"wrap",
"encrypter",
"using",
"AES",
"-",
"CGM",
".",
"Although",
"the",
"name",
"suggests",
"otherwise",
"this",
"does",
"the",
"decryption",
"as",
"well",
"."
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L25-L30
|
143,290 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyDecrypt
|
func (kw KeyWrapEncrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
block, err := aes.NewCipher(kw.sharedkey)
if err != nil {
return nil, errors.Wrap(err, "failed to create cipher from shared key")
}
cek, err := keyunwrap(block, enckey)
if err != nil {
return nil, errors.Wrap(err, "failed to unwrap data")
}
return cek, nil
}
|
go
|
func (kw KeyWrapEncrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
block, err := aes.NewCipher(kw.sharedkey)
if err != nil {
return nil, errors.Wrap(err, "failed to create cipher from shared key")
}
cek, err := keyunwrap(block, enckey)
if err != nil {
return nil, errors.Wrap(err, "failed to unwrap data")
}
return cek, nil
}
|
[
"func",
"(",
"kw",
"KeyWrapEncrypt",
")",
"KeyDecrypt",
"(",
"enckey",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"kw",
".",
"sharedkey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cek",
",",
"err",
":=",
"keyunwrap",
"(",
"block",
",",
"enckey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"cek",
",",
"nil",
"\n",
"}"
] |
// KeyDecrypt decrypts the encrypted key using AES-CGM key unwrap
|
[
"KeyDecrypt",
"decrypts",
"the",
"encrypted",
"key",
"using",
"AES",
"-",
"CGM",
"key",
"unwrap"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L43-L54
|
143,291 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyEncrypt
|
func (kw KeyWrapEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
block, err := aes.NewCipher(kw.sharedkey)
if err != nil {
return nil, errors.Wrap(err, "failed to create cipher from shared key")
}
encrypted, err := keywrap(block, cek)
if err != nil {
return nil, errors.Wrap(err, `keywrap: failed to wrap key`)
}
return ByteKey(encrypted), nil
}
|
go
|
func (kw KeyWrapEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
block, err := aes.NewCipher(kw.sharedkey)
if err != nil {
return nil, errors.Wrap(err, "failed to create cipher from shared key")
}
encrypted, err := keywrap(block, cek)
if err != nil {
return nil, errors.Wrap(err, `keywrap: failed to wrap key`)
}
return ByteKey(encrypted), nil
}
|
[
"func",
"(",
"kw",
"KeyWrapEncrypt",
")",
"KeyEncrypt",
"(",
"cek",
"[",
"]",
"byte",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"kw",
".",
"sharedkey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"encrypted",
",",
"err",
":=",
"keywrap",
"(",
"block",
",",
"cek",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`keywrap: failed to wrap key`",
")",
"\n",
"}",
"\n",
"return",
"ByteKey",
"(",
"encrypted",
")",
",",
"nil",
"\n",
"}"
] |
// KeyEncrypt encrypts the given content encryption key
|
[
"KeyEncrypt",
"encrypts",
"the",
"given",
"content",
"encryption",
"key"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L57-L67
|
143,292 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewEcdhesKeyWrapEncrypt
|
func NewEcdhesKeyWrapEncrypt(alg jwa.KeyEncryptionAlgorithm, key *ecdsa.PublicKey) (*EcdhesKeyWrapEncrypt, error) {
generator, err := NewEcdhesKeyGenerate(alg, key)
if err != nil {
return nil, errors.Wrap(err, "failed to create key generator")
}
return &EcdhesKeyWrapEncrypt{
algorithm: alg,
generator: generator,
}, nil
}
|
go
|
func NewEcdhesKeyWrapEncrypt(alg jwa.KeyEncryptionAlgorithm, key *ecdsa.PublicKey) (*EcdhesKeyWrapEncrypt, error) {
generator, err := NewEcdhesKeyGenerate(alg, key)
if err != nil {
return nil, errors.Wrap(err, "failed to create key generator")
}
return &EcdhesKeyWrapEncrypt{
algorithm: alg,
generator: generator,
}, nil
}
|
[
"func",
"NewEcdhesKeyWrapEncrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"key",
"*",
"ecdsa",
".",
"PublicKey",
")",
"(",
"*",
"EcdhesKeyWrapEncrypt",
",",
"error",
")",
"{",
"generator",
",",
"err",
":=",
"NewEcdhesKeyGenerate",
"(",
"alg",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"EcdhesKeyWrapEncrypt",
"{",
"algorithm",
":",
"alg",
",",
"generator",
":",
"generator",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewEcdhesKeyWrapEncrypt creates a new key encrypter based on ECDH-ES
|
[
"NewEcdhesKeyWrapEncrypt",
"creates",
"a",
"new",
"key",
"encrypter",
"based",
"on",
"ECDH",
"-",
"ES"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L70-L79
|
143,293 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyEncrypt
|
func (kw EcdhesKeyWrapEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
kg, err := kw.generator.KeyGenerate()
if err != nil {
return nil, errors.Wrap(err, "failed to create key generator")
}
bwpk, ok := kg.(ByteWithECPrivateKey)
if !ok {
return nil, errors.New("key generator generated invalid key (expected ByteWithECPrivateKey)")
}
block, err := aes.NewCipher(bwpk.Bytes())
if err != nil {
return nil, errors.Wrap(err, "failed to generate cipher from generated key")
}
jek, err := keywrap(block, cek)
if err != nil {
return nil, errors.Wrap(err, "failed to wrap data")
}
bwpk.ByteKey = ByteKey(jek)
return bwpk, nil
}
|
go
|
func (kw EcdhesKeyWrapEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
kg, err := kw.generator.KeyGenerate()
if err != nil {
return nil, errors.Wrap(err, "failed to create key generator")
}
bwpk, ok := kg.(ByteWithECPrivateKey)
if !ok {
return nil, errors.New("key generator generated invalid key (expected ByteWithECPrivateKey)")
}
block, err := aes.NewCipher(bwpk.Bytes())
if err != nil {
return nil, errors.Wrap(err, "failed to generate cipher from generated key")
}
jek, err := keywrap(block, cek)
if err != nil {
return nil, errors.Wrap(err, "failed to wrap data")
}
bwpk.ByteKey = ByteKey(jek)
return bwpk, nil
}
|
[
"func",
"(",
"kw",
"EcdhesKeyWrapEncrypt",
")",
"KeyEncrypt",
"(",
"cek",
"[",
"]",
"byte",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"kg",
",",
"err",
":=",
"kw",
".",
"generator",
".",
"KeyGenerate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"bwpk",
",",
"ok",
":=",
"kg",
".",
"(",
"ByteWithECPrivateKey",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"bwpk",
".",
"Bytes",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"jek",
",",
"err",
":=",
"keywrap",
"(",
"block",
",",
"cek",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"bwpk",
".",
"ByteKey",
"=",
"ByteKey",
"(",
"jek",
")",
"\n\n",
"return",
"bwpk",
",",
"nil",
"\n",
"}"
] |
// KeyEncrypt encrypts the content encryption key using ECDH-ES
|
[
"KeyEncrypt",
"encrypts",
"the",
"content",
"encryption",
"key",
"using",
"ECDH",
"-",
"ES"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L92-L116
|
143,294 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewEcdhesKeyWrapDecrypt
|
func NewEcdhesKeyWrapDecrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *ecdsa.PublicKey, apu, apv []byte, privkey *ecdsa.PrivateKey) *EcdhesKeyWrapDecrypt {
return &EcdhesKeyWrapDecrypt{
algorithm: alg,
apu: apu,
apv: apv,
privkey: privkey,
pubkey: pubkey,
}
}
|
go
|
func NewEcdhesKeyWrapDecrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *ecdsa.PublicKey, apu, apv []byte, privkey *ecdsa.PrivateKey) *EcdhesKeyWrapDecrypt {
return &EcdhesKeyWrapDecrypt{
algorithm: alg,
apu: apu,
apv: apv,
privkey: privkey,
pubkey: pubkey,
}
}
|
[
"func",
"NewEcdhesKeyWrapDecrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"pubkey",
"*",
"ecdsa",
".",
"PublicKey",
",",
"apu",
",",
"apv",
"[",
"]",
"byte",
",",
"privkey",
"*",
"ecdsa",
".",
"PrivateKey",
")",
"*",
"EcdhesKeyWrapDecrypt",
"{",
"return",
"&",
"EcdhesKeyWrapDecrypt",
"{",
"algorithm",
":",
"alg",
",",
"apu",
":",
"apu",
",",
"apv",
":",
"apv",
",",
"privkey",
":",
"privkey",
",",
"pubkey",
":",
"pubkey",
",",
"}",
"\n",
"}"
] |
// NewEcdhesKeyWrapDecrypt creates a new key decrypter using ECDH-ES
|
[
"NewEcdhesKeyWrapDecrypt",
"creates",
"a",
"new",
"key",
"decrypter",
"using",
"ECDH",
"-",
"ES"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L119-L127
|
143,295 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyDecrypt
|
func (kw EcdhesKeyWrapDecrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
var keysize uint32
switch kw.algorithm {
case jwa.ECDH_ES_A128KW:
keysize = 16
case jwa.ECDH_ES_A192KW:
keysize = 24
case jwa.ECDH_ES_A256KW:
keysize = 32
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid ECDH-ES key wrap algorithm")
}
privkey := kw.privkey
pubkey := kw.pubkey
pubinfo := make([]byte, 4)
binary.BigEndian.PutUint32(pubinfo, keysize*8)
z, _ := privkey.PublicKey.Curve.ScalarMult(pubkey.X, pubkey.Y, privkey.D.Bytes())
kdf := concatkdf.New(crypto.SHA256, []byte(kw.algorithm.String()), z.Bytes(), kw.apu, kw.apv, pubinfo, []byte{})
kek := make([]byte, keysize)
kdf.Read(kek)
block, err := aes.NewCipher(kek)
if err != nil {
return nil, errors.Wrap(err, "failed to create cipher for ECDH-ES key wrap")
}
return keyunwrap(block, enckey)
}
|
go
|
func (kw EcdhesKeyWrapDecrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
var keysize uint32
switch kw.algorithm {
case jwa.ECDH_ES_A128KW:
keysize = 16
case jwa.ECDH_ES_A192KW:
keysize = 24
case jwa.ECDH_ES_A256KW:
keysize = 32
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid ECDH-ES key wrap algorithm")
}
privkey := kw.privkey
pubkey := kw.pubkey
pubinfo := make([]byte, 4)
binary.BigEndian.PutUint32(pubinfo, keysize*8)
z, _ := privkey.PublicKey.Curve.ScalarMult(pubkey.X, pubkey.Y, privkey.D.Bytes())
kdf := concatkdf.New(crypto.SHA256, []byte(kw.algorithm.String()), z.Bytes(), kw.apu, kw.apv, pubinfo, []byte{})
kek := make([]byte, keysize)
kdf.Read(kek)
block, err := aes.NewCipher(kek)
if err != nil {
return nil, errors.Wrap(err, "failed to create cipher for ECDH-ES key wrap")
}
return keyunwrap(block, enckey)
}
|
[
"func",
"(",
"kw",
"EcdhesKeyWrapDecrypt",
")",
"KeyDecrypt",
"(",
"enckey",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"keysize",
"uint32",
"\n",
"switch",
"kw",
".",
"algorithm",
"{",
"case",
"jwa",
".",
"ECDH_ES_A128KW",
":",
"keysize",
"=",
"16",
"\n",
"case",
"jwa",
".",
"ECDH_ES_A192KW",
":",
"keysize",
"=",
"24",
"\n",
"case",
"jwa",
".",
"ECDH_ES_A256KW",
":",
"keysize",
"=",
"32",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"ErrUnsupportedAlgorithm",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"privkey",
":=",
"kw",
".",
"privkey",
"\n",
"pubkey",
":=",
"kw",
".",
"pubkey",
"\n\n",
"pubinfo",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"pubinfo",
",",
"keysize",
"*",
"8",
")",
"\n\n",
"z",
",",
"_",
":=",
"privkey",
".",
"PublicKey",
".",
"Curve",
".",
"ScalarMult",
"(",
"pubkey",
".",
"X",
",",
"pubkey",
".",
"Y",
",",
"privkey",
".",
"D",
".",
"Bytes",
"(",
")",
")",
"\n",
"kdf",
":=",
"concatkdf",
".",
"New",
"(",
"crypto",
".",
"SHA256",
",",
"[",
"]",
"byte",
"(",
"kw",
".",
"algorithm",
".",
"String",
"(",
")",
")",
",",
"z",
".",
"Bytes",
"(",
")",
",",
"kw",
".",
"apu",
",",
"kw",
".",
"apv",
",",
"pubinfo",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"kek",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"keysize",
")",
"\n",
"kdf",
".",
"Read",
"(",
"kek",
")",
"\n\n",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"kek",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"keyunwrap",
"(",
"block",
",",
"enckey",
")",
"\n",
"}"
] |
// KeyDecrypt decrypts the encrypted key using ECDH-ES
|
[
"KeyDecrypt",
"decrypts",
"the",
"encrypted",
"key",
"using",
"ECDH",
"-",
"ES"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L135-L165
|
143,296 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewRSAOAEPKeyEncrypt
|
func NewRSAOAEPKeyEncrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RSAOAEPKeyEncrypt, error) {
switch alg {
case jwa.RSA_OAEP, jwa.RSA_OAEP_256:
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA OAEP encrypt algorithm")
}
return &RSAOAEPKeyEncrypt{
alg: alg,
pubkey: pubkey,
}, nil
}
|
go
|
func NewRSAOAEPKeyEncrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RSAOAEPKeyEncrypt, error) {
switch alg {
case jwa.RSA_OAEP, jwa.RSA_OAEP_256:
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA OAEP encrypt algorithm")
}
return &RSAOAEPKeyEncrypt{
alg: alg,
pubkey: pubkey,
}, nil
}
|
[
"func",
"NewRSAOAEPKeyEncrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"pubkey",
"*",
"rsa",
".",
"PublicKey",
")",
"(",
"*",
"RSAOAEPKeyEncrypt",
",",
"error",
")",
"{",
"switch",
"alg",
"{",
"case",
"jwa",
".",
"RSA_OAEP",
",",
"jwa",
".",
"RSA_OAEP_256",
":",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"ErrUnsupportedAlgorithm",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"RSAOAEPKeyEncrypt",
"{",
"alg",
":",
"alg",
",",
"pubkey",
":",
"pubkey",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewRSAOAEPKeyEncrypt creates a new key encrypter using RSA OAEP
|
[
"NewRSAOAEPKeyEncrypt",
"creates",
"a",
"new",
"key",
"encrypter",
"using",
"RSA",
"OAEP"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L168-L178
|
143,297 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewRSAPKCSKeyEncrypt
|
func NewRSAPKCSKeyEncrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RSAPKCSKeyEncrypt, error) {
switch alg {
case jwa.RSA1_5:
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA PKCS encrypt algorithm")
}
return &RSAPKCSKeyEncrypt{
alg: alg,
pubkey: pubkey,
}, nil
}
|
go
|
func NewRSAPKCSKeyEncrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RSAPKCSKeyEncrypt, error) {
switch alg {
case jwa.RSA1_5:
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA PKCS encrypt algorithm")
}
return &RSAPKCSKeyEncrypt{
alg: alg,
pubkey: pubkey,
}, nil
}
|
[
"func",
"NewRSAPKCSKeyEncrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"pubkey",
"*",
"rsa",
".",
"PublicKey",
")",
"(",
"*",
"RSAPKCSKeyEncrypt",
",",
"error",
")",
"{",
"switch",
"alg",
"{",
"case",
"jwa",
".",
"RSA1_5",
":",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"ErrUnsupportedAlgorithm",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"RSAPKCSKeyEncrypt",
"{",
"alg",
":",
"alg",
",",
"pubkey",
":",
"pubkey",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewRSAPKCSKeyEncrypt creates a new key encrypter using PKCS1v15
|
[
"NewRSAPKCSKeyEncrypt",
"creates",
"a",
"new",
"key",
"encrypter",
"using",
"PKCS1v15"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L181-L192
|
143,298 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyEncrypt
|
func (e RSAPKCSKeyEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
if e.alg != jwa.RSA1_5 {
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA PKCS encrypt algorithm")
}
encrypted, err := rsa.EncryptPKCS1v15(rand.Reader, e.pubkey, cek)
if err != nil {
return nil, errors.Wrap(err, "failed to encrypt using PKCS1v15")
}
return ByteKey(encrypted), nil
}
|
go
|
func (e RSAPKCSKeyEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
if e.alg != jwa.RSA1_5 {
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA PKCS encrypt algorithm")
}
encrypted, err := rsa.EncryptPKCS1v15(rand.Reader, e.pubkey, cek)
if err != nil {
return nil, errors.Wrap(err, "failed to encrypt using PKCS1v15")
}
return ByteKey(encrypted), nil
}
|
[
"func",
"(",
"e",
"RSAPKCSKeyEncrypt",
")",
"KeyEncrypt",
"(",
"cek",
"[",
"]",
"byte",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"if",
"e",
".",
"alg",
"!=",
"jwa",
".",
"RSA1_5",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"ErrUnsupportedAlgorithm",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"encrypted",
",",
"err",
":=",
"rsa",
".",
"EncryptPKCS1v15",
"(",
"rand",
".",
"Reader",
",",
"e",
".",
"pubkey",
",",
"cek",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"ByteKey",
"(",
"encrypted",
")",
",",
"nil",
"\n",
"}"
] |
// KeyEncrypt encrypts the content encryption key using RSA PKCS1v15
|
[
"KeyEncrypt",
"encrypts",
"the",
"content",
"encryption",
"key",
"using",
"RSA",
"PKCS1v15"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L215-L224
|
143,299 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyEncrypt
|
func (e RSAOAEPKeyEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
var hash hash.Hash
switch e.alg {
case jwa.RSA_OAEP:
hash = sha1.New()
case jwa.RSA_OAEP_256:
hash = sha256.New()
default:
return nil, errors.New("failed to generate key encrypter for RSA-OAEP: RSA_OAEP/RSA_OAEP_256 required")
}
encrypted, err := rsa.EncryptOAEP(hash, rand.Reader, e.pubkey, cek, []byte{})
if err != nil {
return nil, errors.Wrap(err, `failed to OAEP encrypt`)
}
return ByteKey(encrypted), nil
}
|
go
|
func (e RSAOAEPKeyEncrypt) KeyEncrypt(cek []byte) (ByteSource, error) {
var hash hash.Hash
switch e.alg {
case jwa.RSA_OAEP:
hash = sha1.New()
case jwa.RSA_OAEP_256:
hash = sha256.New()
default:
return nil, errors.New("failed to generate key encrypter for RSA-OAEP: RSA_OAEP/RSA_OAEP_256 required")
}
encrypted, err := rsa.EncryptOAEP(hash, rand.Reader, e.pubkey, cek, []byte{})
if err != nil {
return nil, errors.Wrap(err, `failed to OAEP encrypt`)
}
return ByteKey(encrypted), nil
}
|
[
"func",
"(",
"e",
"RSAOAEPKeyEncrypt",
")",
"KeyEncrypt",
"(",
"cek",
"[",
"]",
"byte",
")",
"(",
"ByteSource",
",",
"error",
")",
"{",
"var",
"hash",
"hash",
".",
"Hash",
"\n",
"switch",
"e",
".",
"alg",
"{",
"case",
"jwa",
".",
"RSA_OAEP",
":",
"hash",
"=",
"sha1",
".",
"New",
"(",
")",
"\n",
"case",
"jwa",
".",
"RSA_OAEP_256",
":",
"hash",
"=",
"sha256",
".",
"New",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"encrypted",
",",
"err",
":=",
"rsa",
".",
"EncryptOAEP",
"(",
"hash",
",",
"rand",
".",
"Reader",
",",
"e",
".",
"pubkey",
",",
"cek",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"`failed to OAEP encrypt`",
")",
"\n",
"}",
"\n",
"return",
"ByteKey",
"(",
"encrypted",
")",
",",
"nil",
"\n",
"}"
] |
// KeyEncrypt encrypts the content encryption key using RSA OAEP
|
[
"KeyEncrypt",
"encrypts",
"the",
"content",
"encryption",
"key",
"using",
"RSA",
"OAEP"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L227-L242
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.