id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c172100 | r.Path); err == nil {
r.pulled = true
r.lastPull = time.Now()
Logger().Printf("%v pulled.\n", r.URL)
r.lastCommit, err = r.mostRecentCommit()
}
return err
} | |
c172101 | nil {
Logger().Printf("Commit %v checkout done.\n", commitHash)
}
return err
} | |
c172102 |
return r.gitCmdWithKey(params, dir)
}
return runCmd(gitBinary, params, dir)
} | |
c172103 |
}
if isGit {
// check if same repository
var repoURL string
if repoURL, err = r.originURL(); err == nil {
if strings.TrimSuffix(repoURL, ".git") == strings.TrimSuffix(r.URL.Val(), ".git") {
r.pulled = true
return nil
}
}
if err != nil {
return fmt.Errorf("cannot retrieve repo url for %v Error: %v", r.Path, err)
}
return fmt.Errorf("another git repo '%v' exists at %v", repoURL, r.Path)
}
return fmt.Errorf("cannot git clone into %v, directory not empty", r.Path)
} | |
c172104 |
c, args, err := caddy.SplitCommandAndArgs(command)
if err != nil {
return "", err
}
return runCmdOutput(c, args, r.Path)
} | |
c172105 | args := []string{"config", "--get", "remote.origin.url"}
return runCmdOutput(gitBinary, args, r.Path)
} | |
c172106 | Logger().Printf("Command '%v' successful.\n", command.Command())
}
errs = mergeErrors(errs, err)
}
return errs
} | |
c172107 | io.Reader) {
g.Cmd.Stdin = stdin
} | |
c172108 | io.Writer) {
g.Cmd.Stdout = stdout
} | |
c172109 | io.Writer) {
g.Cmd.Stderr = stderr
} | |
c172110 | return os.Mkdir(name, perm)
} | |
c172111 | return os.MkdirAll(path, perm)
} | |
c172112 | (os.FileInfo, error) {
return os.Stat(name)
} | |
c172113 | return exec.LookPath(file)
} | |
c172114 | return ioutil.TempFile(dir, prefix)
} | |
c172115 | return ioutil.ReadDir(dirname)
} | |
c172116 | &gitCmd{exec.Command(name, args...)}
} | |
c172117 | &GitTicker{time.NewTicker(d)}
} | |
c172118 |
return time.Since(t)
} | |
c172119 | := r.Header.Get("Travis-Repo-Slug") + secret
hash := sha256.Sum256([]byte(content))
expectedMac := hex.EncodeToString(hash[:])
if signature != expectedMac {
fmt.Println(signature, expectedMac)
return errors.New("Invalid authorization header")
}
return nil
} | |
c172120 | ignored. Error: %v", h.hookType, h.err)
} | |
c172121 | := range handlers {
if handler == h {
return name
}
}
return ""
} | |
c172122 | handlers. Only one handler ever
// handles a specific request.
if handlers[h].DoesHandle(r.Header) {
status, err := handlers[h].Handle(w, r, repo)
// if the webhook is ignored, log it and allow request to continue.
if hookIgnored(err) {
Logger().Println(err)
err = nil
}
return status, err
}
}
// no compatible handler
Logger().Println("No compatible handler found. Consider enabling generic handler with 'hook_type generic'.")
}
}
return h.Next.ServeHTTP(w, r)
} | |
c172123 | return hostport
}
if i := strings.IndexByte(hostport, ']'); i != -1 {
return strings.TrimPrefix(hostport[:i], "[")
}
return hostport[:colon]
} | |
c172124 | return genOptions(q, "", "=", ";", ",", skipWhenEmpty, ignore...)
} | |
c172125 |
return "?" + s
}
return ""
} | |
c172126 | < len(pairs); j += 2 {
if pairs[j] == z {
z = pairs[j+1]
}
}
x[i] = z
}
n[k] = x
}
return n
} | |
c172127 | nil {
return fi.Mode()
}
return 0
} | |
c172128 | ok {
panic(fmt.Sprintf("scheme %s already registered", alias))
}
scheme.Aliases = append(scheme.Aliases, alias)
if doSort {
sort.Sort(ss(scheme.Aliases))
}
schemeMap[alias] = scheme
} | |
c172129 |
}
}
if !hasShort && len(scheme.Driver) > 2 {
registerAlias(scheme.Driver, scheme.Driver[:2], false)
}
// ensure always at least one alias, and that if Driver is 2 characters,
// that it gets added as well
if len(sz.Aliases) == 0 || len(scheme.Driver) == 2 {
sz.Aliases = append(sz.Aliases, scheme.Driver)
}
// sort
sort.Sort(ss(sz.Aliases))
} | |
c172130 | delete(schemeMap, alias)
}
delete(schemeMap, name)
return scheme
}
return nil
} | |
c172131 | := range a {
if s == b {
return true
}
}
return false
} | |
c172132 |
}
var aliases []string
for _, alias := range scheme.Aliases {
if alias == driver {
continue
}
aliases = append(aliases, alias)
}
sort.Sort(ss(aliases))
return driver, aliases
}
return "", nil
} | |
c172133 | }
q := z.Query()
for k, v := range u.Query() {
q.Set(k, strings.Join(v, " "))
}
fragment := z.Fragment
if u.Fragment != "" {
fragment = u.Fragment
}
y := &url.URL{
Scheme: z.Scheme,
Opaque: opaque,
User: user,
Host: host,
Path: path,
RawPath: rawPath,
RawQuery: q.Encode(),
Fragment: fragment,
}
return y.String(), nil
}
} | |
c172134 |
return u.Opaque + genQueryOptions(u.Query()), nil
} | |
c172135 |
pass, _ := u.User.Password()
q.Set("password", pass)
}
// save host, port, dbname
if u.hostPortDB == nil {
u.hostPortDB = []string{host, port, dbname}
}
return genOptions(q, "", "=", " ", ",", true), nil
} | |
c172136 | pass, _ := u.User.Password()
q.Set("Password", pass)
}
// save host, port, dbname
if u.hostPortDB == nil {
u.hostPortDB = []string{host, port, dbname}
}
return genOptionsODBC(q, true), nil
} | |
c172137 | + ":" + host + port
// add opts
dsn += genOptions(
convertOptions(u.Query(), "true", ""),
",", "=", ",", " ", false,
)
// add dbname
dsn += "*" + dbname
// add user/pass
if u.User != nil {
pass, _ := u.User.Password()
dsn += "/" + u.User.Username() + "/" + pass
} else if strings.HasSuffix(dsn, "*") {
dsn += "//"
}
return dsn, nil
} | |
c172138 | if up, ok := u.User.Password(); ok {
un += "/" + up
}
}
}
return un + "@" + dsn, nil
} | |
c172139 | Fragment: u.Fragment,
}
return strings.TrimPrefix(z.String(), "//"), nil
} | |
c172140 |
if u.User != nil {
q.Set("User ID", u.User.Username())
pass, _ := u.User.Password()
q.Set("Password", pass)
}
// save host, port, dbname
if u.hostPortDB == nil {
n := dsname
if dbname != "" {
n += "/" + dbname
}
u.hostPortDB = []string{host, port, n}
}
return genOptionsODBC(q, true), nil
} | |
c172141 | q.Set("ServiceName", "50000")
default:
q.Set("Port", "1433")
}
} else {
q.Set("Port", port)
}
q.Set("Database", dbname)
// add user/pass
if u.User != nil {
q.Set("UID", u.User.Username())
p, _ := u.User.Password()
q.Set("PWD", p)
}
return genOptionsODBC(q, true), nil
} | |
c172142 |
}
return `Provider=MSDASQL.1;Extended Properties="` + props + `"`, nil
} | |
c172143 | u.User.Username(); len(user) > 0 {
q.Set("username", user)
}
if pass, ok := u.User.Password(); ok {
q.Set("password", pass)
}
}
z.RawQuery = q.Encode()
return z.String(), nil
} | |
c172144 | h != "" {
host = h
}
if p := hostport(u.Host); p != "" {
port = p
}
return host + ":" + port, nil
} | |
c172145 |
z.Host = "localhost"
}
// force port
if hostport(z.Host) == "" {
if z.Scheme == "http" {
z.Host += ":8080"
} else if z.Scheme == "https" {
z.Host += ":8443"
}
}
// add parameters
q := z.Query()
dbname, schema := strings.TrimPrefix(u.Path, "/"), ""
if dbname == "" {
dbname = "default"
} else if i := strings.Index(dbname, "/"); i != -1 {
schema, dbname = dbname[i+1:], dbname[:i]
}
q.Set("catalog", dbname)
if schema != "" {
q.Set("schema", schema)
}
z.RawQuery = q.Encode()
return z.String(), nil
} | |
c172146 | port = p
}
q := u.Query()
// add user/pass
if u.User != nil {
q.Set("username", u.User.Username())
if pass, _ := u.User.Password(); pass != "" {
q.Set("password", pass)
}
}
// add dbname
if dbname != "" {
q.Set("keyspace", dbname)
}
return host + ":" + port + genQueryOptions(q), nil
} | |
c172147 | user = u.User.Username()
if pass, _ := u.User.Password(); pass != "" {
user += ":" + pass
}
user += "@"
}
return user + host + port + "/" + dbname + genQueryOptions(u.Query()), nil
} | |
c172148 | u.Path,
RawPath: u.RawPath,
RawQuery: u.RawQuery,
Fragment: u.Fragment,
}
return p.String()
} | |
c172149 | != nil {
if un := u.User.Username(); un != "" {
s += un + "@"
}
}
if u.Host != "" {
s += u.Host
}
if u.Path != "" && u.Path != "/" {
s += u.Path
}
if u.Opaque != "" {
s += u.Opaque
}
return s
} | |
c172150 | if u.User != nil {
s[4] = u.User.Username()
}
// replace blank entries ...
for i := 0; i < len(s); i++ {
if s[i] == "" {
s[i] = empty
}
}
if cut > 0 {
// cut to only populated fields
i := len(s) - 1
for ; i > cut; i-- {
if s[i] != "" {
break
}
}
s = s[:i]
}
// join
return strings.Join(s, sep)
} | |
c172151 | *RateLimiter {
return &RateLimiter{
redisClient: client,
hasher: hasher,
max: max,
}
} | |
c172152 | {
hash := r.hasher.Hash(id)
return r.redisClient.Exists(hash).Result()
} | |
c172153 | See: http://redis.io/commands/GET
return 0, nil
}
return 0, err
}
if err != nil {
return 0, err
}
return strconv.ParseInt(val, 10, 64)
} | |
c172154 | max minus attempted.
left := r.max - attempted
if left < 0 {
return 0, nil
}
return left, nil
} | |
c172155 | Incr call.
//
// See: http://redis.io/commands/INCR
// See: http://redis.io/commands/INCR#pattern-rate-limiter-1
err = r.redisClient.Watch(func(rx *redis.Tx) error {
_, err := rx.Pipelined(func(pipe *redis.Pipeline) error {
if err := pipe.Incr(hash).Err(); err != nil {
return err
}
return pipe.Expire(hash, r.hasher.Duration()).Err()
})
return err
})
if err != nil {
return false, err
}
return true, nil
} | |
c172156 | privateMasks {
if mask.Contains(ip) {
return false
}
}
return true
} | |
c172157 | if parsed := net.ParseIP(ip); parsed != nil && IsPublicIP(parsed) {
return ip
}
}
return ""
} | |
c172158 | == pmInout || f.mode == pmIn
} | |
c172159 | == pmInout || f.mode == pmOut
} | |
c172160 | newLobChunkReader(f.TypeCode().isCharBased(), rd)
return nil
} | |
c172161 | return fmt.Sprintf("SQL %s %d - %s", e.errorLevel, e.errorCode, e.errorText)
} | |
c172162 | >= e.numArg:
e.idx = e.numArg - 1
default:
e.idx = idx
}
} | |
c172163 | {
return int(e.errors[e.idx].errorCode)
} | |
c172164 | {
return int(e.errors[e.idx].errorPosition)
} | |
c172165 | {
return int(e.errors[e.idx].errorLevel)
} | |
c172166 | {
return string(e.errors[e.idx].errorText)
} | |
c172167 | e.errors[e.idx].errorLevel == errorLevelWarning
} | |
c172168 | e.errors[e.idx].errorLevel == errorLevelError
} | |
c172169 | e.errors[e.idx].errorLevel == errorLevelFatalError
} | |
c172170 | i += size
n += RuneLen(r)
}
return n
} | |
c172171 | n += RuneLen(r)
}
return n
} | |
c172172 |
return true
}
_, _, short = decodeRune(p[n:])
return !short
} | |
c172173 | high, n1
}
low, n2, _ := decodeRune(p[n1:])
if low == utf8.RuneError {
return low, n1 + n2
}
return utf16.DecodeRune(high, low), n1 + n2
} | |
c172174 |
case r <= rune2Max:
return 2
case r <= rune3Max:
return 3
case r <= utf8.MaxRune:
return CESUMax
}
return -1
} | |
c172175 |
tracer.mu.RUnlock()
return on
} | |
c172176 |
tracer.on = on
tracer.mu.Unlock()
} | |
c172177 | = commandOptions(rd.ReadInt8())
rd.Skip(8) //segmentHeaderLength
case skReply:
rd.Skip(1) //reserved
h.functionCode = functionCode(rd.ReadInt16())
rd.Skip(8) //segmentHeaderLength
}
if trace {
outLogger.Printf("read segment header: %s", h)
}
return rd.GetError()
} | |
c172178 |
for {
//up stream
if err := s.stream(dir(true), s.clRd, s.dbWr); err != nil {
return
}
//down stream
if err := s.stream(dir(false), s.dbRd, s.clWr); err != nil {
return
}
}
} | |
c172179 | %s: %s", c.conn.LocalAddr(), c.conn.RemoteAddr(), err)
c.isBad = true
c.badError = err
return n, driver.ErrBadConn
}
return n, nil
} | |
c172180 | new(scramsha256FinalRequest),
scramsha256FinalReply: new(scramsha256FinalReply),
topologyInformation: newTopologyInformation(),
connectOptions: newConnectOptions(),
rowsAffected: new(rowsAffected),
statementID: new(statementID),
resultMetadata: new(resultMetadata),
resultsetID: new(resultsetID),
resultset: new(resultset),
parameterMetadata: new(parameterMetadata),
outputParameters: new(outputParameters),
writeLobRequest: new(writeLobRequest),
readLobRequest: new(readLobRequest),
writeLobReply: new(writeLobReply),
readLobReply: new(readLobReply),
stmtCtx: newStatementContext(),
txFlags: newTransactionFlags(),
lastError: new(hdbErrors),
}
if err = s.init(); err != nil {
return nil, err
}
return s, nil
} | |
c172181 | = newResultFieldSet(p.numArg)
p.resultFieldSet = resultFieldSet
case *resultset:
p.s = s
p.resultFieldSet = resultFieldSet
p.fieldValues = fieldValues
}
}
if err := s.readReply(f); err != nil {
return 0, nil, nil, nil, err
}
return id, resultFieldSet, fieldValues, s.ph.partAttributes, nil
} | |
c172182 | nil {
return nil, err
}
if err := s.readReply(nil); err != nil {
return nil, err
}
if s.sh.functionCode == fcDDL {
return driver.ResultNoRows, nil
}
return driver.RowsAffected(s.rowsAffected.total()), nil
} | |
c172183 | newParameterFieldSet(p.numArg)
p.prmFieldSet = prmFieldSet
case *resultMetadata:
resultFieldSet = newResultFieldSet(p.numArg)
p.resultFieldSet = resultFieldSet
}
}
if err := s.readReply(f); err != nil {
return QtNone, 0, nil, nil, err
}
return s.sh.functionCode.queryType(), id, prmFieldSet, resultFieldSet, nil
} | |
c172184 | s.sh.functionCode == fcDDL {
result = driver.ResultNoRows
} else {
result = driver.RowsAffected(s.rowsAffected.total())
}
if err := s.writeLobStream(prmFieldSet, nil, args); err != nil {
return nil, err
}
return result, nil
} | |
c172185 | {
return err
}
if err := s.readReply(nil); err != nil {
return err
}
return nil
} | |
c172186 | = s
p.outputFields = prmFieldSet.outputFields()
p.fieldValues = prmFieldValues
// table output parameters: meta, id, result (only first param?)
case *resultMetadata:
tableResult = newTableResult(s, p.numArg)
tableResults = append(tableResults, tableResult)
p.resultFieldSet = tableResult.resultFieldSet
case *resultsetID:
p.id = &(tableResult.id)
case *resultset:
p.s = s
tableResult.attrs = s.ph.partAttributes
p.resultFieldSet = tableResult.resultFieldSet
p.fieldValues = tableResult.fieldValues
}
}
if err := s.readReply(f); err != nil {
return nil, nil, err
}
if err := s.writeLobStream(prmFieldSet, prmFieldValues, args); err != nil {
return nil, nil, err
}
return prmFieldValues, tableResults, nil
} | |
c172187 | p.(type) {
case *resultsetID:
p.id = &rsetID
case *resultset:
p.s = s
p.resultFieldSet = resultFieldSet
p.fieldValues = fieldValues
}
}
if err := s.readReply(f); err != nil {
return 0, nil, nil, err
}
return rsetID, fieldValues, s.ph.partAttributes, nil
} | |
c172188 | p.s = s
p.resultFieldSet = resultFieldSet
p.fieldValues = fieldValues
}
}
if err := s.readReply(f); err != nil {
return nil, err
}
return s.ph.partAttributes, nil
} | |
c172189 | nil {
return err
}
if err := s.readReply(nil); err != nil {
return err
}
return nil
} | |
c172190 | return err
}
if trace {
outLogger.Printf("transaction flags: %s", s.txFlags)
}
s.conn.inTx = false
return nil
} | |
c172191 |
rd: bufio.NewReader(r),
tr: unicode.Cesu8ToUtf8Transformer,
}
} | |
c172192 | bufio.NewReaderSize(r, size),
tr: unicode.Cesu8ToUtf8Transformer,
}
} | |
c172193 | r.err
r.err = nil
return err
} | |
c172194 | int
n, r.err = r.rd.Discard(cnt)
r.cnt += n
} | |
c172195 |
if r.err != nil {
return 0
}
var b byte
b, r.err = r.rd.ReadByte()
r.cnt++
return b
} | |
c172196 | n int
n, r.err = io.ReadFull(r.rd, p)
r.cnt += n
} | |
c172197 | != nil {
return false
}
return !(r.ReadB() == 0)
} | |
c172198 | r.err != nil {
return 0
}
return int16(binary.LittleEndian.Uint16(r.b[:2]))
} | |
c172199 | if r.err != nil {
return 0
}
return binary.LittleEndian.Uint16(r.b[:2])
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.