id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
16,800 | ArthurHlt/go-eureka-client | eureka/client.go | UnmarshalJSON | func (c *Client) UnmarshalJSON(b []byte) error {
temp := struct {
Config Config `json:"config"`
Cluster *Cluster `json:"cluster"`
}{}
err := json.Unmarshal(b, &temp)
if err != nil {
return err
}
c.Cluster = temp.Cluster
c.Config = temp.Config
return nil
} | go | func (c *Client) UnmarshalJSON(b []byte) error {
temp := struct {
Config Config `json:"config"`
Cluster *Cluster `json:"cluster"`
}{}
err := json.Unmarshal(b, &temp)
if err != nil {
return err
}
c.Cluster = temp.Cluster
c.Config = temp.Config
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"temp",
":=",
"struct",
"{",
"Config",
"Config",
"`json:\"config\"`",
"\n",
"Cluster",
"*",
"Cluster",
"`json:\"cluster\"`",
"\n",
"}",
"{",
"}",
"\n",
... | // UnmarshalJSON implements the Unmarshaller interface
// as defined by the standard JSON package. | [
"UnmarshalJSON",
"implements",
"the",
"Unmarshaller",
"interface",
"as",
"defined",
"by",
"the",
"standard",
"JSON",
"package",
"."
] | 2f75174c63cf789d5de665a83b42680dfe2e088f | https://github.com/ArthurHlt/go-eureka-client/blob/2f75174c63cf789d5de665a83b42680dfe2e088f/eureka/client.go#L344-L357 |
16,801 | ArthurHlt/go-eureka-client | eureka/requests.go | Get | func (c *Client) Get(endpoint string) (*RawResponse, error) {
return c.getCancelable(endpoint, nil)
} | go | func (c *Client) Get(endpoint string) (*RawResponse, error) {
return c.getCancelable(endpoint, nil)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Get",
"(",
"endpoint",
"string",
")",
"(",
"*",
"RawResponse",
",",
"error",
")",
"{",
"return",
"c",
".",
"getCancelable",
"(",
"endpoint",
",",
"nil",
")",
"\n",
"}"
] | // get issues a GET request | [
"get",
"issues",
"a",
"GET",
"request"
] | 2f75174c63cf789d5de665a83b42680dfe2e088f | https://github.com/ArthurHlt/go-eureka-client/blob/2f75174c63cf789d5de665a83b42680dfe2e088f/eureka/requests.go#L164-L166 |
16,802 | ArthurHlt/go-eureka-client | eureka/requests.go | Put | func (c *Client) Put(endpoint string, body []byte) (*RawResponse, error) {
logger.Debug("put %s, %s, [%s]", endpoint, body, c.Cluster.Leader)
p := endpoint
req := NewRawRequest("PUT", p, body, nil)
resp, err := c.SendRequest(req)
if err != nil {
return nil, err
}
return resp, nil
} | go | func (c *Client) Put(endpoint string, body []byte) (*RawResponse, error) {
logger.Debug("put %s, %s, [%s]", endpoint, body, c.Cluster.Leader)
p := endpoint
req := NewRawRequest("PUT", p, body, nil)
resp, err := c.SendRequest(req)
if err != nil {
return nil, err
}
return resp, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Put",
"(",
"endpoint",
"string",
",",
"body",
"[",
"]",
"byte",
")",
"(",
"*",
"RawResponse",
",",
"error",
")",
"{",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
",",
"endpoint",
",",
"body",
",",
"c",
".",
"... | // put issues a PUT request | [
"put",
"issues",
"a",
"PUT",
"request"
] | 2f75174c63cf789d5de665a83b42680dfe2e088f | https://github.com/ArthurHlt/go-eureka-client/blob/2f75174c63cf789d5de665a83b42680dfe2e088f/eureka/requests.go#L169-L182 |
16,803 | ArthurHlt/go-eureka-client | eureka/requests.go | buildValues | func buildValues(value string, ttl uint64) url.Values {
v := url.Values{}
if value != "" {
v.Set("value", value)
}
if ttl > 0 {
v.Set("ttl", fmt.Sprintf("%v", ttl))
}
return v
} | go | func buildValues(value string, ttl uint64) url.Values {
v := url.Values{}
if value != "" {
v.Set("value", value)
}
if ttl > 0 {
v.Set("ttl", fmt.Sprintf("%v", ttl))
}
return v
} | [
"func",
"buildValues",
"(",
"value",
"string",
",",
"ttl",
"uint64",
")",
"url",
".",
"Values",
"{",
"v",
":=",
"url",
".",
"Values",
"{",
"}",
"\n\n",
"if",
"value",
"!=",
"\"",
"\"",
"{",
"v",
".",
"Set",
"(",
"\"",
"\"",
",",
"value",
")",
"... | // buildValues builds a url.Values map according to the given value and ttl | [
"buildValues",
"builds",
"a",
"url",
".",
"Values",
"map",
"according",
"to",
"the",
"given",
"value",
"and",
"ttl"
] | 2f75174c63cf789d5de665a83b42680dfe2e088f | https://github.com/ArthurHlt/go-eureka-client/blob/2f75174c63cf789d5de665a83b42680dfe2e088f/eureka/requests.go#L427-L439 |
16,804 | fiorix/go-smpp | smpp/pdu/pdutext/latin1.go | Encode | func (s Latin1) Encode() []byte {
e := charmap.Windows1252.NewEncoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | func (s Latin1) Encode() []byte {
e := charmap.Windows1252.NewEncoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | [
"func",
"(",
"s",
"Latin1",
")",
"Encode",
"(",
")",
"[",
"]",
"byte",
"{",
"e",
":=",
"charmap",
".",
"Windows1252",
".",
"NewEncoder",
"(",
")",
"\n",
"es",
",",
"_",
",",
"err",
":=",
"transform",
".",
"Bytes",
"(",
"e",
",",
"s",
")",
"\n",... | // Encode to Latin1. | [
"Encode",
"to",
"Latin1",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutext/latin1.go#L21-L28 |
16,805 | fiorix/go-smpp | smpp/pdu/pdutext/latin1.go | Decode | func (s Latin1) Decode() []byte {
e := charmap.Windows1252.NewDecoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | func (s Latin1) Decode() []byte {
e := charmap.Windows1252.NewDecoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | [
"func",
"(",
"s",
"Latin1",
")",
"Decode",
"(",
")",
"[",
"]",
"byte",
"{",
"e",
":=",
"charmap",
".",
"Windows1252",
".",
"NewDecoder",
"(",
")",
"\n",
"es",
",",
"_",
",",
"err",
":=",
"transform",
".",
"Bytes",
"(",
"e",
",",
"s",
")",
"\n",... | // Decode from Latin1. | [
"Decode",
"from",
"Latin1",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutext/latin1.go#L31-L38 |
16,806 | fiorix/go-smpp | smpp/pdu/pdufield/body.go | New | func New(n Name, data []byte) Body {
switch n {
case
AddrNPI,
AddrTON,
DataCoding,
DestAddrNPI,
DestAddrTON,
ESMClass,
ErrorCode,
InterfaceVersion,
MessageState,
NumberDests,
NoUnsuccess,
PriorityFlag,
ProtocolID,
RegisteredDelivery,
ReplaceIfPresentFlag,
SMDefaultMsgID,
SMLength,
SourceAddrNPI,
SourceAddrTON,
UDHLength:
if data == nil {
data = []byte{0}
}
return &Fixed{Data: data[0]}
case
AddressRange,
DestinationAddr,
DestinationList,
FinalDate,
MessageID,
Password,
ScheduleDeliveryTime,
ServiceType,
SourceAddr,
SystemID,
SystemType,
UnsuccessSme,
ValidityPeriod:
if data == nil {
data = []byte{}
}
return &Variable{Data: data}
case ShortMessage:
if data == nil {
data = []byte{}
}
return &SM{Data: data}
case GSMUserData:
udhData := []UDH{}
if data != nil && len(data) > 2 {
for i := 0; i < len(data); {
udh := UDH{}
udh.IEI = Fixed{Data: data[i]}
udh.IELength = Fixed{Data: data[i+1]}
udh.IEData = Variable{}
l := int(data[i+1])
for j := 2; j < l+2; j++ {
udh.IEData.Data = append(udh.IEData.Data, data[i+j])
}
udhData = append(udhData, udh)
i += l + 3 // Ignore one byte after IEData (which is 0x00)
}
}
return &UDHList{Data: udhData}
default:
return nil
}
} | go | func New(n Name, data []byte) Body {
switch n {
case
AddrNPI,
AddrTON,
DataCoding,
DestAddrNPI,
DestAddrTON,
ESMClass,
ErrorCode,
InterfaceVersion,
MessageState,
NumberDests,
NoUnsuccess,
PriorityFlag,
ProtocolID,
RegisteredDelivery,
ReplaceIfPresentFlag,
SMDefaultMsgID,
SMLength,
SourceAddrNPI,
SourceAddrTON,
UDHLength:
if data == nil {
data = []byte{0}
}
return &Fixed{Data: data[0]}
case
AddressRange,
DestinationAddr,
DestinationList,
FinalDate,
MessageID,
Password,
ScheduleDeliveryTime,
ServiceType,
SourceAddr,
SystemID,
SystemType,
UnsuccessSme,
ValidityPeriod:
if data == nil {
data = []byte{}
}
return &Variable{Data: data}
case ShortMessage:
if data == nil {
data = []byte{}
}
return &SM{Data: data}
case GSMUserData:
udhData := []UDH{}
if data != nil && len(data) > 2 {
for i := 0; i < len(data); {
udh := UDH{}
udh.IEI = Fixed{Data: data[i]}
udh.IELength = Fixed{Data: data[i+1]}
udh.IEData = Variable{}
l := int(data[i+1])
for j := 2; j < l+2; j++ {
udh.IEData.Data = append(udh.IEData.Data, data[i+j])
}
udhData = append(udhData, udh)
i += l + 3 // Ignore one byte after IEData (which is 0x00)
}
}
return &UDHList{Data: udhData}
default:
return nil
}
} | [
"func",
"New",
"(",
"n",
"Name",
",",
"data",
"[",
"]",
"byte",
")",
"Body",
"{",
"switch",
"n",
"{",
"case",
"AddrNPI",
",",
"AddrTON",
",",
"DataCoding",
",",
"DestAddrNPI",
",",
"DestAddrTON",
",",
"ESMClass",
",",
"ErrorCode",
",",
"InterfaceVersion"... | // New parses the given binary data and returns a Data object,
// or nil if the field Name is unknown. | [
"New",
"parses",
"the",
"given",
"binary",
"data",
"and",
"returns",
"a",
"Data",
"object",
"or",
"nil",
"if",
"the",
"field",
"Name",
"is",
"unknown",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdufield/body.go#L20-L90 |
16,807 | fiorix/go-smpp | smpp/transmitter.go | handlePDU | func (t *Transmitter) handlePDU(f HandlerFunc) {
for {
p, err := t.cl.Read()
if err != nil || p == nil {
break
}
seq := p.Header().Seq
t.tx.Lock()
rc := t.tx.inflight[seq]
t.tx.Unlock()
if rc != nil {
rc <- &tx{PDU: p}
} else if f != nil {
f(p)
}
if p.Header().ID == pdu.DeliverSMID { // Send DeliverSMResp
pResp := pdu.NewDeliverSMRespSeq(p.Header().Seq)
t.cl.Write(pResp)
}
}
t.tx.Lock()
for _, rc := range t.tx.inflight {
rc <- &tx{Err: ErrNotConnected}
}
t.tx.Unlock()
} | go | func (t *Transmitter) handlePDU(f HandlerFunc) {
for {
p, err := t.cl.Read()
if err != nil || p == nil {
break
}
seq := p.Header().Seq
t.tx.Lock()
rc := t.tx.inflight[seq]
t.tx.Unlock()
if rc != nil {
rc <- &tx{PDU: p}
} else if f != nil {
f(p)
}
if p.Header().ID == pdu.DeliverSMID { // Send DeliverSMResp
pResp := pdu.NewDeliverSMRespSeq(p.Header().Seq)
t.cl.Write(pResp)
}
}
t.tx.Lock()
for _, rc := range t.tx.inflight {
rc <- &tx{Err: ErrNotConnected}
}
t.tx.Unlock()
} | [
"func",
"(",
"t",
"*",
"Transmitter",
")",
"handlePDU",
"(",
"f",
"HandlerFunc",
")",
"{",
"for",
"{",
"p",
",",
"err",
":=",
"t",
".",
"cl",
".",
"Read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"p",
"==",
"nil",
"{",
"break",
"\n",
"... | // f is only set on transceiver. | [
"f",
"is",
"only",
"set",
"on",
"transceiver",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/transmitter.go#L116-L141 |
16,808 | fiorix/go-smpp | smpp/transmitter.go | newUnsucessDest | func newUnsucessDest(p pdufield.UnSme) UnsucessDest {
unDest := UnsucessDest{}
unDest.AddrTON, _ = p.Ton.Raw().(uint8) // if there is an error default value will be set
unDest.AddrNPI, _ = p.Npi.Raw().(uint8)
unDest.Address = string(p.DestAddr.Bytes())
unDest.Error = pdu.Status(binary.BigEndian.Uint32(p.ErrCode.Bytes()))
return unDest
} | go | func newUnsucessDest(p pdufield.UnSme) UnsucessDest {
unDest := UnsucessDest{}
unDest.AddrTON, _ = p.Ton.Raw().(uint8) // if there is an error default value will be set
unDest.AddrNPI, _ = p.Npi.Raw().(uint8)
unDest.Address = string(p.DestAddr.Bytes())
unDest.Error = pdu.Status(binary.BigEndian.Uint32(p.ErrCode.Bytes()))
return unDest
} | [
"func",
"newUnsucessDest",
"(",
"p",
"pdufield",
".",
"UnSme",
")",
"UnsucessDest",
"{",
"unDest",
":=",
"UnsucessDest",
"{",
"}",
"\n",
"unDest",
".",
"AddrTON",
",",
"_",
"=",
"p",
".",
"Ton",
".",
"Raw",
"(",
")",
".",
"(",
"uint8",
")",
"// if th... | // newUnsucessDest returns a new UnsucessDest constructed from a UnSme struct | [
"newUnsucessDest",
"returns",
"a",
"new",
"UnsucessDest",
"constructed",
"from",
"a",
"UnSme",
"struct"
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/transmitter.go#L163-L170 |
16,809 | fiorix/go-smpp | smpp/transmitter.go | Resp | func (sm *ShortMessage) Resp() pdu.Body {
sm.resp.Lock()
defer sm.resp.Unlock()
return sm.resp.p
} | go | func (sm *ShortMessage) Resp() pdu.Body {
sm.resp.Lock()
defer sm.resp.Unlock()
return sm.resp.p
} | [
"func",
"(",
"sm",
"*",
"ShortMessage",
")",
"Resp",
"(",
")",
"pdu",
".",
"Body",
"{",
"sm",
".",
"resp",
".",
"Lock",
"(",
")",
"\n",
"defer",
"sm",
".",
"resp",
".",
"Unlock",
"(",
")",
"\n",
"return",
"sm",
".",
"resp",
".",
"p",
"\n",
"}... | // Resp returns the response PDU, or nil if not set. | [
"Resp",
"returns",
"the",
"response",
"PDU",
"or",
"nil",
"if",
"not",
"set",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/transmitter.go#L206-L210 |
16,810 | fiorix/go-smpp | smpp/transmitter.go | Submit | func (t *Transmitter) Submit(sm *ShortMessage) (*ShortMessage, error) {
if len(sm.DstList) > 0 || len(sm.DLs) > 0 {
// if we have a single destination address add it to the list
if sm.Dst != "" {
sm.DstList = append(sm.DstList, sm.Dst)
}
p := pdu.NewSubmitMulti(sm.TLVFields)
return t.submitMsgMulti(sm, p, uint8(sm.Text.Type()))
}
p := pdu.NewSubmitSM(sm.TLVFields)
return t.submitMsg(sm, p, uint8(sm.Text.Type()))
} | go | func (t *Transmitter) Submit(sm *ShortMessage) (*ShortMessage, error) {
if len(sm.DstList) > 0 || len(sm.DLs) > 0 {
// if we have a single destination address add it to the list
if sm.Dst != "" {
sm.DstList = append(sm.DstList, sm.Dst)
}
p := pdu.NewSubmitMulti(sm.TLVFields)
return t.submitMsgMulti(sm, p, uint8(sm.Text.Type()))
}
p := pdu.NewSubmitSM(sm.TLVFields)
return t.submitMsg(sm, p, uint8(sm.Text.Type()))
} | [
"func",
"(",
"t",
"*",
"Transmitter",
")",
"Submit",
"(",
"sm",
"*",
"ShortMessage",
")",
"(",
"*",
"ShortMessage",
",",
"error",
")",
"{",
"if",
"len",
"(",
"sm",
".",
"DstList",
")",
">",
"0",
"||",
"len",
"(",
"sm",
".",
"DLs",
")",
">",
"0"... | // Submit sends a short message and returns and updates the given
// sm with the response status. It returns the same sm object. | [
"Submit",
"sends",
"a",
"short",
"message",
"and",
"returns",
"and",
"updates",
"the",
"given",
"sm",
"with",
"the",
"response",
"status",
".",
"It",
"returns",
"the",
"same",
"sm",
"object",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/transmitter.go#L314-L325 |
16,811 | fiorix/go-smpp | smpp/pdu/pdutlv/tlv_list.go | DecodeTLV | func DecodeTLV(r *bytes.Buffer) (Map, error) {
t := make(Map)
for r.Len() >= 4 {
b := r.Next(4)
ft := Tag(binary.BigEndian.Uint16(b[0:2]))
fl := binary.BigEndian.Uint16(b[2:4])
if r.Len() < int(fl) {
return nil, fmt.Errorf("not enough data for tag %s: want %d, have %d",
ft.Hex(), fl, r.Len())
}
b = r.Next(int(fl))
t[ft] = &Field{
Tag: ft,
Data: b,
}
}
return t, nil
} | go | func DecodeTLV(r *bytes.Buffer) (Map, error) {
t := make(Map)
for r.Len() >= 4 {
b := r.Next(4)
ft := Tag(binary.BigEndian.Uint16(b[0:2]))
fl := binary.BigEndian.Uint16(b[2:4])
if r.Len() < int(fl) {
return nil, fmt.Errorf("not enough data for tag %s: want %d, have %d",
ft.Hex(), fl, r.Len())
}
b = r.Next(int(fl))
t[ft] = &Field{
Tag: ft,
Data: b,
}
}
return t, nil
} | [
"func",
"DecodeTLV",
"(",
"r",
"*",
"bytes",
".",
"Buffer",
")",
"(",
"Map",
",",
"error",
")",
"{",
"t",
":=",
"make",
"(",
"Map",
")",
"\n",
"for",
"r",
".",
"Len",
"(",
")",
">=",
"4",
"{",
"b",
":=",
"r",
".",
"Next",
"(",
"4",
")",
"... | // DecodeTLV scans the given byte slice to build a Map from binary data. | [
"DecodeTLV",
"scans",
"the",
"given",
"byte",
"slice",
"to",
"build",
"a",
"Map",
"from",
"binary",
"data",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutlv/tlv_list.go#L14-L31 |
16,812 | fiorix/go-smpp | smpp/receiver.go | Bind | func (r *Receiver) Bind() <-chan ConnStatus {
r.cl.Lock()
defer r.cl.Unlock()
r.chanClose = make(chan struct{})
if r.cl.client != nil {
return r.cl.Status
}
c := &client{
Addr: r.Addr,
TLS: r.TLS,
EnquireLink: r.EnquireLink,
EnquireLinkTimeout: r.EnquireLinkTimeout,
Status: make(chan ConnStatus, 1),
BindFunc: r.bindFunc,
BindInterval: r.BindInterval,
}
r.cl.client = c
c.init()
go c.Bind()
// Set up message merging if requested
if r.MergeInterval > 0 {
if r.MergeCleanupInterval == 0 {
r.MergeCleanupInterval = 1 * time.Second
}
r.mg.mergeHolders = make(map[int]*MergeHolder)
go r.mergeCleaner()
}
return c.Status
} | go | func (r *Receiver) Bind() <-chan ConnStatus {
r.cl.Lock()
defer r.cl.Unlock()
r.chanClose = make(chan struct{})
if r.cl.client != nil {
return r.cl.Status
}
c := &client{
Addr: r.Addr,
TLS: r.TLS,
EnquireLink: r.EnquireLink,
EnquireLinkTimeout: r.EnquireLinkTimeout,
Status: make(chan ConnStatus, 1),
BindFunc: r.bindFunc,
BindInterval: r.BindInterval,
}
r.cl.client = c
c.init()
go c.Bind()
// Set up message merging if requested
if r.MergeInterval > 0 {
if r.MergeCleanupInterval == 0 {
r.MergeCleanupInterval = 1 * time.Second
}
r.mg.mergeHolders = make(map[int]*MergeHolder)
go r.mergeCleaner()
}
return c.Status
} | [
"func",
"(",
"r",
"*",
"Receiver",
")",
"Bind",
"(",
")",
"<-",
"chan",
"ConnStatus",
"{",
"r",
".",
"cl",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"cl",
".",
"Unlock",
"(",
")",
"\n\n",
"r",
".",
"chanClose",
"=",
"make",
"(",
"chan",
... | // Bind starts the Receiver. It creates a persistent connection
// to the server, update its status via the returned channel,
// and calls the registered Handler when new PDU arrives.
//
// Bind implements the ClientConn interface. | [
"Bind",
"starts",
"the",
"Receiver",
".",
"It",
"creates",
"a",
"persistent",
"connection",
"to",
"the",
"server",
"update",
"its",
"status",
"via",
"the",
"returned",
"channel",
"and",
"calls",
"the",
"registered",
"Handler",
"when",
"new",
"PDU",
"arrives",
... | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/receiver.go#L71-L106 |
16,813 | fiorix/go-smpp | smpp/pdu/header.go | DecodeHeader | func DecodeHeader(r io.Reader) (*Header, error) {
b := make([]byte, HeaderLen)
_, err := io.ReadFull(r, b)
if err != nil {
return nil, err
}
l := binary.BigEndian.Uint32(b[0:4])
if l < HeaderLen {
return nil, fmt.Errorf("PDU too small: %d < %d", l, HeaderLen)
}
if l > MaxSize {
return nil, fmt.Errorf("PDU too large: %d > %d", l, MaxSize)
}
hdr := &Header{
Len: l,
ID: ID(binary.BigEndian.Uint32(b[4:8])),
Status: Status(binary.BigEndian.Uint32(b[8:12])),
Seq: binary.BigEndian.Uint32(b[12:16]),
}
return hdr, nil
} | go | func DecodeHeader(r io.Reader) (*Header, error) {
b := make([]byte, HeaderLen)
_, err := io.ReadFull(r, b)
if err != nil {
return nil, err
}
l := binary.BigEndian.Uint32(b[0:4])
if l < HeaderLen {
return nil, fmt.Errorf("PDU too small: %d < %d", l, HeaderLen)
}
if l > MaxSize {
return nil, fmt.Errorf("PDU too large: %d > %d", l, MaxSize)
}
hdr := &Header{
Len: l,
ID: ID(binary.BigEndian.Uint32(b[4:8])),
Status: Status(binary.BigEndian.Uint32(b[8:12])),
Seq: binary.BigEndian.Uint32(b[12:16]),
}
return hdr, nil
} | [
"func",
"DecodeHeader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Header",
",",
"error",
")",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"HeaderLen",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"b",
"... | // DecodeHeader decodes binary PDU header data. | [
"DecodeHeader",
"decodes",
"binary",
"PDU",
"header",
"data",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/header.go#L68-L88 |
16,814 | fiorix/go-smpp | smpp/pdu/header.go | SerializeTo | func (h *Header) SerializeTo(w io.Writer) error {
b := make([]byte, HeaderLen)
binary.BigEndian.PutUint32(b[0:4], h.Len)
binary.BigEndian.PutUint32(b[4:8], uint32(h.ID))
binary.BigEndian.PutUint32(b[8:12], uint32(h.Status))
binary.BigEndian.PutUint32(b[12:16], h.Seq)
_, err := w.Write(b)
return err
} | go | func (h *Header) SerializeTo(w io.Writer) error {
b := make([]byte, HeaderLen)
binary.BigEndian.PutUint32(b[0:4], h.Len)
binary.BigEndian.PutUint32(b[4:8], uint32(h.ID))
binary.BigEndian.PutUint32(b[8:12], uint32(h.Status))
binary.BigEndian.PutUint32(b[12:16], h.Seq)
_, err := w.Write(b)
return err
} | [
"func",
"(",
"h",
"*",
"Header",
")",
"SerializeTo",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"HeaderLen",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"b",
"[",
"0",
":",
... | // SerializeTo serializes the Header to its binary form to the given writer. | [
"SerializeTo",
"serializes",
"the",
"Header",
"to",
"its",
"binary",
"form",
"to",
"the",
"given",
"writer",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/header.go#L91-L99 |
16,815 | fiorix/go-smpp | smpp/pdu/types.go | NewGenericNACK | func NewGenericNACK() Body {
b := newGenericNACK(&Header{ID: GenericNACKID})
b.init()
return b
} | go | func NewGenericNACK() Body {
b := newGenericNACK(&Header{ID: GenericNACKID})
b.init()
return b
} | [
"func",
"NewGenericNACK",
"(",
")",
"Body",
"{",
"b",
":=",
"newGenericNACK",
"(",
"&",
"Header",
"{",
"ID",
":",
"GenericNACKID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewGenericNACK creates and initializes a GenericNACK PDU. | [
"NewGenericNACK",
"creates",
"and",
"initializes",
"a",
"GenericNACK",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L51-L55 |
16,816 | fiorix/go-smpp | smpp/pdu/types.go | NewBindReceiver | func NewBindReceiver() Body {
b := newBind(&Header{ID: BindReceiverID})
b.init()
return b
} | go | func NewBindReceiver() Body {
b := newBind(&Header{ID: BindReceiverID})
b.init()
return b
} | [
"func",
"NewBindReceiver",
"(",
")",
"Body",
"{",
"b",
":=",
"newBind",
"(",
"&",
"Header",
"{",
"ID",
":",
"BindReceiverID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBindReceiver creates a new Bind PDU. | [
"NewBindReceiver",
"creates",
"a",
"new",
"Bind",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L75-L79 |
16,817 | fiorix/go-smpp | smpp/pdu/types.go | NewBindTransceiver | func NewBindTransceiver() Body {
b := newBind(&Header{ID: BindTransceiverID})
b.init()
return b
} | go | func NewBindTransceiver() Body {
b := newBind(&Header{ID: BindTransceiverID})
b.init()
return b
} | [
"func",
"NewBindTransceiver",
"(",
")",
"Body",
"{",
"b",
":=",
"newBind",
"(",
"&",
"Header",
"{",
"ID",
":",
"BindTransceiverID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBindTransceiver creates a new Bind PDU. | [
"NewBindTransceiver",
"creates",
"a",
"new",
"Bind",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L82-L86 |
16,818 | fiorix/go-smpp | smpp/pdu/types.go | NewBindTransmitter | func NewBindTransmitter() Body {
b := newBind(&Header{ID: BindTransmitterID})
b.init()
return b
} | go | func NewBindTransmitter() Body {
b := newBind(&Header{ID: BindTransmitterID})
b.init()
return b
} | [
"func",
"NewBindTransmitter",
"(",
")",
"Body",
"{",
"b",
":=",
"newBind",
"(",
"&",
"Header",
"{",
"ID",
":",
"BindTransmitterID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBindTransmitter creates a new Bind PDU. | [
"NewBindTransmitter",
"creates",
"a",
"new",
"Bind",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L89-L93 |
16,819 | fiorix/go-smpp | smpp/pdu/types.go | NewBindReceiverResp | func NewBindReceiverResp() Body {
b := newBindResp(&Header{ID: BindReceiverRespID})
b.init()
return b
} | go | func NewBindReceiverResp() Body {
b := newBindResp(&Header{ID: BindReceiverRespID})
b.init()
return b
} | [
"func",
"NewBindReceiverResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newBindResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"BindReceiverRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBindReceiverResp creates and initializes a new BindResp PDU. | [
"NewBindReceiverResp",
"creates",
"and",
"initializes",
"a",
"new",
"BindResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L106-L110 |
16,820 | fiorix/go-smpp | smpp/pdu/types.go | NewBindTransceiverResp | func NewBindTransceiverResp() Body {
b := newBindResp(&Header{ID: BindTransceiverRespID})
b.init()
return b
} | go | func NewBindTransceiverResp() Body {
b := newBindResp(&Header{ID: BindTransceiverRespID})
b.init()
return b
} | [
"func",
"NewBindTransceiverResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newBindResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"BindTransceiverRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBindTransceiverResp creates and initializes a new BindResp PDU. | [
"NewBindTransceiverResp",
"creates",
"and",
"initializes",
"a",
"new",
"BindResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L113-L117 |
16,821 | fiorix/go-smpp | smpp/pdu/types.go | NewBindTransmitterResp | func NewBindTransmitterResp() Body {
b := newBindResp(&Header{ID: BindTransmitterRespID})
b.init()
return b
} | go | func NewBindTransmitterResp() Body {
b := newBindResp(&Header{ID: BindTransmitterRespID})
b.init()
return b
} | [
"func",
"NewBindTransmitterResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newBindResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"BindTransmitterRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewBindTransmitterResp creates and initializes a new BindResp PDU. | [
"NewBindTransmitterResp",
"creates",
"and",
"initializes",
"a",
"new",
"BindResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L120-L124 |
16,822 | fiorix/go-smpp | smpp/pdu/types.go | NewQuerySM | func NewQuerySM() Body {
b := newQuerySM(&Header{ID: QuerySMID})
b.init()
return b
} | go | func NewQuerySM() Body {
b := newQuerySM(&Header{ID: QuerySMID})
b.init()
return b
} | [
"func",
"NewQuerySM",
"(",
")",
"Body",
"{",
"b",
":=",
"newQuerySM",
"(",
"&",
"Header",
"{",
"ID",
":",
"QuerySMID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewQuerySM creates and initializes a new QuerySM PDU. | [
"NewQuerySM",
"creates",
"and",
"initializes",
"a",
"new",
"QuerySM",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L142-L146 |
16,823 | fiorix/go-smpp | smpp/pdu/types.go | NewQuerySMResp | func NewQuerySMResp() Body {
b := newQuerySMResp(&Header{ID: QuerySMRespID})
b.init()
return b
} | go | func NewQuerySMResp() Body {
b := newQuerySMResp(&Header{ID: QuerySMRespID})
b.init()
return b
} | [
"func",
"NewQuerySMResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newQuerySMResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"QuerySMRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewQuerySMResp creates and initializes a new QuerySMResp PDU. | [
"NewQuerySMResp",
"creates",
"and",
"initializes",
"a",
"new",
"QuerySMResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L164-L168 |
16,824 | fiorix/go-smpp | smpp/pdu/types.go | NewSubmitSM | func NewSubmitSM(fields pdutlv.Fields) Body {
b := newSubmitSM(&Header{ID: SubmitSMID})
b.init()
for tag, value := range fields {
b.t.Set(tag, value)
}
return b
} | go | func NewSubmitSM(fields pdutlv.Fields) Body {
b := newSubmitSM(&Header{ID: SubmitSMID})
b.init()
for tag, value := range fields {
b.t.Set(tag, value)
}
return b
} | [
"func",
"NewSubmitSM",
"(",
"fields",
"pdutlv",
".",
"Fields",
")",
"Body",
"{",
"b",
":=",
"newSubmitSM",
"(",
"&",
"Header",
"{",
"ID",
":",
"SubmitSMID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"for",
"tag",
",",
"value",
":=",
"range"... | // NewSubmitSM creates and initializes a new SubmitSM PDU. | [
"NewSubmitSM",
"creates",
"and",
"initializes",
"a",
"new",
"SubmitSM",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L200-L207 |
16,825 | fiorix/go-smpp | smpp/pdu/types.go | NewSubmitSMResp | func NewSubmitSMResp() Body {
b := newSubmitSMResp(&Header{ID: SubmitSMRespID})
b.init()
return b
} | go | func NewSubmitSMResp() Body {
b := newSubmitSMResp(&Header{ID: SubmitSMRespID})
b.init()
return b
} | [
"func",
"NewSubmitSMResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newSubmitSMResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"SubmitSMRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewSubmitSMResp creates and initializes a new SubmitSMResp PDU. | [
"NewSubmitSMResp",
"creates",
"and",
"initializes",
"a",
"new",
"SubmitSMResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L222-L226 |
16,826 | fiorix/go-smpp | smpp/pdu/types.go | NewSubmitMulti | func NewSubmitMulti(fields pdutlv.Fields) Body {
b := newSubmitMulti(&Header{ID: SubmitMultiID})
b.init()
for tag, value := range fields {
b.t.Set(tag, value)
}
return b
} | go | func NewSubmitMulti(fields pdutlv.Fields) Body {
b := newSubmitMulti(&Header{ID: SubmitMultiID})
b.init()
for tag, value := range fields {
b.t.Set(tag, value)
}
return b
} | [
"func",
"NewSubmitMulti",
"(",
"fields",
"pdutlv",
".",
"Fields",
")",
"Body",
"{",
"b",
":=",
"newSubmitMulti",
"(",
"&",
"Header",
"{",
"ID",
":",
"SubmitMultiID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"for",
"tag",
",",
"value",
":=",
... | // NewSubmitMulti creates and initializes a new SubmitMulti PDU. | [
"NewSubmitMulti",
"creates",
"and",
"initializes",
"a",
"new",
"SubmitMulti",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L257-L264 |
16,827 | fiorix/go-smpp | smpp/pdu/types.go | NewSubmitMultiResp | func NewSubmitMultiResp() Body {
b := newSubmitMultiResp(&Header{ID: SubmitMultiRespID})
b.init()
return b
} | go | func NewSubmitMultiResp() Body {
b := newSubmitMultiResp(&Header{ID: SubmitMultiRespID})
b.init()
return b
} | [
"func",
"NewSubmitMultiResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newSubmitMultiResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"SubmitMultiRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewSubmitMultiResp creates and initializes a new SubmitMultiResp PDU. | [
"NewSubmitMultiResp",
"creates",
"and",
"initializes",
"a",
"new",
"SubmitMultiResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L281-L285 |
16,828 | fiorix/go-smpp | smpp/pdu/types.go | NewDeliverSM | func NewDeliverSM() Body {
b := newDeliverSM(&Header{ID: DeliverSMID})
b.init()
return b
} | go | func NewDeliverSM() Body {
b := newDeliverSM(&Header{ID: DeliverSMID})
b.init()
return b
} | [
"func",
"NewDeliverSM",
"(",
")",
"Body",
"{",
"b",
":=",
"newDeliverSM",
"(",
"&",
"Header",
"{",
"ID",
":",
"DeliverSMID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewDeliverSM creates and initializes a new DeliverSM PDU. | [
"NewDeliverSM",
"creates",
"and",
"initializes",
"a",
"new",
"DeliverSM",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L319-L323 |
16,829 | fiorix/go-smpp | smpp/pdu/types.go | NewDeliverSMResp | func NewDeliverSMResp() Body {
b := newDeliverSMResp(&Header{ID: DeliverSMRespID})
b.init()
return b
} | go | func NewDeliverSMResp() Body {
b := newDeliverSMResp(&Header{ID: DeliverSMRespID})
b.init()
return b
} | [
"func",
"NewDeliverSMResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newDeliverSMResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"DeliverSMRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewDeliverSMResp creates and initializes a new DeliverSMResp PDU. | [
"NewDeliverSMResp",
"creates",
"and",
"initializes",
"a",
"new",
"DeliverSMResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L338-L342 |
16,830 | fiorix/go-smpp | smpp/pdu/types.go | NewDeliverSMRespSeq | func NewDeliverSMRespSeq(seq uint32) Body {
b := newDeliverSMResp(&Header{ID: DeliverSMRespID, Seq: seq})
b.init()
return b
} | go | func NewDeliverSMRespSeq(seq uint32) Body {
b := newDeliverSMResp(&Header{ID: DeliverSMRespID, Seq: seq})
b.init()
return b
} | [
"func",
"NewDeliverSMRespSeq",
"(",
"seq",
"uint32",
")",
"Body",
"{",
"b",
":=",
"newDeliverSMResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"DeliverSMRespID",
",",
"Seq",
":",
"seq",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n"... | // NewDeliverSMRespSeq creates and initializes a new DeliverSMResp PDU for a specific seq. | [
"NewDeliverSMRespSeq",
"creates",
"and",
"initializes",
"a",
"new",
"DeliverSMResp",
"PDU",
"for",
"a",
"specific",
"seq",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L345-L349 |
16,831 | fiorix/go-smpp | smpp/pdu/types.go | NewUnbind | func NewUnbind() Body {
b := newUnbind(&Header{ID: UnbindID})
b.init()
return b
} | go | func NewUnbind() Body {
b := newUnbind(&Header{ID: UnbindID})
b.init()
return b
} | [
"func",
"NewUnbind",
"(",
")",
"Body",
"{",
"b",
":=",
"newUnbind",
"(",
"&",
"Header",
"{",
"ID",
":",
"UnbindID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewUnbind creates and initializes a Unbind PDU. | [
"NewUnbind",
"creates",
"and",
"initializes",
"a",
"Unbind",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L359-L363 |
16,832 | fiorix/go-smpp | smpp/pdu/types.go | NewUnbindResp | func NewUnbindResp() Body {
b := newUnbindResp(&Header{ID: UnbindRespID})
b.init()
return b
} | go | func NewUnbindResp() Body {
b := newUnbindResp(&Header{ID: UnbindRespID})
b.init()
return b
} | [
"func",
"NewUnbindResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newUnbindResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"UnbindRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewUnbindResp creates and initializes a UnbindResp PDU. | [
"NewUnbindResp",
"creates",
"and",
"initializes",
"a",
"UnbindResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L373-L377 |
16,833 | fiorix/go-smpp | smpp/pdu/types.go | NewEnquireLink | func NewEnquireLink() Body {
b := newEnquireLink(&Header{ID: EnquireLinkID})
b.init()
return b
} | go | func NewEnquireLink() Body {
b := newEnquireLink(&Header{ID: EnquireLinkID})
b.init()
return b
} | [
"func",
"NewEnquireLink",
"(",
")",
"Body",
"{",
"b",
":=",
"newEnquireLink",
"(",
"&",
"Header",
"{",
"ID",
":",
"EnquireLinkID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewEnquireLink creates and initializes a EnquireLink PDU. | [
"NewEnquireLink",
"creates",
"and",
"initializes",
"a",
"EnquireLink",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L387-L391 |
16,834 | fiorix/go-smpp | smpp/pdu/types.go | NewEnquireLinkResp | func NewEnquireLinkResp() Body {
b := newEnquireLinkResp(&Header{ID: EnquireLinkRespID})
b.init()
return b
} | go | func NewEnquireLinkResp() Body {
b := newEnquireLinkResp(&Header{ID: EnquireLinkRespID})
b.init()
return b
} | [
"func",
"NewEnquireLinkResp",
"(",
")",
"Body",
"{",
"b",
":=",
"newEnquireLinkResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"EnquireLinkRespID",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // NewEnquireLinkResp creates and initializes a EnquireLinkResp PDU. | [
"NewEnquireLinkResp",
"creates",
"and",
"initializes",
"a",
"EnquireLinkResp",
"PDU",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L401-L405 |
16,835 | fiorix/go-smpp | smpp/pdu/types.go | NewEnquireLinkRespSeq | func NewEnquireLinkRespSeq(seq uint32) Body {
b := newEnquireLinkResp(&Header{ID: EnquireLinkRespID, Seq: seq})
b.init()
return b
} | go | func NewEnquireLinkRespSeq(seq uint32) Body {
b := newEnquireLinkResp(&Header{ID: EnquireLinkRespID, Seq: seq})
b.init()
return b
} | [
"func",
"NewEnquireLinkRespSeq",
"(",
"seq",
"uint32",
")",
"Body",
"{",
"b",
":=",
"newEnquireLinkResp",
"(",
"&",
"Header",
"{",
"ID",
":",
"EnquireLinkRespID",
",",
"Seq",
":",
"seq",
"}",
")",
"\n",
"b",
".",
"init",
"(",
")",
"\n",
"return",
"b",
... | // NewEnquireLinkRespSeq creates and initializes a EnquireLinkResp PDU for a specific seq. | [
"NewEnquireLinkRespSeq",
"creates",
"and",
"initializes",
"a",
"EnquireLinkResp",
"PDU",
"for",
"a",
"specific",
"seq",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/types.go#L408-L412 |
16,836 | fiorix/go-smpp | smpp/pdu/pdutlv/tlv_body.go | NewTLV | func NewTLV(tag Tag, value []byte) Body {
return &Field{ Tag: tag, Data: value }
} | go | func NewTLV(tag Tag, value []byte) Body {
return &Field{ Tag: tag, Data: value }
} | [
"func",
"NewTLV",
"(",
"tag",
"Tag",
",",
"value",
"[",
"]",
"byte",
")",
"Body",
"{",
"return",
"&",
"Field",
"{",
"Tag",
":",
"tag",
",",
"Data",
":",
"value",
"}",
"\n",
"}"
] | // NewTLV parses the given binary data and returns a Data object,
// or nil if the field Name is unknown. | [
"NewTLV",
"parses",
"the",
"given",
"binary",
"data",
"and",
"returns",
"a",
"Data",
"object",
"or",
"nil",
"if",
"the",
"field",
"Name",
"is",
"unknown",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutlv/tlv_body.go#L22-L24 |
16,837 | fiorix/go-smpp | smpp/conn.go | Dial | func Dial(addr string, TLS *tls.Config) (Conn, error) {
if addr == "" {
addr = "localhost:2775"
}
fd, err := net.Dial("tcp", addr)
if err != nil {
return nil, err
}
if TLS != nil {
fd = tls.Client(fd, TLS)
}
c := &conn{
rwc: fd,
r: bufio.NewReader(fd),
w: bufio.NewWriter(fd),
}
return c, nil
} | go | func Dial(addr string, TLS *tls.Config) (Conn, error) {
if addr == "" {
addr = "localhost:2775"
}
fd, err := net.Dial("tcp", addr)
if err != nil {
return nil, err
}
if TLS != nil {
fd = tls.Client(fd, TLS)
}
c := &conn{
rwc: fd,
r: bufio.NewReader(fd),
w: bufio.NewWriter(fd),
}
return c, nil
} | [
"func",
"Dial",
"(",
"addr",
"string",
",",
"TLS",
"*",
"tls",
".",
"Config",
")",
"(",
"Conn",
",",
"error",
")",
"{",
"if",
"addr",
"==",
"\"",
"\"",
"{",
"addr",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"fd",
",",
"err",
":=",
"net",
".",
"Dial",... | // Dial dials to the SMPP server and returns a Conn, or error.
// TLS is only used if provided. | [
"Dial",
"dials",
"to",
"the",
"SMPP",
"server",
"and",
"returns",
"a",
"Conn",
"or",
"error",
".",
"TLS",
"is",
"only",
"used",
"if",
"provided",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/conn.go#L58-L75 |
16,838 | fiorix/go-smpp | smpp/conn.go | Set | func (cs *connSwitch) Set(c Conn) {
cs.mu.Lock()
if cs.c != nil {
cs.c.Close()
}
cs.c = c
cs.mu.Unlock()
} | go | func (cs *connSwitch) Set(c Conn) {
cs.mu.Lock()
if cs.c != nil {
cs.c.Close()
}
cs.c = c
cs.mu.Unlock()
} | [
"func",
"(",
"cs",
"*",
"connSwitch",
")",
"Set",
"(",
"c",
"Conn",
")",
"{",
"cs",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"cs",
".",
"c",
"!=",
"nil",
"{",
"cs",
".",
"c",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"cs",
".",
"c",
... | // Set sets the underlying Conn with the given one.
// If we hold a Conn already, it will be closed before switching over. | [
"Set",
"sets",
"the",
"underlying",
"Conn",
"with",
"the",
"given",
"one",
".",
"If",
"we",
"hold",
"a",
"Conn",
"already",
"it",
"will",
"be",
"closed",
"before",
"switching",
"over",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/conn.go#L121-L128 |
16,839 | fiorix/go-smpp | smpp/conn.go | Close | func (cs *connSwitch) Close() error {
cs.mu.Lock()
defer cs.mu.Unlock()
if cs.c == nil {
return ErrNotConnected
}
err := cs.c.Close()
cs.c = nil
return err
} | go | func (cs *connSwitch) Close() error {
cs.mu.Lock()
defer cs.mu.Unlock()
if cs.c == nil {
return ErrNotConnected
}
err := cs.c.Close()
cs.c = nil
return err
} | [
"func",
"(",
"cs",
"*",
"connSwitch",
")",
"Close",
"(",
")",
"error",
"{",
"cs",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cs",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"cs",
".",
"c",
"==",
"nil",
"{",
"return",
"ErrNotConnecte... | // Close implements the Conn interface. | [
"Close",
"implements",
"the",
"Conn",
"interface",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/conn.go#L152-L161 |
16,840 | fiorix/go-smpp | smpp/transceiver.go | Bind | func (t *Transceiver) Bind() <-chan ConnStatus {
t.r = rand.New(rand.NewSource(time.Now().UnixNano()))
t.cl.Lock()
defer t.cl.Unlock()
if t.cl.client != nil {
return t.cl.Status
}
t.tx.Lock()
t.tx.inflight = make(map[uint32]chan *tx)
t.tx.Unlock()
c := &client{
Addr: t.Addr,
TLS: t.TLS,
Status: make(chan ConnStatus, 1),
BindFunc: t.bindFunc,
EnquireLink: t.EnquireLink,
EnquireLinkTimeout: t.EnquireLinkTimeout,
RespTimeout: t.RespTimeout,
WindowSize: t.WindowSize,
RateLimiter: t.RateLimiter,
BindInterval: t.BindInterval,
}
t.cl.client = c
c.init()
go c.Bind()
return c.Status
} | go | func (t *Transceiver) Bind() <-chan ConnStatus {
t.r = rand.New(rand.NewSource(time.Now().UnixNano()))
t.cl.Lock()
defer t.cl.Unlock()
if t.cl.client != nil {
return t.cl.Status
}
t.tx.Lock()
t.tx.inflight = make(map[uint32]chan *tx)
t.tx.Unlock()
c := &client{
Addr: t.Addr,
TLS: t.TLS,
Status: make(chan ConnStatus, 1),
BindFunc: t.bindFunc,
EnquireLink: t.EnquireLink,
EnquireLinkTimeout: t.EnquireLinkTimeout,
RespTimeout: t.RespTimeout,
WindowSize: t.WindowSize,
RateLimiter: t.RateLimiter,
BindInterval: t.BindInterval,
}
t.cl.client = c
c.init()
go c.Bind()
return c.Status
} | [
"func",
"(",
"t",
"*",
"Transceiver",
")",
"Bind",
"(",
")",
"<-",
"chan",
"ConnStatus",
"{",
"t",
".",
"r",
"=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
... | // Bind implements the ClientConn interface. | [
"Bind",
"implements",
"the",
"ClientConn",
"interface",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/transceiver.go#L38-L64 |
16,841 | fiorix/go-smpp | smpp/pdu/codec.go | init | func (pdu *codec) init() {
if pdu.l == nil {
pdu.l = pdufield.List{}
}
pdu.f = make(pdufield.Map)
pdu.t = make(pdutlv.Map)
if pdu.h.Seq == 0 { // If Seq not set
pdu.h.Seq = atomic.AddUint32(&nextSeq, 1)
}
} | go | func (pdu *codec) init() {
if pdu.l == nil {
pdu.l = pdufield.List{}
}
pdu.f = make(pdufield.Map)
pdu.t = make(pdutlv.Map)
if pdu.h.Seq == 0 { // If Seq not set
pdu.h.Seq = atomic.AddUint32(&nextSeq, 1)
}
} | [
"func",
"(",
"pdu",
"*",
"codec",
")",
"init",
"(",
")",
"{",
"if",
"pdu",
".",
"l",
"==",
"nil",
"{",
"pdu",
".",
"l",
"=",
"pdufield",
".",
"List",
"{",
"}",
"\n",
"}",
"\n",
"pdu",
".",
"f",
"=",
"make",
"(",
"pdufield",
".",
"Map",
")",... | // init initializes the codec's list and maps and sets the header
// sequence number. | [
"init",
"initializes",
"the",
"codec",
"s",
"list",
"and",
"maps",
"and",
"sets",
"the",
"header",
"sequence",
"number",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/codec.go#L30-L39 |
16,842 | fiorix/go-smpp | smpp/pdu/codec.go | setup | func (pdu *codec) setup(f pdufield.Map, t pdutlv.Map) {
pdu.f, pdu.t = f, t
} | go | func (pdu *codec) setup(f pdufield.Map, t pdutlv.Map) {
pdu.f, pdu.t = f, t
} | [
"func",
"(",
"pdu",
"*",
"codec",
")",
"setup",
"(",
"f",
"pdufield",
".",
"Map",
",",
"t",
"pdutlv",
".",
"Map",
")",
"{",
"pdu",
".",
"f",
",",
"pdu",
".",
"t",
"=",
"f",
",",
"t",
"\n",
"}"
] | // setup replaces the codec's current maps with the given ones. | [
"setup",
"replaces",
"the",
"codec",
"s",
"current",
"maps",
"with",
"the",
"given",
"ones",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/codec.go#L42-L44 |
16,843 | fiorix/go-smpp | smpp/pdu/codec.go | Len | func (pdu *codec) Len() int {
l := HeaderLen
for _, f := range pdu.f {
l += f.Len()
}
for _, t := range pdu.t {
l += t.Len()
}
return l
} | go | func (pdu *codec) Len() int {
l := HeaderLen
for _, f := range pdu.f {
l += f.Len()
}
for _, t := range pdu.t {
l += t.Len()
}
return l
} | [
"func",
"(",
"pdu",
"*",
"codec",
")",
"Len",
"(",
")",
"int",
"{",
"l",
":=",
"HeaderLen",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"pdu",
".",
"f",
"{",
"l",
"+=",
"f",
".",
"Len",
"(",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"t",
":="... | // Len implements the PDU interface. | [
"Len",
"implements",
"the",
"PDU",
"interface",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/codec.go#L52-L61 |
16,844 | fiorix/go-smpp | smpp/pdu/codec.go | SerializeTo | func (pdu *codec) SerializeTo(w io.Writer) error {
var b bytes.Buffer
for _, k := range pdu.FieldList() {
f, ok := pdu.f[k]
if !ok {
pdu.f.Set(k, nil)
f = pdu.f[k]
}
if err := f.SerializeTo(&b); err != nil {
return err
}
}
for _, f := range pdu.TLVFields() {
if err := f.SerializeTo(&b); err != nil {
return err
}
}
pdu.h.Len = uint32(pdu.Len())
err := pdu.h.SerializeTo(w)
if err != nil {
return err
}
_, err = io.Copy(w, &b)
return err
} | go | func (pdu *codec) SerializeTo(w io.Writer) error {
var b bytes.Buffer
for _, k := range pdu.FieldList() {
f, ok := pdu.f[k]
if !ok {
pdu.f.Set(k, nil)
f = pdu.f[k]
}
if err := f.SerializeTo(&b); err != nil {
return err
}
}
for _, f := range pdu.TLVFields() {
if err := f.SerializeTo(&b); err != nil {
return err
}
}
pdu.h.Len = uint32(pdu.Len())
err := pdu.h.SerializeTo(w)
if err != nil {
return err
}
_, err = io.Copy(w, &b)
return err
} | [
"func",
"(",
"pdu",
"*",
"codec",
")",
"SerializeTo",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"pdu",
".",
"FieldList",
"(",
")",
"{",
"f",
",",
"ok",
":=",... | // SerializeTo implements the PDU interface. | [
"SerializeTo",
"implements",
"the",
"PDU",
"interface",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/codec.go#L79-L103 |
16,845 | fiorix/go-smpp | smpp/pdu/pdutext/iso88595.go | Encode | func (s ISO88595) Encode() []byte {
e := charmap.ISO8859_5.NewEncoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | func (s ISO88595) Encode() []byte {
e := charmap.ISO8859_5.NewEncoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | [
"func",
"(",
"s",
"ISO88595",
")",
"Encode",
"(",
")",
"[",
"]",
"byte",
"{",
"e",
":=",
"charmap",
".",
"ISO8859_5",
".",
"NewEncoder",
"(",
")",
"\n",
"es",
",",
"_",
",",
"err",
":=",
"transform",
".",
"Bytes",
"(",
"e",
",",
"s",
")",
"\n",... | // Encode to ISO88595. | [
"Encode",
"to",
"ISO88595",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutext/iso88595.go#L21-L28 |
16,846 | fiorix/go-smpp | smpp/pdu/pdutext/iso88595.go | Decode | func (s ISO88595) Decode() []byte {
e := charmap.ISO8859_5.NewDecoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | func (s ISO88595) Decode() []byte {
e := charmap.ISO8859_5.NewDecoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | [
"func",
"(",
"s",
"ISO88595",
")",
"Decode",
"(",
")",
"[",
"]",
"byte",
"{",
"e",
":=",
"charmap",
".",
"ISO8859_5",
".",
"NewDecoder",
"(",
")",
"\n",
"es",
",",
"_",
",",
"err",
":=",
"transform",
".",
"Bytes",
"(",
"e",
",",
"s",
")",
"\n",... | // Decode from ISO88595. | [
"Decode",
"from",
"ISO88595",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutext/iso88595.go#L31-L38 |
16,847 | fiorix/go-smpp | smpp/pdu/pdutlv/tlv_types.go | Hex | func (t Tag) Hex() string {
bin := make([]byte, 2, 2)
binary.BigEndian.PutUint16(bin, uint16(t))
return hex.EncodeToString(bin)
} | go | func (t Tag) Hex() string {
bin := make([]byte, 2, 2)
binary.BigEndian.PutUint16(bin, uint16(t))
return hex.EncodeToString(bin)
} | [
"func",
"(",
"t",
"Tag",
")",
"Hex",
"(",
")",
"string",
"{",
"bin",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
",",
"2",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"bin",
",",
"uint16",
"(",
"t",
")",
")",
"\n",
"retur... | // Hex returns hexadecimal representation of tag | [
"Hex",
"returns",
"hexadecimal",
"representation",
"of",
"tag"
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutlv/tlv_types.go#L26-L30 |
16,848 | fiorix/go-smpp | smpp/pdu/pdutext/ucs2.go | Encode | func (s UCS2) Encode() []byte {
e := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)
es, _, err := transform.Bytes(e.NewEncoder(), s)
if err != nil {
return s
}
return es
} | go | func (s UCS2) Encode() []byte {
e := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)
es, _, err := transform.Bytes(e.NewEncoder(), s)
if err != nil {
return s
}
return es
} | [
"func",
"(",
"s",
"UCS2",
")",
"Encode",
"(",
")",
"[",
"]",
"byte",
"{",
"e",
":=",
"unicode",
".",
"UTF16",
"(",
"unicode",
".",
"BigEndian",
",",
"unicode",
".",
"IgnoreBOM",
")",
"\n",
"es",
",",
"_",
",",
"err",
":=",
"transform",
".",
"Byte... | // Encode to UCS2. | [
"Encode",
"to",
"UCS2",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutext/ucs2.go#L21-L28 |
16,849 | fiorix/go-smpp | smpp/pdu/pdutext/ucs2.go | Decode | func (s UCS2) Decode() []byte {
e := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)
es, _, err := transform.Bytes(e.NewDecoder(), s)
if err != nil {
return s
}
return es
} | go | func (s UCS2) Decode() []byte {
e := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)
es, _, err := transform.Bytes(e.NewDecoder(), s)
if err != nil {
return s
}
return es
} | [
"func",
"(",
"s",
"UCS2",
")",
"Decode",
"(",
")",
"[",
"]",
"byte",
"{",
"e",
":=",
"unicode",
".",
"UTF16",
"(",
"unicode",
".",
"BigEndian",
",",
"unicode",
".",
"IgnoreBOM",
")",
"\n",
"es",
",",
"_",
",",
"err",
":=",
"transform",
".",
"Byte... | // Decode from UCS2. | [
"Decode",
"from",
"UCS2",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/pdu/pdutext/ucs2.go#L31-L38 |
16,850 | fiorix/go-smpp | smpp/encoding/gsm7.go | ValidateGSM7String | func ValidateGSM7String(text string) []rune {
invalidChars := make([]rune, 0, 4)
for _, r := range text {
if _, ok := forwardLookup[r]; !ok {
if _, ok := forwardEscape[r]; !ok {
invalidChars = append(invalidChars, r)
}
}
}
return invalidChars
} | go | func ValidateGSM7String(text string) []rune {
invalidChars := make([]rune, 0, 4)
for _, r := range text {
if _, ok := forwardLookup[r]; !ok {
if _, ok := forwardEscape[r]; !ok {
invalidChars = append(invalidChars, r)
}
}
}
return invalidChars
} | [
"func",
"ValidateGSM7String",
"(",
"text",
"string",
")",
"[",
"]",
"rune",
"{",
"invalidChars",
":=",
"make",
"(",
"[",
"]",
"rune",
",",
"0",
",",
"4",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"text",
"{",
"if",
"_",
",",
"ok",
":=",
"... | // Returns the characters, in the given text, that can not be represented in GSM 7-bit encoding. | [
"Returns",
"the",
"characters",
"in",
"the",
"given",
"text",
"that",
"can",
"not",
"be",
"represented",
"in",
"GSM",
"7",
"-",
"bit",
"encoding",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/encoding/gsm7.go#L73-L83 |
16,851 | fiorix/go-smpp | smpp/encoding/gsm7.go | ValidateGSM7Buffer | func ValidateGSM7Buffer(buffer []byte) []byte {
invalidBytes := make([]byte, 0, 4)
count := 0
for count < len(buffer) {
b := buffer[count]
if b == escapeSequence {
count++
if count >= len(buffer) {
invalidBytes = append(invalidBytes, b)
break
}
e := buffer[count]
if _, ok := reverseEscape[e]; !ok {
invalidBytes = append(invalidBytes, b, e)
}
} else if _, ok := reverseLookup[b]; !ok {
invalidBytes = append(invalidBytes, b)
}
count++
}
return invalidBytes
} | go | func ValidateGSM7Buffer(buffer []byte) []byte {
invalidBytes := make([]byte, 0, 4)
count := 0
for count < len(buffer) {
b := buffer[count]
if b == escapeSequence {
count++
if count >= len(buffer) {
invalidBytes = append(invalidBytes, b)
break
}
e := buffer[count]
if _, ok := reverseEscape[e]; !ok {
invalidBytes = append(invalidBytes, b, e)
}
} else if _, ok := reverseLookup[b]; !ok {
invalidBytes = append(invalidBytes, b)
}
count++
}
return invalidBytes
} | [
"func",
"ValidateGSM7Buffer",
"(",
"buffer",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"invalidBytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"4",
")",
"\n",
"count",
":=",
"0",
"\n",
"for",
"count",
"<",
"len",
"(",
"buffer",
")... | // Returns the bytes, in the given buffer, that are outside of the GSM 7-bit encoding range. | [
"Returns",
"the",
"bytes",
"in",
"the",
"given",
"buffer",
"that",
"are",
"outside",
"of",
"the",
"GSM",
"7",
"-",
"bit",
"encoding",
"range",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/encoding/gsm7.go#L86-L107 |
16,852 | fiorix/go-smpp | smpp/client.go | Bind | func (c *client) Bind() {
delay := 1.0
const maxdelay = 120.0
for !c.closed() {
eli := make(chan struct{})
c.inbox = make(chan pdu.Body)
conn, err := Dial(c.Addr, c.TLS)
if err != nil {
c.notify(&connStatus{
s: ConnectionFailed,
err: err,
})
goto retry
}
c.conn.Set(conn)
if err = c.BindFunc(c.conn); err != nil {
c.notify(&connStatus{s: BindFailed, err: err})
goto retry
}
go c.enquireLink(eli)
c.notify(&connStatus{s: Connected})
delay = 1
for {
p, err := c.conn.Read()
if err != nil {
c.notify(&connStatus{
s: Disconnected,
err: err,
})
break
}
switch p.Header().ID {
case pdu.EnquireLinkID:
pResp := pdu.NewEnquireLinkRespSeq(p.Header().Seq)
err := c.conn.Write(pResp)
if err != nil {
break
}
case pdu.EnquireLinkRespID:
c.updateEliTime()
default:
c.inbox <- p
}
}
retry:
close(eli)
c.conn.Close()
close(c.inbox)
delayDuration := c.BindInterval
if delayDuration == 0 {
delay = math.Min(delay*math.E, maxdelay)
delayDuration = time.Duration(delay) * time.Second
}
c.trysleep(delayDuration)
}
close(c.Status)
} | go | func (c *client) Bind() {
delay := 1.0
const maxdelay = 120.0
for !c.closed() {
eli := make(chan struct{})
c.inbox = make(chan pdu.Body)
conn, err := Dial(c.Addr, c.TLS)
if err != nil {
c.notify(&connStatus{
s: ConnectionFailed,
err: err,
})
goto retry
}
c.conn.Set(conn)
if err = c.BindFunc(c.conn); err != nil {
c.notify(&connStatus{s: BindFailed, err: err})
goto retry
}
go c.enquireLink(eli)
c.notify(&connStatus{s: Connected})
delay = 1
for {
p, err := c.conn.Read()
if err != nil {
c.notify(&connStatus{
s: Disconnected,
err: err,
})
break
}
switch p.Header().ID {
case pdu.EnquireLinkID:
pResp := pdu.NewEnquireLinkRespSeq(p.Header().Seq)
err := c.conn.Write(pResp)
if err != nil {
break
}
case pdu.EnquireLinkRespID:
c.updateEliTime()
default:
c.inbox <- p
}
}
retry:
close(eli)
c.conn.Close()
close(c.inbox)
delayDuration := c.BindInterval
if delayDuration == 0 {
delay = math.Min(delay*math.E, maxdelay)
delayDuration = time.Duration(delay) * time.Second
}
c.trysleep(delayDuration)
}
close(c.Status)
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Bind",
"(",
")",
"{",
"delay",
":=",
"1.0",
"\n",
"const",
"maxdelay",
"=",
"120.0",
"\n",
"for",
"!",
"c",
".",
"closed",
"(",
")",
"{",
"eli",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
... | // Bind starts the connection manager and blocks until Close is called.
// It must be called in a goroutine. | [
"Bind",
"starts",
"the",
"connection",
"manager",
"and",
"blocks",
"until",
"Close",
"is",
"called",
".",
"It",
"must",
"be",
"called",
"in",
"a",
"goroutine",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L124-L180 |
16,853 | fiorix/go-smpp | smpp/client.go | Read | func (c *client) Read() (pdu.Body, error) {
select {
case pdu := <-c.inbox:
return pdu, nil
case <-c.stop:
return nil, io.EOF
}
} | go | func (c *client) Read() (pdu.Body, error) {
select {
case pdu := <-c.inbox:
return pdu, nil
case <-c.stop:
return nil, io.EOF
}
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Read",
"(",
")",
"(",
"pdu",
".",
"Body",
",",
"error",
")",
"{",
"select",
"{",
"case",
"pdu",
":=",
"<-",
"c",
".",
"inbox",
":",
"return",
"pdu",
",",
"nil",
"\n",
"case",
"<-",
"c",
".",
"stop",
":",... | // Read reads PDU binary data off the wire and returns it. | [
"Read",
"reads",
"PDU",
"binary",
"data",
"off",
"the",
"wire",
"and",
"returns",
"it",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L224-L231 |
16,854 | fiorix/go-smpp | smpp/client.go | Write | func (c *client) Write(w pdu.Body) error {
if c.RateLimiter != nil {
c.RateLimiter.Wait(c.lmctx)
}
return c.conn.Write(w)
} | go | func (c *client) Write(w pdu.Body) error {
if c.RateLimiter != nil {
c.RateLimiter.Wait(c.lmctx)
}
return c.conn.Write(w)
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Write",
"(",
"w",
"pdu",
".",
"Body",
")",
"error",
"{",
"if",
"c",
".",
"RateLimiter",
"!=",
"nil",
"{",
"c",
".",
"RateLimiter",
".",
"Wait",
"(",
"c",
".",
"lmctx",
")",
"\n",
"}",
"\n",
"return",
"c",
... | // Write serializes the given PDU and writes to the connection. | [
"Write",
"serializes",
"the",
"given",
"PDU",
"and",
"writes",
"to",
"the",
"connection",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L234-L239 |
16,855 | fiorix/go-smpp | smpp/client.go | Close | func (c *client) Close() error {
c.once.Do(func() {
close(c.stop)
if err := c.conn.Write(pdu.NewUnbind()); err == nil {
select {
case <-c.inbox: // TODO: validate UnbindResp
case <-time.After(time.Second):
}
}
c.conn.Close()
})
return nil
} | go | func (c *client) Close() error {
c.once.Do(func() {
close(c.stop)
if err := c.conn.Write(pdu.NewUnbind()); err == nil {
select {
case <-c.inbox: // TODO: validate UnbindResp
case <-time.After(time.Second):
}
}
c.conn.Close()
})
return nil
} | [
"func",
"(",
"c",
"*",
"client",
")",
"Close",
"(",
")",
"error",
"{",
"c",
".",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"c",
".",
"stop",
")",
"\n",
"if",
"err",
":=",
"c",
".",
"conn",
".",
"Write",
"(",
"pdu",
".",
... | // Close terminates the current connection and stop any further attempts. | [
"Close",
"terminates",
"the",
"current",
"connection",
"and",
"stop",
"any",
"further",
"attempts",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L242-L254 |
16,856 | fiorix/go-smpp | smpp/client.go | trysleep | func (c *client) trysleep(d time.Duration) {
select {
case <-time.After(d):
case <-c.stop:
}
} | go | func (c *client) trysleep(d time.Duration) {
select {
case <-time.After(d):
case <-c.stop:
}
} | [
"func",
"(",
"c",
"*",
"client",
")",
"trysleep",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"d",
")",
":",
"case",
"<-",
"c",
".",
"stop",
":",
"}",
"\n",
"}"
] | // trysleep for the given duration, or return if Close is called. | [
"trysleep",
"for",
"the",
"given",
"duration",
"or",
"return",
"if",
"Close",
"is",
"called",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L257-L262 |
16,857 | fiorix/go-smpp | smpp/client.go | respTimeout | func (c *client) respTimeout() <-chan time.Time {
if c.RespTimeout == 0 {
return time.After(time.Second)
}
return time.After(c.RespTimeout)
} | go | func (c *client) respTimeout() <-chan time.Time {
if c.RespTimeout == 0 {
return time.After(time.Second)
}
return time.After(c.RespTimeout)
} | [
"func",
"(",
"c",
"*",
"client",
")",
"respTimeout",
"(",
")",
"<-",
"chan",
"time",
".",
"Time",
"{",
"if",
"c",
".",
"RespTimeout",
"==",
"0",
"{",
"return",
"time",
".",
"After",
"(",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"return",
"tim... | // respTimeout returns a channel that fires based on the configured
// response timeout, or the default 1s. | [
"respTimeout",
"returns",
"a",
"channel",
"that",
"fires",
"based",
"on",
"the",
"configured",
"response",
"timeout",
"or",
"the",
"default",
"1s",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L276-L281 |
16,858 | fiorix/go-smpp | smpp/client.go | bind | func bind(c Conn, p pdu.Body) (pdu.Body, error) {
f := p.Fields()
f.Set(pdufield.InterfaceVersion, 0x34)
err := c.Write(p)
if err != nil {
return nil, err
}
resp, err := c.Read()
if err != nil {
return nil, err
}
h := resp.Header()
if h.Status != 0 {
return nil, h.Status
}
return resp, nil
} | go | func bind(c Conn, p pdu.Body) (pdu.Body, error) {
f := p.Fields()
f.Set(pdufield.InterfaceVersion, 0x34)
err := c.Write(p)
if err != nil {
return nil, err
}
resp, err := c.Read()
if err != nil {
return nil, err
}
h := resp.Header()
if h.Status != 0 {
return nil, h.Status
}
return resp, nil
} | [
"func",
"bind",
"(",
"c",
"Conn",
",",
"p",
"pdu",
".",
"Body",
")",
"(",
"pdu",
".",
"Body",
",",
"error",
")",
"{",
"f",
":=",
"p",
".",
"Fields",
"(",
")",
"\n",
"f",
".",
"Set",
"(",
"pdufield",
".",
"InterfaceVersion",
",",
"0x34",
")",
... | // bind attempts to bind the connection. | [
"bind",
"attempts",
"to",
"bind",
"the",
"connection",
"."
] | 6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7 | https://github.com/fiorix/go-smpp/blob/6dbf72b9bcea72cea4a035e3a2fc434c4dabaae7/smpp/client.go#L284-L300 |
16,859 | dedis/protobuf | encode.go | Encode | func Encode(structPtr interface{}) (bytes []byte, err error) {
defer func() {
if e := recover(); e != nil {
err = errors.New(e.(string))
bytes = nil
}
}()
if structPtr == nil {
return nil, nil
}
if bu, ok := structPtr.(encoding.BinaryMarshaler); ok {
return bu.MarshalBinary()
}
en := encoder{}
val := reflect.ValueOf(structPtr)
if val.Kind() != reflect.Ptr {
return nil, errors.New("encode takes a pointer to struct")
}
en.message(val.Elem())
return en.Bytes(), nil
} | go | func Encode(structPtr interface{}) (bytes []byte, err error) {
defer func() {
if e := recover(); e != nil {
err = errors.New(e.(string))
bytes = nil
}
}()
if structPtr == nil {
return nil, nil
}
if bu, ok := structPtr.(encoding.BinaryMarshaler); ok {
return bu.MarshalBinary()
}
en := encoder{}
val := reflect.ValueOf(structPtr)
if val.Kind() != reflect.Ptr {
return nil, errors.New("encode takes a pointer to struct")
}
en.message(val.Elem())
return en.Bytes(), nil
} | [
"func",
"Encode",
"(",
"structPtr",
"interface",
"{",
"}",
")",
"(",
"bytes",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"e",
":=",
"recover",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"err",
"=",
"errors... | // Encode a Go struct into protocol buffer format.
// The caller must pass a pointer to the struct to encode. | [
"Encode",
"a",
"Go",
"struct",
"into",
"protocol",
"buffer",
"format",
".",
"The",
"caller",
"must",
"pass",
"a",
"pointer",
"to",
"the",
"struct",
"to",
"encode",
"."
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/encode.go#L41-L63 |
16,860 | dedis/protobuf | generate.go | GenerateProtobufDefinition | func GenerateProtobufDefinition(w io.Writer, types []interface{}, enumMap EnumMap, renamer GeneratorNamer) (err error) {
defer func() {
if e := recover(); e != nil {
err = errors.New(e.(string))
}
}()
enums := enumTypeMap{}
for name, value := range enumMap {
v := reflect.ValueOf(value)
t := v.Type()
if t.Kind() != reflect.Uint32 {
return fmt.Errorf("enum type aliases must be uint32")
}
if t.Name() == "uint32" {
return fmt.Errorf("enum value must be a type alias, but got uint32")
}
enums[t.Name()] = append(enums[t.Name()], enumValue{name, Enum(v.Uint())})
}
for _, values := range enums {
sort.Sort(values)
}
rt := reflectedTypes{}
for _, t := range types {
typ := reflect.Indirect(reflect.ValueOf(t)).Type()
if typ.Kind() != reflect.Struct {
continue
}
rt = append(rt, typ)
}
sort.Sort(rt)
if renamer == nil {
renamer = &DefaultGeneratorNamer{}
}
t := template.Must(template.New("protobuf").Funcs(template.FuncMap{
"Fields": ProtoFields,
"TypeName": func(f ProtoField) string { return typeName(f, enums, renamer) },
"Options": options,
}).Delims("[[", "]]").Parse(protoTemplate))
return t.Execute(w, map[string]interface{}{
"Renamer": renamer,
"Enums": enums,
"Types": rt,
"Ptr": reflect.Ptr,
"Slice": reflect.Slice,
"Map": reflect.Map,
})
} | go | func GenerateProtobufDefinition(w io.Writer, types []interface{}, enumMap EnumMap, renamer GeneratorNamer) (err error) {
defer func() {
if e := recover(); e != nil {
err = errors.New(e.(string))
}
}()
enums := enumTypeMap{}
for name, value := range enumMap {
v := reflect.ValueOf(value)
t := v.Type()
if t.Kind() != reflect.Uint32 {
return fmt.Errorf("enum type aliases must be uint32")
}
if t.Name() == "uint32" {
return fmt.Errorf("enum value must be a type alias, but got uint32")
}
enums[t.Name()] = append(enums[t.Name()], enumValue{name, Enum(v.Uint())})
}
for _, values := range enums {
sort.Sort(values)
}
rt := reflectedTypes{}
for _, t := range types {
typ := reflect.Indirect(reflect.ValueOf(t)).Type()
if typ.Kind() != reflect.Struct {
continue
}
rt = append(rt, typ)
}
sort.Sort(rt)
if renamer == nil {
renamer = &DefaultGeneratorNamer{}
}
t := template.Must(template.New("protobuf").Funcs(template.FuncMap{
"Fields": ProtoFields,
"TypeName": func(f ProtoField) string { return typeName(f, enums, renamer) },
"Options": options,
}).Delims("[[", "]]").Parse(protoTemplate))
return t.Execute(w, map[string]interface{}{
"Renamer": renamer,
"Enums": enums,
"Types": rt,
"Ptr": reflect.Ptr,
"Slice": reflect.Slice,
"Map": reflect.Map,
})
} | [
"func",
"GenerateProtobufDefinition",
"(",
"w",
"io",
".",
"Writer",
",",
"types",
"[",
"]",
"interface",
"{",
"}",
",",
"enumMap",
"EnumMap",
",",
"renamer",
"GeneratorNamer",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"... | // GenerateProtobufDefinition generates a .proto file from a list of structs via reflection.
// fieldNamer is a function that maps ProtoField types to generated protobuf field names. | [
"GenerateProtobufDefinition",
"generates",
"a",
".",
"proto",
"file",
"from",
"a",
"list",
"of",
"structs",
"via",
"reflection",
".",
"fieldNamer",
"is",
"a",
"function",
"that",
"maps",
"ProtoField",
"types",
"to",
"generated",
"protobuf",
"field",
"names",
"."... | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/generate.go#L214-L260 |
16,861 | dedis/protobuf | decode.go | String | func (c *Constructors) String() string {
var s string
for k := range *c {
s += k.String() + "=>" + "(func() interface {})" + "\t"
}
return s
} | go | func (c *Constructors) String() string {
var s string
for k := range *c {
s += k.String() + "=>" + "(func() interface {})" + "\t"
}
return s
} | [
"func",
"(",
"c",
"*",
"Constructors",
")",
"String",
"(",
")",
"string",
"{",
"var",
"s",
"string",
"\n",
"for",
"k",
":=",
"range",
"*",
"c",
"{",
"s",
"+=",
"k",
".",
"String",
"(",
")",
"+",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"\"",
"\\t",
... | // String returns an easy way to visualize what you have in your constructors. | [
"String",
"returns",
"an",
"easy",
"way",
"to",
"visualize",
"what",
"you",
"have",
"in",
"your",
"constructors",
"."
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/decode.go#L24-L30 |
16,862 | dedis/protobuf | decode.go | DecodeWithConstructors | func DecodeWithConstructors(buf []byte, structPtr interface{}, cons Constructors) (err error) {
defer func() {
if r := recover(); r != nil {
switch e := r.(type) {
case string:
err = errors.New(e)
case error:
err = e
default:
err = errors.New("Failed to decode the field")
}
}
}()
if structPtr == nil {
return nil
}
if bu, ok := structPtr.(encoding.BinaryUnmarshaler); ok {
return bu.UnmarshalBinary(buf)
}
de := decoder{cons}
val := reflect.ValueOf(structPtr)
// if its NOT a pointer, it is bad return an error
if val.Kind() != reflect.Ptr {
return errors.New("Decode has been given a non pointer type")
}
return de.message(buf, val.Elem())
} | go | func DecodeWithConstructors(buf []byte, structPtr interface{}, cons Constructors) (err error) {
defer func() {
if r := recover(); r != nil {
switch e := r.(type) {
case string:
err = errors.New(e)
case error:
err = e
default:
err = errors.New("Failed to decode the field")
}
}
}()
if structPtr == nil {
return nil
}
if bu, ok := structPtr.(encoding.BinaryUnmarshaler); ok {
return bu.UnmarshalBinary(buf)
}
de := decoder{cons}
val := reflect.ValueOf(structPtr)
// if its NOT a pointer, it is bad return an error
if val.Kind() != reflect.Ptr {
return errors.New("Decode has been given a non pointer type")
}
return de.message(buf, val.Elem())
} | [
"func",
"DecodeWithConstructors",
"(",
"buf",
"[",
"]",
"byte",
",",
"structPtr",
"interface",
"{",
"}",
",",
"cons",
"Constructors",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
... | // DecodeWithConstructors is like Decode, but you can pass a map of
// constructors with which to instantiate interface types. | [
"DecodeWithConstructors",
"is",
"like",
"Decode",
"but",
"you",
"can",
"pass",
"a",
"map",
"of",
"constructors",
"with",
"which",
"to",
"instantiate",
"interface",
"types",
"."
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/decode.go#L51-L79 |
16,863 | dedis/protobuf | decode.go | message | func (de *decoder) message(buf []byte, sval reflect.Value) error {
if sval.Kind() != reflect.Struct {
return errors.New("not a struct")
}
// Decode all the fields
fields := ProtoFields(sval.Type())
fieldi := 0
for len(buf) > 0 {
// Parse the key
key, n := binary.Uvarint(buf)
if n <= 0 {
return errors.New("bad protobuf field key")
}
buf = buf[n:]
wiretype := int(key & 7)
fieldnum := key >> 3
// Lookup the corresponding struct field.
// Leave field with a zero Value if fieldnum is out-of-range.
// In this case, as well as for blank fields,
// value() will just skip over and discard the field content.
var field reflect.Value
for fieldi < len(fields) && fields[fieldi].ID < int64(fieldnum) {
fieldi++
}
if fieldi < len(fields) && fields[fieldi].ID == int64(fieldnum) {
// For fields within embedded structs, ensure the embedded values aren't nil.
index := fields[fieldi].Index
path := make([]int, 0, len(index))
for _, id := range index {
path = append(path, id)
field = sval.FieldByIndex(path)
if field.Kind() == reflect.Ptr && field.IsNil() {
field.Set(reflect.New(field.Type().Elem()))
}
}
}
// For more debugging output, uncomment the following three lines.
// if fieldi < len(fields){
// fmt.Printf("Decoding FieldName %+v\n", fields[fieldi].Field)
// }
// Decode the field's value
rem, err := de.value(wiretype, buf, field)
if err != nil {
if fieldi < len(fields) && fields[fieldi] != nil {
return fmt.Errorf("Error while decoding field %+v: %v", fields[fieldi].Field, err)
}
return err
}
buf = rem
}
return nil
} | go | func (de *decoder) message(buf []byte, sval reflect.Value) error {
if sval.Kind() != reflect.Struct {
return errors.New("not a struct")
}
// Decode all the fields
fields := ProtoFields(sval.Type())
fieldi := 0
for len(buf) > 0 {
// Parse the key
key, n := binary.Uvarint(buf)
if n <= 0 {
return errors.New("bad protobuf field key")
}
buf = buf[n:]
wiretype := int(key & 7)
fieldnum := key >> 3
// Lookup the corresponding struct field.
// Leave field with a zero Value if fieldnum is out-of-range.
// In this case, as well as for blank fields,
// value() will just skip over and discard the field content.
var field reflect.Value
for fieldi < len(fields) && fields[fieldi].ID < int64(fieldnum) {
fieldi++
}
if fieldi < len(fields) && fields[fieldi].ID == int64(fieldnum) {
// For fields within embedded structs, ensure the embedded values aren't nil.
index := fields[fieldi].Index
path := make([]int, 0, len(index))
for _, id := range index {
path = append(path, id)
field = sval.FieldByIndex(path)
if field.Kind() == reflect.Ptr && field.IsNil() {
field.Set(reflect.New(field.Type().Elem()))
}
}
}
// For more debugging output, uncomment the following three lines.
// if fieldi < len(fields){
// fmt.Printf("Decoding FieldName %+v\n", fields[fieldi].Field)
// }
// Decode the field's value
rem, err := de.value(wiretype, buf, field)
if err != nil {
if fieldi < len(fields) && fields[fieldi] != nil {
return fmt.Errorf("Error while decoding field %+v: %v", fields[fieldi].Field, err)
}
return err
}
buf = rem
}
return nil
} | [
"func",
"(",
"de",
"*",
"decoder",
")",
"message",
"(",
"buf",
"[",
"]",
"byte",
",",
"sval",
"reflect",
".",
"Value",
")",
"error",
"{",
"if",
"sval",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"errors",
".",
"New",
"(... | // Decode a Protocol Buffers message into a Go struct.
// The Kind of the passed value v must be Struct. | [
"Decode",
"a",
"Protocol",
"Buffers",
"message",
"into",
"a",
"Go",
"struct",
".",
"The",
"Kind",
"of",
"the",
"passed",
"value",
"v",
"must",
"be",
"Struct",
"."
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/decode.go#L83-L139 |
16,864 | dedis/protobuf | decode.go | value | func (de *decoder) value(wiretype int, buf []byte,
val reflect.Value) ([]byte, error) {
// Break out the value from the buffer based on the wire type
var v uint64
var n int
var vb []byte
switch wiretype {
case 0: // varint
v, n = binary.Uvarint(buf)
if n <= 0 {
return nil, errors.New("bad protobuf varint value")
}
buf = buf[n:]
case 5: // 32-bit
if len(buf) < 4 {
return nil, errors.New("bad protobuf 32-bit value")
}
v = uint64(buf[0]) |
uint64(buf[1])<<8 |
uint64(buf[2])<<16 |
uint64(buf[3])<<24
buf = buf[4:]
case 1: // 64-bit
if len(buf) < 8 {
return nil, errors.New("bad protobuf 64-bit value")
}
v = uint64(buf[0]) |
uint64(buf[1])<<8 |
uint64(buf[2])<<16 |
uint64(buf[3])<<24 |
uint64(buf[4])<<32 |
uint64(buf[5])<<40 |
uint64(buf[6])<<48 |
uint64(buf[7])<<56
buf = buf[8:]
case 2: // length-delimited
v, n = binary.Uvarint(buf)
if n <= 0 || v > uint64(len(buf)-n) {
return nil, errors.New(
"bad protobuf length-delimited value")
}
vb = buf[n : n+int(v) : n+int(v)]
buf = buf[n+int(v):]
default:
return nil, errors.New("unknown protobuf wire-type")
}
// We've gotten the value out of the buffer,
// now put it into the appropriate reflective Value.
if err := de.putvalue(wiretype, val, v, vb); err != nil {
return nil, err
}
return buf, nil
} | go | func (de *decoder) value(wiretype int, buf []byte,
val reflect.Value) ([]byte, error) {
// Break out the value from the buffer based on the wire type
var v uint64
var n int
var vb []byte
switch wiretype {
case 0: // varint
v, n = binary.Uvarint(buf)
if n <= 0 {
return nil, errors.New("bad protobuf varint value")
}
buf = buf[n:]
case 5: // 32-bit
if len(buf) < 4 {
return nil, errors.New("bad protobuf 32-bit value")
}
v = uint64(buf[0]) |
uint64(buf[1])<<8 |
uint64(buf[2])<<16 |
uint64(buf[3])<<24
buf = buf[4:]
case 1: // 64-bit
if len(buf) < 8 {
return nil, errors.New("bad protobuf 64-bit value")
}
v = uint64(buf[0]) |
uint64(buf[1])<<8 |
uint64(buf[2])<<16 |
uint64(buf[3])<<24 |
uint64(buf[4])<<32 |
uint64(buf[5])<<40 |
uint64(buf[6])<<48 |
uint64(buf[7])<<56
buf = buf[8:]
case 2: // length-delimited
v, n = binary.Uvarint(buf)
if n <= 0 || v > uint64(len(buf)-n) {
return nil, errors.New(
"bad protobuf length-delimited value")
}
vb = buf[n : n+int(v) : n+int(v)]
buf = buf[n+int(v):]
default:
return nil, errors.New("unknown protobuf wire-type")
}
// We've gotten the value out of the buffer,
// now put it into the appropriate reflective Value.
if err := de.putvalue(wiretype, val, v, vb); err != nil {
return nil, err
}
return buf, nil
} | [
"func",
"(",
"de",
"*",
"decoder",
")",
"value",
"(",
"wiretype",
"int",
",",
"buf",
"[",
"]",
"byte",
",",
"val",
"reflect",
".",
"Value",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Break out the value from the buffer based on the wire type",
... | // Pull a value from the buffer and put it into a reflective Value. | [
"Pull",
"a",
"value",
"from",
"the",
"buffer",
"and",
"put",
"it",
"into",
"a",
"reflective",
"Value",
"."
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/decode.go#L142-L200 |
16,865 | dedis/protobuf | decode.go | instantiate | func (de *decoder) instantiate(t reflect.Type) reflect.Value {
// If it's an interface type, lookup a dynamic constructor for it.
if t.Kind() == reflect.Interface {
newfunc, ok := de.nm[t]
if !ok {
panic("no constructor for interface " + t.String())
}
return reflect.ValueOf(newfunc())
}
// Otherwise, for all concrete types, just instantiate directly.
return reflect.New(t)
} | go | func (de *decoder) instantiate(t reflect.Type) reflect.Value {
// If it's an interface type, lookup a dynamic constructor for it.
if t.Kind() == reflect.Interface {
newfunc, ok := de.nm[t]
if !ok {
panic("no constructor for interface " + t.String())
}
return reflect.ValueOf(newfunc())
}
// Otherwise, for all concrete types, just instantiate directly.
return reflect.New(t)
} | [
"func",
"(",
"de",
"*",
"decoder",
")",
"instantiate",
"(",
"t",
"reflect",
".",
"Type",
")",
"reflect",
".",
"Value",
"{",
"// If it's an interface type, lookup a dynamic constructor for it.",
"if",
"t",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Interface",... | // Instantiate an arbitrary type, handling dynamic interface types.
// Returns a Ptr value. | [
"Instantiate",
"an",
"arbitrary",
"type",
"handling",
"dynamic",
"interface",
"types",
".",
"Returns",
"a",
"Ptr",
"value",
"."
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/decode.go#L369-L382 |
16,866 | dedis/protobuf | decode.go | slice | func (de *decoder) slice(slval reflect.Value, vb []byte) error {
// Find the element type, and create a temporary instance of it.
eltype := slval.Type().Elem()
val := reflect.New(eltype).Elem()
// Decide on the wiretype to use for decoding.
var wiretype int
switch eltype.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Int,
reflect.Uint32, reflect.Uint64, reflect.Uint:
if (eltype.Kind() == reflect.Int || eltype.Kind() == reflect.Uint) && eltype.Size() < 8 {
return errors.New("detected a 32bit machine, please either use (u)int64 or (u)int32")
}
switch eltype {
case sfixed32type:
wiretype = 5 // Packed 32-bit representation
case sfixed64type:
wiretype = 1 // Packed 64-bit representation
case ufixed32type:
wiretype = 5 // Packed 32-bit representation
case ufixed64type:
wiretype = 1 // Packed 64-bit representation
default:
wiretype = 0 // Packed varint representation
}
case reflect.Float32:
wiretype = 5 // Packed 32-bit representation
case reflect.Float64:
wiretype = 1 // Packed 64-bit representation
case reflect.Uint8: // Unpacked byte-slice
if slval.Kind() == reflect.Array {
if slval.Len() != len(vb) {
return errors.New("array length and buffer length differ")
}
for i := 0; i < slval.Len(); i++ {
// no SetByte method in reflect so has to pass down by uint64
slval.Index(i).SetUint(uint64(vb[i]))
}
} else {
slval.SetBytes(vb)
}
return nil
default: // Other unpacked repeated types
// Just unpack and append one value from vb.
if err := de.putvalue(2, val, 0, vb); err != nil {
return err
}
if slval.Kind() != reflect.Slice {
return errors.New("append to non-slice")
}
slval.Set(reflect.Append(slval, val))
return nil
}
// Decode packed values from the buffer and append them to the slice.
for len(vb) > 0 {
rem, err := de.value(wiretype, vb, val)
if err != nil {
return err
}
slval.Set(reflect.Append(slval, val))
vb = rem
}
return nil
} | go | func (de *decoder) slice(slval reflect.Value, vb []byte) error {
// Find the element type, and create a temporary instance of it.
eltype := slval.Type().Elem()
val := reflect.New(eltype).Elem()
// Decide on the wiretype to use for decoding.
var wiretype int
switch eltype.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Int,
reflect.Uint32, reflect.Uint64, reflect.Uint:
if (eltype.Kind() == reflect.Int || eltype.Kind() == reflect.Uint) && eltype.Size() < 8 {
return errors.New("detected a 32bit machine, please either use (u)int64 or (u)int32")
}
switch eltype {
case sfixed32type:
wiretype = 5 // Packed 32-bit representation
case sfixed64type:
wiretype = 1 // Packed 64-bit representation
case ufixed32type:
wiretype = 5 // Packed 32-bit representation
case ufixed64type:
wiretype = 1 // Packed 64-bit representation
default:
wiretype = 0 // Packed varint representation
}
case reflect.Float32:
wiretype = 5 // Packed 32-bit representation
case reflect.Float64:
wiretype = 1 // Packed 64-bit representation
case reflect.Uint8: // Unpacked byte-slice
if slval.Kind() == reflect.Array {
if slval.Len() != len(vb) {
return errors.New("array length and buffer length differ")
}
for i := 0; i < slval.Len(); i++ {
// no SetByte method in reflect so has to pass down by uint64
slval.Index(i).SetUint(uint64(vb[i]))
}
} else {
slval.SetBytes(vb)
}
return nil
default: // Other unpacked repeated types
// Just unpack and append one value from vb.
if err := de.putvalue(2, val, 0, vb); err != nil {
return err
}
if slval.Kind() != reflect.Slice {
return errors.New("append to non-slice")
}
slval.Set(reflect.Append(slval, val))
return nil
}
// Decode packed values from the buffer and append them to the slice.
for len(vb) > 0 {
rem, err := de.value(wiretype, vb, val)
if err != nil {
return err
}
slval.Set(reflect.Append(slval, val))
vb = rem
}
return nil
} | [
"func",
"(",
"de",
"*",
"decoder",
")",
"slice",
"(",
"slval",
"reflect",
".",
"Value",
",",
"vb",
"[",
"]",
"byte",
")",
"error",
"{",
"// Find the element type, and create a temporary instance of it.",
"eltype",
":=",
"slval",
".",
"Type",
"(",
")",
".",
"... | // Handle decoding of slices | [
"Handle",
"decoding",
"of",
"slices"
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/decode.go#L390-L459 |
16,867 | dedis/protobuf | interface.go | register | func (ir *generatorRegistry) register(g InterfaceGeneratorFunc) {
val, ok := g().(InterfaceMarshaler)
if !ok {
panic("Implementation of the interface must fulfilled InterfaceMarshaler")
}
key := val.MarshalID()
ir.generators[key] = g
} | go | func (ir *generatorRegistry) register(g InterfaceGeneratorFunc) {
val, ok := g().(InterfaceMarshaler)
if !ok {
panic("Implementation of the interface must fulfilled InterfaceMarshaler")
}
key := val.MarshalID()
ir.generators[key] = g
} | [
"func",
"(",
"ir",
"*",
"generatorRegistry",
")",
"register",
"(",
"g",
"InterfaceGeneratorFunc",
")",
"{",
"val",
",",
"ok",
":=",
"g",
"(",
")",
".",
"(",
"InterfaceMarshaler",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
... | // register gets the type tag and map it to the generator function | [
"register",
"gets",
"the",
"type",
"tag",
"and",
"map",
"it",
"to",
"the",
"generator",
"function"
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/interface.go#L34-L42 |
16,868 | dedis/protobuf | interface.go | get | func (ir *generatorRegistry) get(key GeneratorID) InterfaceGeneratorFunc {
g, _ := ir.generators[key]
return g
} | go | func (ir *generatorRegistry) get(key GeneratorID) InterfaceGeneratorFunc {
g, _ := ir.generators[key]
return g
} | [
"func",
"(",
"ir",
"*",
"generatorRegistry",
")",
"get",
"(",
"key",
"GeneratorID",
")",
"InterfaceGeneratorFunc",
"{",
"g",
",",
"_",
":=",
"ir",
".",
"generators",
"[",
"key",
"]",
"\n",
"return",
"g",
"\n",
"}"
] | // get returns the generator associated with the tag | [
"get",
"returns",
"the",
"generator",
"associated",
"with",
"the",
"tag"
] | aaafc048527b821ddbe59e5a81fe5c05a61166b4 | https://github.com/dedis/protobuf/blob/aaafc048527b821ddbe59e5a81fe5c05a61166b4/interface.go#L45-L48 |
16,869 | coreos/coreos-cloudinit | system/file.go | WriteFile | func WriteFile(f *File, root string) (string, error) {
if f.Encoding != "" {
return "", fmt.Errorf("Unable to write file with encoding %s", f.Encoding)
}
fullpath := path.Join(root, f.Path)
dir := path.Dir(fullpath)
log.Printf("Writing file to %q", fullpath)
if err := EnsureDirectoryExists(dir); err != nil {
return "", err
}
perm, err := f.Permissions()
if err != nil {
return "", err
}
var tmp *os.File
// Create a temporary file in the same directory to ensure it's on the same filesystem
if tmp, err = ioutil.TempFile(dir, "cloudinit-temp"); err != nil {
return "", err
}
if err := ioutil.WriteFile(tmp.Name(), []byte(f.Content), perm); err != nil {
return "", err
}
if err := tmp.Close(); err != nil {
return "", err
}
// Ensure the permissions are as requested (since WriteFile can be affected by sticky bit)
if err := os.Chmod(tmp.Name(), perm); err != nil {
return "", err
}
if f.Owner != "" {
// We shell out since we don't have a way to look up unix groups natively
cmd := exec.Command("chown", f.Owner, tmp.Name())
if err := cmd.Run(); err != nil {
return "", err
}
}
if err := os.Rename(tmp.Name(), fullpath); err != nil {
return "", err
}
log.Printf("Wrote file to %q", fullpath)
return fullpath, nil
} | go | func WriteFile(f *File, root string) (string, error) {
if f.Encoding != "" {
return "", fmt.Errorf("Unable to write file with encoding %s", f.Encoding)
}
fullpath := path.Join(root, f.Path)
dir := path.Dir(fullpath)
log.Printf("Writing file to %q", fullpath)
if err := EnsureDirectoryExists(dir); err != nil {
return "", err
}
perm, err := f.Permissions()
if err != nil {
return "", err
}
var tmp *os.File
// Create a temporary file in the same directory to ensure it's on the same filesystem
if tmp, err = ioutil.TempFile(dir, "cloudinit-temp"); err != nil {
return "", err
}
if err := ioutil.WriteFile(tmp.Name(), []byte(f.Content), perm); err != nil {
return "", err
}
if err := tmp.Close(); err != nil {
return "", err
}
// Ensure the permissions are as requested (since WriteFile can be affected by sticky bit)
if err := os.Chmod(tmp.Name(), perm); err != nil {
return "", err
}
if f.Owner != "" {
// We shell out since we don't have a way to look up unix groups natively
cmd := exec.Command("chown", f.Owner, tmp.Name())
if err := cmd.Run(); err != nil {
return "", err
}
}
if err := os.Rename(tmp.Name(), fullpath); err != nil {
return "", err
}
log.Printf("Wrote file to %q", fullpath)
return fullpath, nil
} | [
"func",
"WriteFile",
"(",
"f",
"*",
"File",
",",
"root",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"f",
".",
"Encoding",
"!=",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"f",
".",
... | // WriteFile writes given endecoded file to the filesystem | [
"WriteFile",
"writes",
"given",
"endecoded",
"file",
"to",
"the",
"filesystem"
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/file.go#L49-L100 |
16,870 | coreos/coreos-cloudinit | system/ssh_key.go | AuthorizeSSHKeys | func AuthorizeSSHKeys(user string, keysName string, keys []string) error {
for i, key := range keys {
keys[i] = strings.TrimSpace(key)
}
// join all keys with newlines, ensuring the resulting string
// also ends with a newline
joined := fmt.Sprintf("%s\n", strings.Join(keys, "\n"))
cmd := exec.Command("update-ssh-keys", "-u", user, "-a", keysName)
stdin, err := cmd.StdinPipe()
if err != nil {
return err
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
err = cmd.Start()
if err != nil {
stdin.Close()
return err
}
_, err = io.WriteString(stdin, joined)
if err != nil {
return err
}
stdin.Close()
stdoutBytes, _ := ioutil.ReadAll(stdout)
stderrBytes, _ := ioutil.ReadAll(stderr)
err = cmd.Wait()
if err != nil {
return fmt.Errorf("Call to update-ssh-keys failed with %v: %s %s", err, string(stdoutBytes), string(stderrBytes))
}
return nil
} | go | func AuthorizeSSHKeys(user string, keysName string, keys []string) error {
for i, key := range keys {
keys[i] = strings.TrimSpace(key)
}
// join all keys with newlines, ensuring the resulting string
// also ends with a newline
joined := fmt.Sprintf("%s\n", strings.Join(keys, "\n"))
cmd := exec.Command("update-ssh-keys", "-u", user, "-a", keysName)
stdin, err := cmd.StdinPipe()
if err != nil {
return err
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
err = cmd.Start()
if err != nil {
stdin.Close()
return err
}
_, err = io.WriteString(stdin, joined)
if err != nil {
return err
}
stdin.Close()
stdoutBytes, _ := ioutil.ReadAll(stdout)
stderrBytes, _ := ioutil.ReadAll(stderr)
err = cmd.Wait()
if err != nil {
return fmt.Errorf("Call to update-ssh-keys failed with %v: %s %s", err, string(stdoutBytes), string(stderrBytes))
}
return nil
} | [
"func",
"AuthorizeSSHKeys",
"(",
"user",
"string",
",",
"keysName",
"string",
",",
"keys",
"[",
"]",
"string",
")",
"error",
"{",
"for",
"i",
",",
"key",
":=",
"range",
"keys",
"{",
"keys",
"[",
"i",
"]",
"=",
"strings",
".",
"TrimSpace",
"(",
"key",... | // Add the provide SSH public key to the core user's list of
// authorized keys | [
"Add",
"the",
"provide",
"SSH",
"public",
"key",
"to",
"the",
"core",
"user",
"s",
"list",
"of",
"authorized",
"keys"
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/ssh_key.go#L27-L73 |
16,871 | coreos/coreos-cloudinit | config/validate/report.go | Error | func (r *Report) Error(line int, message string) {
r.entries = append(r.entries, Entry{entryError, message, line})
} | go | func (r *Report) Error(line int, message string) {
r.entries = append(r.entries, Entry{entryError, message, line})
} | [
"func",
"(",
"r",
"*",
"Report",
")",
"Error",
"(",
"line",
"int",
",",
"message",
"string",
")",
"{",
"r",
".",
"entries",
"=",
"append",
"(",
"r",
".",
"entries",
",",
"Entry",
"{",
"entryError",
",",
"message",
",",
"line",
"}",
")",
"\n",
"}"... | // Error adds an error entry to the report. | [
"Error",
"adds",
"an",
"error",
"entry",
"to",
"the",
"report",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/report.go#L28-L30 |
16,872 | coreos/coreos-cloudinit | config/validate/report.go | Warning | func (r *Report) Warning(line int, message string) {
r.entries = append(r.entries, Entry{entryWarning, message, line})
} | go | func (r *Report) Warning(line int, message string) {
r.entries = append(r.entries, Entry{entryWarning, message, line})
} | [
"func",
"(",
"r",
"*",
"Report",
")",
"Warning",
"(",
"line",
"int",
",",
"message",
"string",
")",
"{",
"r",
".",
"entries",
"=",
"append",
"(",
"r",
".",
"entries",
",",
"Entry",
"{",
"entryWarning",
",",
"message",
",",
"line",
"}",
")",
"\n",
... | // Warning adds a warning entry to the report. | [
"Warning",
"adds",
"a",
"warning",
"entry",
"to",
"the",
"report",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/report.go#L33-L35 |
16,873 | coreos/coreos-cloudinit | config/validate/report.go | Info | func (r *Report) Info(line int, message string) {
r.entries = append(r.entries, Entry{entryInfo, message, line})
} | go | func (r *Report) Info(line int, message string) {
r.entries = append(r.entries, Entry{entryInfo, message, line})
} | [
"func",
"(",
"r",
"*",
"Report",
")",
"Info",
"(",
"line",
"int",
",",
"message",
"string",
")",
"{",
"r",
".",
"entries",
"=",
"append",
"(",
"r",
".",
"entries",
",",
"Entry",
"{",
"entryInfo",
",",
"message",
",",
"line",
"}",
")",
"\n",
"}"
] | // Info adds an info entry to the report. | [
"Info",
"adds",
"an",
"info",
"entry",
"to",
"the",
"report",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/report.go#L38-L40 |
16,874 | coreos/coreos-cloudinit | config/validate/report.go | String | func (e Entry) String() string {
return fmt.Sprintf("line %d: %s: %s", e.line, e.kind, e.message)
} | go | func (e Entry) String() string {
return fmt.Sprintf("line %d: %s: %s", e.line, e.kind, e.message)
} | [
"func",
"(",
"e",
"Entry",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"line",
",",
"e",
".",
"kind",
",",
"e",
".",
"message",
")",
"\n",
"}"
] | // String returns a human-readable representation of the entry. | [
"String",
"returns",
"a",
"human",
"-",
"readable",
"representation",
"of",
"the",
"entry",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/report.go#L55-L57 |
16,875 | coreos/coreos-cloudinit | config/validate/report.go | MarshalJSON | func (e Entry) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"kind": e.kind.String(),
"message": e.message,
"line": e.line,
})
} | go | func (e Entry) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"kind": e.kind.String(),
"message": e.message,
"line": e.line,
})
} | [
"func",
"(",
"e",
"Entry",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"json",
".",
"Marshal",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"e",
".",
"kind",
".",
"Strin... | // MarshalJSON satisfies the json.Marshaler interface, returning the entry
// encoded as a JSON object. | [
"MarshalJSON",
"satisfies",
"the",
"json",
".",
"Marshaler",
"interface",
"returning",
"the",
"entry",
"encoded",
"as",
"a",
"JSON",
"object",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/report.go#L61-L67 |
16,876 | coreos/coreos-cloudinit | system/systemd.go | PlaceUnit | func (s *systemd) PlaceUnit(u Unit) error {
file := File{config.File{
Path: u.Destination(s.root),
Content: u.Content,
RawFilePermissions: "0644",
}}
_, err := WriteFile(&file, "/")
return err
} | go | func (s *systemd) PlaceUnit(u Unit) error {
file := File{config.File{
Path: u.Destination(s.root),
Content: u.Content,
RawFilePermissions: "0644",
}}
_, err := WriteFile(&file, "/")
return err
} | [
"func",
"(",
"s",
"*",
"systemd",
")",
"PlaceUnit",
"(",
"u",
"Unit",
")",
"error",
"{",
"file",
":=",
"File",
"{",
"config",
".",
"File",
"{",
"Path",
":",
"u",
".",
"Destination",
"(",
"s",
".",
"root",
")",
",",
"Content",
":",
"u",
".",
"Co... | // PlaceUnit writes a unit file at its desired destination, creating parent
// directories as necessary. | [
"PlaceUnit",
"writes",
"a",
"unit",
"file",
"at",
"its",
"desired",
"destination",
"creating",
"parent",
"directories",
"as",
"necessary",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/systemd.go#L44-L53 |
16,877 | coreos/coreos-cloudinit | system/systemd.go | PlaceUnitDropIn | func (s *systemd) PlaceUnitDropIn(u Unit, d config.UnitDropIn) error {
file := File{config.File{
Path: u.DropInDestination(s.root, d),
Content: d.Content,
RawFilePermissions: "0644",
}}
_, err := WriteFile(&file, "/")
return err
} | go | func (s *systemd) PlaceUnitDropIn(u Unit, d config.UnitDropIn) error {
file := File{config.File{
Path: u.DropInDestination(s.root, d),
Content: d.Content,
RawFilePermissions: "0644",
}}
_, err := WriteFile(&file, "/")
return err
} | [
"func",
"(",
"s",
"*",
"systemd",
")",
"PlaceUnitDropIn",
"(",
"u",
"Unit",
",",
"d",
"config",
".",
"UnitDropIn",
")",
"error",
"{",
"file",
":=",
"File",
"{",
"config",
".",
"File",
"{",
"Path",
":",
"u",
".",
"DropInDestination",
"(",
"s",
".",
... | // PlaceUnitDropIn writes a unit drop-in file at its desired destination,
// creating parent directories as necessary. | [
"PlaceUnitDropIn",
"writes",
"a",
"unit",
"drop",
"-",
"in",
"file",
"at",
"its",
"desired",
"destination",
"creating",
"parent",
"directories",
"as",
"necessary",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/systemd.go#L57-L66 |
16,878 | coreos/coreos-cloudinit | config/validate/node.go | Child | func (n node) Child(name string) node {
for _, c := range n.children {
if c.name == name {
return c
}
}
return node{}
} | go | func (n node) Child(name string) node {
for _, c := range n.children {
if c.name == name {
return c
}
}
return node{}
} | [
"func",
"(",
"n",
"node",
")",
"Child",
"(",
"name",
"string",
")",
"node",
"{",
"for",
"_",
",",
"c",
":=",
"range",
"n",
".",
"children",
"{",
"if",
"c",
".",
"name",
"==",
"name",
"{",
"return",
"c",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"... | // Child attempts to find the child with the given name in the node's list of
// children. If no such child is found, an invalid node is returned. | [
"Child",
"attempts",
"to",
"find",
"the",
"child",
"with",
"the",
"given",
"name",
"in",
"the",
"node",
"s",
"list",
"of",
"children",
".",
"If",
"no",
"such",
"child",
"is",
"found",
"an",
"invalid",
"node",
"is",
"returned",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/node.go#L38-L45 |
16,879 | coreos/coreos-cloudinit | config/validate/node.go | HumanType | func (n node) HumanType() string {
switch k := n.Kind(); k {
case reflect.Slice:
c := n.Type().Elem()
return "[]" + node{Value: reflect.New(c).Elem()}.HumanType()
default:
return k.String()
}
} | go | func (n node) HumanType() string {
switch k := n.Kind(); k {
case reflect.Slice:
c := n.Type().Elem()
return "[]" + node{Value: reflect.New(c).Elem()}.HumanType()
default:
return k.String()
}
} | [
"func",
"(",
"n",
"node",
")",
"HumanType",
"(",
")",
"string",
"{",
"switch",
"k",
":=",
"n",
".",
"Kind",
"(",
")",
";",
"k",
"{",
"case",
"reflect",
".",
"Slice",
":",
"c",
":=",
"n",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
"\n",
"... | // HumanType returns the human-consumable string representation of the type of
// the node. | [
"HumanType",
"returns",
"the",
"human",
"-",
"consumable",
"string",
"representation",
"of",
"the",
"type",
"of",
"the",
"node",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/node.go#L49-L57 |
16,880 | coreos/coreos-cloudinit | config/validate/node.go | NewNode | func NewNode(value interface{}, context context) node {
var n node
toNode(value, context, &n)
return n
} | go | func NewNode(value interface{}, context context) node {
var n node
toNode(value, context, &n)
return n
} | [
"func",
"NewNode",
"(",
"value",
"interface",
"{",
"}",
",",
"context",
"context",
")",
"node",
"{",
"var",
"n",
"node",
"\n",
"toNode",
"(",
"value",
",",
"context",
",",
"&",
"n",
")",
"\n",
"return",
"n",
"\n",
"}"
] | // NewNode returns the node representation of the given value. The context
// will be used in an attempt to determine line numbers for the given value. | [
"NewNode",
"returns",
"the",
"node",
"representation",
"of",
"the",
"given",
"value",
".",
"The",
"context",
"will",
"be",
"used",
"in",
"an",
"attempt",
"to",
"determine",
"line",
"numbers",
"for",
"the",
"given",
"value",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/node.go#L61-L65 |
16,881 | coreos/coreos-cloudinit | config/validate/node.go | findKey | func findKey(key string, context context) (context, bool) {
return find(yamlKey, key, context)
} | go | func findKey(key string, context context) (context, bool) {
return find(yamlKey, key, context)
} | [
"func",
"findKey",
"(",
"key",
"string",
",",
"context",
"context",
")",
"(",
"context",
",",
"bool",
")",
"{",
"return",
"find",
"(",
"yamlKey",
",",
"key",
",",
"context",
")",
"\n",
"}"
] | // findKey attempts to find the requested key within the provided context.
// A modified copy of the context is returned with every line up to the key
// incremented past. A boolean, true if the key was found, is also returned. | [
"findKey",
"attempts",
"to",
"find",
"the",
"requested",
"key",
"within",
"the",
"provided",
"context",
".",
"A",
"modified",
"copy",
"of",
"the",
"context",
"is",
"returned",
"with",
"every",
"line",
"up",
"to",
"the",
"key",
"incremented",
"past",
".",
"... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/node.go#L135-L137 |
16,882 | coreos/coreos-cloudinit | system/env_file.go | WriteEnvFile | func WriteEnvFile(ef *EnvFile, root string) error {
// validate new keys, mergeEnvContents uses pending to track writes
pending := make(map[string]string, len(ef.Vars))
for key, value := range ef.Vars {
if !validKey.MatchString(key) {
return fmt.Errorf("Invalid name %q for %s", key, ef.Path)
}
pending[key] = value
}
if len(pending) == 0 {
return nil
}
oldContent, err := ioutil.ReadFile(path.Join(root, ef.Path))
if err != nil {
if os.IsNotExist(err) {
oldContent = []byte{}
} else {
return err
}
}
newContent := mergeEnvContents(oldContent, pending)
if bytes.Equal(oldContent, newContent) {
return nil
}
ef.File.Content = string(newContent)
_, err = WriteFile(ef.File, root)
return err
} | go | func WriteEnvFile(ef *EnvFile, root string) error {
// validate new keys, mergeEnvContents uses pending to track writes
pending := make(map[string]string, len(ef.Vars))
for key, value := range ef.Vars {
if !validKey.MatchString(key) {
return fmt.Errorf("Invalid name %q for %s", key, ef.Path)
}
pending[key] = value
}
if len(pending) == 0 {
return nil
}
oldContent, err := ioutil.ReadFile(path.Join(root, ef.Path))
if err != nil {
if os.IsNotExist(err) {
oldContent = []byte{}
} else {
return err
}
}
newContent := mergeEnvContents(oldContent, pending)
if bytes.Equal(oldContent, newContent) {
return nil
}
ef.File.Content = string(newContent)
_, err = WriteFile(ef.File, root)
return err
} | [
"func",
"WriteEnvFile",
"(",
"ef",
"*",
"EnvFile",
",",
"root",
"string",
")",
"error",
"{",
"// validate new keys, mergeEnvContents uses pending to track writes",
"pending",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"len",
"(",
"ef",
".",
"Va... | // WriteEnvFile updates an existing env `KEY=value` formated file with
// new values provided in EnvFile.Vars; File.Content is ignored.
// Existing ordering and any unknown formatting such as comments are
// preserved. If no changes are required the file is untouched. | [
"WriteEnvFile",
"updates",
"an",
"existing",
"env",
"KEY",
"=",
"value",
"formated",
"file",
"with",
"new",
"values",
"provided",
"in",
"EnvFile",
".",
"Vars",
";",
"File",
".",
"Content",
"is",
"ignored",
".",
"Existing",
"ordering",
"and",
"any",
"unknown"... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/env_file.go#L74-L105 |
16,883 | coreos/coreos-cloudinit | system/env_file.go | keys | func keys(m map[string]string) (s []string) {
for k := range m {
s = append(s, k)
}
sort.Strings(s)
return
} | go | func keys(m map[string]string) (s []string) {
for k := range m {
s = append(s, k)
}
sort.Strings(s)
return
} | [
"func",
"keys",
"(",
"m",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"s",
"[",
"]",
"string",
")",
"{",
"for",
"k",
":=",
"range",
"m",
"{",
"s",
"=",
"append",
"(",
"s",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"s",... | // keys returns the keys of a map in sorted order | [
"keys",
"returns",
"the",
"keys",
"of",
"a",
"map",
"in",
"sorted",
"order"
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/env_file.go#L108-L114 |
16,884 | coreos/coreos-cloudinit | system/fleet.go | Units | func (fe Fleet) Units() []Unit {
return []Unit{{config.Unit{
Name: "fleet.service",
Runtime: true,
DropIns: []config.UnitDropIn{{
Name: "20-cloudinit.conf",
Content: serviceContents(fe.Fleet),
}},
}}}
} | go | func (fe Fleet) Units() []Unit {
return []Unit{{config.Unit{
Name: "fleet.service",
Runtime: true,
DropIns: []config.UnitDropIn{{
Name: "20-cloudinit.conf",
Content: serviceContents(fe.Fleet),
}},
}}}
} | [
"func",
"(",
"fe",
"Fleet",
")",
"Units",
"(",
")",
"[",
"]",
"Unit",
"{",
"return",
"[",
"]",
"Unit",
"{",
"{",
"config",
".",
"Unit",
"{",
"Name",
":",
"\"",
"\"",
",",
"Runtime",
":",
"true",
",",
"DropIns",
":",
"[",
"]",
"config",
".",
"... | // Units generates a Unit file drop-in for fleet, if any fleet options were
// configured in cloud-config | [
"Units",
"generates",
"a",
"Unit",
"file",
"drop",
"-",
"in",
"for",
"fleet",
"if",
"any",
"fleet",
"options",
"were",
"configured",
"in",
"cloud",
"-",
"config"
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/fleet.go#L29-L38 |
16,885 | coreos/coreos-cloudinit | system/env.go | serviceContents | func serviceContents(e interface{}) string {
vars := getEnvVars(e)
if len(vars) == 0 {
return ""
}
out := "[Service]\n"
for _, v := range vars {
out += fmt.Sprintf("Environment=\"%s\"\n", v)
}
return out
} | go | func serviceContents(e interface{}) string {
vars := getEnvVars(e)
if len(vars) == 0 {
return ""
}
out := "[Service]\n"
for _, v := range vars {
out += fmt.Sprintf("Environment=\"%s\"\n", v)
}
return out
} | [
"func",
"serviceContents",
"(",
"e",
"interface",
"{",
"}",
")",
"string",
"{",
"vars",
":=",
"getEnvVars",
"(",
"e",
")",
"\n",
"if",
"len",
"(",
"vars",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"out",
":=",
"\"",
"\\n",
"\"... | // serviceContents generates the contents for a drop-in unit given the config.
// The argument must be a struct from the 'config' package. | [
"serviceContents",
"generates",
"the",
"contents",
"for",
"a",
"drop",
"-",
"in",
"unit",
"given",
"the",
"config",
".",
"The",
"argument",
"must",
"be",
"a",
"struct",
"from",
"the",
"config",
"package",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/env.go#L26-L37 |
16,886 | coreos/coreos-cloudinit | system/locksmith.go | Units | func (ee Locksmith) Units() []Unit {
return []Unit{{config.Unit{
Name: "locksmithd.service",
Runtime: true,
DropIns: []config.UnitDropIn{{
Name: "20-cloudinit.conf",
Content: serviceContents(ee.Locksmith),
}},
}}}
} | go | func (ee Locksmith) Units() []Unit {
return []Unit{{config.Unit{
Name: "locksmithd.service",
Runtime: true,
DropIns: []config.UnitDropIn{{
Name: "20-cloudinit.conf",
Content: serviceContents(ee.Locksmith),
}},
}}}
} | [
"func",
"(",
"ee",
"Locksmith",
")",
"Units",
"(",
")",
"[",
"]",
"Unit",
"{",
"return",
"[",
"]",
"Unit",
"{",
"{",
"config",
".",
"Unit",
"{",
"Name",
":",
"\"",
"\"",
",",
"Runtime",
":",
"true",
",",
"DropIns",
":",
"[",
"]",
"config",
".",... | // Units creates a Unit file drop-in for etcd, using any configured options. | [
"Units",
"creates",
"a",
"Unit",
"file",
"drop",
"-",
"in",
"for",
"etcd",
"using",
"any",
"configured",
"options",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/system/locksmith.go#L28-L37 |
16,887 | coreos/coreos-cloudinit | pkg/http_client.go | GetRetry | func (h *HttpClient) GetRetry(rawurl string) ([]byte, error) {
if rawurl == "" {
return nil, ErrInvalid{errors.New("URL is empty. Skipping.")}
}
url, err := neturl.Parse(rawurl)
if err != nil {
return nil, ErrInvalid{err}
}
// Unfortunately, url.Parse is too generic to throw errors if a URL does not
// have a valid HTTP scheme. So, we have to do this extra validation
if !strings.HasPrefix(url.Scheme, "http") {
return nil, ErrInvalid{fmt.Errorf("URL %s does not have a valid HTTP scheme. Skipping.", rawurl)}
}
dataURL := url.String()
duration := h.InitialBackoff
for retry := 1; retry <= h.MaxRetries; retry++ {
log.Printf("Fetching data from %s. Attempt #%d", dataURL, retry)
data, err := h.Get(dataURL)
switch err.(type) {
case ErrNetwork:
log.Printf(err.Error())
case ErrServer:
log.Printf(err.Error())
case ErrNotFound:
return data, err
default:
return data, err
}
duration = ExpBackoff(duration, h.MaxBackoff)
log.Printf("Sleeping for %v...", duration)
time.Sleep(duration)
}
return nil, ErrTimeout{fmt.Errorf("Unable to fetch data. Maximum retries reached: %d", h.MaxRetries)}
} | go | func (h *HttpClient) GetRetry(rawurl string) ([]byte, error) {
if rawurl == "" {
return nil, ErrInvalid{errors.New("URL is empty. Skipping.")}
}
url, err := neturl.Parse(rawurl)
if err != nil {
return nil, ErrInvalid{err}
}
// Unfortunately, url.Parse is too generic to throw errors if a URL does not
// have a valid HTTP scheme. So, we have to do this extra validation
if !strings.HasPrefix(url.Scheme, "http") {
return nil, ErrInvalid{fmt.Errorf("URL %s does not have a valid HTTP scheme. Skipping.", rawurl)}
}
dataURL := url.String()
duration := h.InitialBackoff
for retry := 1; retry <= h.MaxRetries; retry++ {
log.Printf("Fetching data from %s. Attempt #%d", dataURL, retry)
data, err := h.Get(dataURL)
switch err.(type) {
case ErrNetwork:
log.Printf(err.Error())
case ErrServer:
log.Printf(err.Error())
case ErrNotFound:
return data, err
default:
return data, err
}
duration = ExpBackoff(duration, h.MaxBackoff)
log.Printf("Sleeping for %v...", duration)
time.Sleep(duration)
}
return nil, ErrTimeout{fmt.Errorf("Unable to fetch data. Maximum retries reached: %d", h.MaxRetries)}
} | [
"func",
"(",
"h",
"*",
"HttpClient",
")",
"GetRetry",
"(",
"rawurl",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"rawurl",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrInvalid",
"{",
"errors",
".",
"New",
"(",
"\"",
"\... | // GetRetry fetches a given URL with support for exponential backoff and maximum retries | [
"GetRetry",
"fetches",
"a",
"given",
"URL",
"with",
"support",
"for",
"exponential",
"backoff",
"and",
"maximum",
"retries"
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/pkg/http_client.go#L103-L143 |
16,888 | coreos/coreos-cloudinit | initialize/env.go | Apply | func (e *Environment) Apply(data string) string {
for key, val := range e.substitutions {
matchKey := strings.Replace(key, `$`, `\$`, -1)
replKey := strings.Replace(key, `$`, `$$`, -1)
// "key" -> "val"
data = regexp.MustCompile(`([^\\]|^)`+matchKey).ReplaceAllString(data, `${1}`+val)
// "\key" -> "key"
data = regexp.MustCompile(`\\`+matchKey).ReplaceAllString(data, replKey)
}
return data
} | go | func (e *Environment) Apply(data string) string {
for key, val := range e.substitutions {
matchKey := strings.Replace(key, `$`, `\$`, -1)
replKey := strings.Replace(key, `$`, `$$`, -1)
// "key" -> "val"
data = regexp.MustCompile(`([^\\]|^)`+matchKey).ReplaceAllString(data, `${1}`+val)
// "\key" -> "key"
data = regexp.MustCompile(`\\`+matchKey).ReplaceAllString(data, replKey)
}
return data
} | [
"func",
"(",
"e",
"*",
"Environment",
")",
"Apply",
"(",
"data",
"string",
")",
"string",
"{",
"for",
"key",
",",
"val",
":=",
"range",
"e",
".",
"substitutions",
"{",
"matchKey",
":=",
"strings",
".",
"Replace",
"(",
"key",
",",
"`$`",
",",
"`\\$`",... | // Apply goes through the map of substitutions and replaces all instances of
// the keys with their respective values. It supports escaping substitutions
// with a leading '\'. | [
"Apply",
"goes",
"through",
"the",
"map",
"of",
"substitutions",
"and",
"replaces",
"all",
"instances",
"of",
"the",
"keys",
"with",
"their",
"respective",
"values",
".",
"It",
"supports",
"escaping",
"substitutions",
"with",
"a",
"leading",
"\\",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/initialize/env.go#L79-L90 |
16,889 | coreos/coreos-cloudinit | config/validate/rules.go | checkDiscoveryUrl | func checkDiscoveryUrl(cfg node, report *Report) {
c := cfg.Child("coreos").Child("etcd").Child("discovery")
if !c.IsValid() {
return
}
if _, err := url.ParseRequestURI(c.String()); err != nil {
report.Warning(c.line, "discovery URL is not valid")
}
} | go | func checkDiscoveryUrl(cfg node, report *Report) {
c := cfg.Child("coreos").Child("etcd").Child("discovery")
if !c.IsValid() {
return
}
if _, err := url.ParseRequestURI(c.String()); err != nil {
report.Warning(c.line, "discovery URL is not valid")
}
} | [
"func",
"checkDiscoveryUrl",
"(",
"cfg",
"node",
",",
"report",
"*",
"Report",
")",
"{",
"c",
":=",
"cfg",
".",
"Child",
"(",
"\"",
"\"",
")",
".",
"Child",
"(",
"\"",
"\"",
")",
".",
"Child",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"c",
".",
... | // checkDiscoveryUrl verifies that the string is a valid url. | [
"checkDiscoveryUrl",
"verifies",
"that",
"the",
"string",
"is",
"a",
"valid",
"url",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/rules.go#L40-L49 |
16,890 | coreos/coreos-cloudinit | config/validate/rules.go | checkEncoding | func checkEncoding(cfg node, report *Report) {
for _, f := range cfg.Child("write_files").children {
e := f.Child("encoding")
if !e.IsValid() {
continue
}
c := f.Child("content")
if _, err := config.DecodeContent(c.String(), e.String()); err != nil {
report.Error(c.line, fmt.Sprintf("content cannot be decoded as %q", e.String()))
}
}
} | go | func checkEncoding(cfg node, report *Report) {
for _, f := range cfg.Child("write_files").children {
e := f.Child("encoding")
if !e.IsValid() {
continue
}
c := f.Child("content")
if _, err := config.DecodeContent(c.String(), e.String()); err != nil {
report.Error(c.line, fmt.Sprintf("content cannot be decoded as %q", e.String()))
}
}
} | [
"func",
"checkEncoding",
"(",
"cfg",
"node",
",",
"report",
"*",
"Report",
")",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"cfg",
".",
"Child",
"(",
"\"",
"\"",
")",
".",
"children",
"{",
"e",
":=",
"f",
".",
"Child",
"(",
"\"",
"\"",
")",
"\n",... | // checkEncoding validates that, for each file under 'write_files', the
// content can be decoded given the specified encoding. | [
"checkEncoding",
"validates",
"that",
"for",
"each",
"file",
"under",
"write_files",
"the",
"content",
"can",
"be",
"decoded",
"given",
"the",
"specified",
"encoding",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/rules.go#L53-L65 |
16,891 | coreos/coreos-cloudinit | config/validate/rules.go | checkStructure | func checkStructure(cfg node, report *Report) {
g := NewNode(config.CloudConfig{}, NewContext([]byte{}))
checkNodeStructure(cfg, g, report)
} | go | func checkStructure(cfg node, report *Report) {
g := NewNode(config.CloudConfig{}, NewContext([]byte{}))
checkNodeStructure(cfg, g, report)
} | [
"func",
"checkStructure",
"(",
"cfg",
"node",
",",
"report",
"*",
"Report",
")",
"{",
"g",
":=",
"NewNode",
"(",
"config",
".",
"CloudConfig",
"{",
"}",
",",
"NewContext",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
")",
"\n",
"checkNodeStructure",
"(",
"c... | // checkStructure compares the provided config to the empty config.CloudConfig
// structure. Each node is checked to make sure that it exists in the known
// structure and that its type is compatible. | [
"checkStructure",
"compares",
"the",
"provided",
"config",
"to",
"the",
"empty",
"config",
".",
"CloudConfig",
"structure",
".",
"Each",
"node",
"is",
"checked",
"to",
"make",
"sure",
"that",
"it",
"exists",
"in",
"the",
"known",
"structure",
"and",
"that",
... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/rules.go#L70-L73 |
16,892 | coreos/coreos-cloudinit | config/validate/rules.go | isCompatible | func isCompatible(n, g reflect.Kind) bool {
switch g {
case reflect.String:
return n == reflect.String || n == reflect.Int || n == reflect.Float64 || n == reflect.Bool
case reflect.Struct:
return n == reflect.Struct || n == reflect.Map
case reflect.Float64:
return n == reflect.Float64 || n == reflect.Int
case reflect.Bool, reflect.Slice, reflect.Int:
return n == g
default:
panic(fmt.Sprintf("isCompatible(): unhandled kind %s", g))
}
} | go | func isCompatible(n, g reflect.Kind) bool {
switch g {
case reflect.String:
return n == reflect.String || n == reflect.Int || n == reflect.Float64 || n == reflect.Bool
case reflect.Struct:
return n == reflect.Struct || n == reflect.Map
case reflect.Float64:
return n == reflect.Float64 || n == reflect.Int
case reflect.Bool, reflect.Slice, reflect.Int:
return n == g
default:
panic(fmt.Sprintf("isCompatible(): unhandled kind %s", g))
}
} | [
"func",
"isCompatible",
"(",
"n",
",",
"g",
"reflect",
".",
"Kind",
")",
"bool",
"{",
"switch",
"g",
"{",
"case",
"reflect",
".",
"String",
":",
"return",
"n",
"==",
"reflect",
".",
"String",
"||",
"n",
"==",
"reflect",
".",
"Int",
"||",
"n",
"==",... | // isCompatible determines if the type of kind n can be converted to the type
// of kind g in the context of YAML. This is not an exhaustive list, but its
// enough for the purposes of cloud-config validation. | [
"isCompatible",
"determines",
"if",
"the",
"type",
"of",
"kind",
"n",
"can",
"be",
"converted",
"to",
"the",
"type",
"of",
"kind",
"g",
"in",
"the",
"context",
"of",
"YAML",
".",
"This",
"is",
"not",
"an",
"exhaustive",
"list",
"but",
"its",
"enough",
... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/rules.go#L109-L122 |
16,893 | coreos/coreos-cloudinit | coreos-cloudinit.go | getDatasources | func getDatasources() []datasource.Datasource {
dss := make([]datasource.Datasource, 0, 5)
if flags.sources.file != "" {
dss = append(dss, file.NewDatasource(flags.sources.file))
}
if flags.sources.url != "" {
dss = append(dss, url.NewDatasource(flags.sources.url))
}
if flags.sources.configDrive != "" {
dss = append(dss, configdrive.NewDatasource(flags.sources.configDrive))
}
if flags.sources.metadataService {
dss = append(dss, ec2.NewDatasource(ec2.DefaultAddress))
}
if flags.sources.ec2MetadataService != "" {
dss = append(dss, ec2.NewDatasource(flags.sources.ec2MetadataService))
}
if flags.sources.gceMetadataService != "" {
dss = append(dss, gce.NewDatasource(flags.sources.gceMetadataService))
}
if flags.sources.cloudSigmaMetadataService {
dss = append(dss, cloudsigma.NewServerContextService())
}
if flags.sources.digitalOceanMetadataService != "" {
dss = append(dss, digitalocean.NewDatasource(flags.sources.digitalOceanMetadataService))
}
if flags.sources.waagent != "" {
dss = append(dss, waagent.NewDatasource(flags.sources.waagent))
}
if flags.sources.packetMetadataService != "" {
dss = append(dss, packet.NewDatasource(flags.sources.packetMetadataService))
}
if flags.sources.procCmdLine {
dss = append(dss, proc_cmdline.NewDatasource())
}
if flags.sources.vmware {
dss = append(dss, vmware.NewDatasource(""))
}
if flags.sources.ovfEnv != "" {
dss = append(dss, vmware.NewDatasource(flags.sources.ovfEnv))
}
return dss
} | go | func getDatasources() []datasource.Datasource {
dss := make([]datasource.Datasource, 0, 5)
if flags.sources.file != "" {
dss = append(dss, file.NewDatasource(flags.sources.file))
}
if flags.sources.url != "" {
dss = append(dss, url.NewDatasource(flags.sources.url))
}
if flags.sources.configDrive != "" {
dss = append(dss, configdrive.NewDatasource(flags.sources.configDrive))
}
if flags.sources.metadataService {
dss = append(dss, ec2.NewDatasource(ec2.DefaultAddress))
}
if flags.sources.ec2MetadataService != "" {
dss = append(dss, ec2.NewDatasource(flags.sources.ec2MetadataService))
}
if flags.sources.gceMetadataService != "" {
dss = append(dss, gce.NewDatasource(flags.sources.gceMetadataService))
}
if flags.sources.cloudSigmaMetadataService {
dss = append(dss, cloudsigma.NewServerContextService())
}
if flags.sources.digitalOceanMetadataService != "" {
dss = append(dss, digitalocean.NewDatasource(flags.sources.digitalOceanMetadataService))
}
if flags.sources.waagent != "" {
dss = append(dss, waagent.NewDatasource(flags.sources.waagent))
}
if flags.sources.packetMetadataService != "" {
dss = append(dss, packet.NewDatasource(flags.sources.packetMetadataService))
}
if flags.sources.procCmdLine {
dss = append(dss, proc_cmdline.NewDatasource())
}
if flags.sources.vmware {
dss = append(dss, vmware.NewDatasource(""))
}
if flags.sources.ovfEnv != "" {
dss = append(dss, vmware.NewDatasource(flags.sources.ovfEnv))
}
return dss
} | [
"func",
"getDatasources",
"(",
")",
"[",
"]",
"datasource",
".",
"Datasource",
"{",
"dss",
":=",
"make",
"(",
"[",
"]",
"datasource",
".",
"Datasource",
",",
"0",
",",
"5",
")",
"\n",
"if",
"flags",
".",
"sources",
".",
"file",
"!=",
"\"",
"\"",
"{... | // getDatasources creates a slice of possible Datasources for cloudinit based
// on the different source command-line flags. | [
"getDatasources",
"creates",
"a",
"slice",
"of",
"possible",
"Datasources",
"for",
"cloudinit",
"based",
"on",
"the",
"different",
"source",
"command",
"-",
"line",
"flags",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/coreos-cloudinit.go#L310-L352 |
16,894 | coreos/coreos-cloudinit | coreos-cloudinit.go | selectDatasource | func selectDatasource(sources []datasource.Datasource) datasource.Datasource {
ds := make(chan datasource.Datasource)
stop := make(chan struct{})
var wg sync.WaitGroup
for _, s := range sources {
wg.Add(1)
go func(s datasource.Datasource) {
defer wg.Done()
duration := datasourceInterval
for {
log.Printf("Checking availability of %q\n", s.Type())
if s.IsAvailable() {
ds <- s
return
} else if !s.AvailabilityChanges() {
return
}
select {
case <-stop:
return
case <-time.After(duration):
duration = pkg.ExpBackoff(duration, datasourceMaxInterval)
}
}
}(s)
}
done := make(chan struct{})
go func() {
wg.Wait()
close(done)
}()
var s datasource.Datasource
select {
case s = <-ds:
case <-done:
case <-time.After(datasourceTimeout):
}
close(stop)
return s
} | go | func selectDatasource(sources []datasource.Datasource) datasource.Datasource {
ds := make(chan datasource.Datasource)
stop := make(chan struct{})
var wg sync.WaitGroup
for _, s := range sources {
wg.Add(1)
go func(s datasource.Datasource) {
defer wg.Done()
duration := datasourceInterval
for {
log.Printf("Checking availability of %q\n", s.Type())
if s.IsAvailable() {
ds <- s
return
} else if !s.AvailabilityChanges() {
return
}
select {
case <-stop:
return
case <-time.After(duration):
duration = pkg.ExpBackoff(duration, datasourceMaxInterval)
}
}
}(s)
}
done := make(chan struct{})
go func() {
wg.Wait()
close(done)
}()
var s datasource.Datasource
select {
case s = <-ds:
case <-done:
case <-time.After(datasourceTimeout):
}
close(stop)
return s
} | [
"func",
"selectDatasource",
"(",
"sources",
"[",
"]",
"datasource",
".",
"Datasource",
")",
"datasource",
".",
"Datasource",
"{",
"ds",
":=",
"make",
"(",
"chan",
"datasource",
".",
"Datasource",
")",
"\n",
"stop",
":=",
"make",
"(",
"chan",
"struct",
"{",... | // selectDatasource attempts to choose a valid Datasource to use based on its
// current availability. The first Datasource to report to be available is
// returned. Datasources will be retried if possible if they are not
// immediately available. If all Datasources are permanently unavailable or
// datasourceTimeout is reached before one becomes available, nil is returned. | [
"selectDatasource",
"attempts",
"to",
"choose",
"a",
"valid",
"Datasource",
"to",
"use",
"based",
"on",
"its",
"current",
"availability",
".",
"The",
"first",
"Datasource",
"to",
"report",
"to",
"be",
"available",
"is",
"returned",
".",
"Datasources",
"will",
... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/coreos-cloudinit.go#L359-L403 |
16,895 | coreos/coreos-cloudinit | config/config.go | Decode | func (cc *CloudConfig) Decode() error {
for i, file := range cc.WriteFiles {
content, err := DecodeContent(file.Content, file.Encoding)
if err != nil {
return err
}
cc.WriteFiles[i].Content = string(content)
cc.WriteFiles[i].Encoding = ""
}
return nil
} | go | func (cc *CloudConfig) Decode() error {
for i, file := range cc.WriteFiles {
content, err := DecodeContent(file.Content, file.Encoding)
if err != nil {
return err
}
cc.WriteFiles[i].Content = string(content)
cc.WriteFiles[i].Encoding = ""
}
return nil
} | [
"func",
"(",
"cc",
"*",
"CloudConfig",
")",
"Decode",
"(",
")",
"error",
"{",
"for",
"i",
",",
"file",
":=",
"range",
"cc",
".",
"WriteFiles",
"{",
"content",
",",
"err",
":=",
"DecodeContent",
"(",
"file",
".",
"Content",
",",
"file",
".",
"Encoding... | // Decode decodes the content of cloud config. Currently only WriteFiles section
// supports several types of encoding and all of them are supported. After
// decode operation, Encoding type is unset. | [
"Decode",
"decodes",
"the",
"content",
"of",
"cloud",
"config",
".",
"Currently",
"only",
"WriteFiles",
"section",
"supports",
"several",
"types",
"of",
"encoding",
"and",
"all",
"of",
"them",
"are",
"supported",
".",
"After",
"decode",
"operation",
"Encoding",
... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/config.go#L74-L86 |
16,896 | coreos/coreos-cloudinit | config/config.go | AssertStructValid | func AssertStructValid(c interface{}) error {
ct := reflect.TypeOf(c)
cv := reflect.ValueOf(c)
for i := 0; i < ct.NumField(); i++ {
ft := ct.Field(i)
if !isFieldExported(ft) {
continue
}
if err := AssertValid(cv.Field(i), ft.Tag.Get("valid")); err != nil {
err.Field = ft.Name
return err
}
}
return nil
} | go | func AssertStructValid(c interface{}) error {
ct := reflect.TypeOf(c)
cv := reflect.ValueOf(c)
for i := 0; i < ct.NumField(); i++ {
ft := ct.Field(i)
if !isFieldExported(ft) {
continue
}
if err := AssertValid(cv.Field(i), ft.Tag.Get("valid")); err != nil {
err.Field = ft.Name
return err
}
}
return nil
} | [
"func",
"AssertStructValid",
"(",
"c",
"interface",
"{",
"}",
")",
"error",
"{",
"ct",
":=",
"reflect",
".",
"TypeOf",
"(",
"c",
")",
"\n",
"cv",
":=",
"reflect",
".",
"ValueOf",
"(",
"c",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"ct",
... | // AssertStructValid checks the fields in the structure and makes sure that
// they contain valid values as specified by the 'valid' flag. Empty fields are
// implicitly valid. | [
"AssertStructValid",
"checks",
"the",
"fields",
"in",
"the",
"structure",
"and",
"makes",
"sure",
"that",
"they",
"contain",
"valid",
"values",
"as",
"specified",
"by",
"the",
"valid",
"flag",
".",
"Empty",
"fields",
"are",
"implicitly",
"valid",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/config.go#L118-L133 |
16,897 | coreos/coreos-cloudinit | config/config.go | AssertValid | func AssertValid(value reflect.Value, valid string) *ErrorValid {
if valid == "" || isZero(value) {
return nil
}
vs := fmt.Sprintf("%v", value.Interface())
if m, _ := regexp.MatchString(valid, vs); m {
return nil
}
return &ErrorValid{
Value: vs,
Valid: valid,
}
} | go | func AssertValid(value reflect.Value, valid string) *ErrorValid {
if valid == "" || isZero(value) {
return nil
}
vs := fmt.Sprintf("%v", value.Interface())
if m, _ := regexp.MatchString(valid, vs); m {
return nil
}
return &ErrorValid{
Value: vs,
Valid: valid,
}
} | [
"func",
"AssertValid",
"(",
"value",
"reflect",
".",
"Value",
",",
"valid",
"string",
")",
"*",
"ErrorValid",
"{",
"if",
"valid",
"==",
"\"",
"\"",
"||",
"isZero",
"(",
"value",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"vs",
":=",
"fmt",
".",
... | // AssertValid checks to make sure that the given value is in the list of
// valid values. Zero values are implicitly valid. | [
"AssertValid",
"checks",
"to",
"make",
"sure",
"that",
"the",
"given",
"value",
"is",
"in",
"the",
"list",
"of",
"valid",
"values",
".",
"Zero",
"values",
"are",
"implicitly",
"valid",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/config.go#L137-L151 |
16,898 | coreos/coreos-cloudinit | config/validate/validate.go | Validate | func Validate(userdataBytes []byte) (Report, error) {
switch {
case len(userdataBytes) == 0:
return Report{}, nil
case config.IsScript(string(userdataBytes)):
return Report{}, nil
case config.IsIgnitionConfig(string(userdataBytes)):
return Report{}, nil
case config.IsCloudConfig(string(userdataBytes)):
return validateCloudConfig(userdataBytes, Rules)
default:
return Report{entries: []Entry{
{kind: entryError, message: `must be "#cloud-config" or begin with "#!"`, line: 1},
}}, nil
}
} | go | func Validate(userdataBytes []byte) (Report, error) {
switch {
case len(userdataBytes) == 0:
return Report{}, nil
case config.IsScript(string(userdataBytes)):
return Report{}, nil
case config.IsIgnitionConfig(string(userdataBytes)):
return Report{}, nil
case config.IsCloudConfig(string(userdataBytes)):
return validateCloudConfig(userdataBytes, Rules)
default:
return Report{entries: []Entry{
{kind: entryError, message: `must be "#cloud-config" or begin with "#!"`, line: 1},
}}, nil
}
} | [
"func",
"Validate",
"(",
"userdataBytes",
"[",
"]",
"byte",
")",
"(",
"Report",
",",
"error",
")",
"{",
"switch",
"{",
"case",
"len",
"(",
"userdataBytes",
")",
"==",
"0",
":",
"return",
"Report",
"{",
"}",
",",
"nil",
"\n",
"case",
"config",
".",
... | // Validate runs a series of validation tests against the given userdata and
// returns a report detailing all of the issues. Presently, only cloud-configs
// can be validated. | [
"Validate",
"runs",
"a",
"series",
"of",
"validation",
"tests",
"against",
"the",
"given",
"userdata",
"and",
"returns",
"a",
"report",
"detailing",
"all",
"of",
"the",
"issues",
".",
"Presently",
"only",
"cloud",
"-",
"configs",
"can",
"be",
"validated",
".... | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/validate.go#L37-L52 |
16,899 | coreos/coreos-cloudinit | config/validate/validate.go | validateCloudConfig | func validateCloudConfig(config []byte, rules []rule) (report Report, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
}
}()
c, err := parseCloudConfig(config, &report)
if err != nil {
return report, err
}
for _, r := range rules {
r(c, &report)
}
return report, nil
} | go | func validateCloudConfig(config []byte, rules []rule) (report Report, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
}
}()
c, err := parseCloudConfig(config, &report)
if err != nil {
return report, err
}
for _, r := range rules {
r(c, &report)
}
return report, nil
} | [
"func",
"validateCloudConfig",
"(",
"config",
"[",
"]",
"byte",
",",
"rules",
"[",
"]",
"rule",
")",
"(",
"report",
"Report",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"ni... | // validateCloudConfig runs all of the validation rules in Rules and returns
// the resulting report and any errors encountered. | [
"validateCloudConfig",
"runs",
"all",
"of",
"the",
"validation",
"rules",
"in",
"Rules",
"and",
"returns",
"the",
"resulting",
"report",
"and",
"any",
"errors",
"encountered",
"."
] | f1f0405491dfd073bbf074f7e374c9ef85600691 | https://github.com/coreos/coreos-cloudinit/blob/f1f0405491dfd073bbf074f7e374c9ef85600691/config/validate/validate.go#L56-L72 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.