id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c174200 | error", err.Error())
}
response, berr := s.send(request, nil)
if berr != nil {
return berr
}
defer response.Body.Close()
return nil
} | |
c174201 | %s", string(body))
if response.StatusCode == http.StatusNoContent || response.ContentLength == 0 {
return nil
}
if err := json.Unmarshal(body, &dest); err != nil {
return NewBambouError("HTTP Unmarshaling error", err.Error())
}
return nil
} | |
c174202 | berr
}
defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)
log.Debugf("Response Body: %s", string(body))
dest := IdentifiablesList{child}
if err := json.Unmarshal(body, &dest); err != nil {
return NewBambouError("JSON Unmarshaling error", err.Error())
}
return nil
} | |
c174203 | request, err := http.NewRequest("PUT", url, buffer)
if err != nil {
return NewBambouError("HTTP transaction error", err.Error())
}
response, berr := s.send(request, nil)
if berr != nil {
return berr
}
defer response.Body.Close()
return nil
} | |
c174204 | err.Error())
}
response, berr := s.send(request, nil)
if berr != nil {
return berr
}
defer response.Body.Close()
notification := NewNotification()
if err := json.NewDecoder(response.Body).Decode(notification); err != nil {
return NewBambouError("JSON error", err.Error())
}
if len(notification.Events) > 0 {
channel <- notification
}
return nil
} | |
c174205 | fmt.Sprintf("<Identity %s|%s>", i.Name, i.Category)
} | |
c174206 | make(chan bool),
handlers: eventHandlers{},
session: session,
}
} | |
c174207 | p.defaultHander = handler
return
}
p.handlers[identity.Name] = handler
} | |
c174208 |
p.defaultHander = nil
return
}
if _, exists := p.handlers[identity.Name]; exists {
delete(p.handlers, identity.Name)
}
} | |
c174209 | == AllIdentity.Name {
return p.defaultHander != nil
}
_, exists := p.handlers[identity.Name]
return exists
} | |
c174210 | }
event.Data = buffer.Bytes()
lastEventID = notification.UUID
if p.defaultHander != nil {
p.defaultHander(event)
}
if handler, exists := p.handlers[event.EntityType]; exists {
handler(event)
}
}
case <-p.stop:
return
}
}
}()
return nil
} | |
c174211 | p.stop <- true
p.isRunning = false
return nil
} | |
c174212 |
defaultLogger = logger
logger.SetLevel(logging.ERROR)
}
return defaultLogger
} | |
c174213 | totalcount: %d>", f.Page, f.PageSize, f.TotalCount)
} | |
c174214 | 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
DisableKeepAlives: true,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}},
apiKey: apiKey,
URL: DefaultURL,
}
} | |
c174215 | = zlw
}
if err := json.NewEncoder(dst).Encode(&series); err != nil {
return err
}
if c, ok := dst.(io.Closer); ok {
if err := c.Close(); err != nil {
return err
}
}
return c.post(buf.Bytes(), 0)
} | |
c174216 |
sort.Strings(tags)
return name + "|" + strings.Join(tags, ",")
} | |
c174217 | strings.LastIndexByte(metricID, '|')
if pos > 0 && pos < len(metricID)-1 {
return metricID[:pos], strings.Split(metricID[pos+1:], ",")
}
return metricID, nil
} | |
c174218 | time.Now().UnixNano(),
unit: d.Seconds(),
}
} | |
c174219 |
return r.count.Snapshot() / dur.Seconds() * r.unit
} | |
c174220 | time: time.Now().UnixNano(),
unit: d.Seconds(),
},
}
} | |
c174221 | d.rate.Update(v - math.Float64frombits(p))
} | |
c174222 |
r.m.Lock()
h = r.hist.Copy(h)
r.m.Unlock()
return h
} | |
c174223 |
atomic.StoreUint64(&g.value, math.Float64bits(v))
} | |
c174224 | return math.Float64frombits(u)
} | |
c174225 |
instruments: make(map[string]interface{}),
prefix: prefix,
tags: tags,
}
} | |
c174226 |
r.reporters = append(r.reporters, rep)
r.mutex.Unlock()
} | |
c174227 | := MetricID(name, tags)
r.mutex.RLock()
v := r.instruments[key]
r.mutex.RUnlock()
return v
} | |
c174228 | MetricID(name, tags)
r.mutex.Lock()
r.instruments[key] = v
r.mutex.Unlock()
}
} | |
c174229 |
if v, ok = r.instruments[key]; !ok {
switch v = factory(); v.(type) {
case Discrete, Sample:
r.instruments[key] = v
}
}
return v
} | |
c174230 |
r.mutex.RUnlock()
return size
} | |
c174231 |
r.mutex.RUnlock()
return tags
} | |
c174232 | r.tags = tags
r.mutex.Unlock()
} | |
c174233 | append(r.tags, tags...)
r.mutex.Unlock()
} | |
c174234 |
close(r.closing)
return <-r.closed
} | |
c174235 | Hostname: hostname,
refs: make(map[string]int8),
}
} | |
c174236 | Points: [][2]interface{}{[2]interface{}{r.timestamp, v}},
Tags: tags,
Host: r.Hostname,
})
} | |
c174237 | filter)).Limit(count)
result, err := rootTerm.Run(s.Session)
if err != nil {
return
}
if result.Err() != nil {
return nil, result.Err()
}
if result.IsNil() {
return nil, ErrNotFound
}
rows = RethinkRows{result}
return
} | |
c174238 |
if env[0] == key {
(*e)[i] = keyVal
return
}
}
*e = append(*e, keyVal)
} | |
c174239 | len(s) == 2 {
e.Set(s[0], s[1])
}
} | |
c174240 | 2)
if len(env) < 2 {
continue
}
if env[0] == key {
return env[1]
}
}
return ""
} | |
c174241 | 2)) < 2 {
continue
}
fmt.Fprintln(b, env)
}
return b.String()
} | |
c174242 | s.Unlock()
s.m[value] = struct{}{}
} | |
c174243 |
defer s.Unlock()
for _, value := range values {
s.m[value] = struct{}{}
}
} | |
c174244 | defer s.Unlock()
delete(s.m, value)
} | |
c174245 |
defer s.Unlock()
for _, value := range values {
delete(s.m, value)
}
} | |
c174246 | defer s.RUnlock()
_, ok := s.m[value]
return ok
} | |
c174247 | _, ok := s.m[value]
if !ok {
return false
}
}
return true
} | |
c174248 | {
if f(k) {
return true
}
}
return false
} | |
c174249 | make(map[interface{}]struct{})
} | |
c174250 | IterFunc(func() (interface{}, bool) {
value, ok := <-iterChan
return value, ok
})
} | |
c174251 | k := range s.m {
items[i] = k
i++
}
return items
} | |
c174252 | range s.m {
if f(k) {
items = append(items, k)
}
}
return items
} | |
c174253 |
case time.Sunday:
return in.Add(1 * 24 * time.Hour)
default:
return in
}
} | |
c174254 |
requiredCodes = append(requiredCodes, hds.GetIncludes()...)
result = append(result, hds.GetHolidays(year)...)
requiredCodes = requiredCodes[1:]
}
sort.Sort(holidays(result))
return result, nil
} | |
c174255 | := strconv.Atoi(c.getStringValue(key))
return i
} | |
c174256 | := strconv.ParseFloat(c.getStringValue(key), 32)
return v
} | |
c174257 | strconv.ParseBool(c.getStringValue(key))
return b
} | |
c174258 | := c.getValue(key)
if v != nil {
return true
}
return false
} | |
c174259 | = c.profileConfig.configs[key]
}
if v == nil {
v = c.defaultConfig.configs[key]
}
return v
} | |
c174260 |
//read individual config file
for _, f := range files {
cfpath := filepath.Join(p, f.Name())
pf := fmt.Sprintf("application-%s.properties", gc.Profile)
if f.Name() == StandardPropFileName || pf == f.Name() {
cf, err := readPropertyFile(f, cfpath)
if err != nil {
return configError(err, "Error opening config file %s", f)
}
gc.addConfigFile(cf)
}
}
Gcg = gc
//do a final check if loaded config has any values
if gc.isEmpty() {
log.Printf("Configuration loaded, but empty for profile: '%s'\n", Gcg.Profile)
} else {
log.Printf("Configuration loaded for profile %s\n", Gcg.Profile)
}
return gc, nil
} | |
c174261 | path
if len(path) == 0 {
gp, err := getGoPath()
if err != nil {
return "", err
}
path = gp + "/config"
}
log.Printf("Loading configuration file from path %s\n", path)
return path, nil
} | |
c174262 | {
return &Reader{filename, utf8, nil, sync.Mutex{}}
} | |
c174263 | line := range bytes.Split(data, []byte("\n")) {
fields := bytes.Fields(line)
if len(fields) > 1 {
for _, ext := range fields[1:] {
mimetypes[string(ext)] = string(fields[0])
}
}
}
return mimetypes, nil
} | |
c174264 |
// Using the fallback hash map
if mime, ok := fallback[ext]; ok {
return mime
}
// Unable to find the mime type for the given extension
return ""
}
}
// Use the value from the hash map
if mime, ok := mr.mimetypes[ext]; ok {
return mime
}
// Using the fallback hash map
if mime, ok := fallback[ext]; ok {
return mime
}
// Unable to find the mime type for the given extension
return ""
} | |
c174265 |
// Default mime type
mimestring = "application/octet-stream"
}
if mr.utf8 {
mimestring += "; charset=utf-8"
}
w.Header().Add("Content-Type", mimestring)
} | |
c174266 | fileInfo, err = file.Stat()
fileSize = fileInfo.Size()
} else {
fileSize = -1
}
return
} | |
c174267 |
})
l, err := net.Listen("tcp", s.addr)
if err != nil {
return fmt.Errorf("failed to create TLS listener on network address %v with error: %v", s.addr, err)
}
s.listener = l
log.Printf("server: started %v", s.addr)
s.running.Store(true)
err = http.Serve(l, mux)
if !s.running.Load().(bool) {
return nil
}
return err
} | |
c174268 | mode?
log.Printf("server: send-request: connID: %v, reqID: %v, method: %v, params: %#v, err (if any): %v", connID, reqID, method, params, err)
return
}
return "", fmt.Errorf("connection with requested ID: %v does not exist", connID)
} | |
c174269 | string, err error) {
return s.SendRequest(connID, method, params, resHandler)
} | |
c174270 | != nil {
return fmt.Errorf("an error occured before or while stopping the server: %v", err)
}
s.wg.Wait()
log.Printf("server: stopped %v", s.addr)
return nil
} | |
c174271 | %v", c.ID, ws.RemoteAddr())
s.conns.Set(c.ID, c)
connsCounter.Add(1)
c.setConn(ws)
c.startReceive()
s.conns.Delete(c.ID)
connsCounter.Add(-1)
s.disconnHandler(c)
} | |
c174272 |
if err != nil {
return nil, err
}
} else {
k = s3gof3r.Keys{
AccessKey: s.AccessKey,
SecretKey: s.SecretKey,
}
}
s3 := s3gof3r.New(s.Domain, k)
s.bucket = s3.Bucket(s.Bucket)
return s, nil
} | |
c174273 | s.bucket.PutWriter(path, nil, nil)
} | |
c174274 | error) {
r, _, err := s.bucket.GetReader(path, nil)
return r, err
} | |
c174275 | s.bucket.Delete(path)
} | |
c174276 | connState.PeerCertificates
// if len(certs) == 0 {
// log.Println("Invalid client-certificate authentication attempt:", ctx.Conn.RemoteAddr())
// ctx.Conn.Close()
// return nil
// }
//
// userID := certs[0].Subject.CommonName
// ctx.Session.Set("userid", userID)
// log.Printf("Client authenticated. TLS/IP: %v, User ID: %v, Conn ID: %v\n", ctx.Conn.RemoteAddr(), userID, ctx.Conn.ID)
return ctx.Next()
} | |
c174277 | request parameters")
}
if err := json.Unmarshal(ctx.params, v); err != nil {
return fmt.Errorf("ctx: cannot deserialize request params: %v", err)
}
return nil
} | |
c174278 | len(ctx.mw) {
return ctx.mw[ctx.mwIndex-1](ctx)
}
return nil
} | |
c174279 |
if err := json.Unmarshal(ctx.result, v); err != nil {
return fmt.Errorf("ctx: cannot deserialize response result: %v", err)
}
return nil
} | |
c174280 | data")
}
if err := json.Unmarshal(ctx.errorData, v); err != nil {
return fmt.Errorf("ctx: cannot deserialize error data: %v", err)
}
return nil
} | |
c174281 | range middlware {
next = m(next)
}
return next
})
} | |
c174282 | name, LogLevel: minLogLevel, Writer: writer}
if logType == Lager {
return NewLager(log)
}
return NewLager(log)
} | |
c174283 | make(map[string]func(ctx *neptulon.ReqCtx) error)}
} | |
c174284 | error) {
r.routes[route] = handler
} | |
c174285 | handler, ok := r.routes[ctx.Method]; ok {
return handler(ctx)
}
return ctx.Next()
} | |
c174286 | r *http.Request) {
http.NotFound(w, r)
} | |
c174287 | username,
Password: password,
Caller: command.NewLocalExecuter(),
}
return m
} | |
c174288 | return NewRemoteMysqlDumpWithPath(username, password, sshCfg, "")
} | |
c174289 |
}
err = s.RemoteOps.RemoveRemoteFile()
lo.G.Debug("mysqldump remove remote file called: ", err)
return
} | |
c174290 | s.Caller.Execute(dest, s.getDumpCommand())
lo.G.Debug("mysqldump command called")
return
} | |
c174291 | sshCfg.Host, sshCfg.Port), clientconfig)
if err != nil {
lo.G.Error("ssh connection issue:", err)
return
}
remoteExecutor.Client = NewClientWrapper(client)
}
executor = remoteExecutor
return
} | |
c174292 | }
err = session.Start(command)
if err != nil {
return
}
_, err = io.Copy(dest, stdoutReader)
if err != nil {
return
}
err = session.Wait()
} else {
err = fmt.Errorf("un-initialized client executor")
lo.G.Error(err.Error())
}
return
} | |
c174293 | {
w.Write([]byte("Hello World!"))
} | |
c174294 | := fmt.Sprintf("Hello %s!", name)
w.Write([]byte(msg))
} | |
c174295 | username,
Password: password,
Caller: command.NewLocalExecuter(),
RecreateOnRestore: false,
}
} | |
c174296 | return NewPgRemoteDumpWithPath(port, database, username, password, sshCfg, "")
} | |
c174297 | Import being called")
if err = s.RemoteOps.UploadFile(lfile); err == nil {
err = s.restore()
}
return
} | |
c174298 | bgColor: None, fgColor: None}
} | |
c174299 | *IrcText {
i.fgColor = c
return i
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.