id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c16100 | r.Source.(*FastHttpRequest).Original.Request.Header.VisitAll(addValue)
} else {
r.Source.(*FastHttpResponse).Original.Response.Header.VisitAll(addValue)
}
return
} | |
c16101 | strings.Split(string(r.Source.(*FastHttpResponse).Original.Response.Header.Peek(key)), ",")
}
return
} | |
c16102 | {
r.Source.(*FastHttpResponse).Original.Response.SetStatusCode(statusCode)
}
} | |
c16103 | url.Values {
return url.Values(f.Form.Value)
} | |
c16104 | acecontent)
} else {
acetmpl.engine.templatesByName[newtemplatename] = &AceTemplate{
File: acetmpl.File,
Inner: inner.File,
engine: acetmpl.engine,
TemplateView: acetmpl.TemplateView}
}
}
return acetmpl.engine.templatesByName[newtemplatename].renderInter... | |
c16105 |
}
revel.OnAppStop(func() {
revel.RevelLog.Info("Closing the database (from module)")
if err := Db.Close(); err != nil {
revel.AppLog.Error("Failed to close the database", "error", err)
}
})
} | |
c16106 | "/tmp/app.db"
}
params.DbUser = revel.Config.StringDefault("db.user", "default")
params.DbPassword = revel.Config.StringDefault("db.password", "")
params.DbName = revel.Config.StringDefault("db.name", "default")
params.DbConnection = revel.Config.StringDefault("db.connection", "")
params.DbSchema = revel.Config.... | |
c16107 | Then check for token in custom headers, as with AJAX
if requestToken == "" {
requestToken = c.Request.GetHttpHeader("X-CSRFToken")
}
if requestToken == "" || !compareToken(requestToken, token) {
c.Result = c.Forbidden("REVEL CSRF: Invalid token.")
return
}
return true
} | |
c16108 | host[:i]
}
}
requestUrl.Host = host
}
// If no scheme found in headers use the revel server settings
if requestUrl.Scheme == "" {
// Fix the Request.URL, it is missing information, go http server does this
if revel.HTTPSsl {
requestUrl.Scheme = "https"
} else {
requestUrl.Scheme = "http"
}
f... | |
c16109 | same length
if len(requestToken) != len(token) {
return false
}
return subtle.ConstantTimeCompare([]byte(requestToken), []byte(token)) == 1
} | |
c16110 | u1.Hostname() == u2.Hostname()
} | |
c16111 | CSRF: _csrftoken missing from ViewArgs.")
} else {
return template.HTML(tokenFunc.(string))
}
}
} | |
c16112 | gormdb.InitDBWithParameters(params)
a.db = gormdb.DB
return a
} | |
c16113 | if err != nil {
return err
}
for _, line := range lines {
loadPolicyLine(line, model)
}
return nil
} | |
c16114 | model["g"] {
for _, rule := range ast.Policy {
line := savePolicyLine(ptype, rule)
err := a.db.Create(&line).Error
if err != nil {
return err
}
}
}
return nil
} | |
c16115 | maxWaitTime: maxWaitTime,
done: make(chan struct{}),
}
} | |
c16116 | return nil
}
return ln.waitForZeroConns()
} | |
c16117 | "Template Execution Error",
Path: tmpl.TemplateName,
Description: e.Error(),
Line: e.Line,
}
if revel.DevMode {
rerr.SourceLines = tmpl.Content()
}
err = rerr
}
}
})
return err
} | |
c16118 |
workInfo: workInfo,
},
NumWorkers: numWorkers,
Db: db,
StartWorkTimeout: 0,
LongWorkTimeout: 0,
}
return
} | |
c16119 | ControlChannel: container.ControlChannel,
},
}
// Close the database after worker has ended (Start returned
defer worker.Db.Close()
container.mutex.Lock()
container.Workers = append(container.Workers, worker)
container.mutex.Unlock()
// Only monitor jobs if Status function defined and a timeout is also defin... | |
c16120 | range worker.InputChannel {
worker.invoke(job)
}
worker.workInfo.Status(Stop, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { return Stop, worker }
if worker.TimeoutChannel != nil {
close(worker.TimeoutChannel)
}
} | |
c16121 | nil {
worker.TimeInfo = &timeoutInfo{worker: worker, started: time.Now(), state: StartJob}
worker.TimeoutChannel <- worker.TimeInfo
}
worker.workInfo.Work(job, worker)
if worker.TimeoutChannel != nil {
worker.TimeInfo.state = EndJob
worker.TimeoutChannel <- worker.TimeInfo
}
} | |
c16122 | {
return &DbCallbackImplied{StatusFn: status, WorkFn: work}
} | |
c16123 | worker *DbWorker) {
if dbCallback.StatusFn != nil {
dbCallback.StatusFn(phase, worker)
}
} | |
c16124 |
dbCallback.WorkFn(value, worker)
} | |
c16125 | new State, record and loop
complete.worker.workInfo.Status(complete.state, complete.worker)
break
case <-time.After(time.Second * time.Duration(timeout)):
j.worker.workInfo.Status(JobLongrunning, j.worker)
}
}
}
} | |
c16126 | *dbGorp.Info
newDb = &DbGorp{Info: &dbInfo}
newDb.dbInitFn = dbGorp.dbInitFn
err = newDb.InitDb(open)
return
} | |
c16127 | dbGorp.dbInitFn != nil {
err = dbGorp.dbInitFn(dbGorp)
}
return
} | |
c16128 |
dbGorp.dbInitFn = dbInitFn
return dbGorp.dbInit()
} | |
c16129 | revel.Result {
c.ViewArgs["ace-inner"] = inner
return c.RenderTemplate(base)
} | |
c16130 | txn.Error != nil {
c.Log.Panic("Transaction begine error", "error", txn.Error)
}
c.Txn = txn
return nil
} | |
c16131 | {
fmt.Println(c.Txn.Error)
panic(c.Txn.Error)
}
c.Txn = nil
return nil
} | |
c16132 | c.Request.In.(*revel.GoRequest).Original)
defer txn.End()
} else {
serverLog.Error("Newrelic application not initialized before filter called")
}
}
fc[0](c, fc[1:])
} | |
c16133 | return c.NotFound("")
}
return serve(c, prefix, filepath, true)
} | |
c16134 | size := "bytes"
divider := int64(1)
fileInfo.Size = f.Size()
for x := 0; fileInfo.Size > byteSizeList[x][1].(int64); x++ {
size = byteSizeList[x][0].(string)
divider = byteSizeList[x][1].(int64)
}
fileInfo.Size = fileInfo.Size / divider
fileInfo.SizeType = size
fileInfo.NiceSize = fmt.Spr... | |
c16135 |
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
return c.Host
} | |
c16136 | s3CLISession, err := RunS3CLI(s3CLIPath, configPath, "put", contentFile, s3Filename)
s3Config, err := config.NewFromReader(configFile)
Expect(err).ToNot(HaveOccurred())
client, _ := client.NewSDK(s3Config)
resp, err := client.HeadObject(&s3.HeadObjectInput{
Bucket: aws.String(cfg.BucketName),
Key: aws.Str... | |
c16137 |
Expect(s3CLISession.ExitCode()).ToNot(BeZero())
Expect(s3CLISession.Err.Contents()).To(ContainSubstring("NoSuchKey"))
} | |
c16138 | S3Blobstore{s3Client: s3Client, s3cliConfig: s3cliConfig}, nil
} | |
c16139 | Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(src),
})
if err != nil {
return err
}
return nil
} | |
c16140 | == maxRetries {
log.Println("Upload retry limit exceeded:", err.Error())
return fmt.Errorf("upload retry limit exceeded: %s", err.Error())
}
retry++
time.Sleep(time.Second * time.Duration(retry))
continue
}
log.Println("Upload failed:", err.Error())
return fmt.Errorf("upload failure:... | |
c16141 | client.s3Client.DeleteObject(deleteParams)
if err == nil {
return nil
}
if reqErr, ok := err.(awserr.RequestFailure); ok {
if reqErr.StatusCode() == 404 {
return nil
}
}
return err
} | |
c16142 | if err == nil {
log.Printf("File '%s' exists in bucket '%s'\n", dest, client.s3cliConfig.BucketName)
return true, nil
}
if reqErr, ok := err.(awserr.RequestFailure); ok {
if reqErr.StatusCode() == 404 {
log.Printf("File '%s' does not exist in bucket '%s'\n", dest, client.s3cliConfig.BucketName)
return f... | |
c16143 | //if err := ioutil.WriteFile("mypackage.xml", byteXml, 0644); err != nil {
//ErrorAndExit(err.Error())
//}
return byteXml
} | |
c16144 | pb.Files["package.xml"] = pb.PackageXml()
return pb.Files
} | |
c16145 |
if spath == mpath {
return
}
_, err := os.Stat(spath)
if err != nil {
spath = mpath
}
return
} | |
c16146 | if err != nil {
return
}
fpath = MetaPathToSourcePath(fpath)
metaName, fname := getMetaTypeFromPath(fpath)
if !isDestructiveChanges && !strings.HasSuffix(fpath, "-meta.xml") {
pb.AddMetaToPackage(metaName, fname)
}
// If it's a push, we want to actually add the files
if pb.IsPush {
if isDestructiveChang... | |
c16147 | for dirContentName, dirContentPath := range dirNamePaths {
namePaths[dirContentName] = dirContentPath
}
}
}
name, err := pb.AddFile(dirOrFilePath)
if (err != nil) || (name == "") {
badPaths = append(badPaths, dirOrFilePath)
} else {
namePaths[name] = dirOrFilePath
}
}
return
} | |
c16148 | := true
fmeta := fpath + "-meta.xml"
fmetarel := ""
if _, err = os.Stat(fmeta); err != nil {
if os.IsNotExist(err) {
hasMeta = false
} else {
// Has error
return
}
} else {
// Should be present since we worked back to srcDir
fmetarel, _ = filepath.Rel(srcDir, fmeta)
}
fdata, err := ioutil.Rea... | |
c16149 | if mt.Name == "" {
mt.Name = metaName
}
if !pb.contains(mt.Members, name) {
mt.Members = append(mt.Members, name)
pb.Metadata[metaName] = mt
}
} | |
c16150 | the metadata type and name for the file
metaName, fileName := getMetaForPath(fpath)
name = strings.TrimSuffix(fileName, filepath.Ext(fileName))
//name = strings.TrimSuffix(name, filepath.Ext(name))
return
} | |
c16151 |
objectName = parentName + "/" + fileName
}
return
}
if mp.path == parentName {
metaName = mp.name
objectName = fileName
return
}
}
// Unknown, so use path
metaName = parentName
objectName = fileName
return
} | |
c16152 | {
xmlFile, err := ioutil.ReadFile(path)
mdtype = getFirstXmlElement(xmlFile)
return
} | |
c16153 | }
switch startElement := token.(type) {
case xml.StartElement:
firstElement = startElement.Name.Local
return
}
}
return
} | |
c16154 | folder to get all aura bundles in the directory
folder = filepath.Dir(filepath.Dir(path))
} else {
folder = filepath.Dir(path)
}
return errors.New("walk canceled")
}
return nil
})
return
} | |
c16155 | if !f.IsDir() {
file, err := ioutil.ReadFile(path)
if err != nil {
return err
}
fl, err := zipper.Create(filepath.Join(topLevelFolder, strings.Replace(path, startPath, "", -1)))
if err != nil {
ErrorAndExit(err.Error())
}
_, err = fl.Write([]byte(file))
if err != nil {
... | |
c16156 | (API %s)\n", creds.UserInfo.UserName, ApiVersionNumber())
if err = SaveLogin(creds); err != nil {
return
}
sessionName = creds.SessionName()
err = SetActiveLogin(sessionName)
return
} | |
c16157 | if err != nil {
return
}
var userinfo UserInfo
userinfo, err = getUserInfo(*creds)
if err != nil {
return
}
creds.UserInfo = &userinfo
_, err = ForceSaveLogin(*creds, os.Stderr)
}
return
} | |
c16158 |
// Only structs are supported so return an empty result if the passed object
// isn't a struct
if typ.Kind() != reflect.Struct {
fmt.Printf("%v type can't have attributes inspected\n", typ.Kind())
return attrs
}
// loop through the struct's fields and set the map
for i := 0; i < typ.NumField(); i++ {
p :=... | |
c16159 |
badPaths = append(badPaths, fpath)
} else {
// Store paths by name for error messages
namePaths[name] = fpath
}
}
}
if len(badPaths) == 0 {
fmt.Println("Deploying now...")
t0 := time.Now()
deployFiles(pb.ForceMetadataFiles(), byName, namePaths, opts)
t1 := time.Now()
fmt.Printf("The de... | |
c16160 |
fmt.Printf("\nTest Failures - %d\n", len(testFailures))
for _, failure := range testFailures {
fmt.Printf("\n [FAIL] %s::%s: %s\n", failure.Name, failure.MethodName, failure.Message)
fmt.Println(failure.StackTrace)
}
if len(codeCoverageWarnings) > 0 {
fmt.Printf("\nCode Coverage Warnings - %d\n", len(code... | |
c16161 | fmt.Sprintf("%s/%s", f.Credentials.InstanceUrl, strings.TrimLeft(url, "/"))
} | |
c16162 | nil {
return true
}
return false
} | |
c16163 | }
}
// No source directory found, create a src directory and a symlinked "metadata"
// directory for backward compatibility and return that.
dir = filepath.Join(base, "src")
err = os.Mkdir(dir, 0777)
symlink := filepath.Join(base, "metadata")
os.Symlink(dir, symlink)
dir = symlink
return
} | |
c16164 |
if v == value {
return p
}
}
return -1
} | |
c16165 | continue
}
pairTokens = append(pairTokens, [2]*Token{prevToken, tok})
prevToken = tok
}
pairTokens = append(pairTokens, [2]*Token{prevToken, nil})
return pairTokens
} | |
c16166 | reEllipsis,
reNumeric: reNumeric,
reInitial: reInitial,
reAlpha: reAlpha,
}
return &tok
} | |
c16167 | Tok: %q, SentBreak: %t, Abbr: %t, Position: %d>", p.Tok, p.SentBreak, p.Abbr, p.Position)
} | |
c16168 | _, val := range f.Samples {
sum += float64(val)
}
return sum
} | |
c16169 | tmpRToNr[0] = 0
} else {
tmpRToNr[0] = bins - f.B()
}
return tmpRToNr
} | |
c16170 | Samples {
cf = append(cf, f.Samples[val])
}
return cf
} | |
c16171 | if char == achar {
return true
}
}
}
return false
} | |
c16172 | s,
PunctStrings: p,
TokenExistential: e,
}
} | |
c16173 | word, &DefaultTokenGrouper{}, &OrthoContext{
s, p, word, word,
}},
}
} | |
c16174 |
a.typeAnnotation(augTok)
}
return tokens
} | |
c16175 | tokPair := range a.TokenGrouper.Group(tokens) {
a.tokenAnnotation(tokPair[0], tokPair[1])
}
return tokens
} | |
c16176 | s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
} | |
c16177 | PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
} | |
c16178 | continue
}
sentence := &Sentence{lastBreak, token.Position, text[lastBreak:token.Position]}
sentences = append(sentences, sentence)
lastBreak = token.Position
}
if lastBreak != len(text) {
lastChar := len(text)
sentence := &Sentence{lastBreak, lastChar, text[lastBreak:lastChar]}
sentences = append... | |
c16179 | `."`, `.'`,
`?[`, `?(`,
`![`, `!(`,
}
for _, paren := range parens {
if strings.Index(t.Tok, paren) != -1 {
return true
}
}
return false
} | |
c16180 |
token := NewToken(word)
token.Position = cursor
token.ParaStart = paragraphStart
token.LineStart = lineStart
tokens = append(tokens, token)
lastSpace = cursor
lineStart = false
paragraphStart = false
if hasSentencePunct {
getNextWord = true
} else {
getNextWord = false
}
}
if len(token... | |
c16181 | return typ
}
// removing comma from typ
return strings.Replace(typ, ",", "", -1)
} | |
c16182 |
if len(typ) > 1 && string(typ[len(typ)-1]) == "." {
return string(typ[:len(typ)-1])
}
return typ
} | |
c16183 | return p.TypeNoPeriod(t)
}
return p.Type(t)
} | |
c16184 | }
runes := []rune(t.Tok)
return unicode.IsUpper(runes[0])
} | |
c16185 | }
runes := []rune(t.Tok)
return unicode.IsLower(runes[0])
} | |
c16186 | return t.reEllipsis.MatchString(t.Tok)
} | |
c16187 | strings.HasPrefix(t.Tok, "##number##")
} | |
c16188 | return t.reInitial.MatchString(t.Tok)
} | |
c16189 | return t.reAlpha.MatchString(t.Tok)
} | |
c16190 | := regexp.MustCompile(p.PunctStrings.NonPunct())
return nonPunct.MatchString(p.Type(t))
} | |
c16191 | return strings.HasSuffix(t.Tok, ".")
} | |
c16192 | enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`, `.(`, `."`, `.'`,
`?[`, `?(`,
`![`, `!(`,
}
for _, paren := range parens {
if strings.Index(t.Tok, paren) != -1 {
return true
}
}
return false
} | |
c16193 | return false
}
return true
} | |
c16194 | {
arr = append(arr, key)
}
return arr
} | |
c16195 |
p.OrthoContext[typ] |= flag
} | |
c16196 | := range tokens {
if p.AbbrevTypes.Has(token) {
return true
}
}
return false
} | |
c16197 | append(*ix, &index{name: name, columns: columns, unique: false})
} | |
c16198 | append(*ix, &index{name: name, columns: columns, unique: true})
} | |
c16199 | len(columns) {
oldFields := []*modelField{}
newFields := []*modelField{}
for _, v := range model.fields {
if _, ok := columns[v.name]; ok {
oldFields = append(oldFields, v)
} else {
newFields = append(newFields, v)
}
}
if len(oldFields) != len(columns) {
panic("Column name has changed, re... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.