id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
16,000 | mdlayher/dhcp6 | dhcp6opts/iapd.go | MarshalBinary | func (i *IAPD) MarshalBinary() ([]byte, error) {
// 4 bytes: IAID
// 4 bytes: T1
// 4 bytes: T2
// N bytes: options slice byte count
buf := buffer.New(nil)
buf.WriteBytes(i.IAID[:])
buf.Write32(uint32(i.T1 / time.Second))
buf.Write32(uint32(i.T2 / time.Second))
opts, err := i.Options.MarshalBinary()
if err != nil {
return nil, err
}
buf.WriteBytes(opts)
return buf.Data(), nil
} | go | func (i *IAPD) MarshalBinary() ([]byte, error) {
// 4 bytes: IAID
// 4 bytes: T1
// 4 bytes: T2
// N bytes: options slice byte count
buf := buffer.New(nil)
buf.WriteBytes(i.IAID[:])
buf.Write32(uint32(i.T1 / time.Second))
buf.Write32(uint32(i.T2 / time.Second))
opts, err := i.Options.MarshalBinary()
if err != nil {
return nil, err
}
buf.WriteBytes(opts)
return buf.Data(), nil
} | [
"func",
"(",
"i",
"*",
"IAPD",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 4 bytes: IAID",
"// 4 bytes: T1",
"// 4 bytes: T2",
"// N bytes: options slice byte count",
"buf",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
... | // MarshalBinary allocates a byte slice containing the data from a IAPD. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"IAPD",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iapd.go#L53-L70 |
16,001 | mdlayher/dhcp6 | dhcp6opts/iapd.go | UnmarshalBinary | func (i *IAPD) UnmarshalBinary(b []byte) error {
// IAPD must contain at least an IAID, T1, and T2.
buf := buffer.New(b)
if buf.Len() < 12 {
return io.ErrUnexpectedEOF
}
copy(i.IAID[:], buf.Consume(4))
i.T1 = time.Duration(buf.Read32()) * time.Second
i.T2 = time.Duration(buf.Read32()) * time.Second
return (&i.Options).UnmarshalBinary(buf.Remaining())
} | go | func (i *IAPD) UnmarshalBinary(b []byte) error {
// IAPD must contain at least an IAID, T1, and T2.
buf := buffer.New(b)
if buf.Len() < 12 {
return io.ErrUnexpectedEOF
}
copy(i.IAID[:], buf.Consume(4))
i.T1 = time.Duration(buf.Read32()) * time.Second
i.T2 = time.Duration(buf.Read32()) * time.Second
return (&i.Options).UnmarshalBinary(buf.Remaining())
} | [
"func",
"(",
"i",
"*",
"IAPD",
")",
"UnmarshalBinary",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"// IAPD must contain at least an IAID, T1, and T2.",
"buf",
":=",
"buffer",
".",
"New",
"(",
"b",
")",
"\n",
"if",
"buf",
".",
"Len",
"(",
")",
"<",
... | // UnmarshalBinary unmarshals a raw byte slice into a IAPD.
//
// If the byte slice does not contain enough data to form a valid IAPD,
// io.ErrUnexpectedEOF is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"IAPD",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"IAPD",
"io",
".",
"ErrUnexpectedEOF",
"is",
"returned",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iapd.go#L76-L88 |
16,002 | mdlayher/dhcp6 | dhcp6opts/relaymessage.go | MarshalBinary | func (rm *RelayMessage) MarshalBinary() ([]byte, error) {
// 1 byte: message type
// 1 byte: hop-count
// 16 bytes: link-address
// 16 bytes: peer-address
// N bytes: options slice byte count
b := buffer.New(nil)
b.Write8(uint8(rm.MessageType))
b.Write8(rm.HopCount)
copy(b.WriteN(net.IPv6len), rm.LinkAddress)
copy(b.WriteN(net.IPv6len), rm.PeerAddress)
opts, err := rm.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | go | func (rm *RelayMessage) MarshalBinary() ([]byte, error) {
// 1 byte: message type
// 1 byte: hop-count
// 16 bytes: link-address
// 16 bytes: peer-address
// N bytes: options slice byte count
b := buffer.New(nil)
b.Write8(uint8(rm.MessageType))
b.Write8(rm.HopCount)
copy(b.WriteN(net.IPv6len), rm.LinkAddress)
copy(b.WriteN(net.IPv6len), rm.PeerAddress)
opts, err := rm.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | [
"func",
"(",
"rm",
"*",
"RelayMessage",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 1 byte: message type",
"// 1 byte: hop-count",
"// 16 bytes: link-address",
"// 16 bytes: peer-address",
"// N bytes: options slice byte count",
"b",... | // MarshalBinary allocates a byte slice containing the data
// from a RelayMessage. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"RelayMessage",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/relaymessage.go#L41-L60 |
16,003 | mdlayher/dhcp6 | dhcp6opts/relaymessage.go | UnmarshalBinary | func (rm *RelayMessage) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// RelayMessage must contain at least message type, hop-count, link-address and peer-address
if b.Len() < 34 {
return io.ErrUnexpectedEOF
}
rm.MessageType = dhcp6.MessageType(b.Read8())
rm.HopCount = b.Read8()
rm.LinkAddress = make(net.IP, net.IPv6len)
copy(rm.LinkAddress, b.Consume(net.IPv6len))
rm.PeerAddress = make(net.IP, net.IPv6len)
copy(rm.PeerAddress, b.Consume(net.IPv6len))
if err := (&rm.Options).UnmarshalBinary(b.Remaining()); err != nil {
// Invalid options means an invalid RelayMessage
return dhcp6.ErrInvalidPacket
}
return nil
} | go | func (rm *RelayMessage) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// RelayMessage must contain at least message type, hop-count, link-address and peer-address
if b.Len() < 34 {
return io.ErrUnexpectedEOF
}
rm.MessageType = dhcp6.MessageType(b.Read8())
rm.HopCount = b.Read8()
rm.LinkAddress = make(net.IP, net.IPv6len)
copy(rm.LinkAddress, b.Consume(net.IPv6len))
rm.PeerAddress = make(net.IP, net.IPv6len)
copy(rm.PeerAddress, b.Consume(net.IPv6len))
if err := (&rm.Options).UnmarshalBinary(b.Remaining()); err != nil {
// Invalid options means an invalid RelayMessage
return dhcp6.ErrInvalidPacket
}
return nil
} | [
"func",
"(",
"rm",
"*",
"RelayMessage",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// RelayMessage must contain at least message type, hop-count, link-address and peer-address",
"if",... | // UnmarshalBinary unmarshals a raw byte slice into a RelayMessage.
//
// If the byte slice does not contain enough data to form a valid RelayMessage,
// ErrInvalidPacket is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"RelayMessage",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"RelayMessage",
"ErrInvalidPacket",
"is",
"returned",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/relaymessage.go#L66-L87 |
16,004 | mdlayher/dhcp6 | dhcp6opts/authentication.go | MarshalBinary | func (a *Authentication) MarshalBinary() ([]byte, error) {
// 1 byte: Protocol
// 1 byte: Algorithm
// 1 byte: RDM
// 8 bytes: ReplayDetection
// N bytes: AuthenticationInformation (can have 0 len byte)
b := buffer.New(nil)
b.Write8(a.Protocol)
b.Write8(a.Algorithm)
b.Write8(a.RDM)
b.Write64(a.ReplayDetection)
b.WriteBytes(a.AuthenticationInformation)
return b.Data(), nil
} | go | func (a *Authentication) MarshalBinary() ([]byte, error) {
// 1 byte: Protocol
// 1 byte: Algorithm
// 1 byte: RDM
// 8 bytes: ReplayDetection
// N bytes: AuthenticationInformation (can have 0 len byte)
b := buffer.New(nil)
b.Write8(a.Protocol)
b.Write8(a.Algorithm)
b.Write8(a.RDM)
b.Write64(a.ReplayDetection)
b.WriteBytes(a.AuthenticationInformation)
return b.Data(), nil
} | [
"func",
"(",
"a",
"*",
"Authentication",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 1 byte: Protocol",
"// 1 byte: Algorithm",
"// 1 byte: RDM",
"// 8 bytes: ReplayDetection",
"// N bytes: AuthenticationInformation (can have 0 len ... | // MarshalBinary allocates a byte slice containing the data from a Authentication. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"Authentication",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/authentication.go#L31-L45 |
16,005 | mdlayher/dhcp6 | dhcp6opts/authentication.go | UnmarshalBinary | func (a *Authentication) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid Authentication
if b.Len() < 11 {
return io.ErrUnexpectedEOF
}
a.Protocol = b.Read8()
a.Algorithm = b.Read8()
a.RDM = b.Read8()
a.ReplayDetection = b.Read64()
a.AuthenticationInformation = b.Remaining()
return nil
} | go | func (a *Authentication) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid Authentication
if b.Len() < 11 {
return io.ErrUnexpectedEOF
}
a.Protocol = b.Read8()
a.Algorithm = b.Read8()
a.RDM = b.Read8()
a.ReplayDetection = b.Read64()
a.AuthenticationInformation = b.Remaining()
return nil
} | [
"func",
"(",
"a",
"*",
"Authentication",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// Too short to be valid Authentication",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"11",... | // UnmarshalBinary unmarshals a raw byte slice into a Authentication.
// If the byte slice does not contain enough data to form a valid
// Authentication, io.ErrUnexpectedEOF is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"Authentication",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"Authentication",
"io",
".",
"ErrUnexpectedEOF",
"is",
"retu... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/authentication.go#L50-L63 |
16,006 | mdlayher/dhcp6 | dhcp6server/request.go | ParseRequest | func ParseRequest(b []byte, remoteAddr *net.UDPAddr) (*Request, error) {
p := new(dhcp6.Packet)
if err := p.UnmarshalBinary(b); err != nil {
return nil, err
}
return &Request{
MessageType: p.MessageType,
TransactionID: p.TransactionID,
Options: p.Options,
Length: int64(len(b)),
RemoteAddr: remoteAddr.String(),
}, nil
} | go | func ParseRequest(b []byte, remoteAddr *net.UDPAddr) (*Request, error) {
p := new(dhcp6.Packet)
if err := p.UnmarshalBinary(b); err != nil {
return nil, err
}
return &Request{
MessageType: p.MessageType,
TransactionID: p.TransactionID,
Options: p.Options,
Length: int64(len(b)),
RemoteAddr: remoteAddr.String(),
}, nil
} | [
"func",
"ParseRequest",
"(",
"b",
"[",
"]",
"byte",
",",
"remoteAddr",
"*",
"net",
".",
"UDPAddr",
")",
"(",
"*",
"Request",
",",
"error",
")",
"{",
"p",
":=",
"new",
"(",
"dhcp6",
".",
"Packet",
")",
"\n",
"if",
"err",
":=",
"p",
".",
"Unmarshal... | // ParseRequest creates a new Request from an input byte slice and UDP address.
// It populates the basic struct members which can be used in a DHCP handler.
//
// If the input byte slice is not a valid DHCP packet, ErrInvalidPacket is
// returned. | [
"ParseRequest",
"creates",
"a",
"new",
"Request",
"from",
"an",
"input",
"byte",
"slice",
"and",
"UDP",
"address",
".",
"It",
"populates",
"the",
"basic",
"struct",
"members",
"which",
"can",
"be",
"used",
"in",
"a",
"DHCP",
"handler",
".",
"If",
"the",
... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/request.go#L40-L53 |
16,007 | mdlayher/dhcp6 | packet.go | MarshalBinary | func (p *Packet) MarshalBinary() ([]byte, error) {
// 1 byte: message type
// 3 bytes: transaction ID
// N bytes: options slice byte count
b := buffer.New(nil)
b.Write8(uint8(p.MessageType))
b.WriteBytes(p.TransactionID[:])
opts, err := p.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | go | func (p *Packet) MarshalBinary() ([]byte, error) {
// 1 byte: message type
// 3 bytes: transaction ID
// N bytes: options slice byte count
b := buffer.New(nil)
b.Write8(uint8(p.MessageType))
b.WriteBytes(p.TransactionID[:])
opts, err := p.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 1 byte: message type",
"// 3 bytes: transaction ID",
"// N bytes: options slice byte count",
"b",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
"... | // MarshalBinary allocates a byte slice containing the data
// from a Packet. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"Packet",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/packet.go#L29-L44 |
16,008 | mdlayher/dhcp6 | packet.go | UnmarshalBinary | func (p *Packet) UnmarshalBinary(q []byte) error {
b := buffer.New(q)
// Packet must contain at least a message type and transaction ID
if b.Len() < 4 {
return ErrInvalidPacket
}
p.MessageType = MessageType(b.Read8())
b.ReadBytes(p.TransactionID[:])
if err := (&p.Options).UnmarshalBinary(b.Remaining()); err != nil {
return ErrInvalidPacket
}
return nil
} | go | func (p *Packet) UnmarshalBinary(q []byte) error {
b := buffer.New(q)
// Packet must contain at least a message type and transaction ID
if b.Len() < 4 {
return ErrInvalidPacket
}
p.MessageType = MessageType(b.Read8())
b.ReadBytes(p.TransactionID[:])
if err := (&p.Options).UnmarshalBinary(b.Remaining()); err != nil {
return ErrInvalidPacket
}
return nil
} | [
"func",
"(",
"p",
"*",
"Packet",
")",
"UnmarshalBinary",
"(",
"q",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"q",
")",
"\n",
"// Packet must contain at least a message type and transaction ID",
"if",
"b",
".",
"Len",
"(",
"... | // UnmarshalBinary unmarshals a raw byte slice into a Packet.
//
// If the byte slice does not contain enough data to form a valid Packet,
// ErrInvalidPacket is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"Packet",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"Packet",
"ErrInvalidPacket",
"is",
"returned",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/packet.go#L50-L64 |
16,009 | mdlayher/dhcp6 | dhcp6server/server.go | logf | func (s *Server) logf(format string, args ...interface{}) {
if s.ErrorLog != nil {
s.ErrorLog.Printf(format, args...)
} else {
log.Printf(format, args...)
}
} | go | func (s *Server) logf(format string, args ...interface{}) {
if s.ErrorLog != nil {
s.ErrorLog.Printf(format, args...)
} else {
log.Printf(format, args...)
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"logf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"s",
".",
"ErrorLog",
"!=",
"nil",
"{",
"s",
".",
"ErrorLog",
".",
"Printf",
"(",
"format",
",",
"args",
"...",
")",... | // logf logs a message using the server's ErrorLog logger, or the log package
// standard logger, if ErrorLog is nil. | [
"logf",
"logs",
"a",
"message",
"using",
"the",
"server",
"s",
"ErrorLog",
"logger",
"or",
"the",
"log",
"package",
"standard",
"logger",
"if",
"ErrorLog",
"is",
"nil",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/server.go#L89-L95 |
16,010 | mdlayher/dhcp6 | dhcp6server/server.go | ListenAndServe | func ListenAndServe(iface string, handler Handler) error {
// Verify network interface exists
ifi, err := net.InterfaceByName(iface)
if err != nil {
return err
}
return (&Server{
Iface: ifi,
Addr: "[::]:547",
Handler: handler,
MulticastGroups: []*net.IPAddr{
AllRelayAgentsAndServersAddr,
AllServersAddr,
},
}).ListenAndServe()
} | go | func ListenAndServe(iface string, handler Handler) error {
// Verify network interface exists
ifi, err := net.InterfaceByName(iface)
if err != nil {
return err
}
return (&Server{
Iface: ifi,
Addr: "[::]:547",
Handler: handler,
MulticastGroups: []*net.IPAddr{
AllRelayAgentsAndServersAddr,
AllServersAddr,
},
}).ListenAndServe()
} | [
"func",
"ListenAndServe",
"(",
"iface",
"string",
",",
"handler",
"Handler",
")",
"error",
"{",
"// Verify network interface exists",
"ifi",
",",
"err",
":=",
"net",
".",
"InterfaceByName",
"(",
"iface",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"e... | // ListenAndServe listens for UDP6 connections on the specified address of the
// specified interface, using the default Server configuration and specified
// handler to handle DHCPv6 connections. The Handler must not be nil.
//
// Any traffic which reaches the Server, and is not bound for the specified
// network interface, will be filtered out and ignored.
//
// In this configuration, the server acts as a DHCP server, but NOT as a
// DHCP relay agent. For more information on DHCP relay agents, see RFC 3315,
// Section 20. | [
"ListenAndServe",
"listens",
"for",
"UDP6",
"connections",
"on",
"the",
"specified",
"address",
"of",
"the",
"specified",
"interface",
"using",
"the",
"default",
"Server",
"configuration",
"and",
"specified",
"handler",
"to",
"handle",
"DHCPv6",
"connections",
".",
... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/server.go#L107-L123 |
16,011 | mdlayher/dhcp6 | dhcp6server/server.go | ListenAndServe | func (s *Server) ListenAndServe() error {
// Open UDP6 packet connection listener on specified address
conn, err := net.ListenPacket("udp6", s.Addr)
if err != nil {
return err
}
defer conn.Close()
return s.Serve(ipv6.NewPacketConn(conn))
} | go | func (s *Server) ListenAndServe() error {
// Open UDP6 packet connection listener on specified address
conn, err := net.ListenPacket("udp6", s.Addr)
if err != nil {
return err
}
defer conn.Close()
return s.Serve(ipv6.NewPacketConn(conn))
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"ListenAndServe",
"(",
")",
"error",
"{",
"// Open UDP6 packet connection listener on specified address",
"conn",
",",
"err",
":=",
"net",
".",
"ListenPacket",
"(",
"\"",
"\"",
",",
"s",
".",
"Addr",
")",
"\n",
"if",
"er... | // ListenAndServe listens on the address specified by s.Addr using the network
// interface defined in s.Iface. Traffic from any other interface will be
// filtered out and ignored. Serve is called to handle serving DHCP traffic
// once ListenAndServe opens a UDP6 packet connection. | [
"ListenAndServe",
"listens",
"on",
"the",
"address",
"specified",
"by",
"s",
".",
"Addr",
"using",
"the",
"network",
"interface",
"defined",
"in",
"s",
".",
"Iface",
".",
"Traffic",
"from",
"any",
"other",
"interface",
"will",
"be",
"filtered",
"out",
"and",... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/server.go#L129-L138 |
16,012 | mdlayher/dhcp6 | dhcp6server/server.go | Serve | func (s *Server) Serve(p PacketConn) error {
// If no DUID was set for server previously, generate a DUID-LL
// now using the interface's hardware address, and just assume the
// "Ethernet 10Mb" hardware type since the caller probably doesn't care.
if s.ServerID == nil {
const ethernet10Mb uint16 = 1
s.ServerID = dhcp6opts.NewDUIDLL(ethernet10Mb, s.Iface.HardwareAddr)
}
// Filter any traffic which does not indicate the interface
// defined by s.Iface.
if err := p.SetControlMessage(ipv6.FlagInterface, true); err != nil {
return err
}
// Join appropriate multicast groups
for _, g := range s.MulticastGroups {
if err := p.JoinGroup(s.Iface, g); err != nil {
return err
}
}
// Set up IPv6 packet connection, and on return, handle leaving multicast
// groups and closing connection
defer func() {
for _, g := range s.MulticastGroups {
_ = p.LeaveGroup(s.Iface, g)
}
_ = p.Close()
}()
// Loop and read requests until exit
buf := make([]byte, 1500)
for {
n, cm, addr, err := p.ReadFrom(buf)
if err != nil {
// Stop serve loop gracefully when closing
if err == errClosing {
return nil
}
// BUG(mdlayher): determine if error can be temporary
return err
}
// Filter any traffic with a control message indicating an incorrect
// interface index
if cm != nil && cm.IfIndex != s.Iface.Index {
continue
}
// Create conn struct with data specific to this connection
uc, err := s.newConn(p, addr.(*net.UDPAddr), n, buf)
if err != nil {
continue
}
// Serve conn and continue looping for more connections
go uc.serve()
}
} | go | func (s *Server) Serve(p PacketConn) error {
// If no DUID was set for server previously, generate a DUID-LL
// now using the interface's hardware address, and just assume the
// "Ethernet 10Mb" hardware type since the caller probably doesn't care.
if s.ServerID == nil {
const ethernet10Mb uint16 = 1
s.ServerID = dhcp6opts.NewDUIDLL(ethernet10Mb, s.Iface.HardwareAddr)
}
// Filter any traffic which does not indicate the interface
// defined by s.Iface.
if err := p.SetControlMessage(ipv6.FlagInterface, true); err != nil {
return err
}
// Join appropriate multicast groups
for _, g := range s.MulticastGroups {
if err := p.JoinGroup(s.Iface, g); err != nil {
return err
}
}
// Set up IPv6 packet connection, and on return, handle leaving multicast
// groups and closing connection
defer func() {
for _, g := range s.MulticastGroups {
_ = p.LeaveGroup(s.Iface, g)
}
_ = p.Close()
}()
// Loop and read requests until exit
buf := make([]byte, 1500)
for {
n, cm, addr, err := p.ReadFrom(buf)
if err != nil {
// Stop serve loop gracefully when closing
if err == errClosing {
return nil
}
// BUG(mdlayher): determine if error can be temporary
return err
}
// Filter any traffic with a control message indicating an incorrect
// interface index
if cm != nil && cm.IfIndex != s.Iface.Index {
continue
}
// Create conn struct with data specific to this connection
uc, err := s.newConn(p, addr.(*net.UDPAddr), n, buf)
if err != nil {
continue
}
// Serve conn and continue looping for more connections
go uc.serve()
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Serve",
"(",
"p",
"PacketConn",
")",
"error",
"{",
"// If no DUID was set for server previously, generate a DUID-LL",
"// now using the interface's hardware address, and just assume the",
"// \"Ethernet 10Mb\" hardware type since the caller probab... | // Serve configures and accepts incoming connections on PacketConn p, creating a
// new goroutine for each. Serve configures IPv6 control message settings, joins
// the appropriate multicast groups, and begins listening for incoming connections.
//
// The service goroutine reads requests, generate the appropriate Request and
// ResponseSender values, then calls s.Handler to handle the request. | [
"Serve",
"configures",
"and",
"accepts",
"incoming",
"connections",
"on",
"PacketConn",
"p",
"creating",
"a",
"new",
"goroutine",
"for",
"each",
".",
"Serve",
"configures",
"IPv6",
"control",
"message",
"settings",
"joins",
"the",
"appropriate",
"multicast",
"grou... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/server.go#L146-L207 |
16,013 | mdlayher/dhcp6 | dhcp6server/server.go | Send | func (r *response) Send(mt dhcp6.MessageType) (int, error) {
p := &dhcp6.Packet{
MessageType: mt,
TransactionID: r.req.TransactionID,
Options: r.options,
}
b, err := p.MarshalBinary()
if err != nil {
return 0, err
}
return r.conn.WriteTo(b, nil, r.remoteAddr)
} | go | func (r *response) Send(mt dhcp6.MessageType) (int, error) {
p := &dhcp6.Packet{
MessageType: mt,
TransactionID: r.req.TransactionID,
Options: r.options,
}
b, err := p.MarshalBinary()
if err != nil {
return 0, err
}
return r.conn.WriteTo(b, nil, r.remoteAddr)
} | [
"func",
"(",
"r",
"*",
"response",
")",
"Send",
"(",
"mt",
"dhcp6",
".",
"MessageType",
")",
"(",
"int",
",",
"error",
")",
"{",
"p",
":=",
"&",
"dhcp6",
".",
"Packet",
"{",
"MessageType",
":",
"mt",
",",
"TransactionID",
":",
"r",
".",
"req",
".... | // Send uses the input message typ, the transaction ID sent by a client,
// and the options set by Options, to create and send a Packet to the
// client's address. | [
"Send",
"uses",
"the",
"input",
"message",
"typ",
"the",
"transaction",
"ID",
"sent",
"by",
"a",
"client",
"and",
"the",
"options",
"set",
"by",
"Options",
"to",
"create",
"and",
"send",
"a",
"Packet",
"to",
"the",
"client",
"s",
"address",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/server.go#L255-L268 |
16,014 | mdlayher/dhcp6 | dhcp6server/server.go | serve | func (c *conn) serve() {
// Attempt to parse a Request from a raw packet, providing a nicer
// API for callers to implement their own DHCP request handlers.
r, err := ParseRequest(c.buf, c.remoteAddr)
if err != nil {
// Malformed packets get no response
if err == dhcp6.ErrInvalidPacket {
return
}
// BUG(mdlayher): decide to log or handle other request errors
c.server.logf("%s: error parsing request: %s", c.remoteAddr.String(), err.Error())
return
}
// Filter out unknown/invalid message types, using the lowest and highest
// numbered types
if r.MessageType < dhcp6.MessageTypeSolicit || r.MessageType > dhcp6.MessageTypeDHCPv4Response {
c.server.logf("%s: unrecognized message type: %d", c.remoteAddr.String(), r.MessageType)
return
}
// Set up response to send responses back to the original requester
w := &response{
remoteAddr: c.remoteAddr,
conn: c.conn,
req: r,
options: make(dhcp6.Options),
}
// Add server ID to response
if sID := c.server.ServerID; sID != nil {
_ = w.options.Add(dhcp6.OptionServerID, sID)
}
// If available in request, add client ID to response
if cID, err := dhcp6opts.GetClientID(r.Options); err == nil {
w.options.Add(dhcp6.OptionClientID, cID)
}
// Enforce a valid Handler.
handler := c.server.Handler
if handler == nil {
panic("nil DHCPv6 handler for server")
}
handler.ServeDHCP(w, r)
} | go | func (c *conn) serve() {
// Attempt to parse a Request from a raw packet, providing a nicer
// API for callers to implement their own DHCP request handlers.
r, err := ParseRequest(c.buf, c.remoteAddr)
if err != nil {
// Malformed packets get no response
if err == dhcp6.ErrInvalidPacket {
return
}
// BUG(mdlayher): decide to log or handle other request errors
c.server.logf("%s: error parsing request: %s", c.remoteAddr.String(), err.Error())
return
}
// Filter out unknown/invalid message types, using the lowest and highest
// numbered types
if r.MessageType < dhcp6.MessageTypeSolicit || r.MessageType > dhcp6.MessageTypeDHCPv4Response {
c.server.logf("%s: unrecognized message type: %d", c.remoteAddr.String(), r.MessageType)
return
}
// Set up response to send responses back to the original requester
w := &response{
remoteAddr: c.remoteAddr,
conn: c.conn,
req: r,
options: make(dhcp6.Options),
}
// Add server ID to response
if sID := c.server.ServerID; sID != nil {
_ = w.options.Add(dhcp6.OptionServerID, sID)
}
// If available in request, add client ID to response
if cID, err := dhcp6opts.GetClientID(r.Options); err == nil {
w.options.Add(dhcp6.OptionClientID, cID)
}
// Enforce a valid Handler.
handler := c.server.Handler
if handler == nil {
panic("nil DHCPv6 handler for server")
}
handler.ServeDHCP(w, r)
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"serve",
"(",
")",
"{",
"// Attempt to parse a Request from a raw packet, providing a nicer",
"// API for callers to implement their own DHCP request handlers.",
"r",
",",
"err",
":=",
"ParseRequest",
"(",
"c",
".",
"buf",
",",
"c",
"... | // serve handles serving an individual DHCP connection, and is invoked in a
// goroutine. | [
"serve",
"handles",
"serving",
"an",
"individual",
"DHCP",
"connection",
"and",
"is",
"invoked",
"in",
"a",
"goroutine",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6server/server.go#L272-L319 |
16,015 | mdlayher/dhcp6 | dhcp6opts/remoteid.go | MarshalBinary | func (r *RemoteIdentifier) MarshalBinary() ([]byte, error) {
// 4 bytes: EnterpriseNumber
// N bytes: RemoteId
b := buffer.New(nil)
b.Write32(r.EnterpriseNumber)
b.WriteBytes(r.RemoteID)
return b.Data(), nil
} | go | func (r *RemoteIdentifier) MarshalBinary() ([]byte, error) {
// 4 bytes: EnterpriseNumber
// N bytes: RemoteId
b := buffer.New(nil)
b.Write32(r.EnterpriseNumber)
b.WriteBytes(r.RemoteID)
return b.Data(), nil
} | [
"func",
"(",
"r",
"*",
"RemoteIdentifier",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 4 bytes: EnterpriseNumber",
"// N bytes: RemoteId",
"b",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
"\n",
"b",
".",
"Write32",
... | // MarshalBinary allocates a byte slice containing the data
// from a RemoteIdentifier. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"RemoteIdentifier",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/remoteid.go#L31-L38 |
16,016 | mdlayher/dhcp6 | dhcp6opts/remoteid.go | UnmarshalBinary | func (r *RemoteIdentifier) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid RemoteIdentifier
if b.Len() < 5 {
return io.ErrUnexpectedEOF
}
r.EnterpriseNumber = b.Read32()
r.RemoteID = b.Remaining()
return nil
} | go | func (r *RemoteIdentifier) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid RemoteIdentifier
if b.Len() < 5 {
return io.ErrUnexpectedEOF
}
r.EnterpriseNumber = b.Read32()
r.RemoteID = b.Remaining()
return nil
} | [
"func",
"(",
"r",
"*",
"RemoteIdentifier",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// Too short to be valid RemoteIdentifier",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"... | // UnmarshalBinary unmarshals a raw byte slice into a RemoteIdentifier.
// If the byte slice does not contain enough data to form a valid
// RemoteIdentifier, io.ErrUnexpectedEOF is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"RemoteIdentifier",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"RemoteIdentifier",
"io",
".",
"ErrUnexpectedEOF",
"is",
"... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/remoteid.go#L43-L53 |
16,017 | mdlayher/dhcp6 | internal/buffer/buffer.go | append | func (b *Buffer) append(n int) []byte {
b.data = append(b.data, make([]byte, n)...)
return b.data[len(b.data)-n:]
} | go | func (b *Buffer) append(n int) []byte {
b.data = append(b.data, make([]byte, n)...)
return b.data[len(b.data)-n:]
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"append",
"(",
"n",
"int",
")",
"[",
"]",
"byte",
"{",
"b",
".",
"data",
"=",
"append",
"(",
"b",
".",
"data",
",",
"make",
"(",
"[",
"]",
"byte",
",",
"n",
")",
"...",
")",
"\n",
"return",
"b",
".",
... | // append appends n bytes to the Buffer and returns a slice pointing to the
// newly appended bytes. | [
"append",
"appends",
"n",
"bytes",
"to",
"the",
"Buffer",
"and",
"returns",
"a",
"slice",
"pointing",
"to",
"the",
"newly",
"appended",
"bytes",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L22-L25 |
16,018 | mdlayher/dhcp6 | internal/buffer/buffer.go | Remaining | func (b *Buffer) Remaining() []byte {
p := b.Consume(len(b.Data()))
cp := make([]byte, len(p))
copy(cp, p)
return cp
} | go | func (b *Buffer) Remaining() []byte {
p := b.Consume(len(b.Data()))
cp := make([]byte, len(p))
copy(cp, p)
return cp
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Remaining",
"(",
")",
"[",
"]",
"byte",
"{",
"p",
":=",
"b",
".",
"Consume",
"(",
"len",
"(",
"b",
".",
"Data",
"(",
")",
")",
")",
"\n",
"cp",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"... | // Remaining consumes and returns a copy of all remaining bytes in the Buffer. | [
"Remaining",
"consumes",
"and",
"returns",
"a",
"copy",
"of",
"all",
"remaining",
"bytes",
"in",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L33-L38 |
16,019 | mdlayher/dhcp6 | internal/buffer/buffer.go | consume | func (b *Buffer) consume(n int) ([]byte, bool) {
if !b.Has(n) {
return nil, false
}
rval := b.data[:n]
b.data = b.data[n:]
return rval, true
} | go | func (b *Buffer) consume(n int) ([]byte, bool) {
if !b.Has(n) {
return nil, false
}
rval := b.data[:n]
b.data = b.data[n:]
return rval, true
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"consume",
"(",
"n",
"int",
")",
"(",
"[",
"]",
"byte",
",",
"bool",
")",
"{",
"if",
"!",
"b",
".",
"Has",
"(",
"n",
")",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"rval",
":=",
"b",
".",
"... | // consume consumes n bytes from the Buffer. It returns nil, false if there
// aren't enough bytes left. | [
"consume",
"consumes",
"n",
"bytes",
"from",
"the",
"Buffer",
".",
"It",
"returns",
"nil",
"false",
"if",
"there",
"aren",
"t",
"enough",
"bytes",
"left",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L42-L49 |
16,020 | mdlayher/dhcp6 | internal/buffer/buffer.go | Consume | func (b *Buffer) Consume(n int) []byte {
v, ok := b.consume(n)
if !ok {
return nil
}
return v
} | go | func (b *Buffer) Consume(n int) []byte {
v, ok := b.consume(n)
if !ok {
return nil
}
return v
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Consume",
"(",
"n",
"int",
")",
"[",
"]",
"byte",
"{",
"v",
",",
"ok",
":=",
"b",
".",
"consume",
"(",
"n",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] | // Consume consumes n bytes from the Buffer. It returns nil if there aren't
// enough bytes left. | [
"Consume",
"consumes",
"n",
"bytes",
"from",
"the",
"Buffer",
".",
"It",
"returns",
"nil",
"if",
"there",
"aren",
"t",
"enough",
"bytes",
"left",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L53-L59 |
16,021 | mdlayher/dhcp6 | internal/buffer/buffer.go | Has | func (b *Buffer) Has(n int) bool {
return len(b.data) >= n
} | go | func (b *Buffer) Has(n int) bool {
return len(b.data) >= n
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Has",
"(",
"n",
"int",
")",
"bool",
"{",
"return",
"len",
"(",
"b",
".",
"data",
")",
">=",
"n",
"\n",
"}"
] | // Has returns true if n bytes are available. | [
"Has",
"returns",
"true",
"if",
"n",
"bytes",
"are",
"available",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L62-L64 |
16,022 | mdlayher/dhcp6 | internal/buffer/buffer.go | Read8 | func (b *Buffer) Read8() uint8 {
v, ok := b.consume(1)
if !ok {
return 0
}
return uint8(v[0])
} | go | func (b *Buffer) Read8() uint8 {
v, ok := b.consume(1)
if !ok {
return 0
}
return uint8(v[0])
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Read8",
"(",
")",
"uint8",
"{",
"v",
",",
"ok",
":=",
"b",
".",
"consume",
"(",
"1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"uint8",
"(",
"v",
"[",
"0",
"]",
")",
... | // Read8 reads a byte from the Buffer. | [
"Read8",
"reads",
"a",
"byte",
"from",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L72-L78 |
16,023 | mdlayher/dhcp6 | internal/buffer/buffer.go | Read16 | func (b *Buffer) Read16() uint16 {
v, ok := b.consume(2)
if !ok {
return 0
}
return order.Uint16(v)
} | go | func (b *Buffer) Read16() uint16 {
v, ok := b.consume(2)
if !ok {
return 0
}
return order.Uint16(v)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Read16",
"(",
")",
"uint16",
"{",
"v",
",",
"ok",
":=",
"b",
".",
"consume",
"(",
"2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"order",
".",
"Uint16",
"(",
"v",
")",
... | // Read16 reads a 16-bit value from the Buffer. | [
"Read16",
"reads",
"a",
"16",
"-",
"bit",
"value",
"from",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L81-L87 |
16,024 | mdlayher/dhcp6 | internal/buffer/buffer.go | Read32 | func (b *Buffer) Read32() uint32 {
v, ok := b.consume(4)
if !ok {
return 0
}
return order.Uint32(v)
} | go | func (b *Buffer) Read32() uint32 {
v, ok := b.consume(4)
if !ok {
return 0
}
return order.Uint32(v)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Read32",
"(",
")",
"uint32",
"{",
"v",
",",
"ok",
":=",
"b",
".",
"consume",
"(",
"4",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"order",
".",
"Uint32",
"(",
"v",
")",
... | // Read32 reads a 32-bit value from the Buffer. | [
"Read32",
"reads",
"a",
"32",
"-",
"bit",
"value",
"from",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L90-L96 |
16,025 | mdlayher/dhcp6 | internal/buffer/buffer.go | Read64 | func (b *Buffer) Read64() uint64 {
v, ok := b.consume(8)
if !ok {
return 0
}
return order.Uint64(v)
} | go | func (b *Buffer) Read64() uint64 {
v, ok := b.consume(8)
if !ok {
return 0
}
return order.Uint64(v)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Read64",
"(",
")",
"uint64",
"{",
"v",
",",
"ok",
":=",
"b",
".",
"consume",
"(",
"8",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"order",
".",
"Uint64",
"(",
"v",
")",
... | // Read64 reads a 64-bit value from the Buffer. | [
"Read64",
"reads",
"a",
"64",
"-",
"bit",
"value",
"from",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L99-L105 |
16,026 | mdlayher/dhcp6 | internal/buffer/buffer.go | Write16 | func (b *Buffer) Write16(v uint16) {
order.PutUint16(b.append(2), v)
} | go | func (b *Buffer) Write16(v uint16) {
order.PutUint16(b.append(2), v)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Write16",
"(",
"v",
"uint16",
")",
"{",
"order",
".",
"PutUint16",
"(",
"b",
".",
"append",
"(",
"2",
")",
",",
"v",
")",
"\n",
"}"
] | // Write16 writes a 16-bit value to the Buffer. | [
"Write16",
"writes",
"a",
"16",
"-",
"bit",
"value",
"to",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L118-L120 |
16,027 | mdlayher/dhcp6 | internal/buffer/buffer.go | Write32 | func (b *Buffer) Write32(v uint32) {
order.PutUint32(b.append(4), v)
} | go | func (b *Buffer) Write32(v uint32) {
order.PutUint32(b.append(4), v)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Write32",
"(",
"v",
"uint32",
")",
"{",
"order",
".",
"PutUint32",
"(",
"b",
".",
"append",
"(",
"4",
")",
",",
"v",
")",
"\n",
"}"
] | // Write32 writes a 32-bit value to the Buffer. | [
"Write32",
"writes",
"a",
"32",
"-",
"bit",
"value",
"to",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L123-L125 |
16,028 | mdlayher/dhcp6 | internal/buffer/buffer.go | Write64 | func (b *Buffer) Write64(v uint64) {
order.PutUint64(b.append(8), v)
} | go | func (b *Buffer) Write64(v uint64) {
order.PutUint64(b.append(8), v)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Write64",
"(",
"v",
"uint64",
")",
"{",
"order",
".",
"PutUint64",
"(",
"b",
".",
"append",
"(",
"8",
")",
",",
"v",
")",
"\n",
"}"
] | // Write64 writes a 64-bit value to the Buffer. | [
"Write64",
"writes",
"a",
"64",
"-",
"bit",
"value",
"to",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L128-L130 |
16,029 | mdlayher/dhcp6 | internal/buffer/buffer.go | WriteBytes | func (b *Buffer) WriteBytes(p []byte) {
copy(b.append(len(p)), p)
} | go | func (b *Buffer) WriteBytes(p []byte) {
copy(b.append(len(p)), p)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"WriteBytes",
"(",
"p",
"[",
"]",
"byte",
")",
"{",
"copy",
"(",
"b",
".",
"append",
"(",
"len",
"(",
"p",
")",
")",
",",
"p",
")",
"\n",
"}"
] | // WriteBytes writes p to the Buffer. | [
"WriteBytes",
"writes",
"p",
"to",
"the",
"Buffer",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/internal/buffer/buffer.go#L138-L140 |
16,030 | mdlayher/dhcp6 | dhcp6opts/iana.go | NewIANA | func NewIANA(iaid [4]byte, t1 time.Duration, t2 time.Duration, options dhcp6.Options) *IANA {
if options == nil {
options = make(dhcp6.Options)
}
return &IANA{
IAID: iaid,
T1: t1,
T2: t2,
Options: options,
}
} | go | func NewIANA(iaid [4]byte, t1 time.Duration, t2 time.Duration, options dhcp6.Options) *IANA {
if options == nil {
options = make(dhcp6.Options)
}
return &IANA{
IAID: iaid,
T1: t1,
T2: t2,
Options: options,
}
} | [
"func",
"NewIANA",
"(",
"iaid",
"[",
"4",
"]",
"byte",
",",
"t1",
"time",
".",
"Duration",
",",
"t2",
"time",
".",
"Duration",
",",
"options",
"dhcp6",
".",
"Options",
")",
"*",
"IANA",
"{",
"if",
"options",
"==",
"nil",
"{",
"options",
"=",
"make"... | // NewIANA creates a new IANA from an IAID, T1 and T2 durations, and an
// Options map. If an Options map is not specified, a new one will be
// allocated. | [
"NewIANA",
"creates",
"a",
"new",
"IANA",
"from",
"an",
"IAID",
"T1",
"and",
"T2",
"durations",
"and",
"an",
"Options",
"map",
".",
"If",
"an",
"Options",
"map",
"is",
"not",
"specified",
"a",
"new",
"one",
"will",
"be",
"allocated",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iana.go#L39-L50 |
16,031 | mdlayher/dhcp6 | dhcp6opts/iana.go | UnmarshalBinary | func (i *IANA) UnmarshalBinary(p []byte) error {
// IANA must contain at least an IAID, T1, and T2.
b := buffer.New(p)
if b.Len() < 12 {
return io.ErrUnexpectedEOF
}
b.ReadBytes(i.IAID[:])
i.T1 = time.Duration(b.Read32()) * time.Second
i.T2 = time.Duration(b.Read32()) * time.Second
return (&i.Options).UnmarshalBinary(b.Remaining())
} | go | func (i *IANA) UnmarshalBinary(p []byte) error {
// IANA must contain at least an IAID, T1, and T2.
b := buffer.New(p)
if b.Len() < 12 {
return io.ErrUnexpectedEOF
}
b.ReadBytes(i.IAID[:])
i.T1 = time.Duration(b.Read32()) * time.Second
i.T2 = time.Duration(b.Read32()) * time.Second
return (&i.Options).UnmarshalBinary(b.Remaining())
} | [
"func",
"(",
"i",
"*",
"IANA",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"// IANA must contain at least an IAID, T1, and T2.",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"12"... | // UnmarshalBinary unmarshals a raw byte slice into a IANA.
//
// If the byte slice does not contain enough data to form a valid IANA,
// io.ErrUnexpectedEOF is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"IANA",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"IANA",
"io",
".",
"ErrUnexpectedEOF",
"is",
"returned",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iana.go#L76-L88 |
16,032 | mdlayher/dhcp6 | dhcp6opts/duid.go | MarshalBinary | func (d *DUIDLLT) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 2 bytes: hardware type
// 4 bytes: time duration
// N bytes: hardware address
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.Write16(d.HardwareType)
b.Write32(uint32(d.Time / time.Second))
b.WriteBytes(d.HardwareAddr)
return b.Data(), nil
} | go | func (d *DUIDLLT) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 2 bytes: hardware type
// 4 bytes: time duration
// N bytes: hardware address
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.Write16(d.HardwareType)
b.Write32(uint32(d.Time / time.Second))
b.WriteBytes(d.HardwareAddr)
return b.Data(), nil
} | [
"func",
"(",
"d",
"*",
"DUIDLLT",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 2 bytes: DUID type",
"// 2 bytes: hardware type",
"// 4 bytes: time duration",
"// N bytes: hardware address",
"b",
":=",
"buffer",
".",
"New",
"("... | // MarshalBinary allocates a byte slice containing the data from a DUIDLLT. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"DUIDLLT",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L141-L154 |
16,033 | mdlayher/dhcp6 | dhcp6opts/duid.go | UnmarshalBinary | func (d *DUIDLLT) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid DUIDLLT
if b.Len() < 8 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeLLT {
return errInvalidDUIDLLT
}
d.Type = dType
d.HardwareType = b.Read16()
d.Time = time.Duration(b.Read32()) * time.Second
d.HardwareAddr = b.Remaining()
return nil
} | go | func (d *DUIDLLT) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid DUIDLLT
if b.Len() < 8 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeLLT {
return errInvalidDUIDLLT
}
d.Type = dType
d.HardwareType = b.Read16()
d.Time = time.Duration(b.Read32()) * time.Second
d.HardwareAddr = b.Remaining()
return nil
} | [
"func",
"(",
"d",
"*",
"DUIDLLT",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// Too short to be valid DUIDLLT",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"8",
"{",
"retu... | // UnmarshalBinary unmarshals a raw byte slice into a DUIDLLT.
// If the byte slice does not contain enough data to form a valid
// DUIDLLT, or another DUID type is indicated, errInvalidDUIDLLT is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"DUIDLLT",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"DUIDLLT",
"or",
"another",
"DUID",
"type",
"is",
"indicated",
... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L159-L178 |
16,034 | mdlayher/dhcp6 | dhcp6opts/duid.go | NewDUIDEN | func NewDUIDEN(enterpriseNumber uint32, identifier []byte) *DUIDEN {
return &DUIDEN{
Type: DUIDTypeEN,
EnterpriseNumber: enterpriseNumber,
Identifier: identifier,
}
} | go | func NewDUIDEN(enterpriseNumber uint32, identifier []byte) *DUIDEN {
return &DUIDEN{
Type: DUIDTypeEN,
EnterpriseNumber: enterpriseNumber,
Identifier: identifier,
}
} | [
"func",
"NewDUIDEN",
"(",
"enterpriseNumber",
"uint32",
",",
"identifier",
"[",
"]",
"byte",
")",
"*",
"DUIDEN",
"{",
"return",
"&",
"DUIDEN",
"{",
"Type",
":",
"DUIDTypeEN",
",",
"EnterpriseNumber",
":",
"enterpriseNumber",
",",
"Identifier",
":",
"identifier... | // NewDUIDEN generates a new DUIDEN from an input IANA-assigned Private
// Enterprise Number and a variable length unique identifier byte slice. | [
"NewDUIDEN",
"generates",
"a",
"new",
"DUIDEN",
"from",
"an",
"input",
"IANA",
"-",
"assigned",
"Private",
"Enterprise",
"Number",
"and",
"a",
"variable",
"length",
"unique",
"identifier",
"byte",
"slice",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L199-L205 |
16,035 | mdlayher/dhcp6 | dhcp6opts/duid.go | MarshalBinary | func (d *DUIDEN) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 4 bytes: enterprise number
// N bytes: identifier
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.Write32(d.EnterpriseNumber)
b.WriteBytes(d.Identifier)
return b.Data(), nil
} | go | func (d *DUIDEN) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 4 bytes: enterprise number
// N bytes: identifier
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.Write32(d.EnterpriseNumber)
b.WriteBytes(d.Identifier)
return b.Data(), nil
} | [
"func",
"(",
"d",
"*",
"DUIDEN",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 2 bytes: DUID type",
"// 4 bytes: enterprise number",
"// N bytes: identifier",
"b",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
"\n\n",
"b",... | // MarshalBinary allocates a byte slice containing the data from a DUIDEN. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"DUIDEN",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L208-L219 |
16,036 | mdlayher/dhcp6 | dhcp6opts/duid.go | UnmarshalBinary | func (d *DUIDEN) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid DUIDEN
if b.Len() < 6 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeEN {
return errInvalidDUIDEN
}
d.Type = dType
d.EnterpriseNumber = b.Read32()
d.Identifier = b.Remaining()
return nil
} | go | func (d *DUIDEN) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be valid DUIDEN
if b.Len() < 6 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeEN {
return errInvalidDUIDEN
}
d.Type = dType
d.EnterpriseNumber = b.Read32()
d.Identifier = b.Remaining()
return nil
} | [
"func",
"(",
"d",
"*",
"DUIDEN",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// Too short to be valid DUIDEN",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"6",
"{",
"return... | // UnmarshalBinary unmarshals a raw byte slice into a DUIDEN.
// If the byte slice does not contain enough data to form a valid
// DUIDEN, or another DUID type is indicated, errInvalidDUIDEN is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"DUIDEN",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"DUIDEN",
"or",
"another",
"DUID",
"type",
"is",
"indicated",
"e... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L224-L240 |
16,037 | mdlayher/dhcp6 | dhcp6opts/duid.go | NewDUIDLL | func NewDUIDLL(hardwareType uint16, hardwareAddr net.HardwareAddr) *DUIDLL {
return &DUIDLL{
Type: DUIDTypeLL,
HardwareType: hardwareType,
HardwareAddr: hardwareAddr,
}
} | go | func NewDUIDLL(hardwareType uint16, hardwareAddr net.HardwareAddr) *DUIDLL {
return &DUIDLL{
Type: DUIDTypeLL,
HardwareType: hardwareType,
HardwareAddr: hardwareAddr,
}
} | [
"func",
"NewDUIDLL",
"(",
"hardwareType",
"uint16",
",",
"hardwareAddr",
"net",
".",
"HardwareAddr",
")",
"*",
"DUIDLL",
"{",
"return",
"&",
"DUIDLL",
"{",
"Type",
":",
"DUIDTypeLL",
",",
"HardwareType",
":",
"hardwareType",
",",
"HardwareAddr",
":",
"hardware... | // NewDUIDLL generates a new DUIDLL from an input IANA-assigned hardware
// type and a hardware address. | [
"NewDUIDLL",
"generates",
"a",
"new",
"DUIDLL",
"from",
"an",
"input",
"IANA",
"-",
"assigned",
"hardware",
"type",
"and",
"a",
"hardware",
"address",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L270-L276 |
16,038 | mdlayher/dhcp6 | dhcp6opts/duid.go | MarshalBinary | func (d *DUIDLL) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 2 bytes: hardware type
// N bytes: hardware address
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.Write16(d.HardwareType)
b.WriteBytes(d.HardwareAddr)
return b.Data(), nil
} | go | func (d *DUIDLL) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 2 bytes: hardware type
// N bytes: hardware address
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.Write16(d.HardwareType)
b.WriteBytes(d.HardwareAddr)
return b.Data(), nil
} | [
"func",
"(",
"d",
"*",
"DUIDLL",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 2 bytes: DUID type",
"// 2 bytes: hardware type",
"// N bytes: hardware address",
"b",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
"\n\n",
"b... | // MarshalBinary allocates a byte slice containing the data from a DUIDLL. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"DUIDLL",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L279-L290 |
16,039 | mdlayher/dhcp6 | dhcp6opts/duid.go | UnmarshalBinary | func (d *DUIDLL) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be DUIDLL
if b.Len() < 4 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeLL {
return errInvalidDUIDLL
}
d.Type = dType
d.HardwareType = b.Read16()
d.HardwareAddr = b.Remaining()
return nil
} | go | func (d *DUIDLL) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// Too short to be DUIDLL
if b.Len() < 4 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeLL {
return errInvalidDUIDLL
}
d.Type = dType
d.HardwareType = b.Read16()
d.HardwareAddr = b.Remaining()
return nil
} | [
"func",
"(",
"d",
"*",
"DUIDLL",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// Too short to be DUIDLL",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"4",
"{",
"return",
"... | // UnmarshalBinary unmarshals a raw byte slice into a DUIDLL.
// If the byte slice does not contain enough data to form a valid
// DUIDLL, or another DUID type is indicated, errInvalidDUIDLL is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"DUIDLL",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"DUIDLL",
"or",
"another",
"DUID",
"type",
"is",
"indicated",
"e... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L295-L312 |
16,040 | mdlayher/dhcp6 | dhcp6opts/duid.go | MarshalBinary | func (d *DUIDUUID) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 16 bytes: UUID
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.WriteBytes(d.UUID[:])
return b.Data(), nil
} | go | func (d *DUIDUUID) MarshalBinary() ([]byte, error) {
// 2 bytes: DUID type
// 16 bytes: UUID
b := buffer.New(nil)
b.Write16(uint16(d.Type))
b.WriteBytes(d.UUID[:])
return b.Data(), nil
} | [
"func",
"(",
"d",
"*",
"DUIDUUID",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 2 bytes: DUID type",
"// 16 bytes: UUID",
"b",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
"\n\n",
"b",
".",
"Write16",
"(",
"uint16... | // MarshalBinary allocates a byte slice containing the data from a DUIDUUID. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"DUIDUUID",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L335-L344 |
16,041 | mdlayher/dhcp6 | dhcp6opts/duid.go | UnmarshalBinary | func (d *DUIDUUID) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// DUIDUUIDs are fixed-length structures
if b.Len() != 18 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeUUID {
return errInvalidDUIDUUID
}
d.Type = dType
b.ReadBytes(d.UUID[:])
return nil
} | go | func (d *DUIDUUID) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// DUIDUUIDs are fixed-length structures
if b.Len() != 18 {
return io.ErrUnexpectedEOF
}
// Verify DUID type
dType := DUIDType(b.Read16())
if dType != DUIDTypeUUID {
return errInvalidDUIDUUID
}
d.Type = dType
b.ReadBytes(d.UUID[:])
return nil
} | [
"func",
"(",
"d",
"*",
"DUIDUUID",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// DUIDUUIDs are fixed-length structures",
"if",
"b",
".",
"Len",
"(",
")",
"!=",
"18",
"... | // UnmarshalBinary unmarshals a raw byte slice into a DUIDUUID.
// If the byte slice does not contain the exact number of bytes
// needed to form a valid DUIDUUID, or another DUID type is indicated,
// errInvalidDUIDUUID is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"DUIDUUID",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"the",
"exact",
"number",
"of",
"bytes",
"needed",
"to",
"form",
"a",
"valid",
"DUIDUUID",
"or",
"another",
... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L350-L365 |
16,042 | mdlayher/dhcp6 | dhcp6opts/duid.go | parseDUID | func parseDUID(p []byte) (DUID, error) {
b := buffer.New(p)
// DUID must have enough bytes to determine its type
if b.Len() < 2 {
return nil, io.ErrUnexpectedEOF
}
var d DUID
switch DUIDType(b.Read16()) {
case DUIDTypeLLT:
d = new(DUIDLLT)
case DUIDTypeEN:
d = new(DUIDEN)
case DUIDTypeLL:
d = new(DUIDLL)
case DUIDTypeUUID:
d = new(DUIDUUID)
default:
return nil, errUnknownDUID
}
return d, d.UnmarshalBinary(p)
} | go | func parseDUID(p []byte) (DUID, error) {
b := buffer.New(p)
// DUID must have enough bytes to determine its type
if b.Len() < 2 {
return nil, io.ErrUnexpectedEOF
}
var d DUID
switch DUIDType(b.Read16()) {
case DUIDTypeLLT:
d = new(DUIDLLT)
case DUIDTypeEN:
d = new(DUIDEN)
case DUIDTypeLL:
d = new(DUIDLL)
case DUIDTypeUUID:
d = new(DUIDUUID)
default:
return nil, errUnknownDUID
}
return d, d.UnmarshalBinary(p)
} | [
"func",
"parseDUID",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"DUID",
",",
"error",
")",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// DUID must have enough bytes to determine its type",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"2",
"{",
"... | // parseDUID returns the correct DUID type of the input byte slice as a
// DUID interface type. | [
"parseDUID",
"returns",
"the",
"correct",
"DUID",
"type",
"of",
"the",
"input",
"byte",
"slice",
"as",
"a",
"DUID",
"interface",
"type",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/duid.go#L369-L391 |
16,043 | mdlayher/dhcp6 | dhcp6opts/iaaddr.go | NewIAAddr | func NewIAAddr(ip net.IP, preferred time.Duration, valid time.Duration, options dhcp6.Options) (*IAAddr, error) {
// From documentation: If ip is not an IPv4 address, To4 returns nil.
if ip.To4() != nil {
return nil, ErrInvalidIP
}
// Preferred lifetime must always be less than valid lifetime.
if preferred > valid {
return nil, ErrInvalidLifetimes
}
// If no options set, make empty map
if options == nil {
options = make(dhcp6.Options)
}
return &IAAddr{
IP: ip,
PreferredLifetime: preferred,
ValidLifetime: valid,
Options: options,
}, nil
} | go | func NewIAAddr(ip net.IP, preferred time.Duration, valid time.Duration, options dhcp6.Options) (*IAAddr, error) {
// From documentation: If ip is not an IPv4 address, To4 returns nil.
if ip.To4() != nil {
return nil, ErrInvalidIP
}
// Preferred lifetime must always be less than valid lifetime.
if preferred > valid {
return nil, ErrInvalidLifetimes
}
// If no options set, make empty map
if options == nil {
options = make(dhcp6.Options)
}
return &IAAddr{
IP: ip,
PreferredLifetime: preferred,
ValidLifetime: valid,
Options: options,
}, nil
} | [
"func",
"NewIAAddr",
"(",
"ip",
"net",
".",
"IP",
",",
"preferred",
"time",
".",
"Duration",
",",
"valid",
"time",
".",
"Duration",
",",
"options",
"dhcp6",
".",
"Options",
")",
"(",
"*",
"IAAddr",
",",
"error",
")",
"{",
"// From documentation: If ip is n... | // NewIAAddr creates a new IAAddr from an IPv6 address, preferred and valid lifetime
// durations, and an optional Options map.
//
// The IP must be exactly 16 bytes, the correct length for an IPv6 address.
// The preferred lifetime duration must be less than the valid lifetime
// duration. Failure to meet either of these conditions will result in an error.
// If an Options map is not specified, a new one will be allocated. | [
"NewIAAddr",
"creates",
"a",
"new",
"IAAddr",
"from",
"an",
"IPv6",
"address",
"preferred",
"and",
"valid",
"lifetime",
"durations",
"and",
"an",
"optional",
"Options",
"map",
".",
"The",
"IP",
"must",
"be",
"exactly",
"16",
"bytes",
"the",
"correct",
"lengt... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iaaddr.go#L54-L76 |
16,044 | mdlayher/dhcp6 | dhcp6opts/iaaddr.go | MarshalBinary | func (i *IAAddr) MarshalBinary() ([]byte, error) {
// 16 bytes: IPv6 address
// 4 bytes: preferred lifetime
// 4 bytes: valid lifetime
// N bytes: options
b := buffer.New(nil)
copy(b.WriteN(net.IPv6len), i.IP)
b.Write32(uint32(i.PreferredLifetime / time.Second))
b.Write32(uint32(i.ValidLifetime / time.Second))
opts, err := i.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | go | func (i *IAAddr) MarshalBinary() ([]byte, error) {
// 16 bytes: IPv6 address
// 4 bytes: preferred lifetime
// 4 bytes: valid lifetime
// N bytes: options
b := buffer.New(nil)
copy(b.WriteN(net.IPv6len), i.IP)
b.Write32(uint32(i.PreferredLifetime / time.Second))
b.Write32(uint32(i.ValidLifetime / time.Second))
opts, err := i.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | [
"func",
"(",
"i",
"*",
"IAAddr",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 16 bytes: IPv6 address",
"// 4 bytes: preferred lifetime",
"// 4 bytes: valid lifetime",
"// N bytes: options",
"b",
":=",
"buffer",
".",
"New",
... | // MarshalBinary allocates a byte slice containing the data from a IAAddr. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"IAAddr",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iaaddr.go#L79-L96 |
16,045 | mdlayher/dhcp6 | dhcp6opts/iaaddr.go | UnmarshalBinary | func (i *IAAddr) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
if b.Len() < 24 {
return io.ErrUnexpectedEOF
}
i.IP = make(net.IP, net.IPv6len)
copy(i.IP, b.Consume(net.IPv6len))
i.PreferredLifetime = time.Duration(b.Read32()) * time.Second
i.ValidLifetime = time.Duration(b.Read32()) * time.Second
// Preferred lifetime must always be less than valid lifetime.
if i.PreferredLifetime > i.ValidLifetime {
return ErrInvalidLifetimes
}
return (&i.Options).UnmarshalBinary(b.Remaining())
} | go | func (i *IAAddr) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
if b.Len() < 24 {
return io.ErrUnexpectedEOF
}
i.IP = make(net.IP, net.IPv6len)
copy(i.IP, b.Consume(net.IPv6len))
i.PreferredLifetime = time.Duration(b.Read32()) * time.Second
i.ValidLifetime = time.Duration(b.Read32()) * time.Second
// Preferred lifetime must always be less than valid lifetime.
if i.PreferredLifetime > i.ValidLifetime {
return ErrInvalidLifetimes
}
return (&i.Options).UnmarshalBinary(b.Remaining())
} | [
"func",
"(",
"i",
"*",
"IAAddr",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"24",
"{",
"return",
"io",
".",
"ErrUnexpectedEO... | // UnmarshalBinary unmarshals a raw byte slice into a IAAddr.
//
// If the byte slice does not contain enough data to form a valid IAAddr,
// io.ErrUnexpectedEOF is returned. If the preferred lifetime value in the
// byte slice is less than the valid lifetime, ErrInvalidLifetimes is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"IAAddr",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"IAAddr",
"io",
".",
"ErrUnexpectedEOF",
"is",
"returned",
".",
... | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iaaddr.go#L103-L121 |
16,046 | mdlayher/dhcp6 | dhcp6opts/iata.go | NewIATA | func NewIATA(iaid [4]byte, options dhcp6.Options) *IATA {
if options == nil {
options = make(dhcp6.Options)
}
return &IATA{
IAID: iaid,
Options: options,
}
} | go | func NewIATA(iaid [4]byte, options dhcp6.Options) *IATA {
if options == nil {
options = make(dhcp6.Options)
}
return &IATA{
IAID: iaid,
Options: options,
}
} | [
"func",
"NewIATA",
"(",
"iaid",
"[",
"4",
"]",
"byte",
",",
"options",
"dhcp6",
".",
"Options",
")",
"*",
"IATA",
"{",
"if",
"options",
"==",
"nil",
"{",
"options",
"=",
"make",
"(",
"dhcp6",
".",
"Options",
")",
"\n",
"}",
"\n\n",
"return",
"&",
... | // NewIATA creates a new IATA from an IAID and an Options map. If an Options
// map is not specified, a new one will be allocated. | [
"NewIATA",
"creates",
"a",
"new",
"IATA",
"from",
"an",
"IAID",
"and",
"an",
"Options",
"map",
".",
"If",
"an",
"Options",
"map",
"is",
"not",
"specified",
"a",
"new",
"one",
"will",
"be",
"allocated",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iata.go#L27-L36 |
16,047 | mdlayher/dhcp6 | dhcp6opts/iata.go | MarshalBinary | func (i *IATA) MarshalBinary() ([]byte, error) {
// 4 bytes: IAID
// N bytes: options slice byte count
b := buffer.New(nil)
b.WriteBytes(i.IAID[:])
opts, err := i.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | go | func (i *IATA) MarshalBinary() ([]byte, error) {
// 4 bytes: IAID
// N bytes: options slice byte count
b := buffer.New(nil)
b.WriteBytes(i.IAID[:])
opts, err := i.Options.MarshalBinary()
if err != nil {
return nil, err
}
b.WriteBytes(opts)
return b.Data(), nil
} | [
"func",
"(",
"i",
"*",
"IATA",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// 4 bytes: IAID",
"// N bytes: options slice byte count",
"b",
":=",
"buffer",
".",
"New",
"(",
"nil",
")",
"\n\n",
"b",
".",
"WriteBytes",
"(... | // MarshalBinary allocates a byte slice containing the data from a IATA. | [
"MarshalBinary",
"allocates",
"a",
"byte",
"slice",
"containing",
"the",
"data",
"from",
"a",
"IATA",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iata.go#L39-L52 |
16,048 | mdlayher/dhcp6 | dhcp6opts/iata.go | UnmarshalBinary | func (i *IATA) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// IATA must contain at least an IAID.
if b.Len() < 4 {
return io.ErrUnexpectedEOF
}
b.ReadBytes(i.IAID[:])
return (&i.Options).UnmarshalBinary(b.Remaining())
} | go | func (i *IATA) UnmarshalBinary(p []byte) error {
b := buffer.New(p)
// IATA must contain at least an IAID.
if b.Len() < 4 {
return io.ErrUnexpectedEOF
}
b.ReadBytes(i.IAID[:])
return (&i.Options).UnmarshalBinary(b.Remaining())
} | [
"func",
"(",
"i",
"*",
"IATA",
")",
"UnmarshalBinary",
"(",
"p",
"[",
"]",
"byte",
")",
"error",
"{",
"b",
":=",
"buffer",
".",
"New",
"(",
"p",
")",
"\n",
"// IATA must contain at least an IAID.",
"if",
"b",
".",
"Len",
"(",
")",
"<",
"4",
"{",
"r... | // UnmarshalBinary unmarshals a raw byte slice into a IATA.
//
// If the byte slice does not contain enough data to form a valid IATA,
// io.ErrUnexpectedEOF is returned. | [
"UnmarshalBinary",
"unmarshals",
"a",
"raw",
"byte",
"slice",
"into",
"a",
"IATA",
".",
"If",
"the",
"byte",
"slice",
"does",
"not",
"contain",
"enough",
"data",
"to",
"form",
"a",
"valid",
"IATA",
"io",
".",
"ErrUnexpectedEOF",
"is",
"returned",
"."
] | 2a67805d7d0b0bad6c1103058981afdea583b459 | https://github.com/mdlayher/dhcp6/blob/2a67805d7d0b0bad6c1103058981afdea583b459/dhcp6opts/iata.go#L58-L67 |
16,049 | paypal/gorealis | retry.go | thriftCallWithRetries | func (r *realisClient) thriftCallWithRetries(thriftCall auroraThriftCall) (*aurora.Response, error) {
var resp *aurora.Response
var clientErr error
var curStep int
backoff := r.config.backoff
duration := backoff.Duration
for curStep = 0; curStep < backoff.Steps; curStep++ {
// If this isn't our first try, backoff before the next try.
if curStep != 0 {
adjusted := duration
if backoff.Jitter > 0.0 {
adjusted = Jitter(duration, backoff.Jitter)
}
r.logger.Printf("A retriable error occurred during thrift call, backing off for %v before retry %v\n", adjusted, curStep)
time.Sleep(adjusted)
duration = time.Duration(float64(duration) * backoff.Factor)
}
// Only allow one go-routine make use or modify the thrift client connection.
// Placing this in an anonymous function in order to create a new, short-lived stack allowing unlock
// to be run in case of a panic inside of thriftCall.
func() {
r.lock.Lock()
defer r.lock.Unlock()
resp, clientErr = thriftCall()
r.logger.TracePrintf("Aurora Thrift Call ended resp: %v clientErr: %v\n", resp, clientErr)
}()
// Check if our thrift call is returning an error. This is a retriable event as we don't know
// if it was caused by network issues.
if clientErr != nil {
// Print out the error to the user
r.logger.Printf("Client Error: %v\n", clientErr)
// Determine if error is a temporary URL error by going up the stack
e, ok := clientErr.(thrift.TTransportException)
if ok {
r.logger.DebugPrint("Encountered a transport exception")
e, ok := e.Err().(*url.Error)
if ok {
// EOF error occurs when the server closes the read buffer of the client. This is common
// when the server is overloaded and should be retried. All other errors that are permanent
// will not be retried.
if e.Err != io.EOF && !e.Temporary() {
return nil, errors.Wrap(clientErr, "Permanent connection error")
}
}
}
// In the future, reestablish connection should be able to check if it is actually possible
// to make a thrift call to Aurora. For now, a reconnect should always lead to a retry.
r.ReestablishConn()
} else {
// If there was no client error, but the response is nil, something went wrong.
// Ideally, we'll never encounter this but we're placing a safeguard here.
if resp == nil {
return nil, errors.New("Response from aurora is nil")
}
// Check Response Code from thrift and make a decision to continue retrying or not.
switch responseCode := resp.GetResponseCode(); responseCode {
// If the thrift call succeeded, stop retrying
case aurora.ResponseCode_OK:
return resp, nil
// If the response code is transient, continue retrying
case aurora.ResponseCode_ERROR_TRANSIENT:
r.logger.Println("Aurora replied with Transient error code, retrying")
continue
// Failure scenarios, these indicate a bad payload or a bad config. Stop retrying.
case aurora.ResponseCode_INVALID_REQUEST,
aurora.ResponseCode_ERROR,
aurora.ResponseCode_AUTH_FAILED,
aurora.ResponseCode_JOB_UPDATING_ERROR:
r.logger.Printf("Terminal Response Code %v from Aurora, won't retry\n", resp.GetResponseCode().String())
return resp, errors.New(response.CombineMessage(resp))
// The only case that should fall down to here is a WARNING response code.
// It is currently not used as a response in the scheduler so it is unknown how to handle it.
default:
r.logger.DebugPrintf("unhandled response code %v received from Aurora\n", responseCode)
return nil, errors.Errorf("unhandled response code from Aurora %v\n", responseCode.String())
}
}
}
r.logger.DebugPrintf("it took %v retries to complete this operation\n", curStep)
if curStep > 1 {
r.config.logger.Printf("retried this thrift call %d time(s)", curStep)
}
// Provide more information to the user wherever possible.
if clientErr != nil {
return nil, newRetryError(errors.Wrap(clientErr, "ran out of retries, including latest error"), curStep)
} else {
return nil, newRetryError(errors.New("ran out of retries"), curStep)
}
} | go | func (r *realisClient) thriftCallWithRetries(thriftCall auroraThriftCall) (*aurora.Response, error) {
var resp *aurora.Response
var clientErr error
var curStep int
backoff := r.config.backoff
duration := backoff.Duration
for curStep = 0; curStep < backoff.Steps; curStep++ {
// If this isn't our first try, backoff before the next try.
if curStep != 0 {
adjusted := duration
if backoff.Jitter > 0.0 {
adjusted = Jitter(duration, backoff.Jitter)
}
r.logger.Printf("A retriable error occurred during thrift call, backing off for %v before retry %v\n", adjusted, curStep)
time.Sleep(adjusted)
duration = time.Duration(float64(duration) * backoff.Factor)
}
// Only allow one go-routine make use or modify the thrift client connection.
// Placing this in an anonymous function in order to create a new, short-lived stack allowing unlock
// to be run in case of a panic inside of thriftCall.
func() {
r.lock.Lock()
defer r.lock.Unlock()
resp, clientErr = thriftCall()
r.logger.TracePrintf("Aurora Thrift Call ended resp: %v clientErr: %v\n", resp, clientErr)
}()
// Check if our thrift call is returning an error. This is a retriable event as we don't know
// if it was caused by network issues.
if clientErr != nil {
// Print out the error to the user
r.logger.Printf("Client Error: %v\n", clientErr)
// Determine if error is a temporary URL error by going up the stack
e, ok := clientErr.(thrift.TTransportException)
if ok {
r.logger.DebugPrint("Encountered a transport exception")
e, ok := e.Err().(*url.Error)
if ok {
// EOF error occurs when the server closes the read buffer of the client. This is common
// when the server is overloaded and should be retried. All other errors that are permanent
// will not be retried.
if e.Err != io.EOF && !e.Temporary() {
return nil, errors.Wrap(clientErr, "Permanent connection error")
}
}
}
// In the future, reestablish connection should be able to check if it is actually possible
// to make a thrift call to Aurora. For now, a reconnect should always lead to a retry.
r.ReestablishConn()
} else {
// If there was no client error, but the response is nil, something went wrong.
// Ideally, we'll never encounter this but we're placing a safeguard here.
if resp == nil {
return nil, errors.New("Response from aurora is nil")
}
// Check Response Code from thrift and make a decision to continue retrying or not.
switch responseCode := resp.GetResponseCode(); responseCode {
// If the thrift call succeeded, stop retrying
case aurora.ResponseCode_OK:
return resp, nil
// If the response code is transient, continue retrying
case aurora.ResponseCode_ERROR_TRANSIENT:
r.logger.Println("Aurora replied with Transient error code, retrying")
continue
// Failure scenarios, these indicate a bad payload or a bad config. Stop retrying.
case aurora.ResponseCode_INVALID_REQUEST,
aurora.ResponseCode_ERROR,
aurora.ResponseCode_AUTH_FAILED,
aurora.ResponseCode_JOB_UPDATING_ERROR:
r.logger.Printf("Terminal Response Code %v from Aurora, won't retry\n", resp.GetResponseCode().String())
return resp, errors.New(response.CombineMessage(resp))
// The only case that should fall down to here is a WARNING response code.
// It is currently not used as a response in the scheduler so it is unknown how to handle it.
default:
r.logger.DebugPrintf("unhandled response code %v received from Aurora\n", responseCode)
return nil, errors.Errorf("unhandled response code from Aurora %v\n", responseCode.String())
}
}
}
r.logger.DebugPrintf("it took %v retries to complete this operation\n", curStep)
if curStep > 1 {
r.config.logger.Printf("retried this thrift call %d time(s)", curStep)
}
// Provide more information to the user wherever possible.
if clientErr != nil {
return nil, newRetryError(errors.Wrap(clientErr, "ran out of retries, including latest error"), curStep)
} else {
return nil, newRetryError(errors.New("ran out of retries"), curStep)
}
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"thriftCallWithRetries",
"(",
"thriftCall",
"auroraThriftCall",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"var",
"resp",
"*",
"aurora",
".",
"Response",
"\n",
"var",
"clientErr",
"error",
... | // Duplicates the functionality of ExponentialBackoff but is specifically targeted towards ThriftCalls. | [
"Duplicates",
"the",
"functionality",
"of",
"ExponentialBackoff",
"but",
"is",
"specifically",
"targeted",
"towards",
"ThriftCalls",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/retry.go#L119-L231 |
16,050 | paypal/gorealis | zk.go | LeaderFromZK | func LeaderFromZK(cluster Cluster) (string, error) {
return LeaderFromZKOpts(ZKEndpoints(strings.Split(cluster.ZK, ",")...), ZKPath(cluster.SchedZKPath))
} | go | func LeaderFromZK(cluster Cluster) (string, error) {
return LeaderFromZKOpts(ZKEndpoints(strings.Split(cluster.ZK, ",")...), ZKPath(cluster.SchedZKPath))
} | [
"func",
"LeaderFromZK",
"(",
"cluster",
"Cluster",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"LeaderFromZKOpts",
"(",
"ZKEndpoints",
"(",
"strings",
".",
"Split",
"(",
"cluster",
".",
"ZK",
",",
"\"",
"\"",
")",
"...",
")",
",",
"ZKPath",
"... | // Retrieves current Aurora leader from ZK. | [
"Retrieves",
"current",
"Aurora",
"leader",
"from",
"ZK",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/zk.go#L79-L81 |
16,051 | paypal/gorealis | monitors.go | JobUpdate | func (m *Monitor) JobUpdate(updateKey aurora.JobUpdateKey, interval int, timeout int) (bool, error) {
status, err := m.JobUpdateStatus(updateKey,
map[aurora.JobUpdateStatus]bool{
aurora.JobUpdateStatus_ROLLED_FORWARD: true,
aurora.JobUpdateStatus_ROLLED_BACK: true,
aurora.JobUpdateStatus_ABORTED: true,
aurora.JobUpdateStatus_ERROR: true,
aurora.JobUpdateStatus_FAILED: true,
},
time.Duration(interval)*time.Second,
time.Duration(timeout)*time.Second)
if err != nil {
return false, err
}
m.Client.RealisConfig().logger.Printf("job update status: %v\n", status)
// Rolled forward is the only state in which an update has been successfully updated
// if we encounter an inactive state and it is not at rolled forward, update failed
switch status {
case aurora.JobUpdateStatus_ROLLED_FORWARD:
return true, nil
case aurora.JobUpdateStatus_ROLLED_BACK, aurora.JobUpdateStatus_ABORTED, aurora.JobUpdateStatus_ERROR, aurora.JobUpdateStatus_FAILED:
return false, errors.Errorf("bad terminal state for update: %v", status)
default:
return false, errors.Errorf("unexpected update state: %v", status)
}
} | go | func (m *Monitor) JobUpdate(updateKey aurora.JobUpdateKey, interval int, timeout int) (bool, error) {
status, err := m.JobUpdateStatus(updateKey,
map[aurora.JobUpdateStatus]bool{
aurora.JobUpdateStatus_ROLLED_FORWARD: true,
aurora.JobUpdateStatus_ROLLED_BACK: true,
aurora.JobUpdateStatus_ABORTED: true,
aurora.JobUpdateStatus_ERROR: true,
aurora.JobUpdateStatus_FAILED: true,
},
time.Duration(interval)*time.Second,
time.Duration(timeout)*time.Second)
if err != nil {
return false, err
}
m.Client.RealisConfig().logger.Printf("job update status: %v\n", status)
// Rolled forward is the only state in which an update has been successfully updated
// if we encounter an inactive state and it is not at rolled forward, update failed
switch status {
case aurora.JobUpdateStatus_ROLLED_FORWARD:
return true, nil
case aurora.JobUpdateStatus_ROLLED_BACK, aurora.JobUpdateStatus_ABORTED, aurora.JobUpdateStatus_ERROR, aurora.JobUpdateStatus_FAILED:
return false, errors.Errorf("bad terminal state for update: %v", status)
default:
return false, errors.Errorf("unexpected update state: %v", status)
}
} | [
"func",
"(",
"m",
"*",
"Monitor",
")",
"JobUpdate",
"(",
"updateKey",
"aurora",
".",
"JobUpdateKey",
",",
"interval",
"int",
",",
"timeout",
"int",
")",
"(",
"bool",
",",
"error",
")",
"{",
"status",
",",
"err",
":=",
"m",
".",
"JobUpdateStatus",
"(",
... | // Polls the scheduler every certain amount of time to see if the update has succeeded | [
"Polls",
"the",
"scheduler",
"every",
"certain",
"amount",
"of",
"time",
"to",
"see",
"if",
"the",
"update",
"has",
"succeeded"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/monitors.go#L31-L60 |
16,052 | paypal/gorealis | monitors.go | Instances | func (m *Monitor) Instances(key *aurora.JobKey, instances int32, interval, timeout int) (bool, error) {
return m.ScheduleStatus(key, instances, LiveStates, interval, timeout)
} | go | func (m *Monitor) Instances(key *aurora.JobKey, instances int32, interval, timeout int) (bool, error) {
return m.ScheduleStatus(key, instances, LiveStates, interval, timeout)
} | [
"func",
"(",
"m",
"*",
"Monitor",
")",
"Instances",
"(",
"key",
"*",
"aurora",
".",
"JobKey",
",",
"instances",
"int32",
",",
"interval",
",",
"timeout",
"int",
")",
"(",
"bool",
",",
"error",
")",
"{",
"return",
"m",
".",
"ScheduleStatus",
"(",
"key... | // Monitor a Job until all instances enter one of the LIVE_STATES | [
"Monitor",
"a",
"Job",
"until",
"all",
"instances",
"enter",
"one",
"of",
"the",
"LIVE_STATES"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/monitors.go#L105-L107 |
16,053 | paypal/gorealis | updatejob.go | NewDefaultUpdateJob | func NewDefaultUpdateJob(config *aurora.TaskConfig) *UpdateJob {
req := aurora.NewJobUpdateRequest()
req.TaskConfig = config
req.Settings = NewUpdateSettings()
job := NewJob().(*AuroraJob)
job.jobConfig.TaskConfig = config
// Rebuild resource map from TaskConfig
for _, ptr := range config.Resources {
if ptr.NumCpus != nil {
job.resources[CPU].NumCpus = ptr.NumCpus
continue // Guard against Union violations that Go won't enforce
}
if ptr.RamMb != nil {
job.resources[RAM].RamMb = ptr.RamMb
continue
}
if ptr.DiskMb != nil {
job.resources[DISK].DiskMb = ptr.DiskMb
continue
}
if ptr.NumGpus != nil {
job.resources[GPU] = &aurora.Resource{NumGpus: ptr.NumGpus}
continue
}
}
// Mirrors defaults set by Pystachio
req.Settings.UpdateGroupSize = 1
req.Settings.WaitForBatchCompletion = false
req.Settings.MinWaitInInstanceRunningMs = 45000
req.Settings.MaxPerInstanceFailures = 0
req.Settings.MaxFailedInstances = 0
req.Settings.RollbackOnFailure = true
//TODO(rdelvalle): Deep copy job struct to avoid unexpected behavior
return &UpdateJob{Job: job, req: req}
} | go | func NewDefaultUpdateJob(config *aurora.TaskConfig) *UpdateJob {
req := aurora.NewJobUpdateRequest()
req.TaskConfig = config
req.Settings = NewUpdateSettings()
job := NewJob().(*AuroraJob)
job.jobConfig.TaskConfig = config
// Rebuild resource map from TaskConfig
for _, ptr := range config.Resources {
if ptr.NumCpus != nil {
job.resources[CPU].NumCpus = ptr.NumCpus
continue // Guard against Union violations that Go won't enforce
}
if ptr.RamMb != nil {
job.resources[RAM].RamMb = ptr.RamMb
continue
}
if ptr.DiskMb != nil {
job.resources[DISK].DiskMb = ptr.DiskMb
continue
}
if ptr.NumGpus != nil {
job.resources[GPU] = &aurora.Resource{NumGpus: ptr.NumGpus}
continue
}
}
// Mirrors defaults set by Pystachio
req.Settings.UpdateGroupSize = 1
req.Settings.WaitForBatchCompletion = false
req.Settings.MinWaitInInstanceRunningMs = 45000
req.Settings.MaxPerInstanceFailures = 0
req.Settings.MaxFailedInstances = 0
req.Settings.RollbackOnFailure = true
//TODO(rdelvalle): Deep copy job struct to avoid unexpected behavior
return &UpdateJob{Job: job, req: req}
} | [
"func",
"NewDefaultUpdateJob",
"(",
"config",
"*",
"aurora",
".",
"TaskConfig",
")",
"*",
"UpdateJob",
"{",
"req",
":=",
"aurora",
".",
"NewJobUpdateRequest",
"(",
")",
"\n",
"req",
".",
"TaskConfig",
"=",
"config",
"\n",
"req",
".",
"Settings",
"=",
"NewU... | // Create a default UpdateJob object. | [
"Create",
"a",
"default",
"UpdateJob",
"object",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L28-L70 |
16,054 | paypal/gorealis | updatejob.go | InstanceCount | func (u *UpdateJob) InstanceCount(inst int32) *UpdateJob {
u.req.InstanceCount = inst
return u
} | go | func (u *UpdateJob) InstanceCount(inst int32) *UpdateJob {
u.req.InstanceCount = inst
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"InstanceCount",
"(",
"inst",
"int32",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"InstanceCount",
"=",
"inst",
"\n",
"return",
"u",
"\n",
"}"
] | // Set instance count the job will have after the update. | [
"Set",
"instance",
"count",
"the",
"job",
"will",
"have",
"after",
"the",
"update",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L110-L113 |
16,055 | paypal/gorealis | updatejob.go | BatchSize | func (u *UpdateJob) BatchSize(size int32) *UpdateJob {
u.req.Settings.UpdateGroupSize = size
return u
} | go | func (u *UpdateJob) BatchSize(size int32) *UpdateJob {
u.req.Settings.UpdateGroupSize = size
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"BatchSize",
"(",
"size",
"int32",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"Settings",
".",
"UpdateGroupSize",
"=",
"size",
"\n",
"return",
"u",
"\n",
"}"
] | // Max number of instances being updated at any given moment. | [
"Max",
"number",
"of",
"instances",
"being",
"updated",
"at",
"any",
"given",
"moment",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L116-L119 |
16,056 | paypal/gorealis | updatejob.go | WatchTime | func (u *UpdateJob) WatchTime(ms int32) *UpdateJob {
u.req.Settings.MinWaitInInstanceRunningMs = ms
return u
} | go | func (u *UpdateJob) WatchTime(ms int32) *UpdateJob {
u.req.Settings.MinWaitInInstanceRunningMs = ms
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"WatchTime",
"(",
"ms",
"int32",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"Settings",
".",
"MinWaitInInstanceRunningMs",
"=",
"ms",
"\n",
"return",
"u",
"\n",
"}"
] | // Minimum number of seconds a shard must remain in RUNNING state before considered a success. | [
"Minimum",
"number",
"of",
"seconds",
"a",
"shard",
"must",
"remain",
"in",
"RUNNING",
"state",
"before",
"considered",
"a",
"success",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L122-L125 |
16,057 | paypal/gorealis | updatejob.go | WaitForBatchCompletion | func (u *UpdateJob) WaitForBatchCompletion(batchWait bool) *UpdateJob {
u.req.Settings.WaitForBatchCompletion = batchWait
return u
} | go | func (u *UpdateJob) WaitForBatchCompletion(batchWait bool) *UpdateJob {
u.req.Settings.WaitForBatchCompletion = batchWait
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"WaitForBatchCompletion",
"(",
"batchWait",
"bool",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"Settings",
".",
"WaitForBatchCompletion",
"=",
"batchWait",
"\n",
"return",
"u",
"\n",
"}"
] | // Wait for all instances in a group to be done before moving on. | [
"Wait",
"for",
"all",
"instances",
"in",
"a",
"group",
"to",
"be",
"done",
"before",
"moving",
"on",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L128-L131 |
16,058 | paypal/gorealis | updatejob.go | MaxPerInstanceFailures | func (u *UpdateJob) MaxPerInstanceFailures(inst int32) *UpdateJob {
u.req.Settings.MaxPerInstanceFailures = inst
return u
} | go | func (u *UpdateJob) MaxPerInstanceFailures(inst int32) *UpdateJob {
u.req.Settings.MaxPerInstanceFailures = inst
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"MaxPerInstanceFailures",
"(",
"inst",
"int32",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"Settings",
".",
"MaxPerInstanceFailures",
"=",
"inst",
"\n",
"return",
"u",
"\n",
"}"
] | // Max number of instance failures to tolerate before marking instance as FAILED. | [
"Max",
"number",
"of",
"instance",
"failures",
"to",
"tolerate",
"before",
"marking",
"instance",
"as",
"FAILED",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L134-L137 |
16,059 | paypal/gorealis | updatejob.go | MaxFailedInstances | func (u *UpdateJob) MaxFailedInstances(inst int32) *UpdateJob {
u.req.Settings.MaxFailedInstances = inst
return u
} | go | func (u *UpdateJob) MaxFailedInstances(inst int32) *UpdateJob {
u.req.Settings.MaxFailedInstances = inst
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"MaxFailedInstances",
"(",
"inst",
"int32",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"Settings",
".",
"MaxFailedInstances",
"=",
"inst",
"\n",
"return",
"u",
"\n",
"}"
] | // Max number of FAILED instances to tolerate before terminating the update. | [
"Max",
"number",
"of",
"FAILED",
"instances",
"to",
"tolerate",
"before",
"terminating",
"the",
"update",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L140-L143 |
16,060 | paypal/gorealis | updatejob.go | RollbackOnFail | func (u *UpdateJob) RollbackOnFail(rollback bool) *UpdateJob {
u.req.Settings.RollbackOnFailure = rollback
return u
} | go | func (u *UpdateJob) RollbackOnFail(rollback bool) *UpdateJob {
u.req.Settings.RollbackOnFailure = rollback
return u
} | [
"func",
"(",
"u",
"*",
"UpdateJob",
")",
"RollbackOnFail",
"(",
"rollback",
"bool",
")",
"*",
"UpdateJob",
"{",
"u",
".",
"req",
".",
"Settings",
".",
"RollbackOnFailure",
"=",
"rollback",
"\n",
"return",
"u",
"\n",
"}"
] | // When False, prevents auto rollback of a failed update. | [
"When",
"False",
"prevents",
"auto",
"rollback",
"of",
"a",
"failed",
"update",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/updatejob.go#L146-L149 |
16,061 | paypal/gorealis | examples/jsonClient.go | init | func init() {
flag.StringVar(&configJSONFile, "config", "./config.json", "The config file that contains username, password, and the cluster configuration information.")
flag.StringVar(&jobJSONFile, "job", "./job.json", "JSON file containing job definitions.")
flag.Parse()
job = new(JobJson)
config = new(Config)
if jobsFile, jobJSONReadErr := os.Open(jobJSONFile); jobJSONReadErr != nil {
flag.Usage()
fmt.Println("Error reading the job JSON file: ", jobJSONReadErr)
os.Exit(1)
} else {
if unmarshallErr := json.NewDecoder(jobsFile).Decode(job); unmarshallErr != nil {
flag.Usage()
fmt.Println("Error parsing job json file: ", unmarshallErr)
os.Exit(1)
}
// Need to validate the job JSON file.
if !job.Validate() {
fmt.Println("Invalid Job.")
os.Exit(1)
}
}
if configFile, configJSONErr := os.Open(configJSONFile); configJSONErr != nil {
flag.Usage()
fmt.Println("Error reading the config JSON file: ", configJSONErr)
os.Exit(1)
} else {
if unmarshallErr := json.NewDecoder(configFile).Decode(config); unmarshallErr != nil {
fmt.Println("Error parsing config JSON file: ", unmarshallErr)
os.Exit(1)
}
}
} | go | func init() {
flag.StringVar(&configJSONFile, "config", "./config.json", "The config file that contains username, password, and the cluster configuration information.")
flag.StringVar(&jobJSONFile, "job", "./job.json", "JSON file containing job definitions.")
flag.Parse()
job = new(JobJson)
config = new(Config)
if jobsFile, jobJSONReadErr := os.Open(jobJSONFile); jobJSONReadErr != nil {
flag.Usage()
fmt.Println("Error reading the job JSON file: ", jobJSONReadErr)
os.Exit(1)
} else {
if unmarshallErr := json.NewDecoder(jobsFile).Decode(job); unmarshallErr != nil {
flag.Usage()
fmt.Println("Error parsing job json file: ", unmarshallErr)
os.Exit(1)
}
// Need to validate the job JSON file.
if !job.Validate() {
fmt.Println("Invalid Job.")
os.Exit(1)
}
}
if configFile, configJSONErr := os.Open(configJSONFile); configJSONErr != nil {
flag.Usage()
fmt.Println("Error reading the config JSON file: ", configJSONErr)
os.Exit(1)
} else {
if unmarshallErr := json.NewDecoder(configFile).Decode(config); unmarshallErr != nil {
fmt.Println("Error parsing config JSON file: ", unmarshallErr)
os.Exit(1)
}
}
} | [
"func",
"init",
"(",
")",
"{",
"flag",
".",
"StringVar",
"(",
"&",
"configJSONFile",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"flag",
".",
"StringVar",
"(",
"&",
"jobJSONFile",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"... | // Reading command line arguments and validating.
// If Aurora scheduler URL not provided, then using zookeeper to locate the leader. | [
"Reading",
"command",
"line",
"arguments",
"and",
"validating",
".",
"If",
"Aurora",
"scheduler",
"URL",
"not",
"provided",
"then",
"using",
"zookeeper",
"to",
"locate",
"the",
"leader",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/examples/jsonClient.go#L89-L126 |
16,062 | paypal/gorealis | realis.go | BasicAuth | func BasicAuth(username, password string) ClientOption {
return func(config *RealisConfig) {
config.username = username
config.password = password
}
} | go | func BasicAuth(username, password string) ClientOption {
return func(config *RealisConfig) {
config.username = username
config.password = password
}
} | [
"func",
"BasicAuth",
"(",
"username",
",",
"password",
"string",
")",
"ClientOption",
"{",
"return",
"func",
"(",
"config",
"*",
"RealisConfig",
")",
"{",
"config",
".",
"username",
"=",
"username",
"\n",
"config",
".",
"password",
"=",
"password",
"\n",
"... | //Config sets for options in RealisConfig. | [
"Config",
"sets",
"for",
"options",
"in",
"RealisConfig",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L131-L136 |
16,063 | paypal/gorealis | realis.go | SetLogger | func SetLogger(l Logger) ClientOption {
return func(config *RealisConfig) {
config.logger = &LevelLogger{Logger: l}
}
} | go | func SetLogger(l Logger) ClientOption {
return func(config *RealisConfig) {
config.logger = &LevelLogger{Logger: l}
}
} | [
"func",
"SetLogger",
"(",
"l",
"Logger",
")",
"ClientOption",
"{",
"return",
"func",
"(",
"config",
"*",
"RealisConfig",
")",
"{",
"config",
".",
"logger",
"=",
"&",
"LevelLogger",
"{",
"Logger",
":",
"l",
"}",
"\n",
"}",
"\n",
"}"
] | // Using the word set to avoid name collision with Interface. | [
"Using",
"the",
"word",
"set",
"to",
"avoid",
"name",
"collision",
"with",
"Interface",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L220-L224 |
16,064 | paypal/gorealis | realis.go | defaultTTransport | func defaultTTransport(urlstr string, timeoutms int, config *RealisConfig) (thrift.TTransport, error) {
jar, err := cookiejar.New(nil)
if err != nil {
return &thrift.THttpClient{}, errors.Wrap(err, "Error creating Cookie Jar")
}
var transport http.Transport
if config != nil {
tlsConfig := &tls.Config{}
if config.InsecureSkipVerify {
tlsConfig.InsecureSkipVerify = true
}
if config.certspath != "" {
rootCAs, err := GetCerts(config.certspath)
if err != nil {
config.logger.Println("error occured couldn't fetch certs")
return nil, err
}
tlsConfig.RootCAs = rootCAs
}
if config.clientkey != "" && config.clientcert == "" {
return nil, fmt.Errorf("have to provide both client key,cert. Only client key provided ")
}
if config.clientkey == "" && config.clientcert != "" {
return nil, fmt.Errorf("have to provide both client key,cert. Only client cert provided ")
}
if config.clientkey != "" && config.clientcert != "" {
cert, err := tls.LoadX509KeyPair(config.clientcert, config.clientkey)
if err != nil {
config.logger.Println("error occured loading client certs and keys")
return nil, err
}
tlsConfig.Certificates = []tls.Certificate{cert}
}
transport.TLSClientConfig = tlsConfig
}
trans, err := thrift.NewTHttpPostClientWithOptions(urlstr+"/api",
thrift.THttpClientOptions{Client: &http.Client{Timeout: time.Millisecond * time.Duration(timeoutms), Transport: &transport, Jar: jar}})
if err != nil {
return &thrift.THttpClient{}, errors.Wrap(err, "Error creating transport")
}
if err := trans.Open(); err != nil {
return &thrift.THttpClient{}, errors.Wrapf(err, "Error opening connection to %s", urlstr)
}
return trans, nil
} | go | func defaultTTransport(urlstr string, timeoutms int, config *RealisConfig) (thrift.TTransport, error) {
jar, err := cookiejar.New(nil)
if err != nil {
return &thrift.THttpClient{}, errors.Wrap(err, "Error creating Cookie Jar")
}
var transport http.Transport
if config != nil {
tlsConfig := &tls.Config{}
if config.InsecureSkipVerify {
tlsConfig.InsecureSkipVerify = true
}
if config.certspath != "" {
rootCAs, err := GetCerts(config.certspath)
if err != nil {
config.logger.Println("error occured couldn't fetch certs")
return nil, err
}
tlsConfig.RootCAs = rootCAs
}
if config.clientkey != "" && config.clientcert == "" {
return nil, fmt.Errorf("have to provide both client key,cert. Only client key provided ")
}
if config.clientkey == "" && config.clientcert != "" {
return nil, fmt.Errorf("have to provide both client key,cert. Only client cert provided ")
}
if config.clientkey != "" && config.clientcert != "" {
cert, err := tls.LoadX509KeyPair(config.clientcert, config.clientkey)
if err != nil {
config.logger.Println("error occured loading client certs and keys")
return nil, err
}
tlsConfig.Certificates = []tls.Certificate{cert}
}
transport.TLSClientConfig = tlsConfig
}
trans, err := thrift.NewTHttpPostClientWithOptions(urlstr+"/api",
thrift.THttpClientOptions{Client: &http.Client{Timeout: time.Millisecond * time.Duration(timeoutms), Transport: &transport, Jar: jar}})
if err != nil {
return &thrift.THttpClient{}, errors.Wrap(err, "Error creating transport")
}
if err := trans.Open(); err != nil {
return &thrift.THttpClient{}, errors.Wrapf(err, "Error opening connection to %s", urlstr)
}
return trans, nil
} | [
"func",
"defaultTTransport",
"(",
"urlstr",
"string",
",",
"timeoutms",
"int",
",",
"config",
"*",
"RealisConfig",
")",
"(",
"thrift",
".",
"TTransport",
",",
"error",
")",
"{",
"jar",
",",
"err",
":=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n",
"... | // Creates a default Thrift Transport object for communications in gorealis using an HTTP Post Client | [
"Creates",
"a",
"default",
"Thrift",
"Transport",
"object",
"for",
"communications",
"in",
"gorealis",
"using",
"an",
"HTTP",
"Post",
"Client"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L404-L452 |
16,065 | paypal/gorealis | realis.go | newDefaultConfig | func newDefaultConfig(url string, timeoutms int, config *RealisConfig) (*RealisConfig, error) {
return newTJSONConfig(url, timeoutms, config)
} | go | func newDefaultConfig(url string, timeoutms int, config *RealisConfig) (*RealisConfig, error) {
return newTJSONConfig(url, timeoutms, config)
} | [
"func",
"newDefaultConfig",
"(",
"url",
"string",
",",
"timeoutms",
"int",
",",
"config",
"*",
"RealisConfig",
")",
"(",
"*",
"RealisConfig",
",",
"error",
")",
"{",
"return",
"newTJSONConfig",
"(",
"url",
",",
"timeoutms",
",",
"config",
")",
"\n",
"}"
] | // Create a default configuration of the transport layer, requires a URL to test connection with.
// Uses HTTP Post as transport layer and Thrift JSON as the wire protocol by default. | [
"Create",
"a",
"default",
"configuration",
"of",
"the",
"transport",
"layer",
"requires",
"a",
"URL",
"to",
"test",
"connection",
"with",
".",
"Uses",
"HTTP",
"Post",
"as",
"transport",
"layer",
"and",
"Thrift",
"JSON",
"as",
"the",
"wire",
"protocol",
"by",... | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L456-L458 |
16,066 | paypal/gorealis | realis.go | newTJSONConfig | func newTJSONConfig(url string, timeoutms int, config *RealisConfig) (*RealisConfig, error) {
trans, err := defaultTTransport(url, timeoutms, config)
if err != nil {
return &RealisConfig{}, errors.Wrap(err, "Error creating realis config")
}
httpTrans := (trans).(*thrift.THttpClient)
httpTrans.SetHeader("Content-Type", "application/x-thrift")
httpTrans.SetHeader("User-Agent", "gorealis v"+VERSION)
return &RealisConfig{transport: trans, protoFactory: thrift.NewTJSONProtocolFactory()}, nil
} | go | func newTJSONConfig(url string, timeoutms int, config *RealisConfig) (*RealisConfig, error) {
trans, err := defaultTTransport(url, timeoutms, config)
if err != nil {
return &RealisConfig{}, errors.Wrap(err, "Error creating realis config")
}
httpTrans := (trans).(*thrift.THttpClient)
httpTrans.SetHeader("Content-Type", "application/x-thrift")
httpTrans.SetHeader("User-Agent", "gorealis v"+VERSION)
return &RealisConfig{transport: trans, protoFactory: thrift.NewTJSONProtocolFactory()}, nil
} | [
"func",
"newTJSONConfig",
"(",
"url",
"string",
",",
"timeoutms",
"int",
",",
"config",
"*",
"RealisConfig",
")",
"(",
"*",
"RealisConfig",
",",
"error",
")",
"{",
"trans",
",",
"err",
":=",
"defaultTTransport",
"(",
"url",
",",
"timeoutms",
",",
"config",... | // Creates a realis config object using HTTP Post and Thrift JSON protocol to communicate with Aurora. | [
"Creates",
"a",
"realis",
"config",
"object",
"using",
"HTTP",
"Post",
"and",
"Thrift",
"JSON",
"protocol",
"to",
"communicate",
"with",
"Aurora",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L461-L472 |
16,067 | paypal/gorealis | realis.go | Close | func (r *realisClient) Close() {
r.lock.Lock()
defer r.lock.Unlock()
r.transport.Close()
} | go | func (r *realisClient) Close() {
r.lock.Lock()
defer r.lock.Unlock()
r.transport.Close()
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"Close",
"(",
")",
"{",
"r",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"r",
".",
"transport",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Releases resources associated with the realis client. | [
"Releases",
"resources",
"associated",
"with",
"the",
"realis",
"client",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L526-L532 |
16,068 | paypal/gorealis | realis.go | GetInstanceIds | func (r *realisClient) GetInstanceIds(key *aurora.JobKey, states []aurora.ScheduleStatus) ([]int32, error) {
taskQ := &aurora.TaskQuery{
Role: &key.Role,
Environment: &key.Environment,
JobName: &key.Name,
Statuses: states,
}
r.logger.DebugPrintf("GetTasksWithoutConfigs Thrift Payload: %+v\n", taskQ)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetTasksWithoutConfigs(nil, taskQ)
})
// If we encountered an error we couldn't recover from by retrying, return an error to the user
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for active IDs")
}
// Construct instance id map to stay in line with thrift's representation of sets
tasks := response.ScheduleStatusResult(resp).GetTasks()
jobInstanceIds := make([]int32, 0, len(tasks))
for _, task := range tasks {
jobInstanceIds = append(jobInstanceIds, task.GetAssignedTask().GetInstanceId())
}
return jobInstanceIds, nil
} | go | func (r *realisClient) GetInstanceIds(key *aurora.JobKey, states []aurora.ScheduleStatus) ([]int32, error) {
taskQ := &aurora.TaskQuery{
Role: &key.Role,
Environment: &key.Environment,
JobName: &key.Name,
Statuses: states,
}
r.logger.DebugPrintf("GetTasksWithoutConfigs Thrift Payload: %+v\n", taskQ)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetTasksWithoutConfigs(nil, taskQ)
})
// If we encountered an error we couldn't recover from by retrying, return an error to the user
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for active IDs")
}
// Construct instance id map to stay in line with thrift's representation of sets
tasks := response.ScheduleStatusResult(resp).GetTasks()
jobInstanceIds := make([]int32, 0, len(tasks))
for _, task := range tasks {
jobInstanceIds = append(jobInstanceIds, task.GetAssignedTask().GetInstanceId())
}
return jobInstanceIds, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"GetInstanceIds",
"(",
"key",
"*",
"aurora",
".",
"JobKey",
",",
"states",
"[",
"]",
"aurora",
".",
"ScheduleStatus",
")",
"(",
"[",
"]",
"int32",
",",
"error",
")",
"{",
"taskQ",
":=",
"&",
"aurora",
".",
... | // Uses predefined set of states to retrieve a set of active jobs in Apache Aurora. | [
"Uses",
"predefined",
"set",
"of",
"states",
"to",
"retrieve",
"a",
"set",
"of",
"active",
"jobs",
"in",
"Apache",
"Aurora",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L535-L562 |
16,069 | paypal/gorealis | realis.go | CreateJob | func (r *realisClient) CreateJob(auroraJob Job) (*aurora.Response, error) {
r.logger.DebugPrintf("CreateJob Thrift Payload: %+v\n", auroraJob.JobConfig())
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.CreateJob(nil, auroraJob.JobConfig())
})
if retryErr != nil {
return resp, errors.Wrap(retryErr, "Error sending Create command to Aurora Scheduler")
}
return resp, nil
} | go | func (r *realisClient) CreateJob(auroraJob Job) (*aurora.Response, error) {
r.logger.DebugPrintf("CreateJob Thrift Payload: %+v\n", auroraJob.JobConfig())
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.CreateJob(nil, auroraJob.JobConfig())
})
if retryErr != nil {
return resp, errors.Wrap(retryErr, "Error sending Create command to Aurora Scheduler")
}
return resp, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"CreateJob",
"(",
"auroraJob",
"Job",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
"\"",
"\\n",
"\"",
",",
"auroraJob",
".",
"JobConfig",
"(... | // Sends a create job message to the scheduler with a specific job configuration.
// Although this API is able to create service jobs, it is better to use CreateService instead
// as that API uses the update thrift call which has a few extra features available.
// Use this API to create ad-hoc jobs. | [
"Sends",
"a",
"create",
"job",
"message",
"to",
"the",
"scheduler",
"with",
"a",
"specific",
"job",
"configuration",
".",
"Although",
"this",
"API",
"is",
"able",
"to",
"create",
"service",
"jobs",
"it",
"is",
"better",
"to",
"use",
"CreateService",
"instead... | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L636-L648 |
16,070 | paypal/gorealis | realis.go | CreateService | func (r *realisClient) CreateService(auroraJob Job, settings *aurora.JobUpdateSettings) (*aurora.Response, *aurora.StartJobUpdateResult_, error) {
// Create a new job update object and ship it to the StartJobUpdate api
update := NewUpdateJob(auroraJob.TaskConfig(), settings)
update.InstanceCount(auroraJob.GetInstanceCount())
resp, err := r.StartJobUpdate(update, "")
if err != nil {
return resp, nil, errors.Wrap(err, "unable to create service")
}
if resp.GetResult_() != nil {
return resp, resp.GetResult_().GetStartJobUpdateResult_(), nil
}
return nil, nil, errors.New("results object is nil")
} | go | func (r *realisClient) CreateService(auroraJob Job, settings *aurora.JobUpdateSettings) (*aurora.Response, *aurora.StartJobUpdateResult_, error) {
// Create a new job update object and ship it to the StartJobUpdate api
update := NewUpdateJob(auroraJob.TaskConfig(), settings)
update.InstanceCount(auroraJob.GetInstanceCount())
resp, err := r.StartJobUpdate(update, "")
if err != nil {
return resp, nil, errors.Wrap(err, "unable to create service")
}
if resp.GetResult_() != nil {
return resp, resp.GetResult_().GetStartJobUpdateResult_(), nil
}
return nil, nil, errors.New("results object is nil")
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"CreateService",
"(",
"auroraJob",
"Job",
",",
"settings",
"*",
"aurora",
".",
"JobUpdateSettings",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"*",
"aurora",
".",
"StartJobUpdateResult_",
",",
"error",
")",
"... | // This API uses an update thrift call to create the services giving a few more robust features. | [
"This",
"API",
"uses",
"an",
"update",
"thrift",
"call",
"to",
"create",
"the",
"services",
"giving",
"a",
"few",
"more",
"robust",
"features",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L651-L666 |
16,071 | paypal/gorealis | realis.go | RestartInstances | func (r *realisClient) RestartInstances(key *aurora.JobKey, instances ...int32) (*aurora.Response, error) {
r.logger.DebugPrintf("RestartShards Thrift Payload: %+v %v\n", key, instances)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.RestartShards(nil, key, instances)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending Restart command to Aurora Scheduler")
}
return resp, nil
} | go | func (r *realisClient) RestartInstances(key *aurora.JobKey, instances ...int32) (*aurora.Response, error) {
r.logger.DebugPrintf("RestartShards Thrift Payload: %+v %v\n", key, instances)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.RestartShards(nil, key, instances)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending Restart command to Aurora Scheduler")
}
return resp, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"RestartInstances",
"(",
"key",
"*",
"aurora",
".",
"JobKey",
",",
"instances",
"...",
"int32",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
... | // Restarts specific instances specified | [
"Restarts",
"specific",
"instances",
"specified"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L713-L724 |
16,072 | paypal/gorealis | realis.go | RestartJob | func (r *realisClient) RestartJob(key *aurora.JobKey) (*aurora.Response, error) {
instanceIds, err1 := r.GetInstanceIds(key, aurora.ACTIVE_STATES)
if err1 != nil {
return nil, errors.Wrap(err1, "Could not retrieve relevant task instance IDs")
}
r.logger.DebugPrintf("RestartShards Thrift Payload: %+v %v\n", key, instanceIds)
if len(instanceIds) > 0 {
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.RestartShards(nil, key, instanceIds)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending Restart command to Aurora Scheduler")
}
return resp, nil
} else {
return nil, errors.New("No tasks in the Active state")
}
} | go | func (r *realisClient) RestartJob(key *aurora.JobKey) (*aurora.Response, error) {
instanceIds, err1 := r.GetInstanceIds(key, aurora.ACTIVE_STATES)
if err1 != nil {
return nil, errors.Wrap(err1, "Could not retrieve relevant task instance IDs")
}
r.logger.DebugPrintf("RestartShards Thrift Payload: %+v %v\n", key, instanceIds)
if len(instanceIds) > 0 {
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.RestartShards(nil, key, instanceIds)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending Restart command to Aurora Scheduler")
}
return resp, nil
} else {
return nil, errors.New("No tasks in the Active state")
}
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"RestartJob",
"(",
"key",
"*",
"aurora",
".",
"JobKey",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"instanceIds",
",",
"err1",
":=",
"r",
".",
"GetInstanceIds",
"(",
"key",
",",
"auro... | // Restarts all active tasks under a job configuration. | [
"Restarts",
"all",
"active",
"tasks",
"under",
"a",
"job",
"configuration",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L727-L749 |
16,073 | paypal/gorealis | realis.go | StartJobUpdate | func (r *realisClient) StartJobUpdate(updateJob *UpdateJob, message string) (*aurora.Response, error) {
r.logger.DebugPrintf("StartJobUpdate Thrift Payload: %+v %v\n", updateJob, message)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.StartJobUpdate(nil, updateJob.req, message)
})
if retryErr != nil {
return resp, errors.Wrap(retryErr, "Error sending StartJobUpdate command to Aurora Scheduler")
}
return resp, nil
} | go | func (r *realisClient) StartJobUpdate(updateJob *UpdateJob, message string) (*aurora.Response, error) {
r.logger.DebugPrintf("StartJobUpdate Thrift Payload: %+v %v\n", updateJob, message)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.StartJobUpdate(nil, updateJob.req, message)
})
if retryErr != nil {
return resp, errors.Wrap(retryErr, "Error sending StartJobUpdate command to Aurora Scheduler")
}
return resp, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"StartJobUpdate",
"(",
"updateJob",
"*",
"UpdateJob",
",",
"message",
"string",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
"\"",
"\\n",
"\""... | // Update all tasks under a job configuration. Currently gorealis doesn't support for canary deployments. | [
"Update",
"all",
"tasks",
"under",
"a",
"job",
"configuration",
".",
"Currently",
"gorealis",
"doesn",
"t",
"support",
"for",
"canary",
"deployments",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L752-L764 |
16,074 | paypal/gorealis | realis.go | AbortJobUpdate | func (r *realisClient) AbortJobUpdate(updateKey aurora.JobUpdateKey, message string) (*aurora.Response, error) {
r.logger.DebugPrintf("AbortJobUpdate Thrift Payload: %+v %v\n", updateKey, message)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.AbortJobUpdate(nil, &updateKey, message)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending AbortJobUpdate command to Aurora Scheduler")
}
// Make this call synchronous by blocking until it job has successfully transitioned to aborted
m := Monitor{Client: r}
_, err := m.JobUpdateStatus(updateKey, map[aurora.JobUpdateStatus]bool{aurora.JobUpdateStatus_ABORTED: true}, time.Second*5, time.Minute)
return resp, err
} | go | func (r *realisClient) AbortJobUpdate(updateKey aurora.JobUpdateKey, message string) (*aurora.Response, error) {
r.logger.DebugPrintf("AbortJobUpdate Thrift Payload: %+v %v\n", updateKey, message)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.AbortJobUpdate(nil, &updateKey, message)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending AbortJobUpdate command to Aurora Scheduler")
}
// Make this call synchronous by blocking until it job has successfully transitioned to aborted
m := Monitor{Client: r}
_, err := m.JobUpdateStatus(updateKey, map[aurora.JobUpdateStatus]bool{aurora.JobUpdateStatus_ABORTED: true}, time.Second*5, time.Minute)
return resp, err
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"AbortJobUpdate",
"(",
"updateKey",
"aurora",
".",
"JobUpdateKey",
",",
"message",
"string",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
"\"",
... | // Abort Job Update on Aurora. Requires the updateId which can be obtained on the Aurora web UI.
// This API is meant to be synchronous. It will attempt to wait until the update transitions to the aborted state.
// However, if the job update does not transition to the ABORT state an error will be returned. | [
"Abort",
"Job",
"Update",
"on",
"Aurora",
".",
"Requires",
"the",
"updateId",
"which",
"can",
"be",
"obtained",
"on",
"the",
"Aurora",
"web",
"UI",
".",
"This",
"API",
"is",
"meant",
"to",
"be",
"synchronous",
".",
"It",
"will",
"attempt",
"to",
"wait",
... | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L769-L786 |
16,075 | paypal/gorealis | realis.go | ResumeJobUpdate | func (r *realisClient) ResumeJobUpdate(updateKey *aurora.JobUpdateKey, message string) (*aurora.Response, error) {
r.logger.DebugPrintf("ResumeJobUpdate Thrift Payload: %+v %v\n", updateKey, message)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.ResumeJobUpdate(nil, updateKey, message)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending ResumeJobUpdate command to Aurora Scheduler")
}
return resp, nil
} | go | func (r *realisClient) ResumeJobUpdate(updateKey *aurora.JobUpdateKey, message string) (*aurora.Response, error) {
r.logger.DebugPrintf("ResumeJobUpdate Thrift Payload: %+v %v\n", updateKey, message)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.ResumeJobUpdate(nil, updateKey, message)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending ResumeJobUpdate command to Aurora Scheduler")
}
return resp, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"ResumeJobUpdate",
"(",
"updateKey",
"*",
"aurora",
".",
"JobUpdateKey",
",",
"message",
"string",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
... | //Resume Paused Job Update. UpdateID is returned from StartJobUpdate or the Aurora web UI. | [
"Resume",
"Paused",
"Job",
"Update",
".",
"UpdateID",
"is",
"returned",
"from",
"StartJobUpdate",
"or",
"the",
"Aurora",
"web",
"UI",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L805-L818 |
16,076 | paypal/gorealis | realis.go | AddInstances | func (r *realisClient) AddInstances(instKey aurora.InstanceKey, count int32) (*aurora.Response, error) {
r.logger.DebugPrintf("AddInstances Thrift Payload: %+v %v\n", instKey, count)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.AddInstances(nil, &instKey, count)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending AddInstances command to Aurora Scheduler")
}
return resp, nil
} | go | func (r *realisClient) AddInstances(instKey aurora.InstanceKey, count int32) (*aurora.Response, error) {
r.logger.DebugPrintf("AddInstances Thrift Payload: %+v %v\n", instKey, count)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.AddInstances(nil, &instKey, count)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error sending AddInstances command to Aurora Scheduler")
}
return resp, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"AddInstances",
"(",
"instKey",
"aurora",
".",
"InstanceKey",
",",
"count",
"int32",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
"\"",
"\\n",... | // Scale up the number of instances under a job configuration using the configuration for specific
// instance to scale up. | [
"Scale",
"up",
"the",
"number",
"of",
"instances",
"under",
"a",
"job",
"configuration",
"using",
"the",
"configuration",
"for",
"specific",
"instance",
"to",
"scale",
"up",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L838-L851 |
16,077 | paypal/gorealis | realis.go | RemoveInstances | func (r *realisClient) RemoveInstances(key *aurora.JobKey, count int32) (*aurora.Response, error) {
instanceIds, err := r.GetInstanceIds(key, aurora.ACTIVE_STATES)
if err != nil {
return nil, errors.Wrap(err, "RemoveInstances: Could not retrieve relevant instance IDs")
}
if len(instanceIds) < int(count) {
return nil, errors.Errorf("Insufficient active instances available for killing: "+
" Instances to be killed %d Active instances %d", count, len(instanceIds))
}
// Sort instanceIds in ** decreasing ** order
sort.Slice(instanceIds, func(i, j int) bool {
return instanceIds[i] > instanceIds[j]
})
// Kill the instances with the highest ID number first
return r.KillInstances(key, instanceIds[:count]...)
} | go | func (r *realisClient) RemoveInstances(key *aurora.JobKey, count int32) (*aurora.Response, error) {
instanceIds, err := r.GetInstanceIds(key, aurora.ACTIVE_STATES)
if err != nil {
return nil, errors.Wrap(err, "RemoveInstances: Could not retrieve relevant instance IDs")
}
if len(instanceIds) < int(count) {
return nil, errors.Errorf("Insufficient active instances available for killing: "+
" Instances to be killed %d Active instances %d", count, len(instanceIds))
}
// Sort instanceIds in ** decreasing ** order
sort.Slice(instanceIds, func(i, j int) bool {
return instanceIds[i] > instanceIds[j]
})
// Kill the instances with the highest ID number first
return r.KillInstances(key, instanceIds[:count]...)
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"RemoveInstances",
"(",
"key",
"*",
"aurora",
".",
"JobKey",
",",
"count",
"int32",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"instanceIds",
",",
"err",
":=",
"r",
".",
"GetInstanceIds... | // Scale down the number of instances under a job configuration using the configuration of a specific instance | [
"Scale",
"down",
"the",
"number",
"of",
"instances",
"under",
"a",
"job",
"configuration",
"using",
"the",
"configuration",
"of",
"a",
"specific",
"instance"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L854-L872 |
16,078 | paypal/gorealis | realis.go | GetTaskStatus | func (r *realisClient) GetTaskStatus(query *aurora.TaskQuery) ([]*aurora.ScheduledTask, error) {
r.logger.DebugPrintf("GetTasksStatus Thrift Payload: %+v\n", query)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetTasksStatus(nil, query)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for task status")
}
return response.ScheduleStatusResult(resp).GetTasks(), nil
} | go | func (r *realisClient) GetTaskStatus(query *aurora.TaskQuery) ([]*aurora.ScheduledTask, error) {
r.logger.DebugPrintf("GetTasksStatus Thrift Payload: %+v\n", query)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetTasksStatus(nil, query)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for task status")
}
return response.ScheduleStatusResult(resp).GetTasks(), nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"GetTaskStatus",
"(",
"query",
"*",
"aurora",
".",
"TaskQuery",
")",
"(",
"[",
"]",
"*",
"aurora",
".",
"ScheduledTask",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
"\"",
"\\n",
"\"... | // Get information about task including a fully hydrated task configuration object | [
"Get",
"information",
"about",
"task",
"including",
"a",
"fully",
"hydrated",
"task",
"configuration",
"object"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L875-L888 |
16,079 | paypal/gorealis | realis.go | GetPendingReason | func (r *realisClient) GetPendingReason(query *aurora.TaskQuery) ([]*aurora.PendingReason, error) {
r.logger.DebugPrintf("GetPendingReason Thrift Payload: %+v\n", query)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetPendingReason(nil, query)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for pending Reasons")
}
var pendingReasons []*aurora.PendingReason
if resp.GetResult_() != nil {
pendingReasons = resp.GetResult_().GetGetPendingReasonResult_().GetReasons()
}
return pendingReasons, nil
} | go | func (r *realisClient) GetPendingReason(query *aurora.TaskQuery) ([]*aurora.PendingReason, error) {
r.logger.DebugPrintf("GetPendingReason Thrift Payload: %+v\n", query)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetPendingReason(nil, query)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for pending Reasons")
}
var pendingReasons []*aurora.PendingReason
if resp.GetResult_() != nil {
pendingReasons = resp.GetResult_().GetGetPendingReasonResult_().GetReasons()
}
return pendingReasons, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"GetPendingReason",
"(",
"query",
"*",
"aurora",
".",
"TaskQuery",
")",
"(",
"[",
"]",
"*",
"aurora",
".",
"PendingReason",
",",
"error",
")",
"{",
"r",
".",
"logger",
".",
"DebugPrintf",
"(",
"\"",
"\\n",
... | // Get pending reason | [
"Get",
"pending",
"reason"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L891-L910 |
16,080 | paypal/gorealis | realis.go | FetchTaskConfig | func (r *realisClient) FetchTaskConfig(instKey aurora.InstanceKey) (*aurora.TaskConfig, error) {
taskQ := &aurora.TaskQuery{
Role: &instKey.JobKey.Role,
Environment: &instKey.JobKey.Environment,
JobName: &instKey.JobKey.Name,
InstanceIds: []int32{instKey.InstanceId},
Statuses: aurora.ACTIVE_STATES,
}
r.logger.DebugPrintf("GetTasksStatus Thrift Payload: %+v\n", taskQ)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetTasksStatus(nil, taskQ)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for task configuration")
}
tasks := response.ScheduleStatusResult(resp).GetTasks()
if len(tasks) == 0 {
return nil, errors.Errorf("Instance %d for jobkey %s/%s/%s doesn't exist",
instKey.InstanceId,
instKey.JobKey.Environment,
instKey.JobKey.Role,
instKey.JobKey.Name)
}
// Currently, instance 0 is always picked..
return tasks[0].AssignedTask.Task, nil
} | go | func (r *realisClient) FetchTaskConfig(instKey aurora.InstanceKey) (*aurora.TaskConfig, error) {
taskQ := &aurora.TaskQuery{
Role: &instKey.JobKey.Role,
Environment: &instKey.JobKey.Environment,
JobName: &instKey.JobKey.Name,
InstanceIds: []int32{instKey.InstanceId},
Statuses: aurora.ACTIVE_STATES,
}
r.logger.DebugPrintf("GetTasksStatus Thrift Payload: %+v\n", taskQ)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.client.GetTasksStatus(nil, taskQ)
})
if retryErr != nil {
return nil, errors.Wrap(retryErr, "Error querying Aurora Scheduler for task configuration")
}
tasks := response.ScheduleStatusResult(resp).GetTasks()
if len(tasks) == 0 {
return nil, errors.Errorf("Instance %d for jobkey %s/%s/%s doesn't exist",
instKey.InstanceId,
instKey.JobKey.Environment,
instKey.JobKey.Role,
instKey.JobKey.Name)
}
// Currently, instance 0 is always picked..
return tasks[0].AssignedTask.Task, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"FetchTaskConfig",
"(",
"instKey",
"aurora",
".",
"InstanceKey",
")",
"(",
"*",
"aurora",
".",
"TaskConfig",
",",
"error",
")",
"{",
"taskQ",
":=",
"&",
"aurora",
".",
"TaskQuery",
"{",
"Role",
":",
"&",
"ins... | // Get the task configuration from the aurora scheduler for a job | [
"Get",
"the",
"task",
"configuration",
"from",
"the",
"aurora",
"scheduler",
"for",
"a",
"job"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L930-L961 |
16,081 | paypal/gorealis | realis.go | SLADrainHosts | func (r *realisClient) SLADrainHosts(policy *aurora.SlaPolicy, timeout int64, hosts ...string) (*aurora.DrainHostsResult_, error) {
var result *aurora.DrainHostsResult_
if len(hosts) == 0 {
return nil, errors.New("no hosts provided to drain")
}
drainList := aurora.NewHosts()
drainList.HostNames = hosts
r.logger.DebugPrintf("SLADrainHosts Thrift Payload: %v\n", drainList)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.adminClient.SlaDrainHosts(nil, drainList, policy, timeout)
})
if retryErr != nil {
return result, errors.Wrap(retryErr, "Unable to recover connection")
}
if resp.GetResult_() != nil {
result = resp.GetResult_().GetDrainHostsResult_()
}
return result, nil
} | go | func (r *realisClient) SLADrainHosts(policy *aurora.SlaPolicy, timeout int64, hosts ...string) (*aurora.DrainHostsResult_, error) {
var result *aurora.DrainHostsResult_
if len(hosts) == 0 {
return nil, errors.New("no hosts provided to drain")
}
drainList := aurora.NewHosts()
drainList.HostNames = hosts
r.logger.DebugPrintf("SLADrainHosts Thrift Payload: %v\n", drainList)
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.adminClient.SlaDrainHosts(nil, drainList, policy, timeout)
})
if retryErr != nil {
return result, errors.Wrap(retryErr, "Unable to recover connection")
}
if resp.GetResult_() != nil {
result = resp.GetResult_().GetDrainHostsResult_()
}
return result, nil
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"SLADrainHosts",
"(",
"policy",
"*",
"aurora",
".",
"SlaPolicy",
",",
"timeout",
"int64",
",",
"hosts",
"...",
"string",
")",
"(",
"*",
"aurora",
".",
"DrainHostsResult_",
",",
"error",
")",
"{",
"var",
"result... | // Start SLA Aware Drain.
// defaultSlaPolicy is the fallback SlaPolicy to use if a task does not have an SlaPolicy.
// After timeoutSecs, tasks will be forcefully drained without checking SLA. | [
"Start",
"SLA",
"Aware",
"Drain",
".",
"defaultSlaPolicy",
"is",
"the",
"fallback",
"SlaPolicy",
"to",
"use",
"if",
"a",
"task",
"does",
"not",
"have",
"an",
"SlaPolicy",
".",
"After",
"timeoutSecs",
"tasks",
"will",
"be",
"forcefully",
"drained",
"without",
... | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L1030-L1055 |
16,082 | paypal/gorealis | realis.go | GetQuota | func (r *realisClient) GetQuota(role string) (*aurora.Response, error) {
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.adminClient.GetQuota(nil, role)
})
if retryErr != nil {
return resp, errors.Wrap(retryErr, "Unable to get role quota")
}
return resp, retryErr
} | go | func (r *realisClient) GetQuota(role string) (*aurora.Response, error) {
resp, retryErr := r.thriftCallWithRetries(func() (*aurora.Response, error) {
return r.adminClient.GetQuota(nil, role)
})
if retryErr != nil {
return resp, errors.Wrap(retryErr, "Unable to get role quota")
}
return resp, retryErr
} | [
"func",
"(",
"r",
"*",
"realisClient",
")",
"GetQuota",
"(",
"role",
"string",
")",
"(",
"*",
"aurora",
".",
"Response",
",",
"error",
")",
"{",
"resp",
",",
"retryErr",
":=",
"r",
".",
"thriftCallWithRetries",
"(",
"func",
"(",
")",
"(",
"*",
"auror... | // GetQuota returns the resource aggregate for the given role | [
"GetQuota",
"returns",
"the",
"resource",
"aggregate",
"for",
"the",
"given",
"role"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/realis.go#L1166-L1176 |
16,083 | paypal/gorealis | errors.go | ToRetryCount | func ToRetryCount(err error) *retryErr {
if retryErr, ok := err.(*retryErr); ok {
return retryErr
} else {
return nil
}
} | go | func ToRetryCount(err error) *retryErr {
if retryErr, ok := err.(*retryErr); ok {
return retryErr
} else {
return nil
}
} | [
"func",
"ToRetryCount",
"(",
"err",
"error",
")",
"*",
"retryErr",
"{",
"if",
"retryErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"retryErr",
")",
";",
"ok",
"{",
"return",
"retryErr",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Helper function for testing verification to avoid whitebox testing
// as well as keeping retryErr as a private.
// Should NOT be used under any other context. | [
"Helper",
"function",
"for",
"testing",
"verification",
"to",
"avoid",
"whitebox",
"testing",
"as",
"well",
"as",
"keeping",
"retryErr",
"as",
"a",
"private",
".",
"Should",
"NOT",
"be",
"used",
"under",
"any",
"other",
"context",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/errors.go#L67-L73 |
16,084 | paypal/gorealis | job.go | NewJob | func NewJob() Job {
jobConfig := aurora.NewJobConfiguration()
taskConfig := aurora.NewTaskConfig()
jobKey := aurora.NewJobKey()
// Job Config
jobConfig.Key = jobKey
jobConfig.TaskConfig = taskConfig
// Task Config
taskConfig.Job = jobKey
taskConfig.Container = aurora.NewContainer()
taskConfig.Container.Mesos = aurora.NewMesosContainer()
// Resources
numCpus := aurora.NewResource()
ramMb := aurora.NewResource()
diskMb := aurora.NewResource()
resources := map[ResourceType]*aurora.Resource{CPU: numCpus, RAM: ramMb, DISK: diskMb}
taskConfig.Resources = []*aurora.Resource{numCpus, ramMb, diskMb}
numCpus.NumCpus = new(float64)
ramMb.RamMb = new(int64)
diskMb.DiskMb = new(int64)
return &AuroraJob{
jobConfig: jobConfig,
resources: resources,
metadata: make(map[string]*aurora.Metadata),
portCount: 0,
}
} | go | func NewJob() Job {
jobConfig := aurora.NewJobConfiguration()
taskConfig := aurora.NewTaskConfig()
jobKey := aurora.NewJobKey()
// Job Config
jobConfig.Key = jobKey
jobConfig.TaskConfig = taskConfig
// Task Config
taskConfig.Job = jobKey
taskConfig.Container = aurora.NewContainer()
taskConfig.Container.Mesos = aurora.NewMesosContainer()
// Resources
numCpus := aurora.NewResource()
ramMb := aurora.NewResource()
diskMb := aurora.NewResource()
resources := map[ResourceType]*aurora.Resource{CPU: numCpus, RAM: ramMb, DISK: diskMb}
taskConfig.Resources = []*aurora.Resource{numCpus, ramMb, diskMb}
numCpus.NumCpus = new(float64)
ramMb.RamMb = new(int64)
diskMb.DiskMb = new(int64)
return &AuroraJob{
jobConfig: jobConfig,
resources: resources,
metadata: make(map[string]*aurora.Metadata),
portCount: 0,
}
} | [
"func",
"NewJob",
"(",
")",
"Job",
"{",
"jobConfig",
":=",
"aurora",
".",
"NewJobConfiguration",
"(",
")",
"\n",
"taskConfig",
":=",
"aurora",
".",
"NewTaskConfig",
"(",
")",
"\n",
"jobKey",
":=",
"aurora",
".",
"NewJobKey",
"(",
")",
"\n\n",
"// Job Confi... | // Create a Job object with everything initialized. | [
"Create",
"a",
"Job",
"object",
"with",
"everything",
"initialized",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L82-L114 |
16,085 | paypal/gorealis | job.go | Environment | func (j *AuroraJob) Environment(env string) Job {
j.jobConfig.Key.Environment = env
return j
} | go | func (j *AuroraJob) Environment(env string) Job {
j.jobConfig.Key.Environment = env
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"Environment",
"(",
"env",
"string",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"Key",
".",
"Environment",
"=",
"env",
"\n",
"return",
"j",
"\n",
"}"
] | // Set Job Key environment. | [
"Set",
"Job",
"Key",
"environment",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L117-L120 |
16,086 | paypal/gorealis | job.go | Role | func (j *AuroraJob) Role(role string) Job {
j.jobConfig.Key.Role = role
//Will be deprecated
identity := &aurora.Identity{User: role}
j.jobConfig.Owner = identity
j.jobConfig.TaskConfig.Owner = identity
return j
} | go | func (j *AuroraJob) Role(role string) Job {
j.jobConfig.Key.Role = role
//Will be deprecated
identity := &aurora.Identity{User: role}
j.jobConfig.Owner = identity
j.jobConfig.TaskConfig.Owner = identity
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"Role",
"(",
"role",
"string",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"Key",
".",
"Role",
"=",
"role",
"\n\n",
"//Will be deprecated",
"identity",
":=",
"&",
"aurora",
".",
"Identity",
"{",
"User",
":",
... | // Set Job Key Role. | [
"Set",
"Job",
"Key",
"Role",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L123-L131 |
16,087 | paypal/gorealis | job.go | Name | func (j *AuroraJob) Name(name string) Job {
j.jobConfig.Key.Name = name
return j
} | go | func (j *AuroraJob) Name(name string) Job {
j.jobConfig.Key.Name = name
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"Name",
"(",
"name",
"string",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"Key",
".",
"Name",
"=",
"name",
"\n",
"return",
"j",
"\n",
"}"
] | // Set Job Key Name. | [
"Set",
"Job",
"Key",
"Name",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L134-L137 |
16,088 | paypal/gorealis | job.go | ExecutorName | func (j *AuroraJob) ExecutorName(name string) Job {
if j.jobConfig.TaskConfig.ExecutorConfig == nil {
j.jobConfig.TaskConfig.ExecutorConfig = aurora.NewExecutorConfig()
}
j.jobConfig.TaskConfig.ExecutorConfig.Name = name
return j
} | go | func (j *AuroraJob) ExecutorName(name string) Job {
if j.jobConfig.TaskConfig.ExecutorConfig == nil {
j.jobConfig.TaskConfig.ExecutorConfig = aurora.NewExecutorConfig()
}
j.jobConfig.TaskConfig.ExecutorConfig.Name = name
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"ExecutorName",
"(",
"name",
"string",
")",
"Job",
"{",
"if",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"ExecutorConfig",
"==",
"nil",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"ExecutorConfig",
"="... | // Set name of the executor that will the task will be configured to. | [
"Set",
"name",
"of",
"the",
"executor",
"that",
"will",
"the",
"task",
"will",
"be",
"configured",
"to",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L140-L148 |
16,089 | paypal/gorealis | job.go | ExecutorData | func (j *AuroraJob) ExecutorData(data string) Job {
if j.jobConfig.TaskConfig.ExecutorConfig == nil {
j.jobConfig.TaskConfig.ExecutorConfig = aurora.NewExecutorConfig()
}
j.jobConfig.TaskConfig.ExecutorConfig.Data = data
return j
} | go | func (j *AuroraJob) ExecutorData(data string) Job {
if j.jobConfig.TaskConfig.ExecutorConfig == nil {
j.jobConfig.TaskConfig.ExecutorConfig = aurora.NewExecutorConfig()
}
j.jobConfig.TaskConfig.ExecutorConfig.Data = data
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"ExecutorData",
"(",
"data",
"string",
")",
"Job",
"{",
"if",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"ExecutorConfig",
"==",
"nil",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"ExecutorConfig",
"="... | // Will be included as part of entire task inside the scheduler that will be serialized. | [
"Will",
"be",
"included",
"as",
"part",
"of",
"entire",
"task",
"inside",
"the",
"scheduler",
"that",
"will",
"be",
"serialized",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L151-L159 |
16,090 | paypal/gorealis | job.go | MaxFailure | func (j *AuroraJob) MaxFailure(maxFail int32) Job {
j.jobConfig.TaskConfig.MaxTaskFailures = maxFail
return j
} | go | func (j *AuroraJob) MaxFailure(maxFail int32) Job {
j.jobConfig.TaskConfig.MaxTaskFailures = maxFail
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"MaxFailure",
"(",
"maxFail",
"int32",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"MaxTaskFailures",
"=",
"maxFail",
"\n",
"return",
"j",
"\n",
"}"
] | // How many failures to tolerate before giving up. | [
"How",
"many",
"failures",
"to",
"tolerate",
"before",
"giving",
"up",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L189-L192 |
16,091 | paypal/gorealis | job.go | InstanceCount | func (j *AuroraJob) InstanceCount(instCount int32) Job {
j.jobConfig.InstanceCount = instCount
return j
} | go | func (j *AuroraJob) InstanceCount(instCount int32) Job {
j.jobConfig.InstanceCount = instCount
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"InstanceCount",
"(",
"instCount",
"int32",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"InstanceCount",
"=",
"instCount",
"\n",
"return",
"j",
"\n",
"}"
] | // How many instances of the job to run | [
"How",
"many",
"instances",
"of",
"the",
"job",
"to",
"run"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L195-L198 |
16,092 | paypal/gorealis | job.go | IsService | func (j *AuroraJob) IsService(isService bool) Job {
j.jobConfig.TaskConfig.IsService = isService
return j
} | go | func (j *AuroraJob) IsService(isService bool) Job {
j.jobConfig.TaskConfig.IsService = isService
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"IsService",
"(",
"isService",
"bool",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"IsService",
"=",
"isService",
"\n",
"return",
"j",
"\n",
"}"
] | // Restart the job's tasks if they fail | [
"Restart",
"the",
"job",
"s",
"tasks",
"if",
"they",
"fail"
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L216-L219 |
16,093 | paypal/gorealis | job.go | AddLabel | func (j *AuroraJob) AddLabel(key string, value string) Job {
if _, ok := j.metadata[key]; ok {
j.metadata[key].Value = value
} else {
j.metadata[key] = &aurora.Metadata{Key: key, Value: value}
j.jobConfig.TaskConfig.Metadata = append(j.jobConfig.TaskConfig.Metadata, j.metadata[key])
}
return j
} | go | func (j *AuroraJob) AddLabel(key string, value string) Job {
if _, ok := j.metadata[key]; ok {
j.metadata[key].Value = value
} else {
j.metadata[key] = &aurora.Metadata{Key: key, Value: value}
j.jobConfig.TaskConfig.Metadata = append(j.jobConfig.TaskConfig.Metadata, j.metadata[key])
}
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"AddLabel",
"(",
"key",
"string",
",",
"value",
"string",
")",
"Job",
"{",
"if",
"_",
",",
"ok",
":=",
"j",
".",
"metadata",
"[",
"key",
"]",
";",
"ok",
"{",
"j",
".",
"metadata",
"[",
"key",
"]",
".",
... | // Adds a Mesos label to the job. Note that Aurora will add the
// prefix "org.apache.aurora.metadata." to the beginning of each key. | [
"Adds",
"a",
"Mesos",
"label",
"to",
"the",
"job",
".",
"Note",
"that",
"Aurora",
"will",
"add",
"the",
"prefix",
"org",
".",
"apache",
".",
"aurora",
".",
"metadata",
".",
"to",
"the",
"beginning",
"of",
"each",
"key",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L247-L255 |
16,094 | paypal/gorealis | job.go | AddNamedPorts | func (j *AuroraJob) AddNamedPorts(names ...string) Job {
j.portCount += len(names)
for _, name := range names {
j.jobConfig.TaskConfig.Resources = append(j.jobConfig.TaskConfig.Resources, &aurora.Resource{NamedPort: &name})
}
return j
} | go | func (j *AuroraJob) AddNamedPorts(names ...string) Job {
j.portCount += len(names)
for _, name := range names {
j.jobConfig.TaskConfig.Resources = append(j.jobConfig.TaskConfig.Resources, &aurora.Resource{NamedPort: &name})
}
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"AddNamedPorts",
"(",
"names",
"...",
"string",
")",
"Job",
"{",
"j",
".",
"portCount",
"+=",
"len",
"(",
"names",
")",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"names",
"{",
"j",
".",
"jobConfig",
".",... | // Add a named port to the job configuration These are random ports as it's
// not currently possible to request specific ports using Aurora. | [
"Add",
"a",
"named",
"port",
"to",
"the",
"job",
"configuration",
"These",
"are",
"random",
"ports",
"as",
"it",
"s",
"not",
"currently",
"possible",
"to",
"request",
"specific",
"ports",
"using",
"Aurora",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L259-L266 |
16,095 | paypal/gorealis | job.go | AddPorts | func (j *AuroraJob) AddPorts(num int) Job {
start := j.portCount
j.portCount += num
for i := start; i < j.portCount; i++ {
portName := "org.apache.aurora.port." + strconv.Itoa(i)
j.jobConfig.TaskConfig.Resources = append(j.jobConfig.TaskConfig.Resources, &aurora.Resource{NamedPort: &portName})
}
return j
} | go | func (j *AuroraJob) AddPorts(num int) Job {
start := j.portCount
j.portCount += num
for i := start; i < j.portCount; i++ {
portName := "org.apache.aurora.port." + strconv.Itoa(i)
j.jobConfig.TaskConfig.Resources = append(j.jobConfig.TaskConfig.Resources, &aurora.Resource{NamedPort: &portName})
}
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"AddPorts",
"(",
"num",
"int",
")",
"Job",
"{",
"start",
":=",
"j",
".",
"portCount",
"\n",
"j",
".",
"portCount",
"+=",
"num",
"\n",
"for",
"i",
":=",
"start",
";",
"i",
"<",
"j",
".",
"portCount",
";",
... | // Adds a request for a number of ports to the job configuration. The names chosen for these ports
// will be org.apache.aurora.port.X, where X is the current port count for the job configuration
// starting at 0. These are random ports as it's not currently possible to request
// specific ports using Aurora. | [
"Adds",
"a",
"request",
"for",
"a",
"number",
"of",
"ports",
"to",
"the",
"job",
"configuration",
".",
"The",
"names",
"chosen",
"for",
"these",
"ports",
"will",
"be",
"org",
".",
"apache",
".",
"aurora",
".",
"port",
".",
"X",
"where",
"X",
"is",
"t... | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L272-L281 |
16,096 | paypal/gorealis | job.go | Container | func (j *AuroraJob) Container(container Container) Job {
j.jobConfig.TaskConfig.Container = container.Build()
return j
} | go | func (j *AuroraJob) Container(container Container) Job {
j.jobConfig.TaskConfig.Container = container.Build()
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"Container",
"(",
"container",
"Container",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"Container",
"=",
"container",
".",
"Build",
"(",
")",
"\n\n",
"return",
"j",
"\n",
"}"
] | // Set a container to run for the job configuration to run. | [
"Set",
"a",
"container",
"to",
"run",
"for",
"the",
"job",
"configuration",
"to",
"run",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L327-L331 |
16,097 | paypal/gorealis | job.go | PartitionPolicy | func (j *AuroraJob) PartitionPolicy(policy *aurora.PartitionPolicy) Job {
j.jobConfig.TaskConfig.PartitionPolicy = policy
return j
} | go | func (j *AuroraJob) PartitionPolicy(policy *aurora.PartitionPolicy) Job {
j.jobConfig.TaskConfig.PartitionPolicy = policy
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"PartitionPolicy",
"(",
"policy",
"*",
"aurora",
".",
"PartitionPolicy",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"PartitionPolicy",
"=",
"policy",
"\n",
"return",
"j",
"\n",
"}"
] | // Set a partition policy for the job configuration to implement. | [
"Set",
"a",
"partition",
"policy",
"for",
"the",
"job",
"configuration",
"to",
"implement",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L334-L337 |
16,098 | paypal/gorealis | job.go | Tier | func (j *AuroraJob) Tier(tier string) Job {
j.jobConfig.TaskConfig.Tier = &tier
return j
} | go | func (j *AuroraJob) Tier(tier string) Job {
j.jobConfig.TaskConfig.Tier = &tier
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"Tier",
"(",
"tier",
"string",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"Tier",
"=",
"&",
"tier",
"\n\n",
"return",
"j",
"\n",
"}"
] | // Set the Tier for the Job. | [
"Set",
"the",
"Tier",
"for",
"the",
"Job",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L340-L344 |
16,099 | paypal/gorealis | job.go | SlaPolicy | func (j *AuroraJob) SlaPolicy(policy *aurora.SlaPolicy) Job {
j.jobConfig.TaskConfig.SlaPolicy = policy
return j
} | go | func (j *AuroraJob) SlaPolicy(policy *aurora.SlaPolicy) Job {
j.jobConfig.TaskConfig.SlaPolicy = policy
return j
} | [
"func",
"(",
"j",
"*",
"AuroraJob",
")",
"SlaPolicy",
"(",
"policy",
"*",
"aurora",
".",
"SlaPolicy",
")",
"Job",
"{",
"j",
".",
"jobConfig",
".",
"TaskConfig",
".",
"SlaPolicy",
"=",
"policy",
"\n\n",
"return",
"j",
"\n",
"}"
] | // Set an SlaPolicy for the Job. | [
"Set",
"an",
"SlaPolicy",
"for",
"the",
"Job",
"."
] | e16e390afe057e029334bbbac63942323d4ea50d | https://github.com/paypal/gorealis/blob/e16e390afe057e029334bbbac63942323d4ea50d/job.go#L347-L351 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.