id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c182300 | c.lock.Unlock()
return c.leader
} | |
c182301 | clientID, RedirectURI: redirectURI, UserID: userID, Exp: exp, Code: code}
} | |
c182302 | errors.New("unexpected type")
}
if len(reqID) == 0 {
return "", errors.New("empty value in context")
}
return reqID, nil
} | |
c182303 | := bytes.Buffer{}
m.opts.formatTmpl.Execute(&buff, &struct {
*Colors
Timestamp, Method, Path, CodeColor string
Code int
Duration, Size, IP string
}{
m.opts.Colors,
m.t0.Format(m.opts.TimeFormat), m.method, m.path, cc,
m.Code,
fmtDuration(duration), size, m.ip,
})
//fmt is threadsafe :)
fmt.Fprint(m.opts.Writer, buff.String())
} | |
c182304 | log.Printf("From error: %v", err)
return err
}
for _, addr := range to {
if err = c.Rcpt(addr); err != nil {
log.Printf("Recipient error: %v", err)
return err
}
}
w, err := c.Data()
if err != nil {
return err
}
w.Write(msg)
w.Close()
return c.Quit()
} | |
c182305 | "Subject: " + subject + "\r\n" +
"\r\n" +
message + "\r\n")
err = m.SMTP.SendMail(from, t, msg)
return
} | |
c182306 |
conn := buildConn(host, port, fullConn)
if conn == nil {
return errors.New("Invalid connection")
}
log.Debug("Waiting " + strconv.Itoa(timeout) + " seconds")
if err := pingTCP(conn, timeout); err != nil {
return err
}
if conn.Scheme != "http" && conn.Scheme != "https" {
return nil
}
if err := pingHTTP(conn, timeout); err != nil {
return err
}
return nil
} | |
c182307 | log.Printf("Fatal: %v", err)
return
}
}
err = yaml.Unmarshal(source.([]byte), configEnv)
if err != nil {
log.Printf("Fatal: bad config : %v", err)
return
}
conf = configEnv.GetEnvironment(environment)
if conf == nil {
err = errors.New("No configuration")
return
}
return
} | |
c182308 | as first search path
Viper.AddConfigPath("./") // adding local directory as second search path
Viper.AutomaticEnv() // read in environment variables that match
// If a config file is found, read it in.
if err := Viper.ReadInConfig(); err == nil {
fmt.Println("Using config file:", Viper.ConfigFileUsed())
}
} | |
c182309 |
defer res.Close()
if res.IsNil() {
// upsert into RethinkDB
resp, err := r.Table("samples").Insert(results, r.InsertOpts{Conflict: "replace"}).RunWrite(session)
utils.Assert(err)
log.Debug(resp)
} else {
resp, err := r.Table("samples").Get(results["ID"]).Update(map[string]interface{}{
"plugins": map[string]interface{}{
category: map[string]interface{}{
name: results["Data"],
},
},
}).RunWrite(session)
utils.Assert(err)
log.Debug(resp)
}
} | |
c182310 | AuthController{UserManager: um, cnf: cnf}
return &authController
} | |
c182311 |
claims["username"] = user.Username
claims["email"] = user.Email
claims["exp"] = time.Now().Add(time.Minute * 10).Unix()
tokenString, _ := token.SignedString([]byte(c.cnf.Jwt.Key))
data = map[string]string{
"id_token": tokenString,
}
}
js, _ := json.Marshal(data)
w.Write(js)
} | |
c182312 | OAuth2Controller{cnf: cnf, ApplicationManager: am}
return &oAuth2Controller
} | |
c182313 | }
return []byte(c.cnf.Jwt.Key), nil
})
if err == nil && token.Valid {
token := jwt.New(jwt.GetSigningMethod("HS256"))
claims := token.Claims.(jwt.MapClaims)
claims["exp"] = time.Now().Add(time.Hour * 1).Unix()
tokenString, _ := token.SignedString([]byte(c.cnf.Jwt.Key))
data := map[string]string{
"access_token": tokenString,
"token_type": "bearer",
"expires_in": "3600",
}
js, _ := json.Marshal(data)
w.Write(js)
}
} | |
c182314 |
claims := token.Claims.(jwt.MapClaims)
claims["exp"] = time.Now().Add(time.Hour * 1).Unix()
tokenString, _ := token.SignedString([]byte(c.cnf.Jwt.Key))
refreshToken := jwt.New(jwt.GetSigningMethod("HS256"))
refreshClaims := refreshToken.Claims.(jwt.MapClaims)
refreshClaims["exp"] = 0
refreshTokenString, _ := refreshToken.SignedString([]byte(c.cnf.Jwt.Key))
data := map[string]string{
"access_token": tokenString,
"token_type": "bearer",
"refresh_token": refreshTokenString,
"expires_in": "3600",
}
js, _ := json.Marshal(data)
w.Write(js)
}
} | |
c182315 | log.WithField("client", r.RemoteAddr).WithField("latency", latency).WithField("length", srw.Length()).WithField("code", srw.Status()).Printf("%s %s %s", r.Method, r.URL, r.Proto)
})
} | |
c182316 | *http.Request) {
http.ServeFile(w, r, filename)
})
} | |
c182317 | error) {
w.length = len(data)
return w.ResponseWriter.Write(data)
} | |
c182318 | hj.Hijack()
}
return nil, nil, errors.New("Not a Hijacker")
} | |
c182319 | est incorrect: %s", uri)
return nil, err
}
err = client.Connect(ctx)
if err != nil {
log.Print("Impossible d'utiliser ce context")
return nil, err
}
db := client.Database(cnf.Database)
err = client.Ping(ctx, nil)
if err != nil {
log.Printf("Impossible de contacter %v sur le port %d", cnf.Host, cnf.Port)
return nil, err
}
return &Mongo{Client: client, Database: db, context: ctx}, nil
} | |
c182320 | de fermer la connexion")
return err
}
return nil
} | |
c182321 | make([]map[string]string, 0),
fieldSizes: make(map[string]int),
}
} | |
c182322 | := range rows {
table.AddRow(r)
}
table.Print()
} | |
c182323 | range rows {
table.AddRow(row)
}
table.HideHead = true
table.Print()
} | |
c182324 | New(fields)
table.AddRow(row)
table.Print()
} | |
c182325 | fmt.Sprintf("%v", v)
}
newRow[k] = val
}
t.calculateSizes(newRow)
if len(newRow) > 0 {
t.Rows = append(t.Rows, newRow)
}
} | |
c182326 | if !t.Markdown {
t.printDash()
}
}
if t.Footer != nil {
t.printTableDash()
fmt.Println(t.rowString(t.Footer))
if !t.Markdown {
t.printTableDash()
}
}
} | |
c182327 | {
tableString = append(tableString, t.stringDash())
}
}
if t.Footer != nil {
tableString = append(tableString, t.stringTableDash())
tableString = append(tableString, t.rowString(t.Footer))
if !t.Markdown {
tableString = append(tableString, t.stringDash())
}
}
return strings.Join(tableString[:], "\n")
} | |
c182328 | range t.Fields {
s += t.fieldString(name, strings.Title(name)) + "|"
}
return s
} | |
c182329 | := row[name]
s += t.fieldString(name, value) + "|"
}
return s
} | |
c182330 | {
for i := 0; i < spacesLeft; i++ {
value += " "
}
}
return value
} | |
c182331 | t.stringMarkdownDash()
}
return t.stringDash()
} | |
c182332 | strings.Repeat("-", t.fieldSizes[name]-2)
}
fmt.Println(t.rowString(r))
} | |
c182333 | r[name] = strings.Repeat("-", t.fieldSizes[name]-2)
}
return t.rowString(r)
} | |
c182334 | P, KEYLENGTH)
if err != nil {
return nil, err
}
return
} | |
c182335 | signer, err := jose.NewSigner(jose.SigningKey{Algorithm: jose.HS512, Key: []byte(sharedKey)}, nil)
if err != nil {
log.Printf("Error: %v", err)
}
object, err := signer.Sign([]byte(j64response))
if err != nil {
log.Printf("Error: %v", err)
}
code, err = object.CompactSerialize()
return
} | |
c182336 | err := base64.StdEncoding.Decode(base64Text, output)
if err != nil {
return
}
response = Response{}
err = json.Unmarshal(base64Text[:l], &response)
return
} | |
c182337 | log.Infof("Log Level: %v", level)
}
log.SetLevel(level)
server = &Server{Config: conf, Done: make(chan bool, 1), Error: make(chan error, 1), Server: http.Server{Handler: NewLoggingServeMux(conf)}, quit: make(chan bool), isStarted: false}
return
} | |
c182338 | log.Errorf("%v", err)
s.Error <- err
s.quit <- true
}
close(s.quit)
}
}()
<-s.quit
if err = s.Shutdown(context.Background()); err != nil {
log.Errorf("%v", err)
s.Error <- err
}
<-s.quit
l = nil
log.Info("Lunarc terminated.")
s.isStarted = false
s.Done <- true
return
} | |
c182339 | s.quit <- true
} else {
log.Info("Lunarc is not running")
s.Error <- errors.New("Lunarc is not running")
s.Done <- false
}
} | |
c182340 | http.NewServeMux()
return &LoggingServeMux{serveMux, conf}
} | |
c182341 | (h http.Handler, pattern string) {
return mux.serveMux.Handler(r)
} | |
c182342 | 0666)
if err != nil {
log.Out = os.Stderr
log.Warningf("Can't open logfile: %v", err)
} else {
log.Out = logFile
}
mux.serveMux.Handle(pattern, Logging(handler, log))
} | |
c182343 | *http.Request)) {
mux.serveMux.Handle(pattern, http.HandlerFunc(handler))
} | |
c182344 | index exists")
}
if !exists {
// Index does not exist yet.
createIndex, err := client.CreateIndex(db.Index).BodyString(mapping).Do(context.Background())
if err != nil {
return errors.Wrapf(err, "failed to create index: %s", db.Index)
}
if !createIndex.Acknowledged {
log.Error("index creation not acknowledged")
} else {
log.Debugf("created index %s", db.Index)
}
} else {
log.Debugf("index %s already exists", db.Index)
}
return nil
} | |
c182345 | == nil {
log.Debugf("elasticsearch came online after %d seconds", secondsWaited)
return nil
}
// not ready yet
secondsWaited++
log.Debug(" * could not connect to elasticsearch (sleeping for 1 second)")
time.Sleep(1 * time.Second)
}
}
} | |
c182346 |
"plugins": db.Plugins,
"scan_date": time.Now().Format(time.RFC3339Nano),
}
newScan, err := client.Index().
Index(db.Index).
Type(db.Type).
OpType("index").
// Id("1").
BodyJson(fInfo).
Do(context.Background())
if err != nil {
return elastic.IndexResponse{}, errors.Wrap(err, "failed to index file info")
}
log.WithFields(log.Fields{
"id": newScan.Id,
"index": newScan.Index,
"type": newScan.Type,
}).Debug("indexed sample")
return *newScan, nil
} | |
c182347 | {
return errors.Wrapf(err, "failed to update sample with id: %s", results.ID)
}
log.Debugf("updated version of sample %q is now %d\n", update.Id, update.Version)
} else {
// ID not found so create new document with `index` command
scan := map[string]interface{}{
"plugins": map[string]interface{}{
results.Category: map[string]interface{}{
results.Name: results.Data,
},
},
"scan_date": time.Now().Format(time.RFC3339Nano),
}
newScan, err := client.Index().
Index(db.Index).
Type(db.Type).
OpType("index").
// Id("1").
BodyJson(scan).
Do(context.Background())
if err != nil {
return errors.Wrapf(err, "failed to create new sample plugin doc with id: %s", results.ID)
}
log.WithFields(log.Fields{
"id": newScan.Id,
"index": newScan.Index,
"type": newScan.Type,
}).Debug("indexed sample")
}
return nil
} | |
c182348 | chunks[idx] = bytes.Title(val)
}
}
return string(bytes.Join(chunks, nil))
} | |
c182349 | := os.Getenv(name)
if value == "" {
value = dfault
}
return value
} | |
c182350 |
value := os.Getenv(envVar)
if value == "" {
value = dfault
}
return value
} | |
c182351 | h256.Write(dat)
Assert(err)
return fmt.Sprintf("%x", h256.Sum(nil))
} | |
c182352 | }
output, err := c.Output()
if err != nil {
return string(output), err
}
// check for exec context timeout
if ctx != nil {
if ctx.Err() == context.DeadlineExceeded {
return "", fmt.Errorf("command %s timed out", cmd)
}
}
return string(output), nil
} | |
c182353 | true {
// Do not add duplicate.
} else {
// Record this element as an encountered element.
encountered[elements[v]] = true
// Append to result slice.
result = append(result, elements[v])
}
}
// Return the new slice.
return result
} | |
c182354 | defer fileReader.Close()
targetFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
if err != nil {
return err
}
defer targetFile.Close()
if _, err := io.Copy(targetFile, fileReader); err != nil {
return err
}
}
return nil
} | |
c182355 | strings.Contains(b, a) {
return true
}
}
return false
} | |
c182356 | := smtp.PlainAuth("", conf.Auth.User, conf.Auth.Password, conf.Host)
f := smtp.SendMail
if conf.SSL {
f = SendMailSSL
}
s = &SMTP{auth: auth, send: f, addr: fmt.Sprintf("%s:%d", conf.Host, conf.Port)}
return
} | |
c182357 | []byte) (err error) {
err = s.send(s.addr, s.auth, from, to, msg)
return
} | |
c182358 | if strings.Compare(environment, env) == 0 {
return conf
}
}
return nil
} | |
c182359 | err := config.Get(source, environment, &smtpEnvironment)
smtp = i.(Config)
return
} | |
c182360 | err := config.Get(source, environment, &serverEnvironment)
server = i.(Config)
return
} | |
c182361 | strings.Compare(environment, env) == 0 {
return conf
}
}
return nil
} | |
c182362 | := config.Get(source, environment, &env)
mongo = i.(Config)
return
} | |
c182363 | token.Method.(*jwt.SigningMethodHMAC); !ok {
//TODO: On ne passe jamais à l'intérieur
return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
}
return []byte(cnf.Jwt.Key), nil
})
if err == nil && token.Valid {
next.ServeHTTP(w, r)
} else {
if r.URL.String() == "/" {
next.ServeHTTP(w, r)
} else {
w.WriteHeader(http.StatusUnauthorized)
}
}
})
} | |
c182364 | as delivered and remove from the queue
case "control":
return &m, nil // todo: handle connection draining (and any other control message type?)
case "":
// acknowledge the incoming ordinary messages as per spec
ack := &OutMsg{MessageType: "ack", To: m.From, ID: m.ID}
if _, err = c.Send(ack); err != nil {
return nil, fmt.Errorf("failed to send ack message to CCS with error: %v", err)
}
return &m, nil
default:
// unknown message types can be ignored, as per GCM specs
}
return &m, nil
} | |
c182365 | {
return 0, err
}
ms := string(mb)
res := fmt.Sprintf(gcmMessageStanza, ms)
return c.xmppConn.SendOrg(res)
} | |
c182366 |
var releaseNames []string
for brname := range boshReleaseNamesMap {
releaseNames = append(releaseNames, brname)
}
return releaseNames
} | |
c182367 | {
dj.AddedProperties[name] = *p
} | |
c182368 | p *enaml.JobManifestProperty) {
dj.RemovedProperties[name] = *p
} | |
c182369 | append(r.DeltaJob, *dj)
} | |
c182370 | dj := range other.DeltaJob {
r.DeltaJob = append(r.DeltaJob, dj)
}
} | |
c182371 | if err != nil {
return nil, err
}
rr, err := os.Open(local)
if err != nil {
return nil, err
}
return rr, nil
} | |
c182372 | its in the local cache
filename = r.CacheDir + "/" + path.Base(releaseLocation)
if _, err = os.Stat(filename); os.IsNotExist(err) {
fmt.Println("Could not find release in local cache. Downloading now.")
err = r.download(releaseLocation, filename)
}
}
return
} | |
c182373 | defer specFile.Close()
err = writeMonitFile(monitFile, jobMeta.Name, jobMeta.PIDFile)
if err != nil {
return err
}
err = writeSpecFile(specFile, jobMeta.Name, jobMeta.JobProperties, jobMeta.Packages)
return err
} | |
c182374 |
if cerr := rr.Close(); cerr != nil {
err = cerr
}
}()
release, err = readBoshRelease(rr)
return
} | |
c182375 |
}
err := release.readBoshRelease(rr)
return release, err
} | |
c182376 |
job, jerr := r.readBoshJob(file.Reader)
if jerr == nil {
r.JobManifests[job.Name] = job
}
return jerr
})
err := w.Walk()
return err
} | |
c182377 | := pkg.NewTgzWalker(jr)
jw.OnMatch("job.MF", func(file pkg.FileEntry) error {
return decodeYaml(file.Reader, &job)
})
err := jw.Walk()
return job, err
} | |
c182378 | if err != nil {
return nil, err
}
setAuth(s, req)
return req, nil
} | |
c182379 | if res.StatusCode >= 400 {
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return err
}
return fmt.Errorf("%s error pushing cloud config to BOSH: %s", res.Status, string(body))
}
return nil
} | |
c182380 | ElementAnnotation: createElementAnnotation(elementName),
Meta: v.Yaml,
}
} else {
if previousElement.ElementAnnotation != createElementAnnotation(elementName) {
lo.G.Warning("******** Recommended creating custom yaml marshaller on", structname, "for", attributeName, " ********")
previousElement.ElementAnnotation = "`yaml:\"-\"`"
objects[structname][attributeName] = previousElement
}
}
}
}
}
structs := generateStructs(objects, packagename)
writeStructsToDisk(structs, outputDir)
} | |
c182381 | Length: len(elementArray),
Orig: property,
Slice: elementArray,
Yaml: yaml,
}
return
} | |
c182382 | *ShowCmd {
return &ShowCmd{
releaseRepo: releaseRepo,
release: release,
}
} | |
c182383 | return err
}
for _, br := range pivnetRelease.BoshRelease {
s.printBoshRelease(w, br)
}
return nil
}
boshRelease, err := release.LoadBoshRelease(s.releaseRepo, s.release)
if err != nil {
return err
}
s.printBoshRelease(w, boshRelease)
return nil
} | |
c182384 | atc.ImageResource{
Type: s.defaultImageType,
Source: atc.Source{
"repository": s.defaultImageRepository,
},
}
} | |
c182385 | atc.JobConfig) {
s.Jobs = append(s.Jobs, job)
} | |
c182386 | append(s.Groups, atc.GroupConfig{
Name: name,
Jobs: jobs,
})
} | |
c182387 |
if v.Name == name {
return &s.Resources[i]
}
}
return nil
} | |
c182388 | atc.ResourceConfig) {
s.Resources = append(s.Resources, rawResource)
} | |
c182389 | append(s.Resources, atc.ResourceConfig{
Name: name,
Type: typename,
Source: source,
})
} | |
c182390 | s.AddResource(name, GithubResourceName, source)
} | |
c182391 | s.AddResource(name, BoshIOResourceName, source)
} | |
c182392 | s.AddResource(name, BoshDeploymentResourceName, source)
} | |
c182393 | s.AddResource(name, GitResourceName, source)
} | |
c182394 | }
}
addJobNames(d.release1)
addJobNames(d.release2)
var jobNames []string
for jname := range jobNamesMap {
jobNames = append(jobNames, jname)
}
return jobNames
} | |
c182395 |
fi, _ := f.Stat()
if fi.Size() > 0 {
b, _ = ioutil.ReadAll(f)
}
return NewDeploymentManifest(b)
} | |
c182396 | new(DeploymentManifest)
yaml.Unmarshal(b, dm)
return dm
} | |
c182397 | releaseName,
URL: url,
SHA1: sha1,
Version: ver,
})
return
} | |
c182398 | os,
Alias: alias,
Version: ver,
URL: url,
SHA1: sha1,
})
} | |
c182399 | return ""
}
return s.Tags[key]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.