_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q16800 | UnmarshalJSON | train | 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 | {
"resource": ""
} |
q16801 | Get | train | func (c *Client) Get(endpoint string) (*RawResponse, error) {
return c.getCancelable(endpoint, nil)
} | go | {
"resource": ""
} |
q16802 | Put | train | 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 | {
"resource": ""
} |
q16803 | buildValues | train | 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 | {
"resource": ""
} |
q16804 | Encode | train | func (s Latin1) Encode() []byte {
e := charmap.Windows1252.NewEncoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | {
"resource": ""
} |
q16805 | Decode | train | func (s Latin1) Decode() []byte {
e := charmap.Windows1252.NewDecoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | {
"resource": ""
} |
q16806 | New | train | 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 | {
"resource": ""
} |
q16807 | handlePDU | train | 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 | {
"resource": ""
} |
q16808 | newUnsucessDest | train | 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 | {
"resource": ""
} |
q16809 | Resp | train | func (sm *ShortMessage) Resp() pdu.Body {
sm.resp.Lock()
defer sm.resp.Unlock()
return sm.resp.p
} | go | {
"resource": ""
} |
q16810 | Submit | train | 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 | {
"resource": ""
} |
q16811 | DecodeTLV | train | 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 | {
"resource": ""
} |
q16812 | Bind | train | 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 | {
"resource": ""
} |
q16813 | DecodeHeader | train | 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 | {
"resource": ""
} |
q16814 | SerializeTo | train | 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 | {
"resource": ""
} |
q16815 | NewGenericNACK | train | func NewGenericNACK() Body {
b := newGenericNACK(&Header{ID: GenericNACKID})
b.init()
return b
} | go | {
"resource": ""
} |
q16816 | NewBindReceiver | train | func NewBindReceiver() Body {
b := newBind(&Header{ID: BindReceiverID})
b.init()
return b
} | go | {
"resource": ""
} |
q16817 | NewBindTransceiver | train | func NewBindTransceiver() Body {
b := newBind(&Header{ID: BindTransceiverID})
b.init()
return b
} | go | {
"resource": ""
} |
q16818 | NewBindTransmitter | train | func NewBindTransmitter() Body {
b := newBind(&Header{ID: BindTransmitterID})
b.init()
return b
} | go | {
"resource": ""
} |
q16819 | NewBindReceiverResp | train | func NewBindReceiverResp() Body {
b := newBindResp(&Header{ID: BindReceiverRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16820 | NewBindTransceiverResp | train | func NewBindTransceiverResp() Body {
b := newBindResp(&Header{ID: BindTransceiverRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16821 | NewBindTransmitterResp | train | func NewBindTransmitterResp() Body {
b := newBindResp(&Header{ID: BindTransmitterRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16822 | NewQuerySM | train | func NewQuerySM() Body {
b := newQuerySM(&Header{ID: QuerySMID})
b.init()
return b
} | go | {
"resource": ""
} |
q16823 | NewQuerySMResp | train | func NewQuerySMResp() Body {
b := newQuerySMResp(&Header{ID: QuerySMRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16824 | NewSubmitSM | train | 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 | {
"resource": ""
} |
q16825 | NewSubmitSMResp | train | func NewSubmitSMResp() Body {
b := newSubmitSMResp(&Header{ID: SubmitSMRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16826 | NewSubmitMulti | train | 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 | {
"resource": ""
} |
q16827 | NewSubmitMultiResp | train | func NewSubmitMultiResp() Body {
b := newSubmitMultiResp(&Header{ID: SubmitMultiRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16828 | NewDeliverSM | train | func NewDeliverSM() Body {
b := newDeliverSM(&Header{ID: DeliverSMID})
b.init()
return b
} | go | {
"resource": ""
} |
q16829 | NewDeliverSMResp | train | func NewDeliverSMResp() Body {
b := newDeliverSMResp(&Header{ID: DeliverSMRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16830 | NewDeliverSMRespSeq | train | func NewDeliverSMRespSeq(seq uint32) Body {
b := newDeliverSMResp(&Header{ID: DeliverSMRespID, Seq: seq})
b.init()
return b
} | go | {
"resource": ""
} |
q16831 | NewUnbind | train | func NewUnbind() Body {
b := newUnbind(&Header{ID: UnbindID})
b.init()
return b
} | go | {
"resource": ""
} |
q16832 | NewUnbindResp | train | func NewUnbindResp() Body {
b := newUnbindResp(&Header{ID: UnbindRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16833 | NewEnquireLink | train | func NewEnquireLink() Body {
b := newEnquireLink(&Header{ID: EnquireLinkID})
b.init()
return b
} | go | {
"resource": ""
} |
q16834 | NewEnquireLinkResp | train | func NewEnquireLinkResp() Body {
b := newEnquireLinkResp(&Header{ID: EnquireLinkRespID})
b.init()
return b
} | go | {
"resource": ""
} |
q16835 | NewEnquireLinkRespSeq | train | func NewEnquireLinkRespSeq(seq uint32) Body {
b := newEnquireLinkResp(&Header{ID: EnquireLinkRespID, Seq: seq})
b.init()
return b
} | go | {
"resource": ""
} |
q16836 | NewTLV | train | func NewTLV(tag Tag, value []byte) Body {
return &Field{ Tag: tag, Data: value }
} | go | {
"resource": ""
} |
q16837 | Dial | train | 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 | {
"resource": ""
} |
q16838 | Set | train | func (cs *connSwitch) Set(c Conn) {
cs.mu.Lock()
if cs.c != nil {
cs.c.Close()
}
cs.c = c
cs.mu.Unlock()
} | go | {
"resource": ""
} |
q16839 | Close | train | 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 | {
"resource": ""
} |
q16840 | Bind | train | 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 | {
"resource": ""
} |
q16841 | init | train | 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 | {
"resource": ""
} |
q16842 | setup | train | func (pdu *codec) setup(f pdufield.Map, t pdutlv.Map) {
pdu.f, pdu.t = f, t
} | go | {
"resource": ""
} |
q16843 | Len | train | 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 | {
"resource": ""
} |
q16844 | SerializeTo | train | 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 | {
"resource": ""
} |
q16845 | Encode | train | func (s ISO88595) Encode() []byte {
e := charmap.ISO8859_5.NewEncoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | {
"resource": ""
} |
q16846 | Decode | train | func (s ISO88595) Decode() []byte {
e := charmap.ISO8859_5.NewDecoder()
es, _, err := transform.Bytes(e, s)
if err != nil {
return s
}
return es
} | go | {
"resource": ""
} |
q16847 | Hex | train | func (t Tag) Hex() string {
bin := make([]byte, 2, 2)
binary.BigEndian.PutUint16(bin, uint16(t))
return hex.EncodeToString(bin)
} | go | {
"resource": ""
} |
q16848 | Encode | train | 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 | {
"resource": ""
} |
q16849 | Decode | train | 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 | {
"resource": ""
} |
q16850 | ValidateGSM7String | train | 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 | {
"resource": ""
} |
q16851 | ValidateGSM7Buffer | train | 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 | {
"resource": ""
} |
q16852 | Bind | train | 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 | {
"resource": ""
} |
q16853 | Read | train | func (c *client) Read() (pdu.Body, error) {
select {
case pdu := <-c.inbox:
return pdu, nil
case <-c.stop:
return nil, io.EOF
}
} | go | {
"resource": ""
} |
q16854 | Write | train | func (c *client) Write(w pdu.Body) error {
if c.RateLimiter != nil {
c.RateLimiter.Wait(c.lmctx)
}
return c.conn.Write(w)
} | go | {
"resource": ""
} |
q16855 | Close | train | 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 | {
"resource": ""
} |
q16856 | trysleep | train | func (c *client) trysleep(d time.Duration) {
select {
case <-time.After(d):
case <-c.stop:
}
} | go | {
"resource": ""
} |
q16857 | respTimeout | train | func (c *client) respTimeout() <-chan time.Time {
if c.RespTimeout == 0 {
return time.After(time.Second)
}
return time.After(c.RespTimeout)
} | go | {
"resource": ""
} |
q16858 | bind | train | 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 | {
"resource": ""
} |
q16859 | Encode | train | 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 | {
"resource": ""
} |
q16860 | GenerateProtobufDefinition | train | 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 | {
"resource": ""
} |
q16861 | String | train | func (c *Constructors) String() string {
var s string
for k := range *c {
s += k.String() + "=>" + "(func() interface {})" + "\t"
}
return s
} | go | {
"resource": ""
} |
q16862 | DecodeWithConstructors | train | 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 | {
"resource": ""
} |
q16863 | message | train | 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 | {
"resource": ""
} |
q16864 | value | train | 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 | {
"resource": ""
} |
q16865 | instantiate | train | 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 | {
"resource": ""
} |
q16866 | slice | train | 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 | {
"resource": ""
} |
q16867 | register | train | 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 | {
"resource": ""
} |
q16868 | get | train | func (ir *generatorRegistry) get(key GeneratorID) InterfaceGeneratorFunc {
g, _ := ir.generators[key]
return g
} | go | {
"resource": ""
} |
q16869 | WriteFile | train | 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 | {
"resource": ""
} |
q16870 | AuthorizeSSHKeys | train | 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 | {
"resource": ""
} |
q16871 | Error | train | func (r *Report) Error(line int, message string) {
r.entries = append(r.entries, Entry{entryError, message, line})
} | go | {
"resource": ""
} |
q16872 | Warning | train | func (r *Report) Warning(line int, message string) {
r.entries = append(r.entries, Entry{entryWarning, message, line})
} | go | {
"resource": ""
} |
q16873 | Info | train | func (r *Report) Info(line int, message string) {
r.entries = append(r.entries, Entry{entryInfo, message, line})
} | go | {
"resource": ""
} |
q16874 | String | train | func (e Entry) String() string {
return fmt.Sprintf("line %d: %s: %s", e.line, e.kind, e.message)
} | go | {
"resource": ""
} |
q16875 | MarshalJSON | train | func (e Entry) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"kind": e.kind.String(),
"message": e.message,
"line": e.line,
})
} | go | {
"resource": ""
} |
q16876 | PlaceUnit | train | 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 | {
"resource": ""
} |
q16877 | PlaceUnitDropIn | train | 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 | {
"resource": ""
} |
q16878 | Child | train | func (n node) Child(name string) node {
for _, c := range n.children {
if c.name == name {
return c
}
}
return node{}
} | go | {
"resource": ""
} |
q16879 | HumanType | train | 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 | {
"resource": ""
} |
q16880 | NewNode | train | func NewNode(value interface{}, context context) node {
var n node
toNode(value, context, &n)
return n
} | go | {
"resource": ""
} |
q16881 | findKey | train | func findKey(key string, context context) (context, bool) {
return find(yamlKey, key, context)
} | go | {
"resource": ""
} |
q16882 | WriteEnvFile | train | 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 | {
"resource": ""
} |
q16883 | keys | train | func keys(m map[string]string) (s []string) {
for k := range m {
s = append(s, k)
}
sort.Strings(s)
return
} | go | {
"resource": ""
} |
q16884 | Units | train | 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 | {
"resource": ""
} |
q16885 | serviceContents | train | 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 | {
"resource": ""
} |
q16886 | Units | train | 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 | {
"resource": ""
} |
q16887 | GetRetry | train | 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 | {
"resource": ""
} |
q16888 | Apply | train | 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 | {
"resource": ""
} |
q16889 | checkDiscoveryUrl | train | 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 | {
"resource": ""
} |
q16890 | checkEncoding | train | 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 | {
"resource": ""
} |
q16891 | checkStructure | train | func checkStructure(cfg node, report *Report) {
g := NewNode(config.CloudConfig{}, NewContext([]byte{}))
checkNodeStructure(cfg, g, report)
} | go | {
"resource": ""
} |
q16892 | isCompatible | train | 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 | {
"resource": ""
} |
q16893 | getDatasources | train | 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 | {
"resource": ""
} |
q16894 | selectDatasource | train | 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 | {
"resource": ""
} |
q16895 | Decode | train | 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 | {
"resource": ""
} |
q16896 | AssertStructValid | train | 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 | {
"resource": ""
} |
q16897 | AssertValid | train | 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 | {
"resource": ""
} |
q16898 | Validate | train | 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 | {
"resource": ""
} |
q16899 | validateCloudConfig | train | 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 | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.