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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
mdlayher/netlink | attribute.go | Uint8 | func (ae *AttributeEncoder) Uint8(typ uint16, v uint8) {
if ae.err != nil {
return
}
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: []byte{v},
})
} | go | func (ae *AttributeEncoder) Uint8(typ uint16, v uint8) {
if ae.err != nil {
return
}
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: []byte{v},
})
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"Uint8",
"(",
"typ",
"uint16",
",",
"v",
"uint8",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"ae",
".",
"attrs",
"=",
"append",
"(",
"ae",
".",
"attrs",
",",
"Attribute",
"{",
"Type",
":",
"typ",
",",
"Data",
":",
"[",
"]",
"byte",
"{",
"v",
"}",
",",
"}",
")",
"\n",
"}"
] | // Uint8 encodes uint8 data into an Attribute specified by typ. | [
"Uint8",
"encodes",
"uint8",
"data",
"into",
"an",
"Attribute",
"specified",
"by",
"typ",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L331-L340 | train |
mdlayher/netlink | attribute.go | Uint16 | func (ae *AttributeEncoder) Uint16(typ uint16, v uint16) {
if ae.err != nil {
return
}
b := make([]byte, 2)
ae.ByteOrder.PutUint16(b, v)
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | go | func (ae *AttributeEncoder) Uint16(typ uint16, v uint16) {
if ae.err != nil {
return
}
b := make([]byte, 2)
ae.ByteOrder.PutUint16(b, v)
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"Uint16",
"(",
"typ",
"uint16",
",",
"v",
"uint16",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"ae",
".",
"ByteOrder",
".",
"PutUint16",
"(",
"b",
",",
"v",
")",
"\n\n",
"ae",
".",
"attrs",
"=",
"append",
"(",
"ae",
".",
"attrs",
",",
"Attribute",
"{",
"Type",
":",
"typ",
",",
"Data",
":",
"b",
",",
"}",
")",
"\n",
"}"
] | // Uint16 encodes uint16 data into an Attribute specified by typ. | [
"Uint16",
"encodes",
"uint16",
"data",
"into",
"an",
"Attribute",
"specified",
"by",
"typ",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L343-L355 | train |
mdlayher/netlink | attribute.go | Uint32 | func (ae *AttributeEncoder) Uint32(typ uint16, v uint32) {
if ae.err != nil {
return
}
b := make([]byte, 4)
ae.ByteOrder.PutUint32(b, v)
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | go | func (ae *AttributeEncoder) Uint32(typ uint16, v uint32) {
if ae.err != nil {
return
}
b := make([]byte, 4)
ae.ByteOrder.PutUint32(b, v)
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"Uint32",
"(",
"typ",
"uint16",
",",
"v",
"uint32",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"ae",
".",
"ByteOrder",
".",
"PutUint32",
"(",
"b",
",",
"v",
")",
"\n\n",
"ae",
".",
"attrs",
"=",
"append",
"(",
"ae",
".",
"attrs",
",",
"Attribute",
"{",
"Type",
":",
"typ",
",",
"Data",
":",
"b",
",",
"}",
")",
"\n",
"}"
] | // Uint32 encodes uint32 data into an Attribute specified by typ. | [
"Uint32",
"encodes",
"uint32",
"data",
"into",
"an",
"Attribute",
"specified",
"by",
"typ",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L358-L370 | train |
mdlayher/netlink | attribute.go | Uint64 | func (ae *AttributeEncoder) Uint64(typ uint16, v uint64) {
if ae.err != nil {
return
}
b := make([]byte, 8)
ae.ByteOrder.PutUint64(b, v)
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | go | func (ae *AttributeEncoder) Uint64(typ uint16, v uint64) {
if ae.err != nil {
return
}
b := make([]byte, 8)
ae.ByteOrder.PutUint64(b, v)
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"Uint64",
"(",
"typ",
"uint16",
",",
"v",
"uint64",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"ae",
".",
"ByteOrder",
".",
"PutUint64",
"(",
"b",
",",
"v",
")",
"\n\n",
"ae",
".",
"attrs",
"=",
"append",
"(",
"ae",
".",
"attrs",
",",
"Attribute",
"{",
"Type",
":",
"typ",
",",
"Data",
":",
"b",
",",
"}",
")",
"\n",
"}"
] | // Uint64 encodes uint64 data into an Attribute specified by typ. | [
"Uint64",
"encodes",
"uint64",
"data",
"into",
"an",
"Attribute",
"specified",
"by",
"typ",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L373-L385 | train |
mdlayher/netlink | attribute.go | String | func (ae *AttributeEncoder) String(typ uint16, s string) {
if ae.err != nil {
return
}
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: nlenc.Bytes(s),
})
} | go | func (ae *AttributeEncoder) String(typ uint16, s string) {
if ae.err != nil {
return
}
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: nlenc.Bytes(s),
})
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"String",
"(",
"typ",
"uint16",
",",
"s",
"string",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"ae",
".",
"attrs",
"=",
"append",
"(",
"ae",
".",
"attrs",
",",
"Attribute",
"{",
"Type",
":",
"typ",
",",
"Data",
":",
"nlenc",
".",
"Bytes",
"(",
"s",
")",
",",
"}",
")",
"\n",
"}"
] | // String encodes string s as a null-terminated string into an Attribute
// specified by typ. | [
"String",
"encodes",
"string",
"s",
"as",
"a",
"null",
"-",
"terminated",
"string",
"into",
"an",
"Attribute",
"specified",
"by",
"typ",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L389-L398 | train |
mdlayher/netlink | attribute.go | Bytes | func (ae *AttributeEncoder) Bytes(typ uint16, b []byte) {
if ae.err != nil {
return
}
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | go | func (ae *AttributeEncoder) Bytes(typ uint16, b []byte) {
if ae.err != nil {
return
}
ae.attrs = append(ae.attrs, Attribute{
Type: typ,
Data: b,
})
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"Bytes",
"(",
"typ",
"uint16",
",",
"b",
"[",
"]",
"byte",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"ae",
".",
"attrs",
"=",
"append",
"(",
"ae",
".",
"attrs",
",",
"Attribute",
"{",
"Type",
":",
"typ",
",",
"Data",
":",
"b",
",",
"}",
")",
"\n",
"}"
] | // Bytes embeds raw byte data into an Attribute specified by typ. | [
"Bytes",
"embeds",
"raw",
"byte",
"data",
"into",
"an",
"Attribute",
"specified",
"by",
"typ",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L401-L410 | train |
mdlayher/netlink | attribute.go | Encode | func (ae *AttributeEncoder) Encode() ([]byte, error) {
if ae.err != nil {
return nil, ae.err
}
return MarshalAttributes(ae.attrs)
} | go | func (ae *AttributeEncoder) Encode() ([]byte, error) {
if ae.err != nil {
return nil, ae.err
}
return MarshalAttributes(ae.attrs)
} | [
"func",
"(",
"ae",
"*",
"AttributeEncoder",
")",
"Encode",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"ae",
".",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"ae",
".",
"err",
"\n",
"}",
"\n\n",
"return",
"MarshalAttributes",
"(",
"ae",
".",
"attrs",
")",
"\n",
"}"
] | // Encode returns the encoded bytes representing the attributes. | [
"Encode",
"returns",
"the",
"encoded",
"bytes",
"representing",
"the",
"attributes",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/attribute.go#L436-L442 | train |
mdlayher/netlink | conn.go | Dial | func Dial(family int, config *Config) (*Conn, error) {
// Use OS-specific dial() to create Socket
c, pid, err := dial(family, config)
if err != nil {
return nil, err
}
return NewConn(c, pid), nil
} | go | func Dial(family int, config *Config) (*Conn, error) {
// Use OS-specific dial() to create Socket
c, pid, err := dial(family, config)
if err != nil {
return nil, err
}
return NewConn(c, pid), nil
} | [
"func",
"Dial",
"(",
"family",
"int",
",",
"config",
"*",
"Config",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"// Use OS-specific dial() to create Socket",
"c",
",",
"pid",
",",
"err",
":=",
"dial",
"(",
"family",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewConn",
"(",
"c",
",",
"pid",
")",
",",
"nil",
"\n",
"}"
] | // Dial dials a connection to netlink, using the specified netlink family.
// Config specifies optional configuration for Conn. If config is nil, a default
// configuration will be used. | [
"Dial",
"dials",
"a",
"connection",
"to",
"netlink",
"using",
"the",
"specified",
"netlink",
"family",
".",
"Config",
"specifies",
"optional",
"configuration",
"for",
"Conn",
".",
"If",
"config",
"is",
"nil",
"a",
"default",
"configuration",
"will",
"be",
"used",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L53-L61 | train |
mdlayher/netlink | conn.go | NewConn | func NewConn(sock Socket, pid uint32) *Conn {
// Seed the sequence number using a random number generator.
r := rand.New(rand.NewSource(time.Now().UnixNano()))
seq := r.Uint32()
// Configure a debugger if arguments are set.
var d *debugger
if len(debugArgs) > 0 {
d = newDebugger(debugArgs)
}
return &Conn{
sock: sock,
seq: &seq,
pid: pid,
d: d,
}
} | go | func NewConn(sock Socket, pid uint32) *Conn {
// Seed the sequence number using a random number generator.
r := rand.New(rand.NewSource(time.Now().UnixNano()))
seq := r.Uint32()
// Configure a debugger if arguments are set.
var d *debugger
if len(debugArgs) > 0 {
d = newDebugger(debugArgs)
}
return &Conn{
sock: sock,
seq: &seq,
pid: pid,
d: d,
}
} | [
"func",
"NewConn",
"(",
"sock",
"Socket",
",",
"pid",
"uint32",
")",
"*",
"Conn",
"{",
"// Seed the sequence number using a random number generator.",
"r",
":=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
"seq",
":=",
"r",
".",
"Uint32",
"(",
")",
"\n\n",
"// Configure a debugger if arguments are set.",
"var",
"d",
"*",
"debugger",
"\n",
"if",
"len",
"(",
"debugArgs",
")",
">",
"0",
"{",
"d",
"=",
"newDebugger",
"(",
"debugArgs",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"Conn",
"{",
"sock",
":",
"sock",
",",
"seq",
":",
"&",
"seq",
",",
"pid",
":",
"pid",
",",
"d",
":",
"d",
",",
"}",
"\n",
"}"
] | // NewConn creates a Conn using the specified Socket and PID for netlink
// communications.
//
// NewConn is primarily useful for tests. Most applications should use
// Dial instead. | [
"NewConn",
"creates",
"a",
"Conn",
"using",
"the",
"specified",
"Socket",
"and",
"PID",
"for",
"netlink",
"communications",
".",
"NewConn",
"is",
"primarily",
"useful",
"for",
"tests",
".",
"Most",
"applications",
"should",
"use",
"Dial",
"instead",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L68-L85 | train |
mdlayher/netlink | conn.go | debug | func (c *Conn) debug(fn func(d *debugger)) {
if c.d == nil {
return
}
fn(c.d)
} | go | func (c *Conn) debug(fn func(d *debugger)) {
if c.d == nil {
return
}
fn(c.d)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"debug",
"(",
"fn",
"func",
"(",
"d",
"*",
"debugger",
")",
")",
"{",
"if",
"c",
".",
"d",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"fn",
"(",
"c",
".",
"d",
")",
"\n",
"}"
] | // debug executes fn with the debugger if the debugger is not nil. | [
"debug",
"executes",
"fn",
"with",
"the",
"debugger",
"if",
"the",
"debugger",
"is",
"not",
"nil",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L88-L94 | train |
mdlayher/netlink | conn.go | SendMessages | func (c *Conn) SendMessages(messages []Message) ([]Message, error) {
// Wait for any concurrent calls to Execute to finish before proceeding.
c.mu.RLock()
defer c.mu.RUnlock()
for idx, m := range messages {
ml := nlmsgLength(len(m.Data))
// TODO(mdlayher): fine-tune this limit.
if ml > (1024 * 32) {
return nil, errors.New("netlink message data too large")
}
c.fixMsg(&messages[idx], ml)
}
c.debug(func(d *debugger) {
for _, m := range messages {
d.debugf(1, "send msgs: %+v", m)
}
})
if err := c.sock.SendMessages(messages); err != nil {
c.debug(func(d *debugger) {
d.debugf(1, "send msgs: err: %v", err)
})
return nil, newOpError("send-messages", err)
}
return messages, nil
} | go | func (c *Conn) SendMessages(messages []Message) ([]Message, error) {
// Wait for any concurrent calls to Execute to finish before proceeding.
c.mu.RLock()
defer c.mu.RUnlock()
for idx, m := range messages {
ml := nlmsgLength(len(m.Data))
// TODO(mdlayher): fine-tune this limit.
if ml > (1024 * 32) {
return nil, errors.New("netlink message data too large")
}
c.fixMsg(&messages[idx], ml)
}
c.debug(func(d *debugger) {
for _, m := range messages {
d.debugf(1, "send msgs: %+v", m)
}
})
if err := c.sock.SendMessages(messages); err != nil {
c.debug(func(d *debugger) {
d.debugf(1, "send msgs: err: %v", err)
})
return nil, newOpError("send-messages", err)
}
return messages, nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SendMessages",
"(",
"messages",
"[",
"]",
"Message",
")",
"(",
"[",
"]",
"Message",
",",
"error",
")",
"{",
"// Wait for any concurrent calls to Execute to finish before proceeding.",
"c",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"idx",
",",
"m",
":=",
"range",
"messages",
"{",
"ml",
":=",
"nlmsgLength",
"(",
"len",
"(",
"m",
".",
"Data",
")",
")",
"\n\n",
"// TODO(mdlayher): fine-tune this limit.",
"if",
"ml",
">",
"(",
"1024",
"*",
"32",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"c",
".",
"fixMsg",
"(",
"&",
"messages",
"[",
"idx",
"]",
",",
"ml",
")",
"\n",
"}",
"\n\n",
"c",
".",
"debug",
"(",
"func",
"(",
"d",
"*",
"debugger",
")",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"messages",
"{",
"d",
".",
"debugf",
"(",
"1",
",",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
")",
"\n\n",
"if",
"err",
":=",
"c",
".",
"sock",
".",
"SendMessages",
"(",
"messages",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"debug",
"(",
"func",
"(",
"d",
"*",
"debugger",
")",
"{",
"d",
".",
"debugf",
"(",
"1",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
")",
"\n\n",
"return",
"nil",
",",
"newOpError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"messages",
",",
"nil",
"\n",
"}"
] | // SendMessages sends multiple Messages to netlink. The handling of
// a Header's Length, Sequence and PID fields is the same as when
// calling Send. | [
"SendMessages",
"sends",
"multiple",
"Messages",
"to",
"netlink",
".",
"The",
"handling",
"of",
"a",
"Header",
"s",
"Length",
"Sequence",
"and",
"PID",
"fields",
"is",
"the",
"same",
"as",
"when",
"calling",
"Send",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L144-L175 | train |
mdlayher/netlink | conn.go | Send | func (c *Conn) Send(message Message) (Message, error) {
// Wait for any concurrent calls to Execute to finish before proceeding.
c.mu.RLock()
defer c.mu.RUnlock()
return c.lockedSend(message)
} | go | func (c *Conn) Send(message Message) (Message, error) {
// Wait for any concurrent calls to Execute to finish before proceeding.
c.mu.RLock()
defer c.mu.RUnlock()
return c.lockedSend(message)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Send",
"(",
"message",
"Message",
")",
"(",
"Message",
",",
"error",
")",
"{",
"// Wait for any concurrent calls to Execute to finish before proceeding.",
"c",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"lockedSend",
"(",
"message",
")",
"\n",
"}"
] | // Send sends a single Message to netlink. In most cases, a Header's Length,
// Sequence, and PID fields should be set to 0, so they can be populated
// automatically before the Message is sent. On success, Send returns a copy
// of the Message with all parameters populated, for later validation.
//
// If Header.Length is 0, it will be automatically populated using the
// correct length for the Message, including its payload.
//
// If Header.Sequence is 0, it will be automatically populated using the
// next sequence number for this connection.
//
// If Header.PID is 0, it will be automatically populated using a PID
// assigned by netlink. | [
"Send",
"sends",
"a",
"single",
"Message",
"to",
"netlink",
".",
"In",
"most",
"cases",
"a",
"Header",
"s",
"Length",
"Sequence",
"and",
"PID",
"fields",
"should",
"be",
"set",
"to",
"0",
"so",
"they",
"can",
"be",
"populated",
"automatically",
"before",
"the",
"Message",
"is",
"sent",
".",
"On",
"success",
"Send",
"returns",
"a",
"copy",
"of",
"the",
"Message",
"with",
"all",
"parameters",
"populated",
"for",
"later",
"validation",
".",
"If",
"Header",
".",
"Length",
"is",
"0",
"it",
"will",
"be",
"automatically",
"populated",
"using",
"the",
"correct",
"length",
"for",
"the",
"Message",
"including",
"its",
"payload",
".",
"If",
"Header",
".",
"Sequence",
"is",
"0",
"it",
"will",
"be",
"automatically",
"populated",
"using",
"the",
"next",
"sequence",
"number",
"for",
"this",
"connection",
".",
"If",
"Header",
".",
"PID",
"is",
"0",
"it",
"will",
"be",
"automatically",
"populated",
"using",
"a",
"PID",
"assigned",
"by",
"netlink",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L190-L196 | train |
mdlayher/netlink | conn.go | lockedSend | func (c *Conn) lockedSend(message Message) (Message, error) {
ml := nlmsgLength(len(message.Data))
// TODO(mdlayher): fine-tune this limit.
if ml > (1024 * 32) {
return Message{}, errors.New("netlink message data too large")
}
c.fixMsg(&message, ml)
c.debug(func(d *debugger) {
d.debugf(1, "send: %+v", message)
})
if err := c.sock.Send(message); err != nil {
c.debug(func(d *debugger) {
d.debugf(1, "send: err: %v", err)
})
return Message{}, newOpError("send", err)
}
return message, nil
} | go | func (c *Conn) lockedSend(message Message) (Message, error) {
ml := nlmsgLength(len(message.Data))
// TODO(mdlayher): fine-tune this limit.
if ml > (1024 * 32) {
return Message{}, errors.New("netlink message data too large")
}
c.fixMsg(&message, ml)
c.debug(func(d *debugger) {
d.debugf(1, "send: %+v", message)
})
if err := c.sock.Send(message); err != nil {
c.debug(func(d *debugger) {
d.debugf(1, "send: err: %v", err)
})
return Message{}, newOpError("send", err)
}
return message, nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"lockedSend",
"(",
"message",
"Message",
")",
"(",
"Message",
",",
"error",
")",
"{",
"ml",
":=",
"nlmsgLength",
"(",
"len",
"(",
"message",
".",
"Data",
")",
")",
"\n\n",
"// TODO(mdlayher): fine-tune this limit.",
"if",
"ml",
">",
"(",
"1024",
"*",
"32",
")",
"{",
"return",
"Message",
"{",
"}",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"c",
".",
"fixMsg",
"(",
"&",
"message",
",",
"ml",
")",
"\n\n",
"c",
".",
"debug",
"(",
"func",
"(",
"d",
"*",
"debugger",
")",
"{",
"d",
".",
"debugf",
"(",
"1",
",",
"\"",
"\"",
",",
"message",
")",
"\n",
"}",
")",
"\n\n",
"if",
"err",
":=",
"c",
".",
"sock",
".",
"Send",
"(",
"message",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"debug",
"(",
"func",
"(",
"d",
"*",
"debugger",
")",
"{",
"d",
".",
"debugf",
"(",
"1",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
")",
"\n\n",
"return",
"Message",
"{",
"}",
",",
"newOpError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"message",
",",
"nil",
"\n",
"}"
] | // lockedSend implements Send, but must be called with c.mu acquired for reading.
// We rely on the kernel to deal with concurrent reads and writes to the netlink
// socket itself. | [
"lockedSend",
"implements",
"Send",
"but",
"must",
"be",
"called",
"with",
"c",
".",
"mu",
"acquired",
"for",
"reading",
".",
"We",
"rely",
"on",
"the",
"kernel",
"to",
"deal",
"with",
"concurrent",
"reads",
"and",
"writes",
"to",
"the",
"netlink",
"socket",
"itself",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L201-L224 | train |
mdlayher/netlink | conn.go | Receive | func (c *Conn) Receive() ([]Message, error) {
// Wait for any concurrent calls to Execute to finish before proceeding.
c.mu.RLock()
defer c.mu.RUnlock()
return c.lockedReceive()
} | go | func (c *Conn) Receive() ([]Message, error) {
// Wait for any concurrent calls to Execute to finish before proceeding.
c.mu.RLock()
defer c.mu.RUnlock()
return c.lockedReceive()
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Receive",
"(",
")",
"(",
"[",
"]",
"Message",
",",
"error",
")",
"{",
"// Wait for any concurrent calls to Execute to finish before proceeding.",
"c",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"lockedReceive",
"(",
")",
"\n",
"}"
] | // Receive receives one or more messages from netlink. Multi-part messages are
// handled transparently and returned as a single slice of Messages, with the
// final empty "multi-part done" message removed.
//
// If any of the messages indicate a netlink error, that error will be returned. | [
"Receive",
"receives",
"one",
"or",
"more",
"messages",
"from",
"netlink",
".",
"Multi",
"-",
"part",
"messages",
"are",
"handled",
"transparently",
"and",
"returned",
"as",
"a",
"single",
"slice",
"of",
"Messages",
"with",
"the",
"final",
"empty",
"multi",
"-",
"part",
"done",
"message",
"removed",
".",
"If",
"any",
"of",
"the",
"messages",
"indicate",
"a",
"netlink",
"error",
"that",
"error",
"will",
"be",
"returned",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L231-L237 | train |
mdlayher/netlink | conn.go | lockedReceive | func (c *Conn) lockedReceive() ([]Message, error) {
msgs, err := c.receive()
if err != nil {
c.debug(func(d *debugger) {
d.debugf(1, "recv: err: %v", err)
})
return nil, err
}
c.debug(func(d *debugger) {
for _, m := range msgs {
d.debugf(1, "recv: %+v", m)
}
})
// When using nltest, it's possible for zero messages to be returned by receive.
if len(msgs) == 0 {
return msgs, nil
}
// Trim the final message with multi-part done indicator if
// present.
if m := msgs[len(msgs)-1]; m.Header.Flags&Multi != 0 && m.Header.Type == Done {
return msgs[:len(msgs)-1], nil
}
return msgs, nil
} | go | func (c *Conn) lockedReceive() ([]Message, error) {
msgs, err := c.receive()
if err != nil {
c.debug(func(d *debugger) {
d.debugf(1, "recv: err: %v", err)
})
return nil, err
}
c.debug(func(d *debugger) {
for _, m := range msgs {
d.debugf(1, "recv: %+v", m)
}
})
// When using nltest, it's possible for zero messages to be returned by receive.
if len(msgs) == 0 {
return msgs, nil
}
// Trim the final message with multi-part done indicator if
// present.
if m := msgs[len(msgs)-1]; m.Header.Flags&Multi != 0 && m.Header.Type == Done {
return msgs[:len(msgs)-1], nil
}
return msgs, nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"lockedReceive",
"(",
")",
"(",
"[",
"]",
"Message",
",",
"error",
")",
"{",
"msgs",
",",
"err",
":=",
"c",
".",
"receive",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"debug",
"(",
"func",
"(",
"d",
"*",
"debugger",
")",
"{",
"d",
".",
"debugf",
"(",
"1",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
")",
"\n\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"debug",
"(",
"func",
"(",
"d",
"*",
"debugger",
")",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"msgs",
"{",
"d",
".",
"debugf",
"(",
"1",
",",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
")",
"\n\n",
"// When using nltest, it's possible for zero messages to be returned by receive.",
"if",
"len",
"(",
"msgs",
")",
"==",
"0",
"{",
"return",
"msgs",
",",
"nil",
"\n",
"}",
"\n\n",
"// Trim the final message with multi-part done indicator if",
"// present.",
"if",
"m",
":=",
"msgs",
"[",
"len",
"(",
"msgs",
")",
"-",
"1",
"]",
";",
"m",
".",
"Header",
".",
"Flags",
"&",
"Multi",
"!=",
"0",
"&&",
"m",
".",
"Header",
".",
"Type",
"==",
"Done",
"{",
"return",
"msgs",
"[",
":",
"len",
"(",
"msgs",
")",
"-",
"1",
"]",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"msgs",
",",
"nil",
"\n",
"}"
] | // lockedReceive implements Receive, but must be called with c.mu acquired for reading.
// We rely on the kernel to deal with concurrent reads and writes to the netlink
// socket itself. | [
"lockedReceive",
"implements",
"Receive",
"but",
"must",
"be",
"called",
"with",
"c",
".",
"mu",
"acquired",
"for",
"reading",
".",
"We",
"rely",
"on",
"the",
"kernel",
"to",
"deal",
"with",
"concurrent",
"reads",
"and",
"writes",
"to",
"the",
"netlink",
"socket",
"itself",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L242-L270 | train |
mdlayher/netlink | conn.go | receive | func (c *Conn) receive() ([]Message, error) {
// NB: All non-nil errors returned from this function *must* be of type
// OpError in order to maintain the appropriate contract with callers of
// this package.
//
// This contract also applies to functions called within this function,
// such as checkMessage.
var res []Message
for {
msgs, err := c.sock.Receive()
if err != nil {
return nil, newOpError("receive", err)
}
// If this message is multi-part, we will need to perform an recursive call
// to continue draining the socket
var multi bool
for _, m := range msgs {
if err := checkMessage(m); err != nil {
return nil, err
}
// Does this message indicate a multi-part message?
if m.Header.Flags&Multi == 0 {
// No, check the next messages.
continue
}
// Does this message indicate the last message in a series of
// multi-part messages from a single read?
multi = m.Header.Type != Done
}
res = append(res, msgs...)
if !multi {
// No more messages coming.
return res, nil
}
}
} | go | func (c *Conn) receive() ([]Message, error) {
// NB: All non-nil errors returned from this function *must* be of type
// OpError in order to maintain the appropriate contract with callers of
// this package.
//
// This contract also applies to functions called within this function,
// such as checkMessage.
var res []Message
for {
msgs, err := c.sock.Receive()
if err != nil {
return nil, newOpError("receive", err)
}
// If this message is multi-part, we will need to perform an recursive call
// to continue draining the socket
var multi bool
for _, m := range msgs {
if err := checkMessage(m); err != nil {
return nil, err
}
// Does this message indicate a multi-part message?
if m.Header.Flags&Multi == 0 {
// No, check the next messages.
continue
}
// Does this message indicate the last message in a series of
// multi-part messages from a single read?
multi = m.Header.Type != Done
}
res = append(res, msgs...)
if !multi {
// No more messages coming.
return res, nil
}
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"receive",
"(",
")",
"(",
"[",
"]",
"Message",
",",
"error",
")",
"{",
"// NB: All non-nil errors returned from this function *must* be of type",
"// OpError in order to maintain the appropriate contract with callers of",
"// this package.",
"//",
"// This contract also applies to functions called within this function,",
"// such as checkMessage.",
"var",
"res",
"[",
"]",
"Message",
"\n",
"for",
"{",
"msgs",
",",
"err",
":=",
"c",
".",
"sock",
".",
"Receive",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"newOpError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// If this message is multi-part, we will need to perform an recursive call",
"// to continue draining the socket",
"var",
"multi",
"bool",
"\n\n",
"for",
"_",
",",
"m",
":=",
"range",
"msgs",
"{",
"if",
"err",
":=",
"checkMessage",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Does this message indicate a multi-part message?",
"if",
"m",
".",
"Header",
".",
"Flags",
"&",
"Multi",
"==",
"0",
"{",
"// No, check the next messages.",
"continue",
"\n",
"}",
"\n\n",
"// Does this message indicate the last message in a series of",
"// multi-part messages from a single read?",
"multi",
"=",
"m",
".",
"Header",
".",
"Type",
"!=",
"Done",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"msgs",
"...",
")",
"\n\n",
"if",
"!",
"multi",
"{",
"// No more messages coming.",
"return",
"res",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // receive is the internal implementation of Conn.Receive, which can be called
// recursively to handle multi-part messages. | [
"receive",
"is",
"the",
"internal",
"implementation",
"of",
"Conn",
".",
"Receive",
"which",
"can",
"be",
"called",
"recursively",
"to",
"handle",
"multi",
"-",
"part",
"messages",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L274-L316 | train |
mdlayher/netlink | conn.go | JoinGroup | func (c *Conn) JoinGroup(group uint32) error {
conn, ok := c.sock.(groupJoinLeaver)
if !ok {
return notSupported("join-group")
}
return newOpError("join-group", conn.JoinGroup(group))
} | go | func (c *Conn) JoinGroup(group uint32) error {
conn, ok := c.sock.(groupJoinLeaver)
if !ok {
return notSupported("join-group")
}
return newOpError("join-group", conn.JoinGroup(group))
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"JoinGroup",
"(",
"group",
"uint32",
")",
"error",
"{",
"conn",
",",
"ok",
":=",
"c",
".",
"sock",
".",
"(",
"groupJoinLeaver",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"notSupported",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"newOpError",
"(",
"\"",
"\"",
",",
"conn",
".",
"JoinGroup",
"(",
"group",
")",
")",
"\n",
"}"
] | // JoinGroup joins a netlink multicast group by its ID. | [
"JoinGroup",
"joins",
"a",
"netlink",
"multicast",
"group",
"by",
"its",
"ID",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L327-L334 | train |
mdlayher/netlink | conn.go | SetBPF | func (c *Conn) SetBPF(filter []bpf.RawInstruction) error {
conn, ok := c.sock.(bpfSetter)
if !ok {
return notSupported("set-bpf")
}
return newOpError("set-bpf", conn.SetBPF(filter))
} | go | func (c *Conn) SetBPF(filter []bpf.RawInstruction) error {
conn, ok := c.sock.(bpfSetter)
if !ok {
return notSupported("set-bpf")
}
return newOpError("set-bpf", conn.SetBPF(filter))
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SetBPF",
"(",
"filter",
"[",
"]",
"bpf",
".",
"RawInstruction",
")",
"error",
"{",
"conn",
",",
"ok",
":=",
"c",
".",
"sock",
".",
"(",
"bpfSetter",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"notSupported",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"newOpError",
"(",
"\"",
"\"",
",",
"conn",
".",
"SetBPF",
"(",
"filter",
")",
")",
"\n",
"}"
] | // SetBPF attaches an assembled BPF program to a Conn. | [
"SetBPF",
"attaches",
"an",
"assembled",
"BPF",
"program",
"to",
"a",
"Conn",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L354-L361 | train |
mdlayher/netlink | conn.go | RemoveBPF | func (c *Conn) RemoveBPF() error {
conn, ok := c.sock.(bpfSetter)
if !ok {
return notSupported("remove-bpf")
}
return newOpError("remove-bpf", conn.RemoveBPF())
} | go | func (c *Conn) RemoveBPF() error {
conn, ok := c.sock.(bpfSetter)
if !ok {
return notSupported("remove-bpf")
}
return newOpError("remove-bpf", conn.RemoveBPF())
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"RemoveBPF",
"(",
")",
"error",
"{",
"conn",
",",
"ok",
":=",
"c",
".",
"sock",
".",
"(",
"bpfSetter",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"notSupported",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"newOpError",
"(",
"\"",
"\"",
",",
"conn",
".",
"RemoveBPF",
"(",
")",
")",
"\n",
"}"
] | // RemoveBPF removes a BPF filter from a Conn. | [
"RemoveBPF",
"removes",
"a",
"BPF",
"filter",
"from",
"a",
"Conn",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L364-L371 | train |
mdlayher/netlink | conn.go | SetDeadline | func (c *Conn) SetDeadline(t time.Time) error {
conn, ok := c.sock.(deadlineSetter)
if !ok {
return notSupported("set-deadline")
}
return newOpError("set-deadline", conn.SetDeadline(t))
} | go | func (c *Conn) SetDeadline(t time.Time) error {
conn, ok := c.sock.(deadlineSetter)
if !ok {
return notSupported("set-deadline")
}
return newOpError("set-deadline", conn.SetDeadline(t))
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SetDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"conn",
",",
"ok",
":=",
"c",
".",
"sock",
".",
"(",
"deadlineSetter",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"notSupported",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"newOpError",
"(",
"\"",
"\"",
",",
"conn",
".",
"SetDeadline",
"(",
"t",
")",
")",
"\n",
"}"
] | // SetDeadline sets the read and write deadlines associated with the connection.
//
// Deadline functionality is only supported on Go 1.12+. Calling this function
// on older versions of Go will result in an error. | [
"SetDeadline",
"sets",
"the",
"read",
"and",
"write",
"deadlines",
"associated",
"with",
"the",
"connection",
".",
"Deadline",
"functionality",
"is",
"only",
"supported",
"on",
"Go",
"1",
".",
"12",
"+",
".",
"Calling",
"this",
"function",
"on",
"older",
"versions",
"of",
"Go",
"will",
"result",
"in",
"an",
"error",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L385-L392 | train |
mdlayher/netlink | conn.go | fixMsg | func (c *Conn) fixMsg(m *Message, ml int) {
if m.Header.Length == 0 {
m.Header.Length = uint32(nlmsgAlign(ml))
}
if m.Header.Sequence == 0 {
m.Header.Sequence = c.nextSequence()
}
if m.Header.PID == 0 {
m.Header.PID = c.pid
}
} | go | func (c *Conn) fixMsg(m *Message, ml int) {
if m.Header.Length == 0 {
m.Header.Length = uint32(nlmsgAlign(ml))
}
if m.Header.Sequence == 0 {
m.Header.Sequence = c.nextSequence()
}
if m.Header.PID == 0 {
m.Header.PID = c.pid
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"fixMsg",
"(",
"m",
"*",
"Message",
",",
"ml",
"int",
")",
"{",
"if",
"m",
".",
"Header",
".",
"Length",
"==",
"0",
"{",
"m",
".",
"Header",
".",
"Length",
"=",
"uint32",
"(",
"nlmsgAlign",
"(",
"ml",
")",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Header",
".",
"Sequence",
"==",
"0",
"{",
"m",
".",
"Header",
".",
"Sequence",
"=",
"c",
".",
"nextSequence",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Header",
".",
"PID",
"==",
"0",
"{",
"m",
".",
"Header",
".",
"PID",
"=",
"c",
".",
"pid",
"\n",
"}",
"\n",
"}"
] | // fixMsg updates the fields of m using the logic specified in Send. | [
"fixMsg",
"updates",
"the",
"fields",
"of",
"m",
"using",
"the",
"logic",
"specified",
"in",
"Send",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L513-L525 | train |
mdlayher/netlink | conn.go | Validate | func Validate(request Message, replies []Message) error {
for _, m := range replies {
// Check for mismatched sequence, unless:
// - request had no sequence, meaning we are probably validating
// a multicast reply
if m.Header.Sequence != request.Header.Sequence && request.Header.Sequence != 0 {
return newOpError("validate", errMismatchedSequence)
}
// Check for mismatched PID, unless:
// - request had no PID, meaning we are either:
// - validating a multicast reply
// - netlink has not yet assigned us a PID
// - response had no PID, meaning it's from the kernel as a multicast reply
if m.Header.PID != request.Header.PID && request.Header.PID != 0 && m.Header.PID != 0 {
return newOpError("validate", errMismatchedPID)
}
}
return nil
} | go | func Validate(request Message, replies []Message) error {
for _, m := range replies {
// Check for mismatched sequence, unless:
// - request had no sequence, meaning we are probably validating
// a multicast reply
if m.Header.Sequence != request.Header.Sequence && request.Header.Sequence != 0 {
return newOpError("validate", errMismatchedSequence)
}
// Check for mismatched PID, unless:
// - request had no PID, meaning we are either:
// - validating a multicast reply
// - netlink has not yet assigned us a PID
// - response had no PID, meaning it's from the kernel as a multicast reply
if m.Header.PID != request.Header.PID && request.Header.PID != 0 && m.Header.PID != 0 {
return newOpError("validate", errMismatchedPID)
}
}
return nil
} | [
"func",
"Validate",
"(",
"request",
"Message",
",",
"replies",
"[",
"]",
"Message",
")",
"error",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"replies",
"{",
"// Check for mismatched sequence, unless:",
"// - request had no sequence, meaning we are probably validating",
"// a multicast reply",
"if",
"m",
".",
"Header",
".",
"Sequence",
"!=",
"request",
".",
"Header",
".",
"Sequence",
"&&",
"request",
".",
"Header",
".",
"Sequence",
"!=",
"0",
"{",
"return",
"newOpError",
"(",
"\"",
"\"",
",",
"errMismatchedSequence",
")",
"\n",
"}",
"\n\n",
"// Check for mismatched PID, unless:",
"// - request had no PID, meaning we are either:",
"// - validating a multicast reply",
"// - netlink has not yet assigned us a PID",
"// - response had no PID, meaning it's from the kernel as a multicast reply",
"if",
"m",
".",
"Header",
".",
"PID",
"!=",
"request",
".",
"Header",
".",
"PID",
"&&",
"request",
".",
"Header",
".",
"PID",
"!=",
"0",
"&&",
"m",
".",
"Header",
".",
"PID",
"!=",
"0",
"{",
"return",
"newOpError",
"(",
"\"",
"\"",
",",
"errMismatchedPID",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Validate validates one or more reply Messages against a request Message,
// ensuring that they contain matching sequence numbers and PIDs. | [
"Validate",
"validates",
"one",
"or",
"more",
"reply",
"Messages",
"against",
"a",
"request",
"Message",
"ensuring",
"that",
"they",
"contain",
"matching",
"sequence",
"numbers",
"and",
"PIDs",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn.go#L535-L555 | train |
mdlayher/netlink | errors.go | IsNotExist | func IsNotExist(err error) bool {
switch err := err.(type) {
case *OpError:
// TODO(mdlayher): more error handling logic?
// Unwrap the inner error and use the stdlib's logic.
return os.IsNotExist(err.Err)
default:
return os.IsNotExist(err)
}
} | go | func IsNotExist(err error) bool {
switch err := err.(type) {
case *OpError:
// TODO(mdlayher): more error handling logic?
// Unwrap the inner error and use the stdlib's logic.
return os.IsNotExist(err.Err)
default:
return os.IsNotExist(err)
}
} | [
"func",
"IsNotExist",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"err",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"*",
"OpError",
":",
"// TODO(mdlayher): more error handling logic?",
"// Unwrap the inner error and use the stdlib's logic.",
"return",
"os",
".",
"IsNotExist",
"(",
"err",
".",
"Err",
")",
"\n",
"default",
":",
"return",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // IsNotExist determines if an error is produced as the result of querying some
// file, object, resource, etc. which does not exist. Users of this package
// should always use netlink.IsNotExist, rather than os.IsNotExist, when
// checking for specific netlink-related errors.
//
// Errors types created by this package, such as OpError, can be used with
// IsNotExist, but this function also defers to the behavior of os.IsNotExist
// for unrecognized error types. | [
"IsNotExist",
"determines",
"if",
"an",
"error",
"is",
"produced",
"as",
"the",
"result",
"of",
"querying",
"some",
"file",
"object",
"resource",
"etc",
".",
"which",
"does",
"not",
"exist",
".",
"Users",
"of",
"this",
"package",
"should",
"always",
"use",
"netlink",
".",
"IsNotExist",
"rather",
"than",
"os",
".",
"IsNotExist",
"when",
"checking",
"for",
"specific",
"netlink",
"-",
"related",
"errors",
".",
"Errors",
"types",
"created",
"by",
"this",
"package",
"such",
"as",
"OpError",
"can",
"be",
"used",
"with",
"IsNotExist",
"but",
"this",
"function",
"also",
"defers",
"to",
"the",
"behavior",
"of",
"os",
".",
"IsNotExist",
"for",
"unrecognized",
"error",
"types",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/errors.go#L35-L45 | train |
mdlayher/netlink | errors.go | Temporary | func (e *OpError) Temporary() bool {
if ne, ok := e.Err.(*os.SyscallError); ok {
t, ok := ne.Err.(temporary)
return ok && t.Temporary()
}
t, ok := e.Err.(temporary)
return ok && t.Temporary()
} | go | func (e *OpError) Temporary() bool {
if ne, ok := e.Err.(*os.SyscallError); ok {
t, ok := ne.Err.(temporary)
return ok && t.Temporary()
}
t, ok := e.Err.(temporary)
return ok && t.Temporary()
} | [
"func",
"(",
"e",
"*",
"OpError",
")",
"Temporary",
"(",
")",
"bool",
"{",
"if",
"ne",
",",
"ok",
":=",
"e",
".",
"Err",
".",
"(",
"*",
"os",
".",
"SyscallError",
")",
";",
"ok",
"{",
"t",
",",
"ok",
":=",
"ne",
".",
"Err",
".",
"(",
"temporary",
")",
"\n",
"return",
"ok",
"&&",
"t",
".",
"Temporary",
"(",
")",
"\n",
"}",
"\n",
"t",
",",
"ok",
":=",
"e",
".",
"Err",
".",
"(",
"temporary",
")",
"\n",
"return",
"ok",
"&&",
"t",
".",
"Temporary",
"(",
")",
"\n",
"}"
] | // Temporary reports whether an operation may succeed if retried. | [
"Temporary",
"reports",
"whether",
"an",
"operation",
"may",
"succeed",
"if",
"retried",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/errors.go#L112-L119 | train |
mdlayher/netlink | netns_linux.go | setThreadNetNS | func setThreadNetNS(fd int) error {
return os.NewSyscallError("setns", unix.Setns(fd, unix.CLONE_NEWNET))
} | go | func setThreadNetNS(fd int) error {
return os.NewSyscallError("setns", unix.Setns(fd, unix.CLONE_NEWNET))
} | [
"func",
"setThreadNetNS",
"(",
"fd",
"int",
")",
"error",
"{",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"unix",
".",
"Setns",
"(",
"fd",
",",
"unix",
".",
"CLONE_NEWNET",
")",
")",
"\n",
"}"
] | // setThreadNetNS sets the network namespace of the thread of the current goroutine to
// the namespace described by the user-provided file descriptor. | [
"setThreadNetNS",
"sets",
"the",
"network",
"namespace",
"of",
"the",
"thread",
"of",
"the",
"current",
"goroutine",
"to",
"the",
"namespace",
"described",
"by",
"the",
"user",
"-",
"provided",
"file",
"descriptor",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/netns_linux.go#L25-L27 | train |
mdlayher/netlink | conn_linux.go | dial | func dial(family int, config *Config) (*conn, uint32, error) {
// Prepare sysSocket's internal loop and create the socket.
//
// The conditional is inverted because a zero value of false is desired
// if no config, but it's easier to interpret within this code when the
// value is inverted.
if config == nil {
config = &Config{}
}
sock, err := newSysSocket(config)
if err != nil {
return nil, 0, err
}
if err := sock.Socket(family); err != nil {
return nil, 0, os.NewSyscallError("socket", err)
}
return bind(sock, config)
} | go | func dial(family int, config *Config) (*conn, uint32, error) {
// Prepare sysSocket's internal loop and create the socket.
//
// The conditional is inverted because a zero value of false is desired
// if no config, but it's easier to interpret within this code when the
// value is inverted.
if config == nil {
config = &Config{}
}
sock, err := newSysSocket(config)
if err != nil {
return nil, 0, err
}
if err := sock.Socket(family); err != nil {
return nil, 0, os.NewSyscallError("socket", err)
}
return bind(sock, config)
} | [
"func",
"dial",
"(",
"family",
"int",
",",
"config",
"*",
"Config",
")",
"(",
"*",
"conn",
",",
"uint32",
",",
"error",
")",
"{",
"// Prepare sysSocket's internal loop and create the socket.",
"//",
"// The conditional is inverted because a zero value of false is desired",
"// if no config, but it's easier to interpret within this code when the",
"// value is inverted.",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"Config",
"{",
"}",
"\n",
"}",
"\n\n",
"sock",
",",
"err",
":=",
"newSysSocket",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"sock",
".",
"Socket",
"(",
"family",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"0",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"bind",
"(",
"sock",
",",
"config",
")",
"\n",
"}"
] | // dial is the entry point for Dial. dial opens a netlink socket using
// system calls, and returns its PID. | [
"dial",
"is",
"the",
"entry",
"point",
"for",
"Dial",
".",
"dial",
"opens",
"a",
"netlink",
"socket",
"using",
"system",
"calls",
"and",
"returns",
"its",
"PID",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L49-L69 | train |
mdlayher/netlink | conn_linux.go | bind | func bind(s socket, config *Config) (*conn, uint32, error) {
if config == nil {
config = &Config{}
}
addr := &unix.SockaddrNetlink{
Family: unix.AF_NETLINK,
Groups: config.Groups,
}
// Socket must be closed in the event of any system call errors, to avoid
// leaking file descriptors.
if err := s.Bind(addr); err != nil {
_ = s.Close()
return nil, 0, os.NewSyscallError("bind", err)
}
sa, err := s.Getsockname()
if err != nil {
_ = s.Close()
return nil, 0, os.NewSyscallError("getsockname", err)
}
pid := sa.(*unix.SockaddrNetlink).Pid
return &conn{
s: s,
sa: addr,
}, pid, nil
} | go | func bind(s socket, config *Config) (*conn, uint32, error) {
if config == nil {
config = &Config{}
}
addr := &unix.SockaddrNetlink{
Family: unix.AF_NETLINK,
Groups: config.Groups,
}
// Socket must be closed in the event of any system call errors, to avoid
// leaking file descriptors.
if err := s.Bind(addr); err != nil {
_ = s.Close()
return nil, 0, os.NewSyscallError("bind", err)
}
sa, err := s.Getsockname()
if err != nil {
_ = s.Close()
return nil, 0, os.NewSyscallError("getsockname", err)
}
pid := sa.(*unix.SockaddrNetlink).Pid
return &conn{
s: s,
sa: addr,
}, pid, nil
} | [
"func",
"bind",
"(",
"s",
"socket",
",",
"config",
"*",
"Config",
")",
"(",
"*",
"conn",
",",
"uint32",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"&",
"Config",
"{",
"}",
"\n",
"}",
"\n\n",
"addr",
":=",
"&",
"unix",
".",
"SockaddrNetlink",
"{",
"Family",
":",
"unix",
".",
"AF_NETLINK",
",",
"Groups",
":",
"config",
".",
"Groups",
",",
"}",
"\n\n",
"// Socket must be closed in the event of any system call errors, to avoid",
"// leaking file descriptors.",
"if",
"err",
":=",
"s",
".",
"Bind",
"(",
"addr",
")",
";",
"err",
"!=",
"nil",
"{",
"_",
"=",
"s",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"0",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"sa",
",",
"err",
":=",
"s",
".",
"Getsockname",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"_",
"=",
"s",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"0",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"pid",
":=",
"sa",
".",
"(",
"*",
"unix",
".",
"SockaddrNetlink",
")",
".",
"Pid",
"\n\n",
"return",
"&",
"conn",
"{",
"s",
":",
"s",
",",
"sa",
":",
"addr",
",",
"}",
",",
"pid",
",",
"nil",
"\n",
"}"
] | // bind binds a connection to netlink using the input socket, which may be
// a system call implementation or a mocked one for tests. | [
"bind",
"binds",
"a",
"connection",
"to",
"netlink",
"using",
"the",
"input",
"socket",
"which",
"may",
"be",
"a",
"system",
"call",
"implementation",
"or",
"a",
"mocked",
"one",
"for",
"tests",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L73-L103 | train |
mdlayher/netlink | conn_linux.go | SendMessages | func (c *conn) SendMessages(messages []Message) error {
var buf []byte
for _, m := range messages {
b, err := m.MarshalBinary()
if err != nil {
return err
}
buf = append(buf, b...)
}
addr := &unix.SockaddrNetlink{
Family: unix.AF_NETLINK,
}
return os.NewSyscallError("sendmsg", c.s.Sendmsg(buf, nil, addr, 0))
} | go | func (c *conn) SendMessages(messages []Message) error {
var buf []byte
for _, m := range messages {
b, err := m.MarshalBinary()
if err != nil {
return err
}
buf = append(buf, b...)
}
addr := &unix.SockaddrNetlink{
Family: unix.AF_NETLINK,
}
return os.NewSyscallError("sendmsg", c.s.Sendmsg(buf, nil, addr, 0))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"SendMessages",
"(",
"messages",
"[",
"]",
"Message",
")",
"error",
"{",
"var",
"buf",
"[",
"]",
"byte",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"messages",
"{",
"b",
",",
"err",
":=",
"m",
".",
"MarshalBinary",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"buf",
"=",
"append",
"(",
"buf",
",",
"b",
"...",
")",
"\n",
"}",
"\n\n",
"addr",
":=",
"&",
"unix",
".",
"SockaddrNetlink",
"{",
"Family",
":",
"unix",
".",
"AF_NETLINK",
",",
"}",
"\n\n",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"Sendmsg",
"(",
"buf",
",",
"nil",
",",
"addr",
",",
"0",
")",
")",
"\n",
"}"
] | // SendMessages serializes multiple Messages and sends them to netlink. | [
"SendMessages",
"serializes",
"multiple",
"Messages",
"and",
"sends",
"them",
"to",
"netlink",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L106-L122 | train |
mdlayher/netlink | conn_linux.go | Send | func (c *conn) Send(m Message) error {
b, err := m.MarshalBinary()
if err != nil {
return err
}
addr := &unix.SockaddrNetlink{
Family: unix.AF_NETLINK,
}
return os.NewSyscallError("sendmsg", c.s.Sendmsg(b, nil, addr, 0))
} | go | func (c *conn) Send(m Message) error {
b, err := m.MarshalBinary()
if err != nil {
return err
}
addr := &unix.SockaddrNetlink{
Family: unix.AF_NETLINK,
}
return os.NewSyscallError("sendmsg", c.s.Sendmsg(b, nil, addr, 0))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"Send",
"(",
"m",
"Message",
")",
"error",
"{",
"b",
",",
"err",
":=",
"m",
".",
"MarshalBinary",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"addr",
":=",
"&",
"unix",
".",
"SockaddrNetlink",
"{",
"Family",
":",
"unix",
".",
"AF_NETLINK",
",",
"}",
"\n\n",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"Sendmsg",
"(",
"b",
",",
"nil",
",",
"addr",
",",
"0",
")",
")",
"\n",
"}"
] | // Send sends a single Message to netlink. | [
"Send",
"sends",
"a",
"single",
"Message",
"to",
"netlink",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L125-L136 | train |
mdlayher/netlink | conn_linux.go | Receive | func (c *conn) Receive() ([]Message, error) {
b := make([]byte, os.Getpagesize())
for {
// Peek at the buffer to see how many bytes are available.
//
// TODO(mdlayher): deal with OOB message data if available, such as
// when PacketInfo ConnOption is true.
n, _, _, _, err := c.s.Recvmsg(b, nil, unix.MSG_PEEK)
if err != nil {
return nil, os.NewSyscallError("recvmsg", err)
}
// Break when we can read all messages
if n < len(b) {
break
}
// Double in size if not enough bytes
b = make([]byte, len(b)*2)
}
// Read out all available messages
n, _, _, _, err := c.s.Recvmsg(b, nil, 0)
if err != nil {
return nil, os.NewSyscallError("recvmsg", err)
}
n = nlmsgAlign(n)
raw, err := syscall.ParseNetlinkMessage(b[:n])
if err != nil {
return nil, err
}
msgs := make([]Message, 0, len(raw))
for _, r := range raw {
m := Message{
Header: sysToHeader(r.Header),
Data: r.Data,
}
msgs = append(msgs, m)
}
return msgs, nil
} | go | func (c *conn) Receive() ([]Message, error) {
b := make([]byte, os.Getpagesize())
for {
// Peek at the buffer to see how many bytes are available.
//
// TODO(mdlayher): deal with OOB message data if available, such as
// when PacketInfo ConnOption is true.
n, _, _, _, err := c.s.Recvmsg(b, nil, unix.MSG_PEEK)
if err != nil {
return nil, os.NewSyscallError("recvmsg", err)
}
// Break when we can read all messages
if n < len(b) {
break
}
// Double in size if not enough bytes
b = make([]byte, len(b)*2)
}
// Read out all available messages
n, _, _, _, err := c.s.Recvmsg(b, nil, 0)
if err != nil {
return nil, os.NewSyscallError("recvmsg", err)
}
n = nlmsgAlign(n)
raw, err := syscall.ParseNetlinkMessage(b[:n])
if err != nil {
return nil, err
}
msgs := make([]Message, 0, len(raw))
for _, r := range raw {
m := Message{
Header: sysToHeader(r.Header),
Data: r.Data,
}
msgs = append(msgs, m)
}
return msgs, nil
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"Receive",
"(",
")",
"(",
"[",
"]",
"Message",
",",
"error",
")",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"os",
".",
"Getpagesize",
"(",
")",
")",
"\n",
"for",
"{",
"// Peek at the buffer to see how many bytes are available.",
"//",
"// TODO(mdlayher): deal with OOB message data if available, such as",
"// when PacketInfo ConnOption is true.",
"n",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"c",
".",
"s",
".",
"Recvmsg",
"(",
"b",
",",
"nil",
",",
"unix",
".",
"MSG_PEEK",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Break when we can read all messages",
"if",
"n",
"<",
"len",
"(",
"b",
")",
"{",
"break",
"\n",
"}",
"\n\n",
"// Double in size if not enough bytes",
"b",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"b",
")",
"*",
"2",
")",
"\n",
"}",
"\n\n",
"// Read out all available messages",
"n",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"c",
".",
"s",
".",
"Recvmsg",
"(",
"b",
",",
"nil",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"n",
"=",
"nlmsgAlign",
"(",
"n",
")",
"\n\n",
"raw",
",",
"err",
":=",
"syscall",
".",
"ParseNetlinkMessage",
"(",
"b",
"[",
":",
"n",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"msgs",
":=",
"make",
"(",
"[",
"]",
"Message",
",",
"0",
",",
"len",
"(",
"raw",
")",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"raw",
"{",
"m",
":=",
"Message",
"{",
"Header",
":",
"sysToHeader",
"(",
"r",
".",
"Header",
")",
",",
"Data",
":",
"r",
".",
"Data",
",",
"}",
"\n\n",
"msgs",
"=",
"append",
"(",
"msgs",
",",
"m",
")",
"\n",
"}",
"\n\n",
"return",
"msgs",
",",
"nil",
"\n",
"}"
] | // Receive receives one or more Messages from netlink. | [
"Receive",
"receives",
"one",
"or",
"more",
"Messages",
"from",
"netlink",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L139-L184 | train |
mdlayher/netlink | conn_linux.go | JoinGroup | func (c *conn) JoinGroup(group uint32) error {
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_NETLINK,
unix.NETLINK_ADD_MEMBERSHIP,
int(group),
))
} | go | func (c *conn) JoinGroup(group uint32) error {
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_NETLINK,
unix.NETLINK_ADD_MEMBERSHIP,
int(group),
))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"JoinGroup",
"(",
"group",
"uint32",
")",
"error",
"{",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"SetSockoptInt",
"(",
"unix",
".",
"SOL_NETLINK",
",",
"unix",
".",
"NETLINK_ADD_MEMBERSHIP",
",",
"int",
"(",
"group",
")",
",",
")",
")",
"\n",
"}"
] | // JoinGroup joins a multicast group by ID. | [
"JoinGroup",
"joins",
"a",
"multicast",
"group",
"by",
"ID",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L202-L208 | train |
mdlayher/netlink | conn_linux.go | LeaveGroup | func (c *conn) LeaveGroup(group uint32) error {
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_NETLINK,
unix.NETLINK_DROP_MEMBERSHIP,
int(group),
))
} | go | func (c *conn) LeaveGroup(group uint32) error {
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_NETLINK,
unix.NETLINK_DROP_MEMBERSHIP,
int(group),
))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"LeaveGroup",
"(",
"group",
"uint32",
")",
"error",
"{",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"SetSockoptInt",
"(",
"unix",
".",
"SOL_NETLINK",
",",
"unix",
".",
"NETLINK_DROP_MEMBERSHIP",
",",
"int",
"(",
"group",
")",
",",
")",
")",
"\n",
"}"
] | // LeaveGroup leaves a multicast group by ID. | [
"LeaveGroup",
"leaves",
"a",
"multicast",
"group",
"by",
"ID",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L211-L217 | train |
mdlayher/netlink | conn_linux.go | SetBPF | func (c *conn) SetBPF(filter []bpf.RawInstruction) error {
prog := unix.SockFprog{
Len: uint16(len(filter)),
Filter: (*unix.SockFilter)(unsafe.Pointer(&filter[0])),
}
return os.NewSyscallError("setsockopt", c.s.SetSockoptSockFprog(
unix.SOL_SOCKET,
unix.SO_ATTACH_FILTER,
&prog,
))
} | go | func (c *conn) SetBPF(filter []bpf.RawInstruction) error {
prog := unix.SockFprog{
Len: uint16(len(filter)),
Filter: (*unix.SockFilter)(unsafe.Pointer(&filter[0])),
}
return os.NewSyscallError("setsockopt", c.s.SetSockoptSockFprog(
unix.SOL_SOCKET,
unix.SO_ATTACH_FILTER,
&prog,
))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"SetBPF",
"(",
"filter",
"[",
"]",
"bpf",
".",
"RawInstruction",
")",
"error",
"{",
"prog",
":=",
"unix",
".",
"SockFprog",
"{",
"Len",
":",
"uint16",
"(",
"len",
"(",
"filter",
")",
")",
",",
"Filter",
":",
"(",
"*",
"unix",
".",
"SockFilter",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"filter",
"[",
"0",
"]",
")",
")",
",",
"}",
"\n\n",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"SetSockoptSockFprog",
"(",
"unix",
".",
"SOL_SOCKET",
",",
"unix",
".",
"SO_ATTACH_FILTER",
",",
"&",
"prog",
",",
")",
")",
"\n",
"}"
] | // SetBPF attaches an assembled BPF program to a conn. | [
"SetBPF",
"attaches",
"an",
"assembled",
"BPF",
"program",
"to",
"a",
"conn",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L220-L231 | train |
mdlayher/netlink | conn_linux.go | RemoveBPF | func (c *conn) RemoveBPF() error {
// 0 argument is ignored by SO_DETACH_FILTER.
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_SOCKET,
unix.SO_DETACH_FILTER,
0,
))
} | go | func (c *conn) RemoveBPF() error {
// 0 argument is ignored by SO_DETACH_FILTER.
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_SOCKET,
unix.SO_DETACH_FILTER,
0,
))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"RemoveBPF",
"(",
")",
"error",
"{",
"// 0 argument is ignored by SO_DETACH_FILTER.",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"SetSockoptInt",
"(",
"unix",
".",
"SOL_SOCKET",
",",
"unix",
".",
"SO_DETACH_FILTER",
",",
"0",
",",
")",
")",
"\n",
"}"
] | // RemoveBPF removes a BPF filter from a conn. | [
"RemoveBPF",
"removes",
"a",
"BPF",
"filter",
"from",
"a",
"conn",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L234-L241 | train |
mdlayher/netlink | conn_linux.go | SetWriteBuffer | func (c *conn) SetWriteBuffer(bytes int) error {
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_SOCKET,
unix.SO_SNDBUF,
bytes,
))
} | go | func (c *conn) SetWriteBuffer(bytes int) error {
return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
unix.SOL_SOCKET,
unix.SO_SNDBUF,
bytes,
))
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"SetWriteBuffer",
"(",
"bytes",
"int",
")",
"error",
"{",
"return",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"c",
".",
"s",
".",
"SetSockoptInt",
"(",
"unix",
".",
"SOL_SOCKET",
",",
"unix",
".",
"SO_SNDBUF",
",",
"bytes",
",",
")",
")",
"\n",
"}"
] | // SetReadBuffer sets the size of the operating system's transmit buffer
// associated with the Conn. | [
"SetReadBuffer",
"sets",
"the",
"size",
"of",
"the",
"operating",
"system",
"s",
"transmit",
"buffer",
"associated",
"with",
"the",
"Conn",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L287-L293 | train |
mdlayher/netlink | conn_linux.go | linuxOption | func linuxOption(o ConnOption) (int, bool) {
switch o {
case PacketInfo:
return unix.NETLINK_PKTINFO, true
case BroadcastError:
return unix.NETLINK_BROADCAST_ERROR, true
case NoENOBUFS:
return unix.NETLINK_NO_ENOBUFS, true
case ListenAllNSID:
return unix.NETLINK_LISTEN_ALL_NSID, true
case CapAcknowledge:
return unix.NETLINK_CAP_ACK, true
default:
return 0, false
}
} | go | func linuxOption(o ConnOption) (int, bool) {
switch o {
case PacketInfo:
return unix.NETLINK_PKTINFO, true
case BroadcastError:
return unix.NETLINK_BROADCAST_ERROR, true
case NoENOBUFS:
return unix.NETLINK_NO_ENOBUFS, true
case ListenAllNSID:
return unix.NETLINK_LISTEN_ALL_NSID, true
case CapAcknowledge:
return unix.NETLINK_CAP_ACK, true
default:
return 0, false
}
} | [
"func",
"linuxOption",
"(",
"o",
"ConnOption",
")",
"(",
"int",
",",
"bool",
")",
"{",
"switch",
"o",
"{",
"case",
"PacketInfo",
":",
"return",
"unix",
".",
"NETLINK_PKTINFO",
",",
"true",
"\n",
"case",
"BroadcastError",
":",
"return",
"unix",
".",
"NETLINK_BROADCAST_ERROR",
",",
"true",
"\n",
"case",
"NoENOBUFS",
":",
"return",
"unix",
".",
"NETLINK_NO_ENOBUFS",
",",
"true",
"\n",
"case",
"ListenAllNSID",
":",
"return",
"unix",
".",
"NETLINK_LISTEN_ALL_NSID",
",",
"true",
"\n",
"case",
"CapAcknowledge",
":",
"return",
"unix",
".",
"NETLINK_CAP_ACK",
",",
"true",
"\n",
"default",
":",
"return",
"0",
",",
"false",
"\n",
"}",
"\n",
"}"
] | // linuxOption converts a ConnOption to its Linux value. | [
"linuxOption",
"converts",
"a",
"ConnOption",
"to",
"its",
"Linux",
"value",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L296-L311 | train |
mdlayher/netlink | conn_linux.go | newSysSocket | func newSysSocket(config *Config) (*sysSocket, error) {
g, err := newLockedNetNSGoroutine(config.NetNS)
if err != nil {
return nil, err
}
return &sysSocket{
g: g,
}, nil
} | go | func newSysSocket(config *Config) (*sysSocket, error) {
g, err := newLockedNetNSGoroutine(config.NetNS)
if err != nil {
return nil, err
}
return &sysSocket{
g: g,
}, nil
} | [
"func",
"newSysSocket",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"sysSocket",
",",
"error",
")",
"{",
"g",
",",
"err",
":=",
"newLockedNetNSGoroutine",
"(",
"config",
".",
"NetNS",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"sysSocket",
"{",
"g",
":",
"g",
",",
"}",
",",
"nil",
"\n",
"}"
] | // newSysSocket creates a sysSocket that optionally locks its internal goroutine
// to a single thread. | [
"newSysSocket",
"creates",
"a",
"sysSocket",
"that",
"optionally",
"locks",
"its",
"internal",
"goroutine",
"to",
"a",
"single",
"thread",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L338-L346 | train |
mdlayher/netlink | conn_linux.go | do | func (s *sysSocket) do(f func()) error {
// All operations handled by this function are assumed to only
// read from s.done.
s.mu.RLock()
defer s.mu.RUnlock()
if s.closed {
return syscall.EBADF
}
s.g.run(f)
return nil
} | go | func (s *sysSocket) do(f func()) error {
// All operations handled by this function are assumed to only
// read from s.done.
s.mu.RLock()
defer s.mu.RUnlock()
if s.closed {
return syscall.EBADF
}
s.g.run(f)
return nil
} | [
"func",
"(",
"s",
"*",
"sysSocket",
")",
"do",
"(",
"f",
"func",
"(",
")",
")",
"error",
"{",
"// All operations handled by this function are assumed to only",
"// read from s.done.",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"closed",
"{",
"return",
"syscall",
".",
"EBADF",
"\n",
"}",
"\n\n",
"s",
".",
"g",
".",
"run",
"(",
"f",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // do runs f in a worker goroutine which can be locked to one thread. | [
"do",
"runs",
"f",
"in",
"a",
"worker",
"goroutine",
"which",
"can",
"be",
"locked",
"to",
"one",
"thread",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L349-L361 | train |
mdlayher/netlink | conn_linux.go | read | func (s *sysSocket) read(f func(fd int) bool) error {
s.mu.RLock()
defer s.mu.RUnlock()
if s.closed {
return syscall.EBADF
}
var err error
s.g.run(func() {
err = fdread(s.fd, f)
})
return err
} | go | func (s *sysSocket) read(f func(fd int) bool) error {
s.mu.RLock()
defer s.mu.RUnlock()
if s.closed {
return syscall.EBADF
}
var err error
s.g.run(func() {
err = fdread(s.fd, f)
})
return err
} | [
"func",
"(",
"s",
"*",
"sysSocket",
")",
"read",
"(",
"f",
"func",
"(",
"fd",
"int",
")",
"bool",
")",
"error",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"closed",
"{",
"return",
"syscall",
".",
"EBADF",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"s",
".",
"g",
".",
"run",
"(",
"func",
"(",
")",
"{",
"err",
"=",
"fdread",
"(",
"s",
".",
"fd",
",",
"f",
")",
"\n",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // read executes f, a read function, against the associated file descriptor. | [
"read",
"executes",
"f",
"a",
"read",
"function",
"against",
"the",
"associated",
"file",
"descriptor",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L364-L377 | train |
mdlayher/netlink | conn_linux.go | control | func (s *sysSocket) control(f func(fd int)) error {
s.mu.RLock()
defer s.mu.RUnlock()
if s.closed {
return syscall.EBADF
}
var err error
s.g.run(func() {
err = fdcontrol(s.fd, f)
})
return err
} | go | func (s *sysSocket) control(f func(fd int)) error {
s.mu.RLock()
defer s.mu.RUnlock()
if s.closed {
return syscall.EBADF
}
var err error
s.g.run(func() {
err = fdcontrol(s.fd, f)
})
return err
} | [
"func",
"(",
"s",
"*",
"sysSocket",
")",
"control",
"(",
"f",
"func",
"(",
"fd",
"int",
")",
")",
"error",
"{",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"closed",
"{",
"return",
"syscall",
".",
"EBADF",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"s",
".",
"g",
".",
"run",
"(",
"func",
"(",
")",
"{",
"err",
"=",
"fdcontrol",
"(",
"s",
".",
"fd",
",",
"f",
")",
"\n",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // control executes f, a control function, against the associated file descriptor. | [
"control",
"executes",
"f",
"a",
"control",
"function",
"against",
"the",
"associated",
"file",
"descriptor",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L396-L409 | train |
mdlayher/netlink | conn_linux.go | run | func (g *lockedNetNSGoroutine) run(f func()) {
done := make(chan struct{})
g.funcC <- func() {
defer close(done)
f()
}
<-done
} | go | func (g *lockedNetNSGoroutine) run(f func()) {
done := make(chan struct{})
g.funcC <- func() {
defer close(done)
f()
}
<-done
} | [
"func",
"(",
"g",
"*",
"lockedNetNSGoroutine",
")",
"run",
"(",
"f",
"func",
"(",
")",
")",
"{",
"done",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"g",
".",
"funcC",
"<-",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"done",
")",
"\n",
"f",
"(",
")",
"\n",
"}",
"\n",
"<-",
"done",
"\n",
"}"
] | // run runs f on the worker goroutine. | [
"run",
"runs",
"f",
"on",
"the",
"worker",
"goroutine",
"."
] | b540351f6c5108aa445eaa6677010703c7294f8d | https://github.com/mdlayher/netlink/blob/b540351f6c5108aa445eaa6677010703c7294f8d/conn_linux.go#L670-L677 | train |
looplab/eventhorizon | repo/version/repo.go | Find | func (r *Repo) Find(ctx context.Context, id uuid.UUID) (eh.Entity, error) {
// If there is no min version set just return the item as normally.
minVersion, ok := eh.MinVersionFromContext(ctx)
if !ok || minVersion < 1 {
return r.ReadWriteRepo.Find(ctx, id)
}
// Try to get the correct version, retry with exponentially longer intervals
// until the deadline expires. If there is no deadline just try once.
delay := &backoff.Backoff{}
_, hasDeadline := ctx.Deadline()
for {
entity, err := r.findMinVersion(ctx, id, minVersion)
if rrErr, ok := err.(eh.RepoError); ok &&
(rrErr.Err == eh.ErrIncorrectEntityVersion || rrErr.Err == eh.ErrEntityNotFound) {
// Try again for incorrect version or if the entity was not found.
} else if err != nil {
// Return any real error.
return nil, err
} else {
// Return the entity.
return entity, nil
}
// If there is no deadline, return whatever we have at this point.
if !hasDeadline {
return entity, err
}
select {
case <-time.After(delay.Duration()):
case <-ctx.Done():
return nil, ctx.Err()
}
}
} | go | func (r *Repo) Find(ctx context.Context, id uuid.UUID) (eh.Entity, error) {
// If there is no min version set just return the item as normally.
minVersion, ok := eh.MinVersionFromContext(ctx)
if !ok || minVersion < 1 {
return r.ReadWriteRepo.Find(ctx, id)
}
// Try to get the correct version, retry with exponentially longer intervals
// until the deadline expires. If there is no deadline just try once.
delay := &backoff.Backoff{}
_, hasDeadline := ctx.Deadline()
for {
entity, err := r.findMinVersion(ctx, id, minVersion)
if rrErr, ok := err.(eh.RepoError); ok &&
(rrErr.Err == eh.ErrIncorrectEntityVersion || rrErr.Err == eh.ErrEntityNotFound) {
// Try again for incorrect version or if the entity was not found.
} else if err != nil {
// Return any real error.
return nil, err
} else {
// Return the entity.
return entity, nil
}
// If there is no deadline, return whatever we have at this point.
if !hasDeadline {
return entity, err
}
select {
case <-time.After(delay.Duration()):
case <-ctx.Done():
return nil, ctx.Err()
}
}
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Find",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"uuid",
".",
"UUID",
")",
"(",
"eh",
".",
"Entity",
",",
"error",
")",
"{",
"// If there is no min version set just return the item as normally.",
"minVersion",
",",
"ok",
":=",
"eh",
".",
"MinVersionFromContext",
"(",
"ctx",
")",
"\n",
"if",
"!",
"ok",
"||",
"minVersion",
"<",
"1",
"{",
"return",
"r",
".",
"ReadWriteRepo",
".",
"Find",
"(",
"ctx",
",",
"id",
")",
"\n",
"}",
"\n\n",
"// Try to get the correct version, retry with exponentially longer intervals",
"// until the deadline expires. If there is no deadline just try once.",
"delay",
":=",
"&",
"backoff",
".",
"Backoff",
"{",
"}",
"\n",
"_",
",",
"hasDeadline",
":=",
"ctx",
".",
"Deadline",
"(",
")",
"\n",
"for",
"{",
"entity",
",",
"err",
":=",
"r",
".",
"findMinVersion",
"(",
"ctx",
",",
"id",
",",
"minVersion",
")",
"\n",
"if",
"rrErr",
",",
"ok",
":=",
"err",
".",
"(",
"eh",
".",
"RepoError",
")",
";",
"ok",
"&&",
"(",
"rrErr",
".",
"Err",
"==",
"eh",
".",
"ErrIncorrectEntityVersion",
"||",
"rrErr",
".",
"Err",
"==",
"eh",
".",
"ErrEntityNotFound",
")",
"{",
"// Try again for incorrect version or if the entity was not found.",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"// Return any real error.",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"{",
"// Return the entity.",
"return",
"entity",
",",
"nil",
"\n",
"}",
"\n\n",
"// If there is no deadline, return whatever we have at this point.",
"if",
"!",
"hasDeadline",
"{",
"return",
"entity",
",",
"err",
"\n",
"}",
"\n\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"delay",
".",
"Duration",
"(",
")",
")",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Find implements the Find method of the eventhorizon.ReadModel interface.
// If the context contains a min version set by WithMinVersion it will only
// return an item if its version is at least min version. If a timeout or
// deadline is set on the context it will repetedly try to get the item until
// either the version matches or the deadline is reached. | [
"Find",
"implements",
"the",
"Find",
"method",
"of",
"the",
"eventhorizon",
".",
"ReadModel",
"interface",
".",
"If",
"the",
"context",
"contains",
"a",
"min",
"version",
"set",
"by",
"WithMinVersion",
"it",
"will",
"only",
"return",
"an",
"item",
"if",
"its",
"version",
"is",
"at",
"least",
"min",
"version",
".",
"If",
"a",
"timeout",
"or",
"deadline",
"is",
"set",
"on",
"the",
"context",
"it",
"will",
"repetedly",
"try",
"to",
"get",
"the",
"item",
"until",
"either",
"the",
"version",
"matches",
"or",
"the",
"deadline",
"is",
"reached",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/version/repo.go#L48-L83 | train |
looplab/eventhorizon | repo/version/repo.go | findMinVersion | func (r *Repo) findMinVersion(ctx context.Context, id uuid.UUID, minVersion int) (eh.Entity, error) {
entity, err := r.ReadWriteRepo.Find(ctx, id)
if err != nil {
return nil, err
}
versionable, ok := entity.(eh.Versionable)
if !ok {
return nil, eh.RepoError{
Err: eh.ErrEntityHasNoVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
if versionable.AggregateVersion() < minVersion {
return nil, eh.RepoError{
Err: eh.ErrIncorrectEntityVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return entity, nil
} | go | func (r *Repo) findMinVersion(ctx context.Context, id uuid.UUID, minVersion int) (eh.Entity, error) {
entity, err := r.ReadWriteRepo.Find(ctx, id)
if err != nil {
return nil, err
}
versionable, ok := entity.(eh.Versionable)
if !ok {
return nil, eh.RepoError{
Err: eh.ErrEntityHasNoVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
if versionable.AggregateVersion() < minVersion {
return nil, eh.RepoError{
Err: eh.ErrIncorrectEntityVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return entity, nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"findMinVersion",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"uuid",
".",
"UUID",
",",
"minVersion",
"int",
")",
"(",
"eh",
".",
"Entity",
",",
"error",
")",
"{",
"entity",
",",
"err",
":=",
"r",
".",
"ReadWriteRepo",
".",
"Find",
"(",
"ctx",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"versionable",
",",
"ok",
":=",
"entity",
".",
"(",
"eh",
".",
"Versionable",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"eh",
".",
"ErrEntityHasNoVersion",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"versionable",
".",
"AggregateVersion",
"(",
")",
"<",
"minVersion",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"eh",
".",
"ErrIncorrectEntityVersion",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"entity",
",",
"nil",
"\n",
"}"
] | // findMinVersion finds an item if it has a version and it is at least minVersion. | [
"findMinVersion",
"finds",
"an",
"item",
"if",
"it",
"has",
"a",
"version",
"and",
"it",
"is",
"at",
"least",
"minVersion",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/version/repo.go#L86-L108 | train |
looplab/eventhorizon | repo/version/repo.go | Repository | func Repository(repo eh.ReadRepo) *Repo {
if repo == nil {
return nil
}
if r, ok := repo.(*Repo); ok {
return r
}
return Repository(repo.Parent())
} | go | func Repository(repo eh.ReadRepo) *Repo {
if repo == nil {
return nil
}
if r, ok := repo.(*Repo); ok {
return r
}
return Repository(repo.Parent())
} | [
"func",
"Repository",
"(",
"repo",
"eh",
".",
"ReadRepo",
")",
"*",
"Repo",
"{",
"if",
"repo",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"r",
",",
"ok",
":=",
"repo",
".",
"(",
"*",
"Repo",
")",
";",
"ok",
"{",
"return",
"r",
"\n",
"}",
"\n\n",
"return",
"Repository",
"(",
"repo",
".",
"Parent",
"(",
")",
")",
"\n",
"}"
] | // Repository returns a parent ReadRepo if there is one. | [
"Repository",
"returns",
"a",
"parent",
"ReadRepo",
"if",
"there",
"is",
"one",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/version/repo.go#L111-L121 | train |
looplab/eventhorizon | repo/mongodb/repo.go | NewRepoWithSession | func NewRepoWithSession(session *mgo.Session, dbPrefix, collection string) (*Repo, error) {
if session == nil {
return nil, ErrNoDBSession
}
r := &Repo{
session: session,
dbPrefix: dbPrefix,
collection: collection,
}
return r, nil
} | go | func NewRepoWithSession(session *mgo.Session, dbPrefix, collection string) (*Repo, error) {
if session == nil {
return nil, ErrNoDBSession
}
r := &Repo{
session: session,
dbPrefix: dbPrefix,
collection: collection,
}
return r, nil
} | [
"func",
"NewRepoWithSession",
"(",
"session",
"*",
"mgo",
".",
"Session",
",",
"dbPrefix",
",",
"collection",
"string",
")",
"(",
"*",
"Repo",
",",
"error",
")",
"{",
"if",
"session",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrNoDBSession",
"\n",
"}",
"\n\n",
"r",
":=",
"&",
"Repo",
"{",
"session",
":",
"session",
",",
"dbPrefix",
":",
"dbPrefix",
",",
"collection",
":",
"collection",
",",
"}",
"\n\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] | // NewRepoWithSession creates a new Repo with a session. | [
"NewRepoWithSession",
"creates",
"a",
"new",
"Repo",
"with",
"a",
"session",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/mongodb/repo.go#L64-L76 | train |
looplab/eventhorizon | repo/mongodb/repo.go | FindCustomIter | func (r *Repo) FindCustomIter(ctx context.Context, callback func(*mgo.Collection) *mgo.Query) (eh.Iter, error) {
sess := r.session.Copy()
if r.factoryFn == nil {
return nil, eh.RepoError{
Err: ErrModelNotSet,
Namespace: eh.NamespaceFromContext(ctx),
}
}
collection := sess.DB(r.dbName(ctx)).C(r.collection)
query := callback(collection)
if query == nil {
return nil, eh.RepoError{
Err: ErrInvalidQuery,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return &iter{
session: sess,
iter: query.Iter(),
factoryFn: r.factoryFn,
}, nil
} | go | func (r *Repo) FindCustomIter(ctx context.Context, callback func(*mgo.Collection) *mgo.Query) (eh.Iter, error) {
sess := r.session.Copy()
if r.factoryFn == nil {
return nil, eh.RepoError{
Err: ErrModelNotSet,
Namespace: eh.NamespaceFromContext(ctx),
}
}
collection := sess.DB(r.dbName(ctx)).C(r.collection)
query := callback(collection)
if query == nil {
return nil, eh.RepoError{
Err: ErrInvalidQuery,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return &iter{
session: sess,
iter: query.Iter(),
factoryFn: r.factoryFn,
}, nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"FindCustomIter",
"(",
"ctx",
"context",
".",
"Context",
",",
"callback",
"func",
"(",
"*",
"mgo",
".",
"Collection",
")",
"*",
"mgo",
".",
"Query",
")",
"(",
"eh",
".",
"Iter",
",",
"error",
")",
"{",
"sess",
":=",
"r",
".",
"session",
".",
"Copy",
"(",
")",
"\n\n",
"if",
"r",
".",
"factoryFn",
"==",
"nil",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"ErrModelNotSet",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"collection",
":=",
"sess",
".",
"DB",
"(",
"r",
".",
"dbName",
"(",
"ctx",
")",
")",
".",
"C",
"(",
"r",
".",
"collection",
")",
"\n",
"query",
":=",
"callback",
"(",
"collection",
")",
"\n",
"if",
"query",
"==",
"nil",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"ErrInvalidQuery",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"iter",
"{",
"session",
":",
"sess",
",",
"iter",
":",
"query",
".",
"Iter",
"(",
")",
",",
"factoryFn",
":",
"r",
".",
"factoryFn",
",",
"}",
",",
"nil",
"\n",
"}"
] | // FindCustomIter returns a mgo cursor you can use to stream results of very large datasets | [
"FindCustomIter",
"returns",
"a",
"mgo",
"cursor",
"you",
"can",
"use",
"to",
"stream",
"results",
"of",
"very",
"large",
"datasets"
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/mongodb/repo.go#L163-L187 | train |
looplab/eventhorizon | repo/mongodb/repo.go | FindCustom | func (r *Repo) FindCustom(ctx context.Context, callback func(*mgo.Collection) *mgo.Query) ([]interface{}, error) {
sess := r.session.Copy()
defer sess.Close()
if r.factoryFn == nil {
return nil, eh.RepoError{
Err: ErrModelNotSet,
Namespace: eh.NamespaceFromContext(ctx),
}
}
collection := sess.DB(r.dbName(ctx)).C(r.collection)
query := callback(collection)
if query == nil {
return nil, eh.RepoError{
Err: ErrInvalidQuery,
Namespace: eh.NamespaceFromContext(ctx),
}
}
iter := query.Iter()
result := []interface{}{}
entity := r.factoryFn()
for iter.Next(entity) {
result = append(result, entity)
entity = r.factoryFn()
}
if err := iter.Close(); err != nil {
return nil, eh.RepoError{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return result, nil
} | go | func (r *Repo) FindCustom(ctx context.Context, callback func(*mgo.Collection) *mgo.Query) ([]interface{}, error) {
sess := r.session.Copy()
defer sess.Close()
if r.factoryFn == nil {
return nil, eh.RepoError{
Err: ErrModelNotSet,
Namespace: eh.NamespaceFromContext(ctx),
}
}
collection := sess.DB(r.dbName(ctx)).C(r.collection)
query := callback(collection)
if query == nil {
return nil, eh.RepoError{
Err: ErrInvalidQuery,
Namespace: eh.NamespaceFromContext(ctx),
}
}
iter := query.Iter()
result := []interface{}{}
entity := r.factoryFn()
for iter.Next(entity) {
result = append(result, entity)
entity = r.factoryFn()
}
if err := iter.Close(); err != nil {
return nil, eh.RepoError{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"FindCustom",
"(",
"ctx",
"context",
".",
"Context",
",",
"callback",
"func",
"(",
"*",
"mgo",
".",
"Collection",
")",
"*",
"mgo",
".",
"Query",
")",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"sess",
":=",
"r",
".",
"session",
".",
"Copy",
"(",
")",
"\n",
"defer",
"sess",
".",
"Close",
"(",
")",
"\n\n",
"if",
"r",
".",
"factoryFn",
"==",
"nil",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"ErrModelNotSet",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"collection",
":=",
"sess",
".",
"DB",
"(",
"r",
".",
"dbName",
"(",
"ctx",
")",
")",
".",
"C",
"(",
"r",
".",
"collection",
")",
"\n",
"query",
":=",
"callback",
"(",
"collection",
")",
"\n",
"if",
"query",
"==",
"nil",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"ErrInvalidQuery",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"iter",
":=",
"query",
".",
"Iter",
"(",
")",
"\n",
"result",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"entity",
":=",
"r",
".",
"factoryFn",
"(",
")",
"\n",
"for",
"iter",
".",
"Next",
"(",
"entity",
")",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"entity",
")",
"\n",
"entity",
"=",
"r",
".",
"factoryFn",
"(",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"iter",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // FindCustom uses a callback to specify a custom query for returning models.
// It can also be used to do queries that does not map to the model by executing
// the query in the callback and returning nil to block a second execution of
// the same query in FindCustom. Expect a ErrInvalidQuery if returning a nil
// query from the callback. | [
"FindCustom",
"uses",
"a",
"callback",
"to",
"specify",
"a",
"custom",
"query",
"for",
"returning",
"models",
".",
"It",
"can",
"also",
"be",
"used",
"to",
"do",
"queries",
"that",
"does",
"not",
"map",
"to",
"the",
"model",
"by",
"executing",
"the",
"query",
"in",
"the",
"callback",
"and",
"returning",
"nil",
"to",
"block",
"a",
"second",
"execution",
"of",
"the",
"same",
"query",
"in",
"FindCustom",
".",
"Expect",
"a",
"ErrInvalidQuery",
"if",
"returning",
"a",
"nil",
"query",
"from",
"the",
"callback",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/mongodb/repo.go#L194-L229 | train |
looplab/eventhorizon | repo/mongodb/repo.go | Collection | func (r *Repo) Collection(ctx context.Context, f func(*mgo.Collection) error) error {
sess := r.session.Copy()
defer sess.Close()
c := sess.DB(r.dbName(ctx)).C(r.collection)
if err := f(c); err != nil {
return eh.RepoError{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return nil
} | go | func (r *Repo) Collection(ctx context.Context, f func(*mgo.Collection) error) error {
sess := r.session.Copy()
defer sess.Close()
c := sess.DB(r.dbName(ctx)).C(r.collection)
if err := f(c); err != nil {
return eh.RepoError{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Collection",
"(",
"ctx",
"context",
".",
"Context",
",",
"f",
"func",
"(",
"*",
"mgo",
".",
"Collection",
")",
"error",
")",
"error",
"{",
"sess",
":=",
"r",
".",
"session",
".",
"Copy",
"(",
")",
"\n",
"defer",
"sess",
".",
"Close",
"(",
")",
"\n\n",
"c",
":=",
"sess",
".",
"DB",
"(",
"r",
".",
"dbName",
"(",
"ctx",
")",
")",
".",
"C",
"(",
"r",
".",
"collection",
")",
"\n",
"if",
"err",
":=",
"f",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Collection lets the function do custom actions on the collection. | [
"Collection",
"lets",
"the",
"function",
"do",
"custom",
"actions",
"on",
"the",
"collection",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/mongodb/repo.go#L273-L286 | train |
looplab/eventhorizon | repo/mongodb/repo.go | Clear | func (r *Repo) Clear(ctx context.Context) error {
if err := r.session.DB(r.dbName(ctx)).C(r.collection).DropCollection(); err != nil {
return eh.RepoError{
Err: ErrCouldNotClearDB,
BaseErr: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return nil
} | go | func (r *Repo) Clear(ctx context.Context) error {
if err := r.session.DB(r.dbName(ctx)).C(r.collection).DropCollection(); err != nil {
return eh.RepoError{
Err: ErrCouldNotClearDB,
BaseErr: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Clear",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"err",
":=",
"r",
".",
"session",
".",
"DB",
"(",
"r",
".",
"dbName",
"(",
"ctx",
")",
")",
".",
"C",
"(",
"r",
".",
"collection",
")",
".",
"DropCollection",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"eh",
".",
"RepoError",
"{",
"Err",
":",
"ErrCouldNotClearDB",
",",
"BaseErr",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Clear clears the read model database. | [
"Clear",
"clears",
"the",
"read",
"model",
"database",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/mongodb/repo.go#L294-L303 | train |
looplab/eventhorizon | context.go | NamespaceFromContext | func NamespaceFromContext(ctx context.Context) string {
if ns, ok := ctx.Value(namespaceKey).(string); ok {
return ns
}
return DefaultNamespace
} | go | func NamespaceFromContext(ctx context.Context) string {
if ns, ok := ctx.Value(namespaceKey).(string); ok {
return ns
}
return DefaultNamespace
} | [
"func",
"NamespaceFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"string",
"{",
"if",
"ns",
",",
"ok",
":=",
"ctx",
".",
"Value",
"(",
"namespaceKey",
")",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"ns",
"\n",
"}",
"\n",
"return",
"DefaultNamespace",
"\n",
"}"
] | // NamespaceFromContext returns the namespace from the context, or the default
// namespace. | [
"NamespaceFromContext",
"returns",
"the",
"namespace",
"from",
"the",
"context",
"or",
"the",
"default",
"namespace",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L78-L83 | train |
looplab/eventhorizon | context.go | NewContextWithNamespace | func NewContextWithNamespace(ctx context.Context, namespace string) context.Context {
return context.WithValue(ctx, namespaceKey, namespace)
} | go | func NewContextWithNamespace(ctx context.Context, namespace string) context.Context {
return context.WithValue(ctx, namespaceKey, namespace)
} | [
"func",
"NewContextWithNamespace",
"(",
"ctx",
"context",
".",
"Context",
",",
"namespace",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"namespaceKey",
",",
"namespace",
")",
"\n",
"}"
] | // NewContextWithNamespace sets the namespace to use in the context. The
// namespace is used to determine which database. | [
"NewContextWithNamespace",
"sets",
"the",
"namespace",
"to",
"use",
"in",
"the",
"context",
".",
"The",
"namespace",
"is",
"used",
"to",
"determine",
"which",
"database",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L87-L89 | train |
looplab/eventhorizon | context.go | MinVersionFromContext | func MinVersionFromContext(ctx context.Context) (int, bool) {
minVersion, ok := ctx.Value(minVersionKey).(int)
return minVersion, ok
} | go | func MinVersionFromContext(ctx context.Context) (int, bool) {
minVersion, ok := ctx.Value(minVersionKey).(int)
return minVersion, ok
} | [
"func",
"MinVersionFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"int",
",",
"bool",
")",
"{",
"minVersion",
",",
"ok",
":=",
"ctx",
".",
"Value",
"(",
"minVersionKey",
")",
".",
"(",
"int",
")",
"\n",
"return",
"minVersion",
",",
"ok",
"\n",
"}"
] | // MinVersionFromContext returns the min version from the context. | [
"MinVersionFromContext",
"returns",
"the",
"min",
"version",
"from",
"the",
"context",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L92-L95 | train |
looplab/eventhorizon | context.go | NewContextWithMinVersion | func NewContextWithMinVersion(ctx context.Context, minVersion int) context.Context {
return context.WithValue(ctx, minVersionKey, minVersion)
} | go | func NewContextWithMinVersion(ctx context.Context, minVersion int) context.Context {
return context.WithValue(ctx, minVersionKey, minVersion)
} | [
"func",
"NewContextWithMinVersion",
"(",
"ctx",
"context",
".",
"Context",
",",
"minVersion",
"int",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"minVersionKey",
",",
"minVersion",
")",
"\n",
"}"
] | // NewContextWithMinVersion returns the context with min version set. | [
"NewContextWithMinVersion",
"returns",
"the",
"context",
"with",
"min",
"version",
"set",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L98-L100 | train |
looplab/eventhorizon | context.go | NewContextWithMinVersionWait | func NewContextWithMinVersionWait(ctx context.Context, minVersion int) (c context.Context, cancel func()) {
ctx = context.WithValue(ctx, minVersionKey, minVersion)
return context.WithTimeout(ctx, DefaultMinVersionDeadline)
} | go | func NewContextWithMinVersionWait(ctx context.Context, minVersion int) (c context.Context, cancel func()) {
ctx = context.WithValue(ctx, minVersionKey, minVersion)
return context.WithTimeout(ctx, DefaultMinVersionDeadline)
} | [
"func",
"NewContextWithMinVersionWait",
"(",
"ctx",
"context",
".",
"Context",
",",
"minVersion",
"int",
")",
"(",
"c",
"context",
".",
"Context",
",",
"cancel",
"func",
"(",
")",
")",
"{",
"ctx",
"=",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"minVersionKey",
",",
"minVersion",
")",
"\n",
"return",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"DefaultMinVersionDeadline",
")",
"\n",
"}"
] | // NewContextWithMinVersionWait returns the context with min version and a
// default deadline set. | [
"NewContextWithMinVersionWait",
"returns",
"the",
"context",
"with",
"min",
"version",
"and",
"a",
"default",
"deadline",
"set",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L104-L107 | train |
looplab/eventhorizon | context.go | RegisterContextMarshaler | func RegisterContextMarshaler(f ContextMarshalFunc) {
contextMarshalFuncsMu.Lock()
defer contextMarshalFuncsMu.Unlock()
contextMarshalFuncs = append(contextMarshalFuncs, f)
} | go | func RegisterContextMarshaler(f ContextMarshalFunc) {
contextMarshalFuncsMu.Lock()
defer contextMarshalFuncsMu.Unlock()
contextMarshalFuncs = append(contextMarshalFuncs, f)
} | [
"func",
"RegisterContextMarshaler",
"(",
"f",
"ContextMarshalFunc",
")",
"{",
"contextMarshalFuncsMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"contextMarshalFuncsMu",
".",
"Unlock",
"(",
")",
"\n",
"contextMarshalFuncs",
"=",
"append",
"(",
"contextMarshalFuncs",
",",
"f",
")",
"\n",
"}"
] | // RegisterContextMarshaler registers a marshaler function used by MarshalContext. | [
"RegisterContextMarshaler",
"registers",
"a",
"marshaler",
"function",
"used",
"by",
"MarshalContext",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L123-L127 | train |
looplab/eventhorizon | context.go | MarshalContext | func MarshalContext(ctx context.Context) map[string]interface{} {
contextMarshalFuncsMu.RLock()
defer contextMarshalFuncsMu.RUnlock()
allVals := map[string]interface{}{}
for _, f := range contextMarshalFuncs {
vals := map[string]interface{}{}
f(ctx, vals)
for key, val := range vals {
if _, ok := allVals[key]; ok {
panic("duplicate context entry for: " + key)
}
allVals[key] = val
}
}
return allVals
} | go | func MarshalContext(ctx context.Context) map[string]interface{} {
contextMarshalFuncsMu.RLock()
defer contextMarshalFuncsMu.RUnlock()
allVals := map[string]interface{}{}
for _, f := range contextMarshalFuncs {
vals := map[string]interface{}{}
f(ctx, vals)
for key, val := range vals {
if _, ok := allVals[key]; ok {
panic("duplicate context entry for: " + key)
}
allVals[key] = val
}
}
return allVals
} | [
"func",
"MarshalContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"contextMarshalFuncsMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"contextMarshalFuncsMu",
".",
"RUnlock",
"(",
")",
"\n\n",
"allVals",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n\n",
"for",
"_",
",",
"f",
":=",
"range",
"contextMarshalFuncs",
"{",
"vals",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"f",
"(",
"ctx",
",",
"vals",
")",
"\n\n",
"for",
"key",
",",
"val",
":=",
"range",
"vals",
"{",
"if",
"_",
",",
"ok",
":=",
"allVals",
"[",
"key",
"]",
";",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"key",
")",
"\n",
"}",
"\n",
"allVals",
"[",
"key",
"]",
"=",
"val",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"allVals",
"\n",
"}"
] | // MarshalContext marshals a context into a map. | [
"MarshalContext",
"marshals",
"a",
"context",
"into",
"a",
"map",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L130-L149 | train |
looplab/eventhorizon | context.go | RegisterContextUnmarshaler | func RegisterContextUnmarshaler(f ContextUnmarshalFunc) {
contextUnmarshalFuncsMu.Lock()
defer contextUnmarshalFuncsMu.Unlock()
contextUnmarshalFuncs = append(contextUnmarshalFuncs, f)
} | go | func RegisterContextUnmarshaler(f ContextUnmarshalFunc) {
contextUnmarshalFuncsMu.Lock()
defer contextUnmarshalFuncsMu.Unlock()
contextUnmarshalFuncs = append(contextUnmarshalFuncs, f)
} | [
"func",
"RegisterContextUnmarshaler",
"(",
"f",
"ContextUnmarshalFunc",
")",
"{",
"contextUnmarshalFuncsMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"contextUnmarshalFuncsMu",
".",
"Unlock",
"(",
")",
"\n",
"contextUnmarshalFuncs",
"=",
"append",
"(",
"contextUnmarshalFuncs",
",",
"f",
")",
"\n",
"}"
] | // RegisterContextUnmarshaler registers a marshaler function used by UnmarshalContext. | [
"RegisterContextUnmarshaler",
"registers",
"a",
"marshaler",
"function",
"used",
"by",
"UnmarshalContext",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L156-L160 | train |
looplab/eventhorizon | context.go | UnmarshalContext | func UnmarshalContext(vals map[string]interface{}) context.Context {
contextUnmarshalFuncsMu.RLock()
defer contextUnmarshalFuncsMu.RUnlock()
ctx := context.Background()
if vals == nil {
return ctx
}
for _, f := range contextUnmarshalFuncs {
ctx = f(ctx, vals)
}
return ctx
} | go | func UnmarshalContext(vals map[string]interface{}) context.Context {
contextUnmarshalFuncsMu.RLock()
defer contextUnmarshalFuncsMu.RUnlock()
ctx := context.Background()
if vals == nil {
return ctx
}
for _, f := range contextUnmarshalFuncs {
ctx = f(ctx, vals)
}
return ctx
} | [
"func",
"UnmarshalContext",
"(",
"vals",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"context",
".",
"Context",
"{",
"contextUnmarshalFuncsMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"contextUnmarshalFuncsMu",
".",
"RUnlock",
"(",
")",
"\n\n",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"if",
"vals",
"==",
"nil",
"{",
"return",
"ctx",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"f",
":=",
"range",
"contextUnmarshalFuncs",
"{",
"ctx",
"=",
"f",
"(",
"ctx",
",",
"vals",
")",
"\n",
"}",
"\n\n",
"return",
"ctx",
"\n",
"}"
] | // UnmarshalContext unmarshals a context from a map. | [
"UnmarshalContext",
"unmarshals",
"a",
"context",
"from",
"a",
"map",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/context.go#L163-L177 | train |
looplab/eventhorizon | middleware/commandhandler/validator/commandhandler.go | NewMiddleware | func NewMiddleware() eh.CommandHandlerMiddleware {
return eh.CommandHandlerMiddleware(func(h eh.CommandHandler) eh.CommandHandler {
return eh.CommandHandlerFunc(func(ctx context.Context, cmd eh.Command) error {
// Call the validation method if it exists
if c, ok := cmd.(Command); ok {
err := c.Validate()
if err != nil {
return err
}
}
// Immediate command execution.
return h.HandleCommand(ctx, cmd)
})
})
} | go | func NewMiddleware() eh.CommandHandlerMiddleware {
return eh.CommandHandlerMiddleware(func(h eh.CommandHandler) eh.CommandHandler {
return eh.CommandHandlerFunc(func(ctx context.Context, cmd eh.Command) error {
// Call the validation method if it exists
if c, ok := cmd.(Command); ok {
err := c.Validate()
if err != nil {
return err
}
}
// Immediate command execution.
return h.HandleCommand(ctx, cmd)
})
})
} | [
"func",
"NewMiddleware",
"(",
")",
"eh",
".",
"CommandHandlerMiddleware",
"{",
"return",
"eh",
".",
"CommandHandlerMiddleware",
"(",
"func",
"(",
"h",
"eh",
".",
"CommandHandler",
")",
"eh",
".",
"CommandHandler",
"{",
"return",
"eh",
".",
"CommandHandlerFunc",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cmd",
"eh",
".",
"Command",
")",
"error",
"{",
"// Call the validation method if it exists",
"if",
"c",
",",
"ok",
":=",
"cmd",
".",
"(",
"Command",
")",
";",
"ok",
"{",
"err",
":=",
"c",
".",
"Validate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Immediate command execution.",
"return",
"h",
".",
"HandleCommand",
"(",
"ctx",
",",
"cmd",
")",
"\n",
"}",
")",
"\n",
"}",
")",
"\n",
"}"
] | // NewMiddleware returns a new async handling middleware that validate commands
// with its own validation method. | [
"NewMiddleware",
"returns",
"a",
"new",
"async",
"handling",
"middleware",
"that",
"validate",
"commands",
"with",
"its",
"own",
"validation",
"method",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/middleware/commandhandler/validator/commandhandler.go#L25-L40 | train |
looplab/eventhorizon | middleware/commandhandler/validator/commandhandler.go | CommandWithValidation | func CommandWithValidation(cmd eh.Command, v func() error) Command {
return &command{Command: cmd, validate: v}
} | go | func CommandWithValidation(cmd eh.Command, v func() error) Command {
return &command{Command: cmd, validate: v}
} | [
"func",
"CommandWithValidation",
"(",
"cmd",
"eh",
".",
"Command",
",",
"v",
"func",
"(",
")",
"error",
")",
"Command",
"{",
"return",
"&",
"command",
"{",
"Command",
":",
"cmd",
",",
"validate",
":",
"v",
"}",
"\n",
"}"
] | // CommandWithValidation returns a wrapped command with a validation method. | [
"CommandWithValidation",
"returns",
"a",
"wrapped",
"command",
"with",
"a",
"validation",
"method",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/middleware/commandhandler/validator/commandhandler.go#L51-L53 | train |
looplab/eventhorizon | mocks/mocks.go | NewAggregate | func NewAggregate(id uuid.UUID) *Aggregate {
return &Aggregate{
ID: id,
Commands: []eh.Command{},
}
} | go | func NewAggregate(id uuid.UUID) *Aggregate {
return &Aggregate{
ID: id,
Commands: []eh.Command{},
}
} | [
"func",
"NewAggregate",
"(",
"id",
"uuid",
".",
"UUID",
")",
"*",
"Aggregate",
"{",
"return",
"&",
"Aggregate",
"{",
"ID",
":",
"id",
",",
"Commands",
":",
"[",
"]",
"eh",
".",
"Command",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewAggregate returns a new Aggregate. | [
"NewAggregate",
"returns",
"a",
"new",
"Aggregate",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L66-L71 | train |
looplab/eventhorizon | mocks/mocks.go | HandleCommand | func (a *Aggregate) HandleCommand(ctx context.Context, cmd eh.Command) error {
if a.Err != nil {
return a.Err
}
a.Commands = append(a.Commands, cmd)
a.Context = ctx
return nil
} | go | func (a *Aggregate) HandleCommand(ctx context.Context, cmd eh.Command) error {
if a.Err != nil {
return a.Err
}
a.Commands = append(a.Commands, cmd)
a.Context = ctx
return nil
} | [
"func",
"(",
"a",
"*",
"Aggregate",
")",
"HandleCommand",
"(",
"ctx",
"context",
".",
"Context",
",",
"cmd",
"eh",
".",
"Command",
")",
"error",
"{",
"if",
"a",
".",
"Err",
"!=",
"nil",
"{",
"return",
"a",
".",
"Err",
"\n",
"}",
"\n",
"a",
".",
"Commands",
"=",
"append",
"(",
"a",
".",
"Commands",
",",
"cmd",
")",
"\n",
"a",
".",
"Context",
"=",
"ctx",
"\n",
"return",
"nil",
"\n",
"}"
] | // HandleCommand implements the HandleCommand method of the eventhorizon.Aggregate interface. | [
"HandleCommand",
"implements",
"the",
"HandleCommand",
"method",
"of",
"the",
"eventhorizon",
".",
"Aggregate",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L86-L93 | train |
looplab/eventhorizon | mocks/mocks.go | Reset | func (m *EventHandler) Reset() {
m.Events = []eh.Event{}
m.Context = context.Background()
m.Time = time.Time{}
} | go | func (m *EventHandler) Reset() {
m.Events = []eh.Event{}
m.Context = context.Background()
m.Time = time.Time{}
} | [
"func",
"(",
"m",
"*",
"EventHandler",
")",
"Reset",
"(",
")",
"{",
"m",
".",
"Events",
"=",
"[",
"]",
"eh",
".",
"Event",
"{",
"}",
"\n",
"m",
".",
"Context",
"=",
"context",
".",
"Background",
"(",
")",
"\n",
"m",
".",
"Time",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"}"
] | // Reset resets the mock data. | [
"Reset",
"resets",
"the",
"mock",
"data",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L231-L235 | train |
looplab/eventhorizon | mocks/mocks.go | Wait | func (m *EventHandler) Wait(d time.Duration) bool {
select {
case <-m.Recv:
return true
case <-time.After(d):
return false
}
} | go | func (m *EventHandler) Wait(d time.Duration) bool {
select {
case <-m.Recv:
return true
case <-time.After(d):
return false
}
} | [
"func",
"(",
"m",
"*",
"EventHandler",
")",
"Wait",
"(",
"d",
"time",
".",
"Duration",
")",
"bool",
"{",
"select",
"{",
"case",
"<-",
"m",
".",
"Recv",
":",
"return",
"true",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"d",
")",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] | // Wait is a helper to wait some duration until for an event to be handled. | [
"Wait",
"is",
"a",
"helper",
"to",
"wait",
"some",
"duration",
"until",
"for",
"an",
"event",
"to",
"be",
"handled",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L238-L245 | train |
looplab/eventhorizon | mocks/mocks.go | Load | func (m *AggregateStore) Load(ctx context.Context, aggregateType eh.AggregateType, id uuid.UUID) (eh.Aggregate, error) {
if m.Err != nil {
return nil, m.Err
}
m.Context = ctx
return m.Aggregates[id], nil
} | go | func (m *AggregateStore) Load(ctx context.Context, aggregateType eh.AggregateType, id uuid.UUID) (eh.Aggregate, error) {
if m.Err != nil {
return nil, m.Err
}
m.Context = ctx
return m.Aggregates[id], nil
} | [
"func",
"(",
"m",
"*",
"AggregateStore",
")",
"Load",
"(",
"ctx",
"context",
".",
"Context",
",",
"aggregateType",
"eh",
".",
"AggregateType",
",",
"id",
"uuid",
".",
"UUID",
")",
"(",
"eh",
".",
"Aggregate",
",",
"error",
")",
"{",
"if",
"m",
".",
"Err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"m",
".",
"Err",
"\n",
"}",
"\n",
"m",
".",
"Context",
"=",
"ctx",
"\n",
"return",
"m",
".",
"Aggregates",
"[",
"id",
"]",
",",
"nil",
"\n",
"}"
] | // Load implements the Load method of the eventhorizon.AggregateStore interface. | [
"Load",
"implements",
"the",
"Load",
"method",
"of",
"the",
"eventhorizon",
".",
"AggregateStore",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L258-L264 | train |
looplab/eventhorizon | mocks/mocks.go | Save | func (m *AggregateStore) Save(ctx context.Context, aggregate eh.Aggregate) error {
if m.Err != nil {
return m.Err
}
m.Context = ctx
m.Aggregates[aggregate.EntityID()] = aggregate
return nil
} | go | func (m *AggregateStore) Save(ctx context.Context, aggregate eh.Aggregate) error {
if m.Err != nil {
return m.Err
}
m.Context = ctx
m.Aggregates[aggregate.EntityID()] = aggregate
return nil
} | [
"func",
"(",
"m",
"*",
"AggregateStore",
")",
"Save",
"(",
"ctx",
"context",
".",
"Context",
",",
"aggregate",
"eh",
".",
"Aggregate",
")",
"error",
"{",
"if",
"m",
".",
"Err",
"!=",
"nil",
"{",
"return",
"m",
".",
"Err",
"\n",
"}",
"\n",
"m",
".",
"Context",
"=",
"ctx",
"\n",
"m",
".",
"Aggregates",
"[",
"aggregate",
".",
"EntityID",
"(",
")",
"]",
"=",
"aggregate",
"\n",
"return",
"nil",
"\n",
"}"
] | // Save implements the Save method of the eventhorizon.AggregateStore interface. | [
"Save",
"implements",
"the",
"Save",
"method",
"of",
"the",
"eventhorizon",
".",
"AggregateStore",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L267-L274 | train |
looplab/eventhorizon | mocks/mocks.go | Save | func (r *Repo) Save(ctx context.Context, entity eh.Entity) error {
r.SaveCalled = true
if r.SaveErr != nil {
return r.SaveErr
}
r.Entity = entity
return nil
} | go | func (r *Repo) Save(ctx context.Context, entity eh.Entity) error {
r.SaveCalled = true
if r.SaveErr != nil {
return r.SaveErr
}
r.Entity = entity
return nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Save",
"(",
"ctx",
"context",
".",
"Context",
",",
"entity",
"eh",
".",
"Entity",
")",
"error",
"{",
"r",
".",
"SaveCalled",
"=",
"true",
"\n",
"if",
"r",
".",
"SaveErr",
"!=",
"nil",
"{",
"return",
"r",
".",
"SaveErr",
"\n",
"}",
"\n",
"r",
".",
"Entity",
"=",
"entity",
"\n",
"return",
"nil",
"\n",
"}"
] | // Save implements the Save method of the eventhorizon.ReadRepo interface. | [
"Save",
"implements",
"the",
"Save",
"method",
"of",
"the",
"eventhorizon",
".",
"ReadRepo",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L387-L394 | train |
looplab/eventhorizon | mocks/mocks.go | Remove | func (r *Repo) Remove(ctx context.Context, id uuid.UUID) error {
r.RemoveCalled = true
if r.SaveErr != nil {
return r.SaveErr
}
r.Entity = nil
return nil
} | go | func (r *Repo) Remove(ctx context.Context, id uuid.UUID) error {
r.RemoveCalled = true
if r.SaveErr != nil {
return r.SaveErr
}
r.Entity = nil
return nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Remove",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"uuid",
".",
"UUID",
")",
"error",
"{",
"r",
".",
"RemoveCalled",
"=",
"true",
"\n",
"if",
"r",
".",
"SaveErr",
"!=",
"nil",
"{",
"return",
"r",
".",
"SaveErr",
"\n",
"}",
"\n",
"r",
".",
"Entity",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] | // Remove implements the Remove method of the eventhorizon.ReadRepo interface. | [
"Remove",
"implements",
"the",
"Remove",
"method",
"of",
"the",
"eventhorizon",
".",
"ReadRepo",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L397-L404 | train |
looplab/eventhorizon | mocks/mocks.go | WithContextOne | func WithContextOne(ctx context.Context, val string) context.Context {
return context.WithValue(ctx, contextKeyOne, val)
} | go | func WithContextOne(ctx context.Context, val string) context.Context {
return context.WithValue(ctx, contextKeyOne, val)
} | [
"func",
"WithContextOne",
"(",
"ctx",
"context",
".",
"Context",
",",
"val",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"contextKeyOne",
",",
"val",
")",
"\n",
"}"
] | // WithContextOne sets a value for One one the context. | [
"WithContextOne",
"sets",
"a",
"value",
"for",
"One",
"one",
"the",
"context",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L413-L415 | train |
looplab/eventhorizon | mocks/mocks.go | ContextOne | func ContextOne(ctx context.Context) (string, bool) {
val, ok := ctx.Value(contextKeyOne).(string)
return val, ok
} | go | func ContextOne(ctx context.Context) (string, bool) {
val, ok := ctx.Value(contextKeyOne).(string)
return val, ok
} | [
"func",
"ContextOne",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"string",
",",
"bool",
")",
"{",
"val",
",",
"ok",
":=",
"ctx",
".",
"Value",
"(",
"contextKeyOne",
")",
".",
"(",
"string",
")",
"\n",
"return",
"val",
",",
"ok",
"\n",
"}"
] | // ContextOne returns a value for One from the context. | [
"ContextOne",
"returns",
"a",
"value",
"for",
"One",
"from",
"the",
"context",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L418-L421 | train |
looplab/eventhorizon | mocks/mocks.go | init | func init() {
eh.RegisterContextMarshaler(func(ctx context.Context, vals map[string]interface{}) {
if val, ok := ContextOne(ctx); ok {
vals[contextKeyOneStr] = val
}
})
eh.RegisterContextUnmarshaler(func(ctx context.Context, vals map[string]interface{}) context.Context {
if val, ok := vals[contextKeyOneStr].(string); ok {
return WithContextOne(ctx, val)
}
return ctx
})
} | go | func init() {
eh.RegisterContextMarshaler(func(ctx context.Context, vals map[string]interface{}) {
if val, ok := ContextOne(ctx); ok {
vals[contextKeyOneStr] = val
}
})
eh.RegisterContextUnmarshaler(func(ctx context.Context, vals map[string]interface{}) context.Context {
if val, ok := vals[contextKeyOneStr].(string); ok {
return WithContextOne(ctx, val)
}
return ctx
})
} | [
"func",
"init",
"(",
")",
"{",
"eh",
".",
"RegisterContextMarshaler",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"vals",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"if",
"val",
",",
"ok",
":=",
"ContextOne",
"(",
"ctx",
")",
";",
"ok",
"{",
"vals",
"[",
"contextKeyOneStr",
"]",
"=",
"val",
"\n",
"}",
"\n",
"}",
")",
"\n",
"eh",
".",
"RegisterContextUnmarshaler",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"vals",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"context",
".",
"Context",
"{",
"if",
"val",
",",
"ok",
":=",
"vals",
"[",
"contextKeyOneStr",
"]",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"WithContextOne",
"(",
"ctx",
",",
"val",
")",
"\n",
"}",
"\n",
"return",
"ctx",
"\n",
"}",
")",
"\n",
"}"
] | // Register the marshalers and unmarshalers for ContextOne. | [
"Register",
"the",
"marshalers",
"and",
"unmarshalers",
"for",
"ContextOne",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/mocks/mocks.go#L429-L441 | train |
looplab/eventhorizon | eventbus/local/eventbus.go | NewEventBus | func NewEventBus(g *Group) *EventBus {
if g == nil {
g = NewGroup()
}
return &EventBus{
group: g,
registered: map[eh.EventHandlerType]struct{}{},
errCh: make(chan eh.EventBusError, 100),
}
} | go | func NewEventBus(g *Group) *EventBus {
if g == nil {
g = NewGroup()
}
return &EventBus{
group: g,
registered: map[eh.EventHandlerType]struct{}{},
errCh: make(chan eh.EventBusError, 100),
}
} | [
"func",
"NewEventBus",
"(",
"g",
"*",
"Group",
")",
"*",
"EventBus",
"{",
"if",
"g",
"==",
"nil",
"{",
"g",
"=",
"NewGroup",
"(",
")",
"\n",
"}",
"\n",
"return",
"&",
"EventBus",
"{",
"group",
":",
"g",
",",
"registered",
":",
"map",
"[",
"eh",
".",
"EventHandlerType",
"]",
"struct",
"{",
"}",
"{",
"}",
",",
"errCh",
":",
"make",
"(",
"chan",
"eh",
".",
"EventBusError",
",",
"100",
")",
",",
"}",
"\n",
"}"
] | // NewEventBus creates a EventBus. | [
"NewEventBus",
"creates",
"a",
"EventBus",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventbus/local/eventbus.go#L40-L49 | train |
looplab/eventhorizon | eventbus/local/eventbus.go | channel | func (b *EventBus) channel(m eh.EventMatcher, h eh.EventHandler, observer bool) <-chan evt {
b.registeredMu.Lock()
defer b.registeredMu.Unlock()
if m == nil {
panic("matcher can't be nil")
}
if h == nil {
panic("handler can't be nil")
}
if _, ok := b.registered[h.HandlerType()]; ok {
panic(fmt.Sprintf("multiple registrations for %s", h.HandlerType()))
}
b.registered[h.HandlerType()] = struct{}{}
id := string(h.HandlerType())
if observer { // Generate unique ID for each observer.
id = fmt.Sprintf("%s-%s", id, uuid.New())
}
return b.group.channel(id)
} | go | func (b *EventBus) channel(m eh.EventMatcher, h eh.EventHandler, observer bool) <-chan evt {
b.registeredMu.Lock()
defer b.registeredMu.Unlock()
if m == nil {
panic("matcher can't be nil")
}
if h == nil {
panic("handler can't be nil")
}
if _, ok := b.registered[h.HandlerType()]; ok {
panic(fmt.Sprintf("multiple registrations for %s", h.HandlerType()))
}
b.registered[h.HandlerType()] = struct{}{}
id := string(h.HandlerType())
if observer { // Generate unique ID for each observer.
id = fmt.Sprintf("%s-%s", id, uuid.New())
}
return b.group.channel(id)
} | [
"func",
"(",
"b",
"*",
"EventBus",
")",
"channel",
"(",
"m",
"eh",
".",
"EventMatcher",
",",
"h",
"eh",
".",
"EventHandler",
",",
"observer",
"bool",
")",
"<-",
"chan",
"evt",
"{",
"b",
".",
"registeredMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"registeredMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"h",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"b",
".",
"registered",
"[",
"h",
".",
"HandlerType",
"(",
")",
"]",
";",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"HandlerType",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"b",
".",
"registered",
"[",
"h",
".",
"HandlerType",
"(",
")",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"id",
":=",
"string",
"(",
"h",
".",
"HandlerType",
"(",
")",
")",
"\n",
"if",
"observer",
"{",
"// Generate unique ID for each observer.",
"id",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
",",
"uuid",
".",
"New",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"b",
".",
"group",
".",
"channel",
"(",
"id",
")",
"\n",
"}"
] | // Checks the matcher and handler and gets the event channel from the group. | [
"Checks",
"the",
"matcher",
"and",
"handler",
"and",
"gets",
"the",
"event",
"channel",
"from",
"the",
"group",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventbus/local/eventbus.go#L93-L113 | train |
looplab/eventhorizon | eventbus/local/eventbus.go | Close | func (g *Group) Close() {
for _, ch := range g.bus {
close(ch)
}
g.bus = nil
} | go | func (g *Group) Close() {
for _, ch := range g.bus {
close(ch)
}
g.bus = nil
} | [
"func",
"(",
"g",
"*",
"Group",
")",
"Close",
"(",
")",
"{",
"for",
"_",
",",
"ch",
":=",
"range",
"g",
".",
"bus",
"{",
"close",
"(",
"ch",
")",
"\n",
"}",
"\n",
"g",
".",
"bus",
"=",
"nil",
"\n",
"}"
] | // Close all the open channels | [
"Close",
"all",
"the",
"open",
"channels"
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventbus/local/eventbus.go#L170-L175 | train |
looplab/eventhorizon | middleware/commandhandler/scheduler/commandhandler.go | CommandWithExecuteTime | func CommandWithExecuteTime(cmd eh.Command, t time.Time) Command {
return &command{Command: cmd, t: t}
} | go | func CommandWithExecuteTime(cmd eh.Command, t time.Time) Command {
return &command{Command: cmd, t: t}
} | [
"func",
"CommandWithExecuteTime",
"(",
"cmd",
"eh",
".",
"Command",
",",
"t",
"time",
".",
"Time",
")",
"Command",
"{",
"return",
"&",
"command",
"{",
"Command",
":",
"cmd",
",",
"t",
":",
"t",
"}",
"\n",
"}"
] | // CommandWithExecuteTime returns a wrapped command with a execution time set. | [
"CommandWithExecuteTime",
"returns",
"a",
"wrapped",
"command",
"with",
"a",
"execution",
"time",
"set",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/middleware/commandhandler/scheduler/commandhandler.go#L68-L70 | train |
looplab/eventhorizon | examples/guestlist/domain/saga.go | NewResponseSaga | func NewResponseSaga(guestLimit int) *ResponseSaga {
return &ResponseSaga{
acceptedGuests: map[uuid.UUID]bool{},
guestLimit: guestLimit,
}
} | go | func NewResponseSaga(guestLimit int) *ResponseSaga {
return &ResponseSaga{
acceptedGuests: map[uuid.UUID]bool{},
guestLimit: guestLimit,
}
} | [
"func",
"NewResponseSaga",
"(",
"guestLimit",
"int",
")",
"*",
"ResponseSaga",
"{",
"return",
"&",
"ResponseSaga",
"{",
"acceptedGuests",
":",
"map",
"[",
"uuid",
".",
"UUID",
"]",
"bool",
"{",
"}",
",",
"guestLimit",
":",
"guestLimit",
",",
"}",
"\n",
"}"
] | // NewResponseSaga returns a new ResponseSage with a guest limit. | [
"NewResponseSaga",
"returns",
"a",
"new",
"ResponseSage",
"with",
"a",
"guest",
"limit",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/examples/guestlist/domain/saga.go#L38-L43 | train |
looplab/eventhorizon | examples/guestlist/domain/saga.go | RunSaga | func (s *ResponseSaga) RunSaga(ctx context.Context, event eh.Event) []eh.Command {
switch event.EventType() {
case InviteAcceptedEvent:
// Do nothing for already accepted guests.
s.acceptedGuestsMu.RLock()
ok, _ := s.acceptedGuests[event.AggregateID()]
s.acceptedGuestsMu.RUnlock()
if ok {
return nil
}
// Deny the invite if the guest list is full.
if len(s.acceptedGuests) >= s.guestLimit {
return []eh.Command{
&DenyInvite{ID: event.AggregateID()},
}
}
// Confirm the invite when there is space left.
s.acceptedGuestsMu.Lock()
s.acceptedGuests[event.AggregateID()] = true
s.acceptedGuestsMu.Unlock()
return []eh.Command{
&ConfirmInvite{ID: event.AggregateID()},
}
}
return nil
} | go | func (s *ResponseSaga) RunSaga(ctx context.Context, event eh.Event) []eh.Command {
switch event.EventType() {
case InviteAcceptedEvent:
// Do nothing for already accepted guests.
s.acceptedGuestsMu.RLock()
ok, _ := s.acceptedGuests[event.AggregateID()]
s.acceptedGuestsMu.RUnlock()
if ok {
return nil
}
// Deny the invite if the guest list is full.
if len(s.acceptedGuests) >= s.guestLimit {
return []eh.Command{
&DenyInvite{ID: event.AggregateID()},
}
}
// Confirm the invite when there is space left.
s.acceptedGuestsMu.Lock()
s.acceptedGuests[event.AggregateID()] = true
s.acceptedGuestsMu.Unlock()
return []eh.Command{
&ConfirmInvite{ID: event.AggregateID()},
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"ResponseSaga",
")",
"RunSaga",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"eh",
".",
"Event",
")",
"[",
"]",
"eh",
".",
"Command",
"{",
"switch",
"event",
".",
"EventType",
"(",
")",
"{",
"case",
"InviteAcceptedEvent",
":",
"// Do nothing for already accepted guests.",
"s",
".",
"acceptedGuestsMu",
".",
"RLock",
"(",
")",
"\n",
"ok",
",",
"_",
":=",
"s",
".",
"acceptedGuests",
"[",
"event",
".",
"AggregateID",
"(",
")",
"]",
"\n",
"s",
".",
"acceptedGuestsMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Deny the invite if the guest list is full.",
"if",
"len",
"(",
"s",
".",
"acceptedGuests",
")",
">=",
"s",
".",
"guestLimit",
"{",
"return",
"[",
"]",
"eh",
".",
"Command",
"{",
"&",
"DenyInvite",
"{",
"ID",
":",
"event",
".",
"AggregateID",
"(",
")",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"// Confirm the invite when there is space left.",
"s",
".",
"acceptedGuestsMu",
".",
"Lock",
"(",
")",
"\n",
"s",
".",
"acceptedGuests",
"[",
"event",
".",
"AggregateID",
"(",
")",
"]",
"=",
"true",
"\n",
"s",
".",
"acceptedGuestsMu",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"[",
"]",
"eh",
".",
"Command",
"{",
"&",
"ConfirmInvite",
"{",
"ID",
":",
"event",
".",
"AggregateID",
"(",
")",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // RunSaga implements the Run saga method of the Saga interface. | [
"RunSaga",
"implements",
"the",
"Run",
"saga",
"method",
"of",
"the",
"Saga",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/examples/guestlist/domain/saga.go#L51-L80 | train |
looplab/eventhorizon | examples/guestlist/domain/logger.go | LoggingMiddleware | func LoggingMiddleware(h eh.CommandHandler) eh.CommandHandler {
return eh.CommandHandlerFunc(func(ctx context.Context, cmd eh.Command) error {
log.Printf("command: %#v", cmd)
return h.HandleCommand(ctx, cmd)
})
} | go | func LoggingMiddleware(h eh.CommandHandler) eh.CommandHandler {
return eh.CommandHandlerFunc(func(ctx context.Context, cmd eh.Command) error {
log.Printf("command: %#v", cmd)
return h.HandleCommand(ctx, cmd)
})
} | [
"func",
"LoggingMiddleware",
"(",
"h",
"eh",
".",
"CommandHandler",
")",
"eh",
".",
"CommandHandler",
"{",
"return",
"eh",
".",
"CommandHandlerFunc",
"(",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"cmd",
"eh",
".",
"Command",
")",
"error",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"cmd",
")",
"\n",
"return",
"h",
".",
"HandleCommand",
"(",
"ctx",
",",
"cmd",
")",
"\n",
"}",
")",
"\n",
"}"
] | // LoggingMiddleware is a tiny command handle middleware for logging. | [
"LoggingMiddleware",
"is",
"a",
"tiny",
"command",
"handle",
"middleware",
"for",
"logging",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/examples/guestlist/domain/logger.go#L25-L30 | train |
looplab/eventhorizon | repo/cache/repo.go | Notify | func (r *Repo) Notify(ctx context.Context, event eh.Event) {
// Bust the cache on entity updates.
ns := r.namespace(ctx)
r.cacheMu.Lock()
delete(r.cache[ns], event.AggregateID())
r.cacheMu.Unlock()
} | go | func (r *Repo) Notify(ctx context.Context, event eh.Event) {
// Bust the cache on entity updates.
ns := r.namespace(ctx)
r.cacheMu.Lock()
delete(r.cache[ns], event.AggregateID())
r.cacheMu.Unlock()
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Notify",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"eh",
".",
"Event",
")",
"{",
"// Bust the cache on entity updates.",
"ns",
":=",
"r",
".",
"namespace",
"(",
"ctx",
")",
"\n",
"r",
".",
"cacheMu",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"r",
".",
"cache",
"[",
"ns",
"]",
",",
"event",
".",
"AggregateID",
"(",
")",
")",
"\n",
"r",
".",
"cacheMu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Notify implements the Notify method of the eventhorizon.Observer interface. | [
"Notify",
"implements",
"the",
"Notify",
"method",
"of",
"the",
"eventhorizon",
".",
"Observer",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/cache/repo.go#L47-L53 | train |
looplab/eventhorizon | repo/cache/repo.go | Find | func (r *Repo) Find(ctx context.Context, id uuid.UUID) (eh.Entity, error) {
ns := r.namespace(ctx)
// First check the cache.
r.cacheMu.RLock()
entity, ok := r.cache[ns][id]
r.cacheMu.RUnlock()
if ok {
return entity, nil
}
// Fetch and store the entity in the cache.
entity, err := r.ReadWriteRepo.Find(ctx, id)
if err != nil {
return nil, err
}
r.cacheMu.Lock()
r.cache[ns][id] = entity
r.cacheMu.Unlock()
return entity, nil
} | go | func (r *Repo) Find(ctx context.Context, id uuid.UUID) (eh.Entity, error) {
ns := r.namespace(ctx)
// First check the cache.
r.cacheMu.RLock()
entity, ok := r.cache[ns][id]
r.cacheMu.RUnlock()
if ok {
return entity, nil
}
// Fetch and store the entity in the cache.
entity, err := r.ReadWriteRepo.Find(ctx, id)
if err != nil {
return nil, err
}
r.cacheMu.Lock()
r.cache[ns][id] = entity
r.cacheMu.Unlock()
return entity, nil
} | [
"func",
"(",
"r",
"*",
"Repo",
")",
"Find",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"uuid",
".",
"UUID",
")",
"(",
"eh",
".",
"Entity",
",",
"error",
")",
"{",
"ns",
":=",
"r",
".",
"namespace",
"(",
"ctx",
")",
"\n\n",
"// First check the cache.",
"r",
".",
"cacheMu",
".",
"RLock",
"(",
")",
"\n",
"entity",
",",
"ok",
":=",
"r",
".",
"cache",
"[",
"ns",
"]",
"[",
"id",
"]",
"\n",
"r",
".",
"cacheMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"return",
"entity",
",",
"nil",
"\n",
"}",
"\n\n",
"// Fetch and store the entity in the cache.",
"entity",
",",
"err",
":=",
"r",
".",
"ReadWriteRepo",
".",
"Find",
"(",
"ctx",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"r",
".",
"cacheMu",
".",
"Lock",
"(",
")",
"\n",
"r",
".",
"cache",
"[",
"ns",
"]",
"[",
"id",
"]",
"=",
"entity",
"\n",
"r",
".",
"cacheMu",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"entity",
",",
"nil",
"\n",
"}"
] | // Find implements the Find method of the eventhorizon.ReadModel interface. | [
"Find",
"implements",
"the",
"Find",
"method",
"of",
"the",
"eventhorizon",
".",
"ReadModel",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/repo/cache/repo.go#L61-L82 | train |
looplab/eventhorizon | commandhandler/aggregate/commandhandler.go | NewCommandHandler | func NewCommandHandler(t eh.AggregateType, store eh.AggregateStore) (*CommandHandler, error) {
if store == nil {
return nil, ErrNilAggregateStore
}
h := &CommandHandler{
t: t,
store: store,
}
return h, nil
} | go | func NewCommandHandler(t eh.AggregateType, store eh.AggregateStore) (*CommandHandler, error) {
if store == nil {
return nil, ErrNilAggregateStore
}
h := &CommandHandler{
t: t,
store: store,
}
return h, nil
} | [
"func",
"NewCommandHandler",
"(",
"t",
"eh",
".",
"AggregateType",
",",
"store",
"eh",
".",
"AggregateStore",
")",
"(",
"*",
"CommandHandler",
",",
"error",
")",
"{",
"if",
"store",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrNilAggregateStore",
"\n",
"}",
"\n\n",
"h",
":=",
"&",
"CommandHandler",
"{",
"t",
":",
"t",
",",
"store",
":",
"store",
",",
"}",
"\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] | // NewCommandHandler creates a new CommandHandler for an aggregate type. | [
"NewCommandHandler",
"creates",
"a",
"new",
"CommandHandler",
"for",
"an",
"aggregate",
"type",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/commandhandler/aggregate/commandhandler.go#L42-L52 | train |
looplab/eventhorizon | commandhandler/aggregate/commandhandler.go | HandleCommand | func (h *CommandHandler) HandleCommand(ctx context.Context, cmd eh.Command) error {
err := eh.CheckCommand(cmd)
if err != nil {
return err
}
a, err := h.store.Load(ctx, h.t, cmd.AggregateID())
if err != nil {
return err
} else if a == nil {
return eh.ErrAggregateNotFound
}
if err = a.HandleCommand(ctx, cmd); err != nil {
return err
}
return h.store.Save(ctx, a)
} | go | func (h *CommandHandler) HandleCommand(ctx context.Context, cmd eh.Command) error {
err := eh.CheckCommand(cmd)
if err != nil {
return err
}
a, err := h.store.Load(ctx, h.t, cmd.AggregateID())
if err != nil {
return err
} else if a == nil {
return eh.ErrAggregateNotFound
}
if err = a.HandleCommand(ctx, cmd); err != nil {
return err
}
return h.store.Save(ctx, a)
} | [
"func",
"(",
"h",
"*",
"CommandHandler",
")",
"HandleCommand",
"(",
"ctx",
"context",
".",
"Context",
",",
"cmd",
"eh",
".",
"Command",
")",
"error",
"{",
"err",
":=",
"eh",
".",
"CheckCommand",
"(",
"cmd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"a",
",",
"err",
":=",
"h",
".",
"store",
".",
"Load",
"(",
"ctx",
",",
"h",
".",
"t",
",",
"cmd",
".",
"AggregateID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"a",
"==",
"nil",
"{",
"return",
"eh",
".",
"ErrAggregateNotFound",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"a",
".",
"HandleCommand",
"(",
"ctx",
",",
"cmd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"h",
".",
"store",
".",
"Save",
"(",
"ctx",
",",
"a",
")",
"\n",
"}"
] | // HandleCommand handles a command with the registered aggregate.
// Returns ErrAggregateNotFound if no aggregate could be found. | [
"HandleCommand",
"handles",
"a",
"command",
"with",
"the",
"registered",
"aggregate",
".",
"Returns",
"ErrAggregateNotFound",
"if",
"no",
"aggregate",
"could",
"be",
"found",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/commandhandler/aggregate/commandhandler.go#L56-L74 | train |
looplab/eventhorizon | event.go | NewEvent | func NewEvent(eventType EventType, data EventData, timestamp time.Time) Event {
return event{
eventType: eventType,
data: data,
timestamp: timestamp,
}
} | go | func NewEvent(eventType EventType, data EventData, timestamp time.Time) Event {
return event{
eventType: eventType,
data: data,
timestamp: timestamp,
}
} | [
"func",
"NewEvent",
"(",
"eventType",
"EventType",
",",
"data",
"EventData",
",",
"timestamp",
"time",
".",
"Time",
")",
"Event",
"{",
"return",
"event",
"{",
"eventType",
":",
"eventType",
",",
"data",
":",
"data",
",",
"timestamp",
":",
"timestamp",
",",
"}",
"\n",
"}"
] | // NewEvent creates a new event with a type and data, setting its timestamp. | [
"NewEvent",
"creates",
"a",
"new",
"event",
"with",
"a",
"type",
"and",
"data",
"setting",
"its",
"timestamp",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/event.go#L62-L68 | train |
looplab/eventhorizon | event.go | NewEventForAggregate | func NewEventForAggregate(eventType EventType, data EventData, timestamp time.Time,
aggregateType AggregateType, aggregateID uuid.UUID, version int) Event {
return event{
eventType: eventType,
data: data,
timestamp: timestamp,
aggregateType: aggregateType,
aggregateID: aggregateID,
version: version,
}
} | go | func NewEventForAggregate(eventType EventType, data EventData, timestamp time.Time,
aggregateType AggregateType, aggregateID uuid.UUID, version int) Event {
return event{
eventType: eventType,
data: data,
timestamp: timestamp,
aggregateType: aggregateType,
aggregateID: aggregateID,
version: version,
}
} | [
"func",
"NewEventForAggregate",
"(",
"eventType",
"EventType",
",",
"data",
"EventData",
",",
"timestamp",
"time",
".",
"Time",
",",
"aggregateType",
"AggregateType",
",",
"aggregateID",
"uuid",
".",
"UUID",
",",
"version",
"int",
")",
"Event",
"{",
"return",
"event",
"{",
"eventType",
":",
"eventType",
",",
"data",
":",
"data",
",",
"timestamp",
":",
"timestamp",
",",
"aggregateType",
":",
"aggregateType",
",",
"aggregateID",
":",
"aggregateID",
",",
"version",
":",
"version",
",",
"}",
"\n",
"}"
] | // NewEventForAggregate creates a new event with a type and data, setting its
// timestamp. It also sets the aggregate data on it. | [
"NewEventForAggregate",
"creates",
"a",
"new",
"event",
"with",
"a",
"type",
"and",
"data",
"setting",
"its",
"timestamp",
".",
"It",
"also",
"sets",
"the",
"aggregate",
"data",
"on",
"it",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/event.go#L72-L82 | train |
looplab/eventhorizon | event.go | String | func (e event) String() string {
return fmt.Sprintf("%s@%d", e.eventType, e.version)
} | go | func (e event) String() string {
return fmt.Sprintf("%s@%d", e.eventType, e.version)
} | [
"func",
"(",
"e",
"event",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"eventType",
",",
"e",
".",
"version",
")",
"\n",
"}"
] | // String implements the String method of the Event interface. | [
"String",
"implements",
"the",
"String",
"method",
"of",
"the",
"Event",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/event.go#L127-L129 | train |
looplab/eventhorizon | event.go | UnregisterEventData | func UnregisterEventData(eventType EventType) {
if eventType == EventType("") {
panic("eventhorizon: attempt to unregister empty event type")
}
eventDataFactoriesMu.Lock()
defer eventDataFactoriesMu.Unlock()
if _, ok := eventDataFactories[eventType]; !ok {
panic(fmt.Sprintf("eventhorizon: unregister of non-registered type %q", eventType))
}
delete(eventDataFactories, eventType)
} | go | func UnregisterEventData(eventType EventType) {
if eventType == EventType("") {
panic("eventhorizon: attempt to unregister empty event type")
}
eventDataFactoriesMu.Lock()
defer eventDataFactoriesMu.Unlock()
if _, ok := eventDataFactories[eventType]; !ok {
panic(fmt.Sprintf("eventhorizon: unregister of non-registered type %q", eventType))
}
delete(eventDataFactories, eventType)
} | [
"func",
"UnregisterEventData",
"(",
"eventType",
"EventType",
")",
"{",
"if",
"eventType",
"==",
"EventType",
"(",
"\"",
"\"",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"eventDataFactoriesMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"eventDataFactoriesMu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"eventDataFactories",
"[",
"eventType",
"]",
";",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"eventType",
")",
")",
"\n",
"}",
"\n",
"delete",
"(",
"eventDataFactories",
",",
"eventType",
")",
"\n",
"}"
] | // UnregisterEventData removes the registration of the event data factory for
// a type. This is mainly useful in mainenance situations where the event data
// needs to be switched in a migrations. | [
"UnregisterEventData",
"removes",
"the",
"registration",
"of",
"the",
"event",
"data",
"factory",
"for",
"a",
"type",
".",
"This",
"is",
"mainly",
"useful",
"in",
"mainenance",
"situations",
"where",
"the",
"event",
"data",
"needs",
"to",
"be",
"switched",
"in",
"a",
"migrations",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/event.go#L161-L172 | train |
looplab/eventhorizon | event.go | CreateEventData | func CreateEventData(eventType EventType) (EventData, error) {
eventDataFactoriesMu.RLock()
defer eventDataFactoriesMu.RUnlock()
if factory, ok := eventDataFactories[eventType]; ok {
return factory(), nil
}
return nil, ErrEventDataNotRegistered
} | go | func CreateEventData(eventType EventType) (EventData, error) {
eventDataFactoriesMu.RLock()
defer eventDataFactoriesMu.RUnlock()
if factory, ok := eventDataFactories[eventType]; ok {
return factory(), nil
}
return nil, ErrEventDataNotRegistered
} | [
"func",
"CreateEventData",
"(",
"eventType",
"EventType",
")",
"(",
"EventData",
",",
"error",
")",
"{",
"eventDataFactoriesMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"eventDataFactoriesMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"factory",
",",
"ok",
":=",
"eventDataFactories",
"[",
"eventType",
"]",
";",
"ok",
"{",
"return",
"factory",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrEventDataNotRegistered",
"\n",
"}"
] | // CreateEventData creates an event data of a type using the factory registered
// with RegisterEventData. | [
"CreateEventData",
"creates",
"an",
"event",
"data",
"of",
"a",
"type",
"using",
"the",
"factory",
"registered",
"with",
"RegisterEventData",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/event.go#L176-L183 | train |
looplab/eventhorizon | examples/todomvc/internal/domain/aggregate.go | ApplyEvent | func (a *Aggregate) ApplyEvent(ctx context.Context, event eh.Event) error {
switch event.EventType() {
case Created:
a.created = true
case Deleted:
a.created = false
case ItemAdded:
data, ok := event.Data().(*ItemAddedData)
if !ok {
return errors.New("invalid event data")
}
a.items = append(a.items, &TodoItem{
ID: data.ItemID,
Description: data.Description,
})
a.nextItemID++
case ItemRemoved:
data, ok := event.Data().(*ItemRemovedData)
if !ok {
return errors.New("invalid event data")
}
for i, item := range a.items {
if item.ID == data.ItemID {
a.items = append(a.items[:i], a.items[i+1:]...)
break
}
}
case ItemDescriptionSet:
data, ok := event.Data().(*ItemDescriptionSetData)
if !ok {
return errors.New("invalid event data")
}
for _, item := range a.items {
if item.ID == data.ItemID {
item.Description = data.Description
}
}
case ItemChecked:
data, ok := event.Data().(*ItemCheckedData)
if !ok {
return errors.New("invalid event data")
}
for _, item := range a.items {
if item.ID == data.ItemID {
item.Completed = data.Checked
}
}
default:
return fmt.Errorf("could not apply event: %s", event.EventType())
}
return nil
} | go | func (a *Aggregate) ApplyEvent(ctx context.Context, event eh.Event) error {
switch event.EventType() {
case Created:
a.created = true
case Deleted:
a.created = false
case ItemAdded:
data, ok := event.Data().(*ItemAddedData)
if !ok {
return errors.New("invalid event data")
}
a.items = append(a.items, &TodoItem{
ID: data.ItemID,
Description: data.Description,
})
a.nextItemID++
case ItemRemoved:
data, ok := event.Data().(*ItemRemovedData)
if !ok {
return errors.New("invalid event data")
}
for i, item := range a.items {
if item.ID == data.ItemID {
a.items = append(a.items[:i], a.items[i+1:]...)
break
}
}
case ItemDescriptionSet:
data, ok := event.Data().(*ItemDescriptionSetData)
if !ok {
return errors.New("invalid event data")
}
for _, item := range a.items {
if item.ID == data.ItemID {
item.Description = data.Description
}
}
case ItemChecked:
data, ok := event.Data().(*ItemCheckedData)
if !ok {
return errors.New("invalid event data")
}
for _, item := range a.items {
if item.ID == data.ItemID {
item.Completed = data.Checked
}
}
default:
return fmt.Errorf("could not apply event: %s", event.EventType())
}
return nil
} | [
"func",
"(",
"a",
"*",
"Aggregate",
")",
"ApplyEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"eh",
".",
"Event",
")",
"error",
"{",
"switch",
"event",
".",
"EventType",
"(",
")",
"{",
"case",
"Created",
":",
"a",
".",
"created",
"=",
"true",
"\n",
"case",
"Deleted",
":",
"a",
".",
"created",
"=",
"false",
"\n",
"case",
"ItemAdded",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemAddedData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"a",
".",
"items",
"=",
"append",
"(",
"a",
".",
"items",
",",
"&",
"TodoItem",
"{",
"ID",
":",
"data",
".",
"ItemID",
",",
"Description",
":",
"data",
".",
"Description",
",",
"}",
")",
"\n",
"a",
".",
"nextItemID",
"++",
"\n",
"case",
"ItemRemoved",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemRemovedData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"a",
".",
"items",
"{",
"if",
"item",
".",
"ID",
"==",
"data",
".",
"ItemID",
"{",
"a",
".",
"items",
"=",
"append",
"(",
"a",
".",
"items",
"[",
":",
"i",
"]",
",",
"a",
".",
"items",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"ItemDescriptionSet",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemDescriptionSetData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"a",
".",
"items",
"{",
"if",
"item",
".",
"ID",
"==",
"data",
".",
"ItemID",
"{",
"item",
".",
"Description",
"=",
"data",
".",
"Description",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"ItemChecked",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemCheckedData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"a",
".",
"items",
"{",
"if",
"item",
".",
"ID",
"==",
"data",
".",
"ItemID",
"{",
"item",
".",
"Completed",
"=",
"data",
".",
"Checked",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"event",
".",
"EventType",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ApplyEvent implements the ApplyEvent method of the
// eventhorizon.Aggregate interface. | [
"ApplyEvent",
"implements",
"the",
"ApplyEvent",
"method",
"of",
"the",
"eventhorizon",
".",
"Aggregate",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/examples/todomvc/internal/domain/aggregate.go#L155-L206 | train |
looplab/eventhorizon | examples/todomvc/internal/domain/projector.go | Project | func (p *Projector) Project(ctx context.Context,
event eh.Event, entity eh.Entity) (eh.Entity, error) {
model, ok := entity.(*TodoList)
if !ok {
return nil, errors.New("model is of incorrect type")
}
switch event.EventType() {
case Created:
// Set the ID when first created.
model.ID = event.AggregateID()
model.Items = []*TodoItem{} // Prevents "null" in JSON.
model.CreatedAt = TimeNow()
case Deleted:
// Return nil as the entity to delete the model.
return nil, nil
case ItemAdded:
data, ok := event.Data().(*ItemAddedData)
if !ok {
return nil, errors.New("invalid event data")
}
model.Items = append(model.Items, &TodoItem{
ID: data.ItemID,
Description: data.Description,
})
case ItemRemoved:
data, ok := event.Data().(*ItemRemovedData)
if !ok {
return nil, errors.New("invalid event data")
}
for i, item := range model.Items {
if item.ID == data.ItemID {
model.Items = append(model.Items[:i], model.Items[i+1:]...)
break
}
}
case ItemDescriptionSet:
data, ok := event.Data().(*ItemDescriptionSetData)
if !ok {
return nil, errors.New("invalid event data")
}
for _, item := range model.Items {
if item.ID == data.ItemID {
item.Description = data.Description
}
}
case ItemChecked:
data, ok := event.Data().(*ItemCheckedData)
if !ok {
return nil, errors.New("invalid event data")
}
for _, item := range model.Items {
if item.ID == data.ItemID {
item.Completed = data.Checked
}
}
default:
// Also return the modele here to not delete it.
return model, fmt.Errorf("could not project event: %s", event.EventType())
}
// Always increment the version and set update time on successful updates.
model.Version++
model.UpdatedAt = TimeNow()
return model, nil
} | go | func (p *Projector) Project(ctx context.Context,
event eh.Event, entity eh.Entity) (eh.Entity, error) {
model, ok := entity.(*TodoList)
if !ok {
return nil, errors.New("model is of incorrect type")
}
switch event.EventType() {
case Created:
// Set the ID when first created.
model.ID = event.AggregateID()
model.Items = []*TodoItem{} // Prevents "null" in JSON.
model.CreatedAt = TimeNow()
case Deleted:
// Return nil as the entity to delete the model.
return nil, nil
case ItemAdded:
data, ok := event.Data().(*ItemAddedData)
if !ok {
return nil, errors.New("invalid event data")
}
model.Items = append(model.Items, &TodoItem{
ID: data.ItemID,
Description: data.Description,
})
case ItemRemoved:
data, ok := event.Data().(*ItemRemovedData)
if !ok {
return nil, errors.New("invalid event data")
}
for i, item := range model.Items {
if item.ID == data.ItemID {
model.Items = append(model.Items[:i], model.Items[i+1:]...)
break
}
}
case ItemDescriptionSet:
data, ok := event.Data().(*ItemDescriptionSetData)
if !ok {
return nil, errors.New("invalid event data")
}
for _, item := range model.Items {
if item.ID == data.ItemID {
item.Description = data.Description
}
}
case ItemChecked:
data, ok := event.Data().(*ItemCheckedData)
if !ok {
return nil, errors.New("invalid event data")
}
for _, item := range model.Items {
if item.ID == data.ItemID {
item.Completed = data.Checked
}
}
default:
// Also return the modele here to not delete it.
return model, fmt.Errorf("could not project event: %s", event.EventType())
}
// Always increment the version and set update time on successful updates.
model.Version++
model.UpdatedAt = TimeNow()
return model, nil
} | [
"func",
"(",
"p",
"*",
"Projector",
")",
"Project",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"eh",
".",
"Event",
",",
"entity",
"eh",
".",
"Entity",
")",
"(",
"eh",
".",
"Entity",
",",
"error",
")",
"{",
"model",
",",
"ok",
":=",
"entity",
".",
"(",
"*",
"TodoList",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"switch",
"event",
".",
"EventType",
"(",
")",
"{",
"case",
"Created",
":",
"// Set the ID when first created.",
"model",
".",
"ID",
"=",
"event",
".",
"AggregateID",
"(",
")",
"\n",
"model",
".",
"Items",
"=",
"[",
"]",
"*",
"TodoItem",
"{",
"}",
"// Prevents \"null\" in JSON.",
"\n",
"model",
".",
"CreatedAt",
"=",
"TimeNow",
"(",
")",
"\n",
"case",
"Deleted",
":",
"// Return nil as the entity to delete the model.",
"return",
"nil",
",",
"nil",
"\n",
"case",
"ItemAdded",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemAddedData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"model",
".",
"Items",
"=",
"append",
"(",
"model",
".",
"Items",
",",
"&",
"TodoItem",
"{",
"ID",
":",
"data",
".",
"ItemID",
",",
"Description",
":",
"data",
".",
"Description",
",",
"}",
")",
"\n",
"case",
"ItemRemoved",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemRemovedData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"model",
".",
"Items",
"{",
"if",
"item",
".",
"ID",
"==",
"data",
".",
"ItemID",
"{",
"model",
".",
"Items",
"=",
"append",
"(",
"model",
".",
"Items",
"[",
":",
"i",
"]",
",",
"model",
".",
"Items",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"ItemDescriptionSet",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemDescriptionSetData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"model",
".",
"Items",
"{",
"if",
"item",
".",
"ID",
"==",
"data",
".",
"ItemID",
"{",
"item",
".",
"Description",
"=",
"data",
".",
"Description",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"ItemChecked",
":",
"data",
",",
"ok",
":=",
"event",
".",
"Data",
"(",
")",
".",
"(",
"*",
"ItemCheckedData",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"model",
".",
"Items",
"{",
"if",
"item",
".",
"ID",
"==",
"data",
".",
"ItemID",
"{",
"item",
".",
"Completed",
"=",
"data",
".",
"Checked",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"// Also return the modele here to not delete it.",
"return",
"model",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"event",
".",
"EventType",
"(",
")",
")",
"\n",
"}",
"\n\n",
"// Always increment the version and set update time on successful updates.",
"model",
".",
"Version",
"++",
"\n",
"model",
".",
"UpdatedAt",
"=",
"TimeNow",
"(",
")",
"\n",
"return",
"model",
",",
"nil",
"\n",
"}"
] | // Project implements the Project method of the eventhorizon.Projector interface. | [
"Project",
"implements",
"the",
"Project",
"method",
"of",
"the",
"eventhorizon",
".",
"Projector",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/examples/todomvc/internal/domain/projector.go#L36-L102 | train |
looplab/eventhorizon | eventhandler/waiter/eventhandler.go | NewEventHandler | func NewEventHandler() *EventHandler {
h := EventHandler{
inbox: make(chan eh.Event, 1),
register: make(chan *EventListener),
unregister: make(chan *EventListener),
}
go h.run()
return &h
} | go | func NewEventHandler() *EventHandler {
h := EventHandler{
inbox: make(chan eh.Event, 1),
register: make(chan *EventListener),
unregister: make(chan *EventListener),
}
go h.run()
return &h
} | [
"func",
"NewEventHandler",
"(",
")",
"*",
"EventHandler",
"{",
"h",
":=",
"EventHandler",
"{",
"inbox",
":",
"make",
"(",
"chan",
"eh",
".",
"Event",
",",
"1",
")",
",",
"register",
":",
"make",
"(",
"chan",
"*",
"EventListener",
")",
",",
"unregister",
":",
"make",
"(",
"chan",
"*",
"EventListener",
")",
",",
"}",
"\n",
"go",
"h",
".",
"run",
"(",
")",
"\n",
"return",
"&",
"h",
"\n",
"}"
] | // NewEventHandler returns a new EventHandler. | [
"NewEventHandler",
"returns",
"a",
"new",
"EventHandler",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventhandler/waiter/eventhandler.go#L34-L42 | train |
looplab/eventhorizon | eventhandler/waiter/eventhandler.go | HandleEvent | func (h *EventHandler) HandleEvent(ctx context.Context, event eh.Event) error {
h.inbox <- event
return nil
} | go | func (h *EventHandler) HandleEvent(ctx context.Context, event eh.Event) error {
h.inbox <- event
return nil
} | [
"func",
"(",
"h",
"*",
"EventHandler",
")",
"HandleEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"eh",
".",
"Event",
")",
"error",
"{",
"h",
".",
"inbox",
"<-",
"event",
"\n",
"return",
"nil",
"\n",
"}"
] | // HandleEvent implements the HandleEvent method of the eventhorizon.EventHandler interface.
// It forwards events to the waiters so that they can match the events. | [
"HandleEvent",
"implements",
"the",
"HandleEvent",
"method",
"of",
"the",
"eventhorizon",
".",
"EventHandler",
"interface",
".",
"It",
"forwards",
"events",
"to",
"the",
"waiters",
"so",
"that",
"they",
"can",
"match",
"the",
"events",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventhandler/waiter/eventhandler.go#L51-L54 | train |
looplab/eventhorizon | eventhandler/waiter/eventhandler.go | Listen | func (h *EventHandler) Listen(match func(eh.Event) bool) *EventListener {
l := &EventListener{
id: uuid.New(),
inbox: make(chan eh.Event, 1),
match: match,
unregister: h.unregister,
}
// Register us to the in-flight listeners.
h.register <- l
return l
} | go | func (h *EventHandler) Listen(match func(eh.Event) bool) *EventListener {
l := &EventListener{
id: uuid.New(),
inbox: make(chan eh.Event, 1),
match: match,
unregister: h.unregister,
}
// Register us to the in-flight listeners.
h.register <- l
return l
} | [
"func",
"(",
"h",
"*",
"EventHandler",
")",
"Listen",
"(",
"match",
"func",
"(",
"eh",
".",
"Event",
")",
"bool",
")",
"*",
"EventListener",
"{",
"l",
":=",
"&",
"EventListener",
"{",
"id",
":",
"uuid",
".",
"New",
"(",
")",
",",
"inbox",
":",
"make",
"(",
"chan",
"eh",
".",
"Event",
",",
"1",
")",
",",
"match",
":",
"match",
",",
"unregister",
":",
"h",
".",
"unregister",
",",
"}",
"\n",
"// Register us to the in-flight listeners.",
"h",
".",
"register",
"<-",
"l",
"\n\n",
"return",
"l",
"\n",
"}"
] | // Listen waits unil the match function returns true for an event, or the context
// deadline expires. The match function can be used to filter or otherwise select
// interesting events by analysing the event data. | [
"Listen",
"waits",
"unil",
"the",
"match",
"function",
"returns",
"true",
"for",
"an",
"event",
"or",
"the",
"context",
"deadline",
"expires",
".",
"The",
"match",
"function",
"can",
"be",
"used",
"to",
"filter",
"or",
"otherwise",
"select",
"interesting",
"events",
"by",
"analysing",
"the",
"event",
"data",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventhandler/waiter/eventhandler.go#L59-L70 | train |
looplab/eventhorizon | eventhandler/waiter/eventhandler.go | Wait | func (l *EventListener) Wait(ctx context.Context) (eh.Event, error) {
select {
case event := <-l.inbox:
return event, nil
case <-ctx.Done():
return nil, ctx.Err()
}
} | go | func (l *EventListener) Wait(ctx context.Context) (eh.Event, error) {
select {
case event := <-l.inbox:
return event, nil
case <-ctx.Done():
return nil, ctx.Err()
}
} | [
"func",
"(",
"l",
"*",
"EventListener",
")",
"Wait",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"eh",
".",
"Event",
",",
"error",
")",
"{",
"select",
"{",
"case",
"event",
":=",
"<-",
"l",
".",
"inbox",
":",
"return",
"event",
",",
"nil",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Wait waits for the event to arrive or the context to be cancelled. | [
"Wait",
"waits",
"for",
"the",
"event",
"to",
"arrive",
"or",
"the",
"context",
"to",
"be",
"cancelled",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventhandler/waiter/eventhandler.go#L81-L88 | train |
looplab/eventhorizon | examples/guestlist/domain/setup.go | Setup | func Setup(
eventStore eh.EventStore,
eventBus eh.EventBus,
commandBus *bus.CommandHandler,
invitationRepo, guestListRepo eh.ReadWriteRepo,
eventID uuid.UUID) {
// Add a logger as an observer.
eventBus.AddObserver(eh.MatchAny(), &Logger{})
// Create the aggregate repository.
aggregateStore, err := events.NewAggregateStore(eventStore, eventBus)
if err != nil {
log.Fatalf("could not create aggregate store: %s", err)
}
// Create the aggregate command handler and register the commands it handles.
invitationHandler, err := aggregate.NewCommandHandler(InvitationAggregateType, aggregateStore)
if err != nil {
log.Fatalf("could not create command handler: %s", err)
}
commandHandler := eh.UseCommandHandlerMiddleware(invitationHandler, LoggingMiddleware)
commandBus.SetHandler(commandHandler, CreateInviteCommand)
commandBus.SetHandler(commandHandler, AcceptInviteCommand)
commandBus.SetHandler(commandHandler, DeclineInviteCommand)
commandBus.SetHandler(commandHandler, ConfirmInviteCommand)
commandBus.SetHandler(commandHandler, DenyInviteCommand)
// Create and register a read model for individual invitations.
invitationProjector := projector.NewEventHandler(
NewInvitationProjector(), invitationRepo)
invitationProjector.SetEntityFactory(func() eh.Entity { return &Invitation{} })
eventBus.AddHandler(eh.MatchAnyEventOf(
InviteCreatedEvent,
InviteAcceptedEvent,
InviteDeclinedEvent,
InviteConfirmedEvent,
InviteDeniedEvent,
), invitationProjector)
// Create and register a read model for a guest list.
guestListProjector := NewGuestListProjector(guestListRepo, eventID)
eventBus.AddHandler(eh.MatchAnyEventOf(
InviteAcceptedEvent,
InviteDeclinedEvent,
InviteConfirmedEvent,
InviteDeniedEvent,
), guestListProjector)
// Setup the saga that responds to the accepted guests and limits the total
// amount of guests, responding with a confirmation or denial.
responseSaga := saga.NewEventHandler(NewResponseSaga(2), commandBus)
eventBus.AddHandler(eh.MatchEvent(InviteAcceptedEvent), responseSaga)
} | go | func Setup(
eventStore eh.EventStore,
eventBus eh.EventBus,
commandBus *bus.CommandHandler,
invitationRepo, guestListRepo eh.ReadWriteRepo,
eventID uuid.UUID) {
// Add a logger as an observer.
eventBus.AddObserver(eh.MatchAny(), &Logger{})
// Create the aggregate repository.
aggregateStore, err := events.NewAggregateStore(eventStore, eventBus)
if err != nil {
log.Fatalf("could not create aggregate store: %s", err)
}
// Create the aggregate command handler and register the commands it handles.
invitationHandler, err := aggregate.NewCommandHandler(InvitationAggregateType, aggregateStore)
if err != nil {
log.Fatalf("could not create command handler: %s", err)
}
commandHandler := eh.UseCommandHandlerMiddleware(invitationHandler, LoggingMiddleware)
commandBus.SetHandler(commandHandler, CreateInviteCommand)
commandBus.SetHandler(commandHandler, AcceptInviteCommand)
commandBus.SetHandler(commandHandler, DeclineInviteCommand)
commandBus.SetHandler(commandHandler, ConfirmInviteCommand)
commandBus.SetHandler(commandHandler, DenyInviteCommand)
// Create and register a read model for individual invitations.
invitationProjector := projector.NewEventHandler(
NewInvitationProjector(), invitationRepo)
invitationProjector.SetEntityFactory(func() eh.Entity { return &Invitation{} })
eventBus.AddHandler(eh.MatchAnyEventOf(
InviteCreatedEvent,
InviteAcceptedEvent,
InviteDeclinedEvent,
InviteConfirmedEvent,
InviteDeniedEvent,
), invitationProjector)
// Create and register a read model for a guest list.
guestListProjector := NewGuestListProjector(guestListRepo, eventID)
eventBus.AddHandler(eh.MatchAnyEventOf(
InviteAcceptedEvent,
InviteDeclinedEvent,
InviteConfirmedEvent,
InviteDeniedEvent,
), guestListProjector)
// Setup the saga that responds to the accepted guests and limits the total
// amount of guests, responding with a confirmation or denial.
responseSaga := saga.NewEventHandler(NewResponseSaga(2), commandBus)
eventBus.AddHandler(eh.MatchEvent(InviteAcceptedEvent), responseSaga)
} | [
"func",
"Setup",
"(",
"eventStore",
"eh",
".",
"EventStore",
",",
"eventBus",
"eh",
".",
"EventBus",
",",
"commandBus",
"*",
"bus",
".",
"CommandHandler",
",",
"invitationRepo",
",",
"guestListRepo",
"eh",
".",
"ReadWriteRepo",
",",
"eventID",
"uuid",
".",
"UUID",
")",
"{",
"// Add a logger as an observer.",
"eventBus",
".",
"AddObserver",
"(",
"eh",
".",
"MatchAny",
"(",
")",
",",
"&",
"Logger",
"{",
"}",
")",
"\n\n",
"// Create the aggregate repository.",
"aggregateStore",
",",
"err",
":=",
"events",
".",
"NewAggregateStore",
"(",
"eventStore",
",",
"eventBus",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Create the aggregate command handler and register the commands it handles.",
"invitationHandler",
",",
"err",
":=",
"aggregate",
".",
"NewCommandHandler",
"(",
"InvitationAggregateType",
",",
"aggregateStore",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"commandHandler",
":=",
"eh",
".",
"UseCommandHandlerMiddleware",
"(",
"invitationHandler",
",",
"LoggingMiddleware",
")",
"\n",
"commandBus",
".",
"SetHandler",
"(",
"commandHandler",
",",
"CreateInviteCommand",
")",
"\n",
"commandBus",
".",
"SetHandler",
"(",
"commandHandler",
",",
"AcceptInviteCommand",
")",
"\n",
"commandBus",
".",
"SetHandler",
"(",
"commandHandler",
",",
"DeclineInviteCommand",
")",
"\n",
"commandBus",
".",
"SetHandler",
"(",
"commandHandler",
",",
"ConfirmInviteCommand",
")",
"\n",
"commandBus",
".",
"SetHandler",
"(",
"commandHandler",
",",
"DenyInviteCommand",
")",
"\n\n",
"// Create and register a read model for individual invitations.",
"invitationProjector",
":=",
"projector",
".",
"NewEventHandler",
"(",
"NewInvitationProjector",
"(",
")",
",",
"invitationRepo",
")",
"\n",
"invitationProjector",
".",
"SetEntityFactory",
"(",
"func",
"(",
")",
"eh",
".",
"Entity",
"{",
"return",
"&",
"Invitation",
"{",
"}",
"}",
")",
"\n",
"eventBus",
".",
"AddHandler",
"(",
"eh",
".",
"MatchAnyEventOf",
"(",
"InviteCreatedEvent",
",",
"InviteAcceptedEvent",
",",
"InviteDeclinedEvent",
",",
"InviteConfirmedEvent",
",",
"InviteDeniedEvent",
",",
")",
",",
"invitationProjector",
")",
"\n\n",
"// Create and register a read model for a guest list.",
"guestListProjector",
":=",
"NewGuestListProjector",
"(",
"guestListRepo",
",",
"eventID",
")",
"\n",
"eventBus",
".",
"AddHandler",
"(",
"eh",
".",
"MatchAnyEventOf",
"(",
"InviteAcceptedEvent",
",",
"InviteDeclinedEvent",
",",
"InviteConfirmedEvent",
",",
"InviteDeniedEvent",
",",
")",
",",
"guestListProjector",
")",
"\n\n",
"// Setup the saga that responds to the accepted guests and limits the total",
"// amount of guests, responding with a confirmation or denial.",
"responseSaga",
":=",
"saga",
".",
"NewEventHandler",
"(",
"NewResponseSaga",
"(",
"2",
")",
",",
"commandBus",
")",
"\n",
"eventBus",
".",
"AddHandler",
"(",
"eh",
".",
"MatchEvent",
"(",
"InviteAcceptedEvent",
")",
",",
"responseSaga",
")",
"\n",
"}"
] | // Setup configures the domain. | [
"Setup",
"configures",
"the",
"domain",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/examples/guestlist/domain/setup.go#L30-L83 | train |
looplab/eventhorizon | commandhandler.go | HandleCommand | func (h CommandHandlerFunc) HandleCommand(ctx context.Context, cmd Command) error {
return h(ctx, cmd)
} | go | func (h CommandHandlerFunc) HandleCommand(ctx context.Context, cmd Command) error {
return h(ctx, cmd)
} | [
"func",
"(",
"h",
"CommandHandlerFunc",
")",
"HandleCommand",
"(",
"ctx",
"context",
".",
"Context",
",",
"cmd",
"Command",
")",
"error",
"{",
"return",
"h",
"(",
"ctx",
",",
"cmd",
")",
"\n",
"}"
] | // HandleCommand implements the HandleCommand method of the CommandHandler. | [
"HandleCommand",
"implements",
"the",
"HandleCommand",
"method",
"of",
"the",
"CommandHandler",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/commandhandler.go#L30-L32 | train |
looplab/eventhorizon | commandhandler.go | UseCommandHandlerMiddleware | func UseCommandHandlerMiddleware(h CommandHandler, middleware ...CommandHandlerMiddleware) CommandHandler {
// Apply in reverse order.
for i := len(middleware) - 1; i >= 0; i-- {
m := middleware[i]
h = m(h)
}
return h
} | go | func UseCommandHandlerMiddleware(h CommandHandler, middleware ...CommandHandlerMiddleware) CommandHandler {
// Apply in reverse order.
for i := len(middleware) - 1; i >= 0; i-- {
m := middleware[i]
h = m(h)
}
return h
} | [
"func",
"UseCommandHandlerMiddleware",
"(",
"h",
"CommandHandler",
",",
"middleware",
"...",
"CommandHandlerMiddleware",
")",
"CommandHandler",
"{",
"// Apply in reverse order.",
"for",
"i",
":=",
"len",
"(",
"middleware",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"m",
":=",
"middleware",
"[",
"i",
"]",
"\n",
"h",
"=",
"m",
"(",
"h",
")",
"\n",
"}",
"\n",
"return",
"h",
"\n",
"}"
] | // UseCommandHandlerMiddleware wraps a CommandHandler in one or more middleware. | [
"UseCommandHandlerMiddleware",
"wraps",
"a",
"CommandHandler",
"in",
"one",
"or",
"more",
"middleware",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/commandhandler.go#L39-L46 | train |
looplab/eventhorizon | eventhandler/projector/eventhandler.go | Error | func (e Error) Error() string {
errStr := e.Err.Error()
if e.BaseErr != nil {
errStr += ": " + e.BaseErr.Error()
}
return "projector: " + errStr + " (" + e.Namespace + ")"
} | go | func (e Error) Error() string {
errStr := e.Err.Error()
if e.BaseErr != nil {
errStr += ": " + e.BaseErr.Error()
}
return "projector: " + errStr + " (" + e.Namespace + ")"
} | [
"func",
"(",
"e",
"Error",
")",
"Error",
"(",
")",
"string",
"{",
"errStr",
":=",
"e",
".",
"Err",
".",
"Error",
"(",
")",
"\n",
"if",
"e",
".",
"BaseErr",
"!=",
"nil",
"{",
"errStr",
"+=",
"\"",
"\"",
"+",
"e",
".",
"BaseErr",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"+",
"errStr",
"+",
"\"",
"\"",
"+",
"e",
".",
"Namespace",
"+",
"\"",
"\"",
"\n",
"}"
] | // Error implements the Error method of the errors.Error interface. | [
"Error",
"implements",
"the",
"Error",
"method",
"of",
"the",
"errors",
".",
"Error",
"interface",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventhandler/projector/eventhandler.go#L57-L63 | train |
looplab/eventhorizon | eventhandler/projector/eventhandler.go | HandleEvent | func (h *EventHandler) HandleEvent(ctx context.Context, event eh.Event) error {
// Get or create the model, trying to use a waiting find with a min version
// if the underlying repo supports it.
findCtx, cancel := eh.NewContextWithMinVersionWait(ctx, event.Version()-1)
defer cancel()
entity, err := h.repo.Find(findCtx, event.AggregateID())
if rrErr, ok := err.(eh.RepoError); ok && rrErr.Err == eh.ErrEntityNotFound {
if h.factoryFn == nil {
return Error{
Err: ErrModelNotSet,
Namespace: eh.NamespaceFromContext(ctx),
}
}
entity = h.factoryFn()
} else if err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
// The entity should be one version behind the event.
if entity, ok := entity.(eh.Versionable); ok {
if entity.AggregateVersion()+1 != event.Version() {
return Error{
Err: eh.ErrIncorrectEntityVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
}
// Run the projection, which will possibly increment the version.
newEntity, err := h.projector.Project(ctx, event, entity)
if err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
// The model should now be at the same version as the event.
if newEntity, ok := newEntity.(eh.Versionable); ok {
if newEntity.AggregateVersion() != event.Version() {
return Error{
Err: eh.ErrIncorrectEntityVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
}
// Update or remove the model.
if newEntity != nil {
if err := h.repo.Save(ctx, newEntity); err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
} else {
if err := h.repo.Remove(ctx, event.AggregateID()); err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
}
return nil
} | go | func (h *EventHandler) HandleEvent(ctx context.Context, event eh.Event) error {
// Get or create the model, trying to use a waiting find with a min version
// if the underlying repo supports it.
findCtx, cancel := eh.NewContextWithMinVersionWait(ctx, event.Version()-1)
defer cancel()
entity, err := h.repo.Find(findCtx, event.AggregateID())
if rrErr, ok := err.(eh.RepoError); ok && rrErr.Err == eh.ErrEntityNotFound {
if h.factoryFn == nil {
return Error{
Err: ErrModelNotSet,
Namespace: eh.NamespaceFromContext(ctx),
}
}
entity = h.factoryFn()
} else if err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
// The entity should be one version behind the event.
if entity, ok := entity.(eh.Versionable); ok {
if entity.AggregateVersion()+1 != event.Version() {
return Error{
Err: eh.ErrIncorrectEntityVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
}
// Run the projection, which will possibly increment the version.
newEntity, err := h.projector.Project(ctx, event, entity)
if err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
// The model should now be at the same version as the event.
if newEntity, ok := newEntity.(eh.Versionable); ok {
if newEntity.AggregateVersion() != event.Version() {
return Error{
Err: eh.ErrIncorrectEntityVersion,
Namespace: eh.NamespaceFromContext(ctx),
}
}
}
// Update or remove the model.
if newEntity != nil {
if err := h.repo.Save(ctx, newEntity); err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
} else {
if err := h.repo.Remove(ctx, event.AggregateID()); err != nil {
return Error{
Err: err,
Namespace: eh.NamespaceFromContext(ctx),
}
}
}
return nil
} | [
"func",
"(",
"h",
"*",
"EventHandler",
")",
"HandleEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"event",
"eh",
".",
"Event",
")",
"error",
"{",
"// Get or create the model, trying to use a waiting find with a min version",
"// if the underlying repo supports it.",
"findCtx",
",",
"cancel",
":=",
"eh",
".",
"NewContextWithMinVersionWait",
"(",
"ctx",
",",
"event",
".",
"Version",
"(",
")",
"-",
"1",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"entity",
",",
"err",
":=",
"h",
".",
"repo",
".",
"Find",
"(",
"findCtx",
",",
"event",
".",
"AggregateID",
"(",
")",
")",
"\n",
"if",
"rrErr",
",",
"ok",
":=",
"err",
".",
"(",
"eh",
".",
"RepoError",
")",
";",
"ok",
"&&",
"rrErr",
".",
"Err",
"==",
"eh",
".",
"ErrEntityNotFound",
"{",
"if",
"h",
".",
"factoryFn",
"==",
"nil",
"{",
"return",
"Error",
"{",
"Err",
":",
"ErrModelNotSet",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n",
"entity",
"=",
"h",
".",
"factoryFn",
"(",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Error",
"{",
"Err",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// The entity should be one version behind the event.",
"if",
"entity",
",",
"ok",
":=",
"entity",
".",
"(",
"eh",
".",
"Versionable",
")",
";",
"ok",
"{",
"if",
"entity",
".",
"AggregateVersion",
"(",
")",
"+",
"1",
"!=",
"event",
".",
"Version",
"(",
")",
"{",
"return",
"Error",
"{",
"Err",
":",
"eh",
".",
"ErrIncorrectEntityVersion",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Run the projection, which will possibly increment the version.",
"newEntity",
",",
"err",
":=",
"h",
".",
"projector",
".",
"Project",
"(",
"ctx",
",",
"event",
",",
"entity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Error",
"{",
"Err",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// The model should now be at the same version as the event.",
"if",
"newEntity",
",",
"ok",
":=",
"newEntity",
".",
"(",
"eh",
".",
"Versionable",
")",
";",
"ok",
"{",
"if",
"newEntity",
".",
"AggregateVersion",
"(",
")",
"!=",
"event",
".",
"Version",
"(",
")",
"{",
"return",
"Error",
"{",
"Err",
":",
"eh",
".",
"ErrIncorrectEntityVersion",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Update or remove the model.",
"if",
"newEntity",
"!=",
"nil",
"{",
"if",
"err",
":=",
"h",
".",
"repo",
".",
"Save",
"(",
"ctx",
",",
"newEntity",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Error",
"{",
"Err",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"h",
".",
"repo",
".",
"Remove",
"(",
"ctx",
",",
"event",
".",
"AggregateID",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"Error",
"{",
"Err",
":",
"err",
",",
"Namespace",
":",
"eh",
".",
"NamespaceFromContext",
"(",
"ctx",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // HandleEvent implements the HandleEvent method of the eventhorizon.EventHandler interface.
// It will try to find the correct version of the model, waiting for it if needed. | [
"HandleEvent",
"implements",
"the",
"HandleEvent",
"method",
"of",
"the",
"eventhorizon",
".",
"EventHandler",
"interface",
".",
"It",
"will",
"try",
"to",
"find",
"the",
"correct",
"version",
"of",
"the",
"model",
"waiting",
"for",
"it",
"if",
"needed",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventhandler/projector/eventhandler.go#L83-L151 | train |
looplab/eventhorizon | eventbus/gcp/eventbus.go | NewEventBus | func NewEventBus(projectID, appID string, opts ...option.ClientOption) (*EventBus, error) {
ctx := context.Background()
client, err := pubsub.NewClient(ctx, projectID, opts...)
if err != nil {
return nil, err
}
// Get or create the topic.
name := appID + "_events"
topic := client.Topic(name)
if ok, err := topic.Exists(ctx); err != nil {
return nil, err
} else if !ok {
if topic, err = client.CreateTopic(ctx, name); err != nil {
return nil, err
}
}
return &EventBus{
appID: appID,
client: client,
topic: topic,
registered: map[eh.EventHandlerType]struct{}{},
errCh: make(chan eh.EventBusError, 100),
}, nil
} | go | func NewEventBus(projectID, appID string, opts ...option.ClientOption) (*EventBus, error) {
ctx := context.Background()
client, err := pubsub.NewClient(ctx, projectID, opts...)
if err != nil {
return nil, err
}
// Get or create the topic.
name := appID + "_events"
topic := client.Topic(name)
if ok, err := topic.Exists(ctx); err != nil {
return nil, err
} else if !ok {
if topic, err = client.CreateTopic(ctx, name); err != nil {
return nil, err
}
}
return &EventBus{
appID: appID,
client: client,
topic: topic,
registered: map[eh.EventHandlerType]struct{}{},
errCh: make(chan eh.EventBusError, 100),
}, nil
} | [
"func",
"NewEventBus",
"(",
"projectID",
",",
"appID",
"string",
",",
"opts",
"...",
"option",
".",
"ClientOption",
")",
"(",
"*",
"EventBus",
",",
"error",
")",
"{",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n",
"client",
",",
"err",
":=",
"pubsub",
".",
"NewClient",
"(",
"ctx",
",",
"projectID",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Get or create the topic.",
"name",
":=",
"appID",
"+",
"\"",
"\"",
"\n",
"topic",
":=",
"client",
".",
"Topic",
"(",
"name",
")",
"\n",
"if",
"ok",
",",
"err",
":=",
"topic",
".",
"Exists",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"!",
"ok",
"{",
"if",
"topic",
",",
"err",
"=",
"client",
".",
"CreateTopic",
"(",
"ctx",
",",
"name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"EventBus",
"{",
"appID",
":",
"appID",
",",
"client",
":",
"client",
",",
"topic",
":",
"topic",
",",
"registered",
":",
"map",
"[",
"eh",
".",
"EventHandlerType",
"]",
"struct",
"{",
"}",
"{",
"}",
",",
"errCh",
":",
"make",
"(",
"chan",
"eh",
".",
"EventBusError",
",",
"100",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewEventBus creates an EventBus, with optional GCP connection settings. | [
"NewEventBus",
"creates",
"an",
"EventBus",
"with",
"optional",
"GCP",
"connection",
"settings",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventbus/gcp/eventbus.go#L47-L72 | train |
looplab/eventhorizon | eventbus/gcp/eventbus.go | subscription | func (b *EventBus) subscription(m eh.EventMatcher, h eh.EventHandler, observer bool) *pubsub.Subscription {
b.registeredMu.Lock()
defer b.registeredMu.Unlock()
if m == nil {
panic("matcher can't be nil")
}
if h == nil {
panic("handler can't be nil")
}
if _, ok := b.registered[h.HandlerType()]; ok {
panic(fmt.Sprintf("multiple registrations for %s", h.HandlerType()))
}
b.registered[h.HandlerType()] = struct{}{}
id := string(h.HandlerType())
if observer { // Generate unique ID for each observer.
id = fmt.Sprintf("%s-%s", id, uuid.New())
}
ctx := context.Background()
// Get or create the subscription.
subscriptionID := b.appID + "_" + id
sub := b.client.Subscription(subscriptionID)
if ok, err := sub.Exists(ctx); err != nil {
panic("could not check subscription: " + err.Error())
} else if !ok {
if sub, err = b.client.CreateSubscription(ctx, subscriptionID,
pubsub.SubscriptionConfig{
Topic: b.topic,
AckDeadline: 60 * time.Second,
},
); err != nil {
panic("could not create subscription: " + err.Error())
}
}
return sub
} | go | func (b *EventBus) subscription(m eh.EventMatcher, h eh.EventHandler, observer bool) *pubsub.Subscription {
b.registeredMu.Lock()
defer b.registeredMu.Unlock()
if m == nil {
panic("matcher can't be nil")
}
if h == nil {
panic("handler can't be nil")
}
if _, ok := b.registered[h.HandlerType()]; ok {
panic(fmt.Sprintf("multiple registrations for %s", h.HandlerType()))
}
b.registered[h.HandlerType()] = struct{}{}
id := string(h.HandlerType())
if observer { // Generate unique ID for each observer.
id = fmt.Sprintf("%s-%s", id, uuid.New())
}
ctx := context.Background()
// Get or create the subscription.
subscriptionID := b.appID + "_" + id
sub := b.client.Subscription(subscriptionID)
if ok, err := sub.Exists(ctx); err != nil {
panic("could not check subscription: " + err.Error())
} else if !ok {
if sub, err = b.client.CreateSubscription(ctx, subscriptionID,
pubsub.SubscriptionConfig{
Topic: b.topic,
AckDeadline: 60 * time.Second,
},
); err != nil {
panic("could not create subscription: " + err.Error())
}
}
return sub
} | [
"func",
"(",
"b",
"*",
"EventBus",
")",
"subscription",
"(",
"m",
"eh",
".",
"EventMatcher",
",",
"h",
"eh",
".",
"EventHandler",
",",
"observer",
"bool",
")",
"*",
"pubsub",
".",
"Subscription",
"{",
"b",
".",
"registeredMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"registeredMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"m",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"h",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"b",
".",
"registered",
"[",
"h",
".",
"HandlerType",
"(",
")",
"]",
";",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"HandlerType",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"b",
".",
"registered",
"[",
"h",
".",
"HandlerType",
"(",
")",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n\n",
"id",
":=",
"string",
"(",
"h",
".",
"HandlerType",
"(",
")",
")",
"\n",
"if",
"observer",
"{",
"// Generate unique ID for each observer.",
"id",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"id",
",",
"uuid",
".",
"New",
"(",
")",
")",
"\n",
"}",
"\n\n",
"ctx",
":=",
"context",
".",
"Background",
"(",
")",
"\n\n",
"// Get or create the subscription.",
"subscriptionID",
":=",
"b",
".",
"appID",
"+",
"\"",
"\"",
"+",
"id",
"\n",
"sub",
":=",
"b",
".",
"client",
".",
"Subscription",
"(",
"subscriptionID",
")",
"\n",
"if",
"ok",
",",
"err",
":=",
"sub",
".",
"Exists",
"(",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"!",
"ok",
"{",
"if",
"sub",
",",
"err",
"=",
"b",
".",
"client",
".",
"CreateSubscription",
"(",
"ctx",
",",
"subscriptionID",
",",
"pubsub",
".",
"SubscriptionConfig",
"{",
"Topic",
":",
"b",
".",
"topic",
",",
"AckDeadline",
":",
"60",
"*",
"time",
".",
"Second",
",",
"}",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"sub",
"\n",
"}"
] | // Checks the matcher and handler and gets the event subscription. | [
"Checks",
"the",
"matcher",
"and",
"handler",
"and",
"gets",
"the",
"event",
"subscription",
"."
] | 6fd1f17be266c5a217ff8c05dd1403d722cae7f2 | https://github.com/looplab/eventhorizon/blob/6fd1f17be266c5a217ff8c05dd1403d722cae7f2/eventbus/gcp/eventbus.go#L131-L170 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.