_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q18100 | SendHostEvent | train | func SendHostEvent(title string, text string, sev severity, duration time.Duration) {
sendEvent(&EventData{
Title: title,
Text: text,
Duration: int(duration / time.Millisecond),
Severity: int(sev),
})
} | go | {
"resource": ""
} |
q18101 | NewTracerWithOptions | train | func NewTracerWithOptions(options *Options) ot.Tracer {
InitSensor(options)
return NewTracerWithEverything(options, NewRecorder())
} | go | {
"resource": ""
} |
q18102 | NewTracerWithEverything | train | func NewTracerWithEverything(options *Options, recorder SpanRecorder) ot.Tracer {
InitSensor(options)
ret := &tracerS{options: TracerOptions{
Recorder: recorder,
ShouldSample: shouldSample,
MaxLogsPerSpan: MaxLogsPerSpan}}
ret.textPropagator = &textMapPropagator{ret}
return ret
} | go | {
"resource": ""
} |
q18103 | RecordSpan | train | func (r *Recorder) RecordSpan(span *spanS) {
// If we're not announced and not in test mode then just
// return
if !r.testMode && !sensor.agent.canSend() {
return
}
var data = &jsonData{}
kindTag := span.getSpanKindTag()
data.SDK = &jsonSDKData{
Name: span.Operation,
Type: kindTag,
Custom: &jsonCus... | go | {
"resource": ""
} |
q18104 | QueuedSpansCount | train | func (r *Recorder) QueuedSpansCount() int {
r.RLock()
defer r.RUnlock()
return len(r.spans)
} | go | {
"resource": ""
} |
q18105 | GetQueuedSpans | train | func (r *Recorder) GetQueuedSpans() []jsonSpan {
r.Lock()
defer r.Unlock()
// Copy queued spans
queuedSpans := make([]jsonSpan, len(r.spans))
copy(queuedSpans, r.spans)
// and clear out the source
r.clearQueuedSpans()
return queuedSpans
} | go | {
"resource": ""
} |
q18106 | send | train | func (r *Recorder) send() {
spansToSend := r.GetQueuedSpans()
if len(spansToSend) > 0 {
go func() {
_, err := sensor.agent.request(sensor.agent.makeURL(agentTracesURL), "POST", spansToSend)
if err != nil {
log.debug("Posting traces failed in send(): ", err)
sensor.agent.reset()
}
}()
}
} | go | {
"resource": ""
} |
q18107 | CutText | train | func (c *ClientConn) CutText(text string) error {
var buf bytes.Buffer
// This is the fixed size data we'll send
fixedData := []interface{}{
uint8(6),
uint8(0),
uint8(0),
uint8(0),
uint32(len(text)),
}
for _, val := range fixedData {
if err := binary.Write(&buf, binary.BigEndian, val); err != nil {
... | go | {
"resource": ""
} |
q18108 | FramebufferUpdateRequest | train | func (c *ClientConn) FramebufferUpdateRequest(incremental bool, x, y, width, height uint16) error {
var buf bytes.Buffer
var incrementalByte uint8 = 0
if incremental {
incrementalByte = 1
}
data := []interface{}{
uint8(3),
incrementalByte,
x, y, width, height,
}
for _, val := range data {
if err := ... | go | {
"resource": ""
} |
q18109 | KeyEvent | train | func (c *ClientConn) KeyEvent(keysym uint32, down bool) error {
var downFlag uint8 = 0
if down {
downFlag = 1
}
data := []interface{}{
uint8(4),
downFlag,
uint8(0),
uint8(0),
keysym,
}
for _, val := range data {
if err := binary.Write(c.c, binary.BigEndian, val); err != nil {
return err
}
}
... | go | {
"resource": ""
} |
q18110 | PointerEvent | train | func (c *ClientConn) PointerEvent(mask ButtonMask, x, y uint16) error {
var buf bytes.Buffer
data := []interface{}{
uint8(5),
uint8(mask),
x,
y,
}
for _, val := range data {
if err := binary.Write(&buf, binary.BigEndian, val); err != nil {
return err
}
}
if _, err := c.c.Write(buf.Bytes()[0:6]);... | go | {
"resource": ""
} |
q18111 | SetEncodings | train | func (c *ClientConn) SetEncodings(encs []Encoding) error {
data := make([]interface{}, 3+len(encs))
data[0] = uint8(2)
data[1] = uint8(0)
data[2] = uint16(len(encs))
for i, enc := range encs {
data[3+i] = int32(enc.Type())
}
var buf bytes.Buffer
for _, val := range data {
if err := binary.Write(&buf, bina... | go | {
"resource": ""
} |
q18112 | SetPixelFormat | train | func (c *ClientConn) SetPixelFormat(format *PixelFormat) error {
var keyEvent [20]byte
keyEvent[0] = 0
pfBytes, err := writePixelFormat(format)
if err != nil {
return err
}
// Copy the pixel format bytes into the proper slice location
copy(keyEvent[4:], pfBytes)
// Send the data down the connection
if _, ... | go | {
"resource": ""
} |
q18113 | mainLoop | train | func (c *ClientConn) mainLoop() {
defer c.Close()
// Build the map of available server messages
typeMap := make(map[uint8]ServerMessage)
defaultMessages := []ServerMessage{
new(FramebufferUpdateMessage),
new(SetColorMapEntriesMessage),
new(BellMessage),
new(ServerCutTextMessage),
}
for _, msg := range ... | go | {
"resource": ""
} |
q18114 | unixDialer | train | func (w *Writer) unixDialer() (serverConn, string, error) {
sc, err := unixSyslog()
hostname := w.hostname
if hostname == "" {
hostname = "localhost"
}
return sc, hostname, err
} | go | {
"resource": ""
} |
q18115 | tlsDialer | train | func (w *Writer) tlsDialer() (serverConn, string, error) {
c, err := tls.Dial("tcp", w.raddr, w.tlsConfig)
var sc serverConn
hostname := w.hostname
if err == nil {
sc = &netConn{conn: c}
if hostname == "" {
hostname = c.LocalAddr().String()
}
}
return sc, hostname, err
} | go | {
"resource": ""
} |
q18116 | basicDialer | train | func (w *Writer) basicDialer() (serverConn, string, error) {
c, err := net.Dial(w.network, w.raddr)
var sc serverConn
hostname := w.hostname
if err == nil {
sc = &netConn{conn: c}
if hostname == "" {
hostname = c.LocalAddr().String()
}
}
return sc, hostname, err
} | go | {
"resource": ""
} |
q18117 | customDialer | train | func (w *Writer) customDialer() (serverConn, string, error) {
c, err := w.customDial(w.network, w.raddr)
var sc serverConn
hostname := w.hostname
if err == nil {
sc = &netConn{conn: c}
if hostname == "" {
hostname = c.LocalAddr().String()
}
}
return sc, hostname, err
} | go | {
"resource": ""
} |
q18118 | getConn | train | func (w *Writer) getConn() serverConn {
w.mu.RLock()
conn := w.conn
w.mu.RUnlock()
return conn
} | go | {
"resource": ""
} |
q18119 | setConn | train | func (w *Writer) setConn(c serverConn) {
w.mu.Lock()
w.conn = c
w.mu.Unlock()
} | go | {
"resource": ""
} |
q18120 | connect | train | func (w *Writer) connect() (serverConn, error) {
conn := w.getConn()
if conn != nil {
// ignore err from close, it makes sense to continue anyway
conn.close()
w.setConn(nil)
}
var hostname string
var err error
dialer := w.getDialer()
conn, hostname, err = dialer.Call()
if err == nil {
w.setConn(conn)
... | go | {
"resource": ""
} |
q18121 | WriteWithPriority | train | func (w *Writer) WriteWithPriority(p Priority, b []byte) (int, error) {
return w.writeAndRetryWithPriority(p, string(b))
} | go | {
"resource": ""
} |
q18122 | writeAndRetry | train | func (w *Writer) writeAndRetry(severity Priority, s string) (int, error) {
pr := (w.priority & facilityMask) | (severity & severityMask)
return w.writeAndRetryWithPriority(pr, s)
} | go | {
"resource": ""
} |
q18123 | writeAndRetryWithPriority | train | func (w *Writer) writeAndRetryWithPriority(p Priority, s string) (int, error) {
conn := w.getConn()
if conn != nil {
if n, err := w.write(conn, p, s); err == nil {
return n, err
}
}
var err error
if conn, err = w.connect(); err != nil {
return 0, err
}
return w.write(conn, p, s)
} | go | {
"resource": ""
} |
q18124 | write | train | func (w *Writer) write(conn serverConn, p Priority, msg string) (int, error) {
// ensure it ends in a \n
if !strings.HasSuffix(msg, "\n") {
msg += "\n"
}
err := conn.writeString(w.framer, w.formatter, p, w.hostname, w.tag, msg)
if err != nil {
return 0, err
}
// Note: return the length of the input, not the... | go | {
"resource": ""
} |
q18125 | writeString | train | func (n *netConn) writeString(framer Framer, formatter Formatter, p Priority, hostname, tag, msg string) error {
if framer == nil {
framer = DefaultFramer
}
if formatter == nil {
formatter = DefaultFormatter
}
formattedMessage := framer(formatter(p, hostname, tag, msg))
_, err := n.conn.Write([]byte(formatted... | go | {
"resource": ""
} |
q18126 | UnixFormatter | train | func UnixFormatter(p Priority, hostname, tag, content string) string {
timestamp := time.Now().Format(time.Stamp)
msg := fmt.Sprintf("<%d>%s %s[%d]: %s",
p, timestamp, tag, os.Getpid(), content)
return msg
} | go | {
"resource": ""
} |
q18127 | truncateStartStr | train | func truncateStartStr(s string, max int) string {
if (len(s) > max) {
return s[len(s) - max:]
}
return s
} | go | {
"resource": ""
} |
q18128 | RFC5424Formatter | train | func RFC5424Formatter(p Priority, hostname, tag, content string) string {
timestamp := time.Now().Format(time.RFC3339)
pid := os.Getpid()
appName := truncateStartStr(os.Args[0], appNameMaxLength)
msg := fmt.Sprintf("<%d>%d %s %s %s %d %s - %s",
p, 1, timestamp, hostname, appName, pid, tag, content)
return msg
} | go | {
"resource": ""
} |
q18129 | Dial | train | func Dial(network, raddr string, priority Priority, tag string) (*Writer, error) {
return DialWithTLSConfig(network, raddr, priority, tag, nil)
} | go | {
"resource": ""
} |
q18130 | DialWithCustomDialer | train | func DialWithCustomDialer(network, raddr string, priority Priority, tag string, customDial DialFunc) (*Writer, error) {
if customDial == nil {
return nil, ErrNilDialFunc
}
return dialAllParameters(network, raddr, priority, tag, nil, customDial)
} | go | {
"resource": ""
} |
q18131 | DialWithTLSCertPath | train | func DialWithTLSCertPath(network, raddr string, priority Priority, tag, certPath string) (*Writer, error) {
serverCert, err := ioutil.ReadFile(certPath)
if err != nil {
return nil, err
}
return DialWithTLSCert(network, raddr, priority, tag, serverCert)
} | go | {
"resource": ""
} |
q18132 | DialWithTLSCert | train | func DialWithTLSCert(network, raddr string, priority Priority, tag string, serverCert []byte) (*Writer, error) {
pool := x509.NewCertPool()
pool.AppendCertsFromPEM(serverCert)
config := tls.Config{
RootCAs: pool,
}
return DialWithTLSConfig(network, raddr, priority, tag, &config)
} | go | {
"resource": ""
} |
q18133 | DialWithTLSConfig | train | func DialWithTLSConfig(network, raddr string, priority Priority, tag string, tlsConfig *tls.Config) (*Writer, error) {
return dialAllParameters(network, raddr, priority, tag, tlsConfig, nil)
} | go | {
"resource": ""
} |
q18134 | dialAllParameters | train | func dialAllParameters(network, raddr string, priority Priority, tag string, tlsConfig *tls.Config, customDial DialFunc) (*Writer, error) {
if err := validatePriority(priority); err != nil {
return nil, err
}
if tag == "" {
tag = os.Args[0]
}
hostname, _ := os.Hostname()
w := &Writer{
priority: priority... | go | {
"resource": ""
} |
q18135 | NewLogger | train | func NewLogger(p Priority, logFlag int) (*log.Logger, error) {
s, err := New(p, "")
if err != nil {
return nil, err
}
return log.New(s, "", logFlag), nil
} | go | {
"resource": ""
} |
q18136 | unixSyslog | train | func unixSyslog() (conn serverConn, err error) {
logTypes := []string{"unixgram", "unix"}
logPaths := []string{"/dev/log", "/var/run/syslog", "/var/run/log"}
for _, network := range logTypes {
for _, path := range logPaths {
conn, err := net.Dial(network, path)
if err != nil {
continue
} else {
re... | go | {
"resource": ""
} |
q18137 | GetSocketFromTCPConnection | train | func GetSocketFromTCPConnection(ctx context.Context, dsn string) (socket string, err error) {
db, err := sql.Open("mysql", dsn)
if err != nil {
return "", ErrNoSocket
}
defer db.Close()
err = db.QueryRowContext(ctx, "SELECT @@socket").Scan(socket)
if err != nil {
return "", ErrNoSocket
}
if !path.IsAbs(soc... | go | {
"resource": ""
} |
q18138 | GetSocket | train | func GetSocket(ctx context.Context, dsn string) (string, error) {
var socket string
var err error
socket, err = GetSocketFromTCPConnection(ctx, dsn)
if err != nil {
socket, err = GetSocketFromProcessList(ctx)
if err != nil {
socket, err = GetSocketFromNetstat(ctx)
}
}
return socket, err
} | go | {
"resource": ""
} |
q18139 | AddEvent | train | func (a *Aggregator) AddEvent(event *log.Event, id, fingerprint string) {
if a.rateLimit != event.RateLimit {
a.rateLimit = event.RateLimit
}
outlier := false
if a.outlierTime > 0 && event.TimeMetrics["Query_time"] > a.outlierTime {
outlier = true
}
a.global.AddEvent(event, outlier)
class, ok := a.classes... | go | {
"resource": ""
} |
q18140 | Finalize | train | func (a *Aggregator) Finalize() Result {
a.global.Finalize(a.rateLimit)
a.global.UniqueQueries = uint(len(a.classes))
for _, class := range a.classes {
class.Finalize(a.rateLimit)
class.UniqueQueries = 1
if class.Example != nil && class.Example.Ts != "" {
if t, err := time.Parse("2006-01-02 15:04:05", class... | go | {
"resource": ""
} |
q18141 | NewSlowLogParser | train | func NewSlowLogParser(file *os.File, opt log.Options) *SlowLogParser {
if opt.DefaultLocation == nil {
// Old MySQL format assumes time is taken from SYSTEM.
opt.DefaultLocation = time.Local
}
p := &SlowLogParser{
file: file,
opt: opt,
// --
stopChan: make(chan bool, 1),
eventChan: make(chan *log... | go | {
"resource": ""
} |
q18142 | Stop | train | func (p *SlowLogParser) Stop() {
if p.opt.Debug {
l.Println("stopping")
}
p.stopChan <- true
return
} | go | {
"resource": ""
} |
q18143 | Start | train | func (p *SlowLogParser) Start() error {
if p.opt.Debug {
l.SetFlags(l.Ltime | l.Lmicroseconds)
fmt.Println()
l.Println("parsing " + p.file.Name())
}
// Seek to the offset, if any.
// @todo error if start off > file size
if p.opt.StartOffset > 0 {
if _, err := p.file.Seek(int64(p.opt.StartOffset), os.SEEK_... | go | {
"resource": ""
} |
q18144 | NewClass | train | func NewClass(id, fingerprint string, sample bool) *Class {
class := &Class{
Id: id,
Fingerprint: fingerprint,
Metrics: NewMetrics(),
TotalQueries: 0,
Example: &Example{},
sample: sample,
}
return class
} | go | {
"resource": ""
} |
q18145 | AddEvent | train | func (c *Class) AddEvent(e *log.Event, outlier bool) {
if outlier {
c.outliers++
} else {
c.TotalQueries++
}
c.Metrics.AddEvent(e, outlier)
// Save last db seen for this query. This helps ensure the sample query
// has a db.
if e.Db != "" {
c.lastDb = e.Db
}
if c.sample {
if n, ok := e.TimeMetrics["Q... | go | {
"resource": ""
} |
q18146 | AddClass | train | func (c *Class) AddClass(newClass *Class) {
c.UniqueQueries++
c.TotalQueries += newClass.TotalQueries
c.Example = nil
for newMetric, newStats := range newClass.Metrics.TimeMetrics {
stats, ok := c.Metrics.TimeMetrics[newMetric]
if !ok {
m := *newStats
c.Metrics.TimeMetrics[newMetric] = &m
} else {
s... | go | {
"resource": ""
} |
q18147 | Finalize | train | func (c *Class) Finalize(rateLimit uint) {
if rateLimit == 0 {
rateLimit = 1
}
c.TotalQueries = (c.TotalQueries * rateLimit) + c.outliers
c.Metrics.Finalize(rateLimit, c.TotalQueries)
if c.Example.QueryTime == 0 {
c.Example = nil
}
} | go | {
"resource": ""
} |
q18148 | NewEvent | train | func NewEvent() *Event {
event := new(Event)
event.TimeMetrics = make(map[string]float64)
event.NumberMetrics = make(map[string]uint64)
event.BoolMetrics = make(map[string]bool)
return event
} | go | {
"resource": ""
} |
q18149 | Id | train | func Id(fingerprint string) string {
id := md5.New()
io.WriteString(id, fingerprint)
h := fmt.Sprintf("%x", id.Sum(nil))
return strings.ToUpper(h[16:32])
} | go | {
"resource": ""
} |
q18150 | NewMetrics | train | func NewMetrics() *Metrics {
m := &Metrics{
TimeMetrics: make(map[string]*TimeStats),
NumberMetrics: make(map[string]*NumberStats),
BoolMetrics: make(map[string]*BoolStats),
}
return m
} | go | {
"resource": ""
} |
q18151 | AddEvent | train | func (m *Metrics) AddEvent(e *log.Event, outlier bool) {
for metric, val := range e.TimeMetrics {
stats, seenMetric := m.TimeMetrics[metric]
if !seenMetric {
m.TimeMetrics[metric] = &TimeStats{
vals: []float64{},
}
stats = m.TimeMetrics[metric]
}
if outlier {
stats.outlierSum += val
} else {... | go | {
"resource": ""
} |
q18152 | Finalize | train | func (m *Metrics) Finalize(rateLimit uint, totalQueries uint) {
if rateLimit == 0 {
rateLimit = 1
}
for _, s := range m.TimeMetrics {
sort.Float64s(s.vals)
cnt := len(s.vals)
s.Min = Float64(s.vals[0])
s.Med = Float64(s.vals[(50*cnt)/100]) // median = 50th percentile
s.P95 = Float64(s.vals[(95*cnt)/100... | go | {
"resource": ""
} |
q18153 | String | train | func (v SensorType) String() string {
if v == DHT11 {
return "DHT11"
} else if v == DHT12 {
return "DHT12"
} else if v == DHT22 || v == AM2302 {
return "DHT22|AM2302"
} else {
return "!!! unknown !!!"
}
} | go | {
"resource": ""
} |
q18154 | GetHandshakeDuration | train | func (v SensorType) GetHandshakeDuration() time.Duration {
if v == DHT11 {
return 18 * time.Millisecond
} else if v == DHT12 {
return 200 * time.Millisecond
} else if v == DHT22 || v == AM2302 {
return 18 * time.Millisecond
} else {
return 0
}
} | go | {
"resource": ""
} |
q18155 | dialDHTxxAndGetResponse | train | func dialDHTxxAndGetResponse(pin int, handshakeDur time.Duration,
boostPerfFlag bool) ([]Pulse, error) {
var arr *C.int32_t
var arrLen C.int32_t
var list []int32
var hsDurUsec C.int32_t = C.int32_t(handshakeDur / time.Microsecond)
var boost C.int32_t = 0
var err2 *C.Error
if boostPerfFlag {
boost = 1
}
// ... | go | {
"resource": ""
} |
q18156 | decodeByte | train | func decodeByte(tLow, tHigh0, tHigh1 time.Duration, start int, pulses []Pulse) (byte, error) {
if len(pulses)-start < 16 {
return 0, fmt.Errorf("Can't decode byte, since range between "+
"index and array length is less than 16: %d, %d", start, len(pulses))
}
HIGH_DUR_MAX := tLow + tHigh1
HIGH_LOW_DUR_AVG := ((... | go | {
"resource": ""
} |
q18157 | toMasks | train | func toMasks(ips []string) (masks []net.IPNet, err error) {
for _, cidr := range ips {
var network *net.IPNet
_, network, err = net.ParseCIDR(cidr)
if err != nil {
return
}
masks = append(masks, *network)
}
return
} | go | {
"resource": ""
} |
q18158 | ipInMasks | train | func ipInMasks(ip net.IP, masks []net.IPNet) bool {
for _, mask := range masks {
if mask.Contains(ip) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q18159 | IsPublicIP | train | func IsPublicIP(ip net.IP) bool {
if !ip.IsGlobalUnicast() {
return false
}
return !ipInMasks(ip, privateMasks)
} | go | {
"resource": ""
} |
q18160 | Parse | train | func Parse(ipList string) string {
for _, ip := range strings.Split(ipList, ",") {
ip = strings.TrimSpace(ip)
if IP := net.ParseIP(ip); IP != nil && IsPublicIP(IP) {
return ip
}
}
return ""
} | go | {
"resource": ""
} |
q18161 | GetRemoteAddr | train | func GetRemoteAddr(r *http.Request) string {
return GetRemoteAddrIfAllowed(r, func(sip string) bool { return true })
} | go | {
"resource": ""
} |
q18162 | GetRemoteAddrIfAllowed | train | func GetRemoteAddrIfAllowed(r *http.Request, allowed func(sip string) bool) string {
if xffh := r.Header.Get("X-Forwarded-For"); xffh != "" {
if sip, sport, err := net.SplitHostPort(r.RemoteAddr); err == nil && sip != "" {
if allowed(sip) {
if xip := Parse(xffh); xip != "" {
return net.JoinHostPort(xip, ... | go | {
"resource": ""
} |
q18163 | New | train | func New(options Options) (*XFF, error) {
allowedMasks, err := toMasks(options.AllowedSubnets)
if err != nil {
return nil, err
}
xff := &XFF{
allowAll: len(options.AllowedSubnets) == 0,
allowedMasks: allowedMasks,
}
if options.Debug {
xff.Log = log.New(os.Stdout, "[xff] ", log.LstdFlags)
}
return xf... | go | {
"resource": ""
} |
q18164 | Handler | train | func (xff *XFF) Handler(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.RemoteAddr = GetRemoteAddrIfAllowed(r, xff.allowed)
h.ServeHTTP(w, r)
})
} | go | {
"resource": ""
} |
q18165 | ServeHTTP | train | func (xff *XFF) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
r.RemoteAddr = GetRemoteAddrIfAllowed(r, xff.allowed)
next(w, r)
} | go | {
"resource": ""
} |
q18166 | allowed | train | func (xff *XFF) allowed(sip string) bool {
if xff.allowAll {
return true
} else if ip := net.ParseIP(sip); ip != nil && ipInMasks(ip, xff.allowedMasks) {
return true
}
return false
} | go | {
"resource": ""
} |
q18167 | Errorf | train | func Errorf(t *testing.T, format string, args ...interface{}) {
t.Error(Scolorf(ErrorColorSyntaxCode, format, args...))
} | go | {
"resource": ""
} |
q18168 | Fatalf | train | func Fatalf(t *testing.T, format string, args ...interface{}) {
t.Fatal(Scolorf(FatalColorSyntaxCode, format, args...))
} | go | {
"resource": ""
} |
q18169 | Dump | train | func Dump(t T, resp *http.Response) {
// dump request
var buffer bytes.Buffer
buffer.WriteString("\n")
buffer.WriteString(fmt.Sprintf("%v %v\n", resp.Request.Method, resp.Request.URL))
for k, v := range resp.Request.Header {
if IsMaskedHeader(k) {
v = []string{strings.Repeat(MaskChar, len(v[0]))}
}
if len... | go | {
"resource": ""
} |
q18170 | SkipUnless | train | func SkipUnless(t skippeable, labels ...string) {
env := strings.Split(os.Getenv("LABELS"), ",")
for _, each := range labels {
for _, other := range env {
if each == other {
return
}
}
}
t.Skipf("skipped because provided LABELS=%v does not include any of %v", env, labels)
} | go | {
"resource": ""
} |
q18171 | Logf | train | func (l Logger) Logf(format string, args ...interface{}) {
if l.InfoEnabled {
LoggingPrintf("\tinfo : "+tabify(format)+"\n", args...)
}
} | go | {
"resource": ""
} |
q18172 | Fatal | train | func (l Logger) Fatal(args ...interface{}) {
if l.ErrorEnabled {
LoggingPrintf("\tfatal: "+tabify("%s")+"\n", args...)
}
if l.ExitOnFatal {
os.Exit(1)
}
} | go | {
"resource": ""
} |
q18173 | CheckError | train | func CheckError(t T, err error) bool {
if err != nil {
logerror(t, serrorf("CheckError: did not expect to receive err: %v", err))
}
return err != nil
} | go | {
"resource": ""
} |
q18174 | ExpectHeader | train | func ExpectHeader(t T, r *http.Response, name, value string) bool {
if r == nil {
logerror(t, serrorf("ExpectHeader: got nil but want a Http response"))
return false
}
rname := r.Header.Get(name)
if rname != value {
logerror(t, serrorf("ExpectHeader: got header %s=%s but want %s", name, rname, value))
}
ret... | go | {
"resource": ""
} |
q18175 | ExpectJSONHash | train | func ExpectJSONHash(t T, r *http.Response, callback func(hash map[string]interface{})) bool {
if r == nil {
logerror(t, serrorf("ExpectJSONHash: no response available"))
return false
}
if r.Body == nil {
logerror(t, serrorf("ExpectJSONHash: no body to read"))
return false
}
data, err := ioutil.ReadAll(r.Bo... | go | {
"resource": ""
} |
q18176 | ExpectJSONArray | train | func ExpectJSONArray(t T, r *http.Response, callback func(array []interface{})) bool {
if r == nil {
logerror(t, serrorf("ExpectJSONArray: no response available"))
return false
}
if r.Body == nil {
logerror(t, serrorf("ExpectJSONArray: no body to read"))
return false
}
data, err := ioutil.ReadAll(r.Body)
... | go | {
"resource": ""
} |
q18177 | ExpectString | train | func ExpectString(t T, r *http.Response, callback func(content string)) bool {
if r == nil {
logerror(t, serrorf("ExpectString: no response available"))
return false
}
if r.Body == nil {
logerror(t, serrorf("ExpectString: no body to read"))
return false
}
data, err := ioutil.ReadAll(r.Body)
defer r.Body.C... | go | {
"resource": ""
} |
q18178 | NewConfig | train | func NewConfig(pathTemplate string, pathParams ...interface{}) *RequestConfig {
cfg := &RequestConfig{
HeaderMap: http.Header{},
Values: url.Values{},
}
cfg.Path(pathTemplate, pathParams...)
return cfg
} | go | {
"resource": ""
} |
q18179 | Do | train | func (r *RequestConfig) Do(block func(config *RequestConfig)) *RequestConfig {
block(r)
return r
} | go | {
"resource": ""
} |
q18180 | Query | train | func (r *RequestConfig) Query(name string, value interface{}) *RequestConfig {
r.Values.Add(name, fmt.Sprintf("%v", value))
return r
} | go | {
"resource": ""
} |
q18181 | Header | train | func (r *RequestConfig) Header(name, value string) *RequestConfig {
r.HeaderMap.Add(name, value)
return r
} | go | {
"resource": ""
} |
q18182 | Body | train | func (r *RequestConfig) Body(body string) *RequestConfig {
r.BodyReader = strings.NewReader(body)
return r
} | go | {
"resource": ""
} |
q18183 | Read | train | func (r *RequestConfig) Read(bodyReader io.Reader) *RequestConfig {
r.BodyReader = bodyReader
return r
} | go | {
"resource": ""
} |
q18184 | ProcessTemplate | train | func ProcessTemplate(t T, templateContent string, value interface{}) string {
tmp, err := template.New("temporary").Parse(templateContent)
if err != nil {
logfatal(t, sfatalf("failed to parse:%v", err))
return ""
}
var buf bytes.Buffer
err = tmp.Execute(&buf, value)
if err != nil {
logfatal(t, sfatalf("fail... | go | {
"resource": ""
} |
q18185 | structToMapString | train | func structToMapString(i interface{}) map[string][]string {
ms := map[string][]string{}
iv := reflect.ValueOf(i).Elem()
tp := iv.Type()
for i := 0; i < iv.NumField(); i++ {
k := tp.Field(i).Name
f := iv.Field(i)
ms[k] = valueToString(f)
}
return ms
} | go | {
"resource": ""
} |
q18186 | valueToString | train | func valueToString(f reflect.Value) []string {
var v []string
switch reflect.TypeOf(f.Interface()).Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v = []string{strconv.FormatInt(f.Int(), 10)}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
... | go | {
"resource": ""
} |
q18187 | SendSMS | train | func (s *MessageService) SendSMS(from, to, body string) (*Message, *Response, error) {
return s.Send(from, to, MessageParams{Body: body})
} | go | {
"resource": ""
} |
q18188 | NewClient | train | func NewClient(accountSid, authToken string, httpClient *http.Client) *Client {
if httpClient == nil {
httpClient = http.DefaultClient
}
baseURL, _ := url.Parse(apiBaseURL)
c := &Client{
client: httpClient,
UserAgent: userAgent,
BaseURL: baseURL,
AccountSid: accountSid,
AuthToken: authToken,
... | go | {
"resource": ""
} |
q18189 | getInts | train | func (hdr *rpmHeader) getInts(tag int) (buf interface{}, n int, err error) {
ent, ok := hdr.entries[tag]
if !ok {
return nil, 0, NewNoSuchTagError(tag)
}
n = len(ent.contents)
switch ent.dataType {
case RPM_INT8_TYPE:
buf = make([]uint8, n)
case RPM_INT16_TYPE:
n >>= 1
buf = make([]uint16, n)
case RPM_I... | go | {
"resource": ""
} |
q18190 | GetInts | train | func (hdr *rpmHeader) GetInts(tag int) ([]int, error) {
buf, n, err := hdr.getInts(tag)
if err != nil {
return nil, err
}
out := make([]int, n)
switch bvals := buf.(type) {
case []uint8:
for i, v := range bvals {
out[i] = int(v)
}
case []uint16:
for i, v := range bvals {
out[i] = int(v)
}
case [... | go | {
"resource": ""
} |
q18191 | GetUint32s | train | func (hdr *rpmHeader) GetUint32s(tag int) ([]uint32, error) {
buf, n, err := hdr.getInts(tag)
if err != nil {
return nil, err
}
if out, ok := buf.([]uint32); ok {
return out, nil
}
out := make([]uint32, n)
switch bvals := buf.(type) {
case []uint8:
for i, v := range bvals {
out[i] = uint32(v)
}
case... | go | {
"resource": ""
} |
q18192 | GetUint64s | train | func (hdr *rpmHeader) GetUint64s(tag int) ([]uint64, error) {
buf, n, err := hdr.getInts(tag)
if err != nil {
return nil, err
}
if out, ok := buf.([]uint64); ok {
return out, nil
}
out := make([]uint64, n)
switch bvals := buf.(type) {
case []uint8:
for i, v := range bvals {
out[i] = uint64(v)
}
case... | go | {
"resource": ""
} |
q18193 | GetUint64Fallback | train | func (hdr *rpmHeader) GetUint64Fallback(intTag, longTag int) ([]uint64, error) {
if _, ok := hdr.entries[longTag]; ok {
return hdr.GetUint64s(longTag)
} else {
return hdr.GetUint64s(intTag)
}
} | go | {
"resource": ""
} |
q18194 | InstalledSize | train | func (hdr *RpmHeader) InstalledSize() (int64, error) {
u, err := hdr.GetUint64Fallback(SIZE, LONGSIZE)
if err != nil {
return -1, err
}
return int64(u), nil
} | go | {
"resource": ""
} |
q18195 | PayloadSize | train | func (hdr *RpmHeader) PayloadSize() (int64, error) {
u, err := hdr.sigHeader.GetUint64Fallback(SIG_PAYLOADSIZE-_SIGHEADER_TAG_BASE, SIG_LONGARCHIVESIZE)
if err != nil {
return -1, err
} else if len(u) != 1 {
return -1, errors.New("incorrect number of values")
}
return int64(u[0]), err
} | go | {
"resource": ""
} |
q18196 | SignRpmStream | train | func SignRpmStream(stream io.Reader, key *packet.PrivateKey, opts *SignatureOptions) (header *RpmHeader, err error) {
lead, sigHeader, err := readSignatureHeader(stream)
if err != nil {
return
}
// parse the general header and also tee it into a buffer
genHeaderBuf := new(bytes.Buffer)
headerTee := io.TeeReader... | go | {
"resource": ""
} |
q18197 | SignRpmFileIntoStream | train | func SignRpmFileIntoStream(outstream io.Writer, infile io.ReadSeeker, key *packet.PrivateKey, opts *SignatureOptions) error {
header, err := SignRpmStream(infile, key, opts)
if err != nil {
return err
}
delete(header.sigHeader.entries, SIG_RESERVEDSPACE-_SIGHEADER_TAG_BASE)
return writeRpm(infile, outstream, hea... | go | {
"resource": ""
} |
q18198 | uncompressRpmPayloadReader | train | func uncompressRpmPayloadReader(r io.Reader, hdr *RpmHeader) (io.Reader, error) {
// Check to make sure payload format is a cpio archive. If the tag does
// not exist, assume archive is cpio.
if hdr.HasTag(PAYLOADFORMAT) {
val, err := hdr.GetString(PAYLOADFORMAT)
if err != nil {
return nil, err
}
if val !... | go | {
"resource": ""
} |
q18199 | Less | train | func (vs VersionSlice) Less(i, j int) bool {
return Vercmp(vs[i], vs[j]) == -1
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.