_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q6400 | UnmarshalYAML | train | func (c *HTTPClientConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
type plain HTTPClientConfig
if err := unmarshal((*plain)(c)); err != nil {
return err
}
return c.Validate()
} | go | {
"resource": ""
} |
q6401 | newClient | train | func newClient(rt http.RoundTripper) *http.Client {
return &http.Client{Transport: rt}
} | go | {
"resource": ""
} |
q6402 | NewClientFromConfig | train | func NewClientFromConfig(cfg HTTPClientConfig, name string) (*http.Client, error) {
rt, err := NewRoundTripperFromConfig(cfg, name)
if err != nil {
return nil, err
}
return newClient(rt), nil
} | go | {
"resource": ""
} |
q6403 | NewRoundTripperFromConfig | train | func NewRoundTripperFromConfig(cfg HTTPClientConfig, name string) (http.RoundTripper, error) {
newRT := func(tlsConfig *tls.Config) (http.RoundTripper, error) {
// The only timeout we care about is the configured scrape timeout.
// It is applied on request. So we leave out any timings here.
var rt http.RoundTrip... | go | {
"resource": ""
} |
q6404 | NewBearerAuthFileRoundTripper | train | func NewBearerAuthFileRoundTripper(bearerFile string, rt http.RoundTripper) http.RoundTripper {
return &bearerAuthFileRoundTripper{bearerFile, rt}
} | go | {
"resource": ""
} |
q6405 | NewTLSConfig | train | func NewTLSConfig(cfg *TLSConfig) (*tls.Config, error) {
tlsConfig := &tls.Config{InsecureSkipVerify: cfg.InsecureSkipVerify}
// If a CA cert is provided then let's read it in so we can validate the
// scrape target's certificate properly.
if len(cfg.CAFile) > 0 {
b, err := readCAFile(cfg.CAFile)
if err != nil... | go | {
"resource": ""
} |
q6406 | getClientCertificate | train | func (c *TLSConfig) getClientCertificate(*tls.CertificateRequestInfo) (*tls.Certificate, error) {
cert, err := tls.LoadX509KeyPair(c.CertFile, c.KeyFile)
if err != nil {
return nil, fmt.Errorf("unable to use specified client cert (%s) & key (%s): %s", c.CertFile, c.KeyFile, err)
}
return &cert, nil
} | go | {
"resource": ""
} |
q6407 | readCAFile | train | func readCAFile(f string) ([]byte, error) {
data, err := ioutil.ReadFile(f)
if err != nil {
return nil, fmt.Errorf("unable to load specified CA cert %s: %s", f, err)
}
return data, nil
} | go | {
"resource": ""
} |
q6408 | updateRootCA | train | func updateRootCA(cfg *tls.Config, b []byte) bool {
caCertPool := x509.NewCertPool()
if !caCertPool.AppendCertsFromPEM(b) {
return false
}
cfg.RootCAs = caCertPool
return true
} | go | {
"resource": ""
} |
q6409 | RoundTrip | train | func (t *tlsRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
b, h, err := t.getCAWithHash()
if err != nil {
return nil, err
}
t.mtx.RLock()
equal := bytes.Equal(h[:], t.hashCAFile)
rt := t.rt
t.mtx.RUnlock()
if equal {
// The CA cert hasn't changed, use the existing RoundTripper.
retu... | go | {
"resource": ""
} |
q6410 | labelSetToFastFingerprint | train | func labelSetToFastFingerprint(ls LabelSet) Fingerprint {
if len(ls) == 0 {
return Fingerprint(emptyLabelSignature)
}
var result uint64
for labelName, labelValue := range ls {
sum := hashNew()
sum = hashAdd(sum, string(labelName))
sum = hashAddByte(sum, SeparatorByte)
sum = hashAdd(sum, string(labelValue... | go | {
"resource": ""
} |
q6411 | sourced | train | func (l logger) sourced() *logrus.Entry {
_, file, line, ok := runtime.Caller(2)
if !ok {
file = "<???>"
line = 1
} else {
slash := strings.LastIndex(file, "/")
file = file[slash+1:]
}
return l.entry.WithField("source", fmt.Sprintf("%s:%d", file, line))
} | go | {
"resource": ""
} |
q6412 | NewLogger | train | func NewLogger(w io.Writer) Logger {
l := logrus.New()
l.Out = w
return logger{entry: logrus.NewEntry(l)}
} | go | {
"resource": ""
} |
q6413 | NewNopLogger | train | func NewNopLogger() Logger {
l := logrus.New()
l.Out = ioutil.Discard
return logger{entry: logrus.NewEntry(l)}
} | go | {
"resource": ""
} |
q6414 | Equal | train | func (m Metric) Equal(o Metric) bool {
return LabelSet(m).Equal(LabelSet(o))
} | go | {
"resource": ""
} |
q6415 | Before | train | func (m Metric) Before(o Metric) bool {
return LabelSet(m).Before(LabelSet(o))
} | go | {
"resource": ""
} |
q6416 | Clone | train | func (m Metric) Clone() Metric {
clone := make(Metric, len(m))
for k, v := range m {
clone[k] = v
}
return clone
} | go | {
"resource": ""
} |
q6417 | IsValidMetricName | train | func IsValidMetricName(n LabelValue) bool {
if len(n) == 0 {
return false
}
for i, b := range n {
if !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || b == ':' || (b >= '0' && b <= '9' && i > 0)) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q6418 | NewCollector | train | func NewCollector(program string) *prometheus.GaugeVec {
buildInfo := prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Namespace: program,
Name: "build_info",
Help: fmt.Sprintf(
"A metric with a constant '1' value labeled by version, revision, branch, and goversion from which %s was built.",
progr... | go | {
"resource": ""
} |
q6419 | Print | train | func Print(program string) string {
m := map[string]string{
"program": program,
"version": Version,
"revision": Revision,
"branch": Branch,
"buildUser": BuildUser,
"buildDate": BuildDate,
"goVersion": GoVersion,
}
t := template.Must(template.New("version").Parse(versionInfoTmpl))
var buf byte... | go | {
"resource": ""
} |
q6420 | Set | train | func (l *AllowedLevel) Set(s string) error {
switch s {
case "debug":
l.o = level.AllowDebug()
case "info":
l.o = level.AllowInfo()
case "warn":
l.o = level.AllowWarn()
case "error":
l.o = level.AllowError()
default:
return errors.Errorf("unrecognized log level %q", s)
}
l.s = s
return nil
} | go | {
"resource": ""
} |
q6421 | Set | train | func (f *AllowedFormat) Set(s string) error {
switch s {
case "logfmt", "json":
f.s = s
default:
return errors.Errorf("unrecognized log format %q", s)
}
return nil
} | go | {
"resource": ""
} |
q6422 | New | train | func New(config *Config) log.Logger {
var l log.Logger
if config.Format.s == "logfmt" {
l = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
} else {
l = log.NewJSONLogger(log.NewSyncWriter(os.Stderr))
}
l = level.NewFilter(l, config.Level.o)
l = log.With(l, "ts", timestampFormat, "caller", log.DefaultCalle... | go | {
"resource": ""
} |
q6423 | Validate | train | func (ls LabelSet) Validate() error {
for ln, lv := range ls {
if !ln.IsValid() {
return fmt.Errorf("invalid name %q", ln)
}
if !lv.IsValid() {
return fmt.Errorf("invalid value %q", lv)
}
}
return nil
} | go | {
"resource": ""
} |
q6424 | Clone | train | func (ls LabelSet) Clone() LabelSet {
lsn := make(LabelSet, len(ls))
for ln, lv := range ls {
lsn[ln] = lv
}
return lsn
} | go | {
"resource": ""
} |
q6425 | Merge | train | func (l LabelSet) Merge(other LabelSet) LabelSet {
result := make(LabelSet, len(l))
for k, v := range l {
result[k] = v
}
for k, v := range other {
result[k] = v
}
return result
} | go | {
"resource": ""
} |
q6426 | Add | train | func (t Time) Add(d time.Duration) Time {
return t + Time(d/minimumTick)
} | go | {
"resource": ""
} |
q6427 | Sub | train | func (t Time) Sub(o Time) time.Duration {
return time.Duration(t-o) * minimumTick
} | go | {
"resource": ""
} |
q6428 | Time | train | func (t Time) Time() time.Time {
return time.Unix(int64(t)/second, (int64(t)%second)*nanosPerTick)
} | go | {
"resource": ""
} |
q6429 | String | train | func (t Time) String() string {
return strconv.FormatFloat(float64(t)/float64(second), 'f', -1, 64)
} | go | {
"resource": ""
} |
q6430 | ParseDuration | train | func ParseDuration(durationStr string) (Duration, error) {
matches := durationRE.FindStringSubmatch(durationStr)
if len(matches) != 3 {
return 0, fmt.Errorf("not a valid duration string: %q", durationStr)
}
var (
n, _ = strconv.Atoi(matches[1])
dur = time.Duration(n) * time.Millisecond
)
switch unit := mat... | go | {
"resource": ""
} |
q6431 | Equal | train | func (v SampleValue) Equal(o SampleValue) bool {
if v == o {
return true
}
return math.IsNaN(float64(v)) && math.IsNaN(float64(o))
} | go | {
"resource": ""
} |
q6432 | Equal | train | func (s *SamplePair) Equal(o *SamplePair) bool {
return s == o || (s.Value.Equal(o.Value) && s.Timestamp.Equal(o.Timestamp))
} | go | {
"resource": ""
} |
q6433 | Equal | train | func (s *Sample) Equal(o *Sample) bool {
if s == o {
return true
}
if !s.Metric.Equal(o.Metric) {
return false
}
if !s.Timestamp.Equal(o.Timestamp) {
return false
}
return s.Value.Equal(o.Value)
} | go | {
"resource": ""
} |
q6434 | parseError | train | func (p *TextParser) parseError(msg string) {
p.err = ParseError{
Line: p.lineCount,
Msg: msg,
}
} | go | {
"resource": ""
} |
q6435 | readTokenAsLabelValue | train | func (p *TextParser) readTokenAsLabelValue() {
p.currentToken.Reset()
escaped := false
for {
if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil {
return
}
if escaped {
switch p.currentByte {
case '"', '\\':
p.currentToken.WriteByte(p.currentByte)
case 'n':
p.currentToken.WriteByte('\n... | go | {
"resource": ""
} |
q6436 | Param | train | func Param(ctx context.Context, p string) string {
if v := ctx.Value(param(p)); v != nil {
return v.(string)
}
return ""
} | go | {
"resource": ""
} |
q6437 | WithParam | train | func WithParam(ctx context.Context, p, v string) context.Context {
return context.WithValue(ctx, param(p), v)
} | go | {
"resource": ""
} |
q6438 | WithInstrumentation | train | func (r *Router) WithInstrumentation(instrh func(handlerName string, handler http.HandlerFunc) http.HandlerFunc) *Router {
return &Router{rtr: r.rtr, prefix: r.prefix, instrh: instrh}
} | go | {
"resource": ""
} |
q6439 | WithPrefix | train | func (r *Router) WithPrefix(prefix string) *Router {
return &Router{rtr: r.rtr, prefix: r.prefix + prefix, instrh: r.instrh}
} | go | {
"resource": ""
} |
q6440 | handle | train | func (r *Router) handle(handlerName string, h http.HandlerFunc) httprouter.Handle {
if r.instrh != nil {
// This needs to be outside the closure to avoid data race when reading and writing to 'h'.
h = r.instrh(handlerName, h)
}
return func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
c... | go | {
"resource": ""
} |
q6441 | Get | train | func (r *Router) Get(path string, h http.HandlerFunc) {
r.rtr.GET(r.prefix+path, r.handle(path, h))
} | go | {
"resource": ""
} |
q6442 | Options | train | func (r *Router) Options(path string, h http.HandlerFunc) {
r.rtr.OPTIONS(r.prefix+path, r.handle(path, h))
} | go | {
"resource": ""
} |
q6443 | Del | train | func (r *Router) Del(path string, h http.HandlerFunc) {
r.rtr.DELETE(r.prefix+path, r.handle(path, h))
} | go | {
"resource": ""
} |
q6444 | Put | train | func (r *Router) Put(path string, h http.HandlerFunc) {
r.rtr.PUT(r.prefix+path, r.handle(path, h))
} | go | {
"resource": ""
} |
q6445 | Post | train | func (r *Router) Post(path string, h http.HandlerFunc) {
r.rtr.POST(r.prefix+path, r.handle(path, h))
} | go | {
"resource": ""
} |
q6446 | Redirect | train | func (r *Router) Redirect(w http.ResponseWriter, req *http.Request, path string, code int) {
http.Redirect(w, req, r.prefix+path, code)
} | go | {
"resource": ""
} |
q6447 | ResponseFormat | train | func ResponseFormat(h http.Header) Format {
ct := h.Get(hdrContentType)
mediatype, params, err := mime.ParseMediaType(ct)
if err != nil {
return FmtUnknown
}
const textType = "text/plain"
switch mediatype {
case ProtoType:
if p, ok := params["proto"]; ok && p != ProtoProtocol {
return FmtUnknown
}
... | go | {
"resource": ""
} |
q6448 | NewDecoder | train | func NewDecoder(r io.Reader, format Format) Decoder {
switch format {
case FmtProtoDelim:
return &protoDecoder{r: r}
}
return &textDecoder{r: r}
} | go | {
"resource": ""
} |
q6449 | Decode | train | func (sd *SampleDecoder) Decode(s *model.Vector) error {
err := sd.Dec.Decode(&sd.f)
if err != nil {
return err
}
*s, err = extractSamples(&sd.f, sd.Opts)
return err
} | go | {
"resource": ""
} |
q6450 | ExtractSamples | train | func ExtractSamples(o *DecodeOptions, fams ...*dto.MetricFamily) (model.Vector, error) {
var (
all model.Vector
lastErr error
)
for _, f := range fams {
some, err := extractSamples(f, o)
if err != nil {
lastErr = err
continue
}
all = append(all, some...)
}
return all, lastErr
} | go | {
"resource": ""
} |
q6451 | UnmarshalYAML | train | func (s *Secret) UnmarshalYAML(unmarshal func(interface{}) error) error {
type plain Secret
return unmarshal((*plain)(s))
} | go | {
"resource": ""
} |
q6452 | MetricFamilyToText | train | func MetricFamilyToText(out io.Writer, in *dto.MetricFamily) (written int, err error) {
// Fail-fast checks.
if len(in.Metric) == 0 {
return 0, fmt.Errorf("MetricFamily has no metrics: %s", in)
}
name := in.GetName()
if name == "" {
return 0, fmt.Errorf("MetricFamily has no name: %s", in)
}
// Try the inter... | go | {
"resource": ""
} |
q6453 | writeFloat | train | func writeFloat(w enhancedWriter, f float64) (int, error) {
switch {
case f == 1:
return 1, w.WriteByte('1')
case f == 0:
return 1, w.WriteByte('0')
case f == -1:
return w.WriteString("-1")
case math.IsNaN(f):
return w.WriteString("NaN")
case math.IsInf(f, +1):
return w.WriteString("+Inf")
case math.Is... | go | {
"resource": ""
} |
q6454 | writeInt | train | func writeInt(w enhancedWriter, i int64) (int, error) {
bp := numBufPool.Get().(*[]byte)
*bp = strconv.AppendInt((*bp)[:0], i, 10)
written, err := w.Write(*bp)
numBufPool.Put(bp)
return written, err
} | go | {
"resource": ""
} |
q6455 | Validate | train | func (a *Alert) Validate() error {
if a.StartsAt.IsZero() {
return fmt.Errorf("start time missing")
}
if !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) {
return fmt.Errorf("start time must be before end time")
}
if err := a.Labels.Validate(); err != nil {
return fmt.Errorf("invalid label set: %s", err)
}... | go | {
"resource": ""
} |
q6456 | HasFiring | train | func (as Alerts) HasFiring() bool {
for _, a := range as {
if !a.Resolved() {
return true
}
}
return false
} | go | {
"resource": ""
} |
q6457 | IsValid | train | func (ln LabelName) IsValid() bool {
if len(ln) == 0 {
return false
}
for i, b := range ln {
if !((b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || b == '_' || (b >= '0' && b <= '9' && i > 0)) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q6458 | Validate | train | func (m *Matcher) Validate() error {
if !m.Name.IsValid() {
return fmt.Errorf("invalid name %q", m.Name)
}
if m.IsRegex {
if _, err := regexp.Compile(m.Value); err != nil {
return fmt.Errorf("invalid regular expression %q", m.Value)
}
} else if !LabelValue(m.Value).IsValid() || len(m.Value) == 0 {
return... | go | {
"resource": ""
} |
q6459 | Validate | train | func (s *Silence) Validate() error {
if len(s.Matchers) == 0 {
return fmt.Errorf("at least one matcher required")
}
for _, m := range s.Matchers {
if err := m.Validate(); err != nil {
return fmt.Errorf("invalid matcher: %s", err)
}
}
if s.StartsAt.IsZero() {
return fmt.Errorf("start time missing")
}
i... | go | {
"resource": ""
} |
q6460 | Dial | train | func Dial(n, addr string) (*Conn, error) {
uaddr, err := net.ResolveUDPAddr(n, addr)
if err != nil {
return nil, err
}
s, err := net.DialUDP("udp", nil, uaddr)
if err != nil {
return nil, err
}
return &Conn{s, make([]byte, maxPktLen)}, nil
} | go | {
"resource": ""
} |
q6461 | Send | train | func (c *Conn) Send(req Message) (*Message, error) {
err := Transmit(c.conn, nil, req)
if err != nil {
return nil, err
}
if !req.IsConfirmable() {
return nil, nil
}
rv, err := Receive(c.conn, c.buf)
if err != nil {
return nil, err
}
return &rv, nil
} | go | {
"resource": ""
} |
q6462 | pathMatch | train | func pathMatch(pattern, path string) bool {
if len(pattern) == 0 {
// should not happen
return false
}
n := len(pattern)
if pattern[n-1] != '/' {
return pattern == path
}
return len(path) >= n && path[0:n] == pattern
} | go | {
"resource": ""
} |
q6463 | ServeCOAP | train | func (mux *ServeMux) ServeCOAP(l *net.UDPConn, a *net.UDPAddr, m *Message) *Message {
h, _ := mux.match(m.PathString())
if h == nil {
h, _ = funcHandler(notFoundHandler), ""
}
// TODO: Rewrite path?
return h.ServeCOAP(l, a, m)
} | go | {
"resource": ""
} |
q6464 | Handle | train | func (mux *ServeMux) Handle(pattern string, handler Handler) {
for pattern != "" && pattern[0] == '/' {
pattern = pattern[1:]
}
if pattern == "" {
panic("http: invalid pattern " + pattern)
}
if handler == nil {
panic("http: nil handler")
}
mux.m[pattern] = muxEntry{h: handler, pattern: pattern}
} | go | {
"resource": ""
} |
q6465 | HandleFunc | train | func (mux *ServeMux) HandleFunc(pattern string,
f func(l *net.UDPConn, a *net.UDPAddr, m *Message) *Message) {
mux.Handle(pattern, FuncHandler(f))
} | go | {
"resource": ""
} |
q6466 | FuncHandler | train | func FuncHandler(f func(l *net.UDPConn, a *net.UDPAddr, m *Message) *Message) Handler {
return funcHandler(f)
} | go | {
"resource": ""
} |
q6467 | Transmit | train | func Transmit(l *net.UDPConn, a *net.UDPAddr, m Message) error {
d, err := m.MarshalBinary()
if err != nil {
return err
}
if a == nil {
_, err = l.Write(d)
} else {
_, err = l.WriteTo(d, a)
}
return err
} | go | {
"resource": ""
} |
q6468 | ListenAndServe | train | func ListenAndServe(n, addr string, rh Handler) error {
uaddr, err := net.ResolveUDPAddr(n, addr)
if err != nil {
return err
}
l, err := net.ListenUDP(n, uaddr)
if err != nil {
return err
}
return Serve(l, rh)
} | go | {
"resource": ""
} |
q6469 | Options | train | func (m Message) Options(o OptionID) []interface{} {
var rv []interface{}
for _, v := range m.opts {
if o == v.ID {
rv = append(rv, v.Value)
}
}
return rv
} | go | {
"resource": ""
} |
q6470 | Option | train | func (m Message) Option(o OptionID) interface{} {
for _, v := range m.opts {
if o == v.ID {
return v.Value
}
}
return nil
} | go | {
"resource": ""
} |
q6471 | RemoveOption | train | func (m *Message) RemoveOption(opID OptionID) {
m.opts = m.opts.Minus(opID)
} | go | {
"resource": ""
} |
q6472 | AddOption | train | func (m *Message) AddOption(opID OptionID, val interface{}) {
iv := reflect.ValueOf(val)
if (iv.Kind() == reflect.Slice || iv.Kind() == reflect.Array) &&
iv.Type().Elem().Kind() == reflect.String {
for i := 0; i < iv.Len(); i++ {
m.opts = append(m.opts, option{opID, iv.Index(i).Interface()})
}
return
}
m... | go | {
"resource": ""
} |
q6473 | SetOption | train | func (m *Message) SetOption(opID OptionID, val interface{}) {
m.RemoveOption(opID)
m.AddOption(opID, val)
} | go | {
"resource": ""
} |
q6474 | MarshalBinary | train | func (m *Message) MarshalBinary() ([]byte, error) {
tmpbuf := []byte{0, 0}
binary.BigEndian.PutUint16(tmpbuf, m.MessageID)
/*
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+... | go | {
"resource": ""
} |
q6475 | ParseMessage | train | func ParseMessage(data []byte) (Message, error) {
rv := Message{}
return rv, rv.UnmarshalBinary(data)
} | go | {
"resource": ""
} |
q6476 | Decode | train | func Decode(r io.Reader) (*TcpMessage, error) {
var ln uint16
err := binary.Read(r, binary.BigEndian, &ln)
if err != nil {
return nil, err
}
packet := make([]byte, ln)
_, err = io.ReadFull(r, packet)
if err != nil {
return nil, err
}
m := TcpMessage{}
err = m.UnmarshalBinary(packet)
return &m, err
} | go | {
"resource": ""
} |
q6477 | isDate | train | func isDate(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
_, err := time.Parse("2006-01-02", s)
return err == nil
} | go | {
"resource": ""
} |
q6478 | isTime | train | func isTime(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
if _, err := time.Parse("15:04:05Z07:00", s); err == nil {
return true
}
if _, err := time.Parse("15:04:05.999999999Z07:00", s); err == nil {
return true
}
return false
} | go | {
"resource": ""
} |
q6479 | isIPV4 | train | func isIPV4(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
groups := strings.Split(s, ".")
if len(groups) != 4 {
return false
}
for _, group := range groups {
n, err := strconv.Atoi(group)
if err != nil {
return false
}
if n < 0 || n > 255 {
return false
}
}
return true
} | go | {
"resource": ""
} |
q6480 | isIPV6 | train | func isIPV6(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
if !strings.Contains(s, ":") {
return false
}
return net.ParseIP(s) != nil
} | go | {
"resource": ""
} |
q6481 | isURI | train | func isURI(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
u, err := url.Parse(s)
return err == nil && u.IsAbs()
} | go | {
"resource": ""
} |
q6482 | isURITemplate | train | func isURITemplate(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
u, err := url.Parse(s)
if err != nil {
return false
}
for _, item := range strings.Split(u.RawPath, "/") {
depth := 0
for _, ch := range item {
switch ch {
case '{':
depth++
if depth != 1 {
return fals... | go | {
"resource": ""
} |
q6483 | isRegex | train | func isRegex(v interface{}) bool {
s, ok := v.(string)
if !ok {
return false
}
_, err := regexp.Compile(s)
return err == nil
} | go | {
"resource": ""
} |
q6484 | DecodeJSON | train | func DecodeJSON(r io.Reader) (interface{}, error) {
decoder := json.NewDecoder(r)
decoder.UseNumber()
var doc interface{}
if err := decoder.Decode(&doc); err != nil {
return nil, err
}
if t, _ := decoder.Token(); t != nil {
return nil, fmt.Errorf("invalid character %v after top-level value", t)
}
return doc... | go | {
"resource": ""
} |
q6485 | jsonType | train | func jsonType(v interface{}) string {
switch v.(type) {
case nil:
return "null"
case bool:
return "boolean"
case json.Number, float64, int, int32, int64:
return "number"
case string:
return "string"
case []interface{}:
return "array"
case map[string]interface{}:
return "object"
}
panic(InvalidJSONT... | go | {
"resource": ""
} |
q6486 | equals | train | func equals(v1, v2 interface{}) bool {
v1Type := jsonType(v1)
if v1Type != jsonType(v2) {
return false
}
switch v1Type {
case "array":
arr1, arr2 := v1.([]interface{}), v2.([]interface{})
if len(arr1) != len(arr2) {
return false
}
for i := range arr1 {
if !equals(arr1[i], arr2[i]) {
return fals... | go | {
"resource": ""
} |
q6487 | escape | train | func escape(token string) string {
token = strings.Replace(token, "~", "~0", -1)
token = strings.Replace(token, "/", "~1", -1)
return url.PathEscape(token)
} | go | {
"resource": ""
} |
q6488 | AddResource | train | func (c *Compiler) AddResource(url string, r io.Reader) error {
res, err := newResource(url, r)
if err != nil {
return err
}
c.resources[res.url] = res
return nil
} | go | {
"resource": ""
} |
q6489 | Compile | train | func (c *Compiler) Compile(url string) (*Schema, error) {
base, fragment := split(url)
if _, ok := c.resources[base]; !ok {
r, err := LoadURL(base)
if err != nil {
return nil, err
}
defer r.Close()
if err := c.AddResource(base, r); err != nil {
return nil, err
}
}
r := c.resources[base]
if r.draf... | go | {
"resource": ""
} |
q6490 | BackgroundRun | train | func (u *Updater) BackgroundRun() error {
if err := os.MkdirAll(u.getExecRelativeDir(u.Dir), 0777); err != nil {
// fail
return err
}
if u.wantUpdate() {
if err := up.CanUpdate(); err != nil {
// fail
return err
}
//self, err := osext.Executable()
//if err != nil {
// fail update, couldn't figure... | go | {
"resource": ""
} |
q6491 | Fetch | train | func (httpRequester *HTTPRequester) Fetch(url string) (io.ReadCloser, error) {
resp, err := http.Get(url)
if err != nil {
return nil, err
}
if resp.StatusCode != 200 {
return nil, fmt.Errorf("bad http status from %s: %v", url, resp.Status)
}
return resp.Body, nil
} | go | {
"resource": ""
} |
q6492 | InitLabels | train | func InitLabels(options []string) (plabel string, mlabel string, Err error) {
if !selinux.GetEnabled() {
return "", "", nil
}
processLabel, mountLabel := selinux.ContainerLabels()
if processLabel != "" {
defer func() {
if Err != nil {
ReleaseLabel(mountLabel)
}
}()
pcon, err := selinux.NewContext(... | go | {
"resource": ""
} |
q6493 | SetFileLabel | train | func SetFileLabel(path string, fileLabel string) error {
if selinux.GetEnabled() && fileLabel != "" {
return selinux.SetFileLabel(path, fileLabel)
}
return nil
} | go | {
"resource": ""
} |
q6494 | SetFileCreateLabel | train | func SetFileCreateLabel(fileLabel string) error {
if selinux.GetEnabled() {
return selinux.SetFSCreateLabel(fileLabel)
}
return nil
} | go | {
"resource": ""
} |
q6495 | Relabel | train | func Relabel(path string, fileLabel string, shared bool) error {
if !selinux.GetEnabled() {
return nil
}
if fileLabel == "" {
return nil
}
exclude_paths := map[string]bool{
"/": true,
"/bin": true,
"/boot": true,
"/dev": true,
"/etc": true,
"/etc/passwd": true... | go | {
"resource": ""
} |
q6496 | Validate | train | func Validate(label string) error {
if strings.Contains(label, "z") && strings.Contains(label, "Z") {
return ErrIncompatibleLabel
}
return nil
} | go | {
"resource": ""
} |
q6497 | RelabelNeeded | train | func RelabelNeeded(label string) bool {
return strings.Contains(label, "z") || strings.Contains(label, "Z")
} | go | {
"resource": ""
} |
q6498 | findSELinuxfsMount | train | func findSELinuxfsMount(s *bufio.Scanner) string {
for s.Scan() {
txt := s.Text()
// The first field after - is fs type.
// Safe as spaces in mountpoints are encoded as \040
if !strings.Contains(txt, " - selinuxfs ") {
continue
}
const mPos = 5 // mount point is 5th field
fields := strings.SplitN(txt,... | go | {
"resource": ""
} |
q6499 | SetFileLabel | train | func SetFileLabel(fpath string, label string) error {
if fpath == "" {
return ErrEmptyPath
}
return lsetxattr(fpath, xattrNameSelinux, []byte(label), 0)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.