id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c20700 |
sourceContext.SetContext(ctx)
}
if !hasScanner {
e, hasSourceExec := p.Conn.(ExecutorSource)
if hasSourceExec {
s := &Source{
TaskBase: NewTaskBase(ctx),
ExecSource: e,
p: p,
}
return s, nil
}
u.Warnf("source %T does not implement datasource.Scanner", p.Conn)
return nil, ... | |
c20701 | u.Warnf("got nil")
// Signal to quit
return false
default:
u.Errorf("could not convert to message reader: %T", msg)
}
return true
}
return m
} | |
c20702 | NewTaskBase(ctx),
}
m.Handler = resultWrite(m)
return m
} | |
c20703 | := NewTaskStepper(ctx)
m := &ResultWriter{
TaskBase: stepper.TaskBase,
cols: cols,
}
return m
} | |
c20704 | }
m.Handler = func(ctx *plan.Context, msg schema.Message) bool {
*writeTo = append(*writeTo, msg)
//u.Infof("write to msgs: %v", len(*writeTo))
return true
}
return m
} | |
c20705 | {
return &qlbResult{m.lastInsertID, m.rowsAffected, m.err}
} | |
c20706 | FileHandler {
return &jsonHandlerTables{
FileHandler: &jsonHandler{lh},
tables: tables,
}
} | |
c20707 | value.MapIntType, value.MapNumberType:
return true
}
}
// Nothing else is numeric
return false
} | |
c20708 | := &qlbStmt{conn: m, query: query}
return stmt.Exec(args)
} | |
c20709 | := &qlbStmt{conn: m, query: query}
return stmt.Query(args)
} | |
c20710 | if m.job != nil {
m.job.Close()
}
return nil
} | |
c20711 | to run")
err = job.Run()
//u.Debugf("After qlb driver.Run() in Exec()")
if err != nil {
u.Errorf("error on Query.Run(): %v", err)
//resultWriter.ErrChan() <- err
//job.Close()
}
return resultWriter.Result(), nil
} | |
c20712 | sqlSelect, ok := job.Ctx.Stmt.(*rel.SqlSelect)
if !ok {
u.Warnf("ctx? %v", job.Ctx)
return nil, fmt.Errorf("We could not recognize that as a select query: %T", job.Ctx.Stmt)
}
// Prepare a result writer, we manually append this task to end
// of job?
resultWriter := NewResultRows(ctx, sqlSelect.Columns.Alias... | |
c20713 | err := os.Stat(bashPath); os.IsNotExist(err) {
err = RestoreAsset(bashDir, "bash")
if err != nil {
log.Fatal(err, "1")
}
}
ApplicationWithPath(funcs, scripts, loader, copyEnv, bashPath)
} | |
c20714 | scripts {
bash.Source(script, loader)
}
if copyEnv {
bash.CopyEnv()
}
status, err := bash.Run("main", os.Args[1:])
if err != nil {
log.Fatal(err)
}
os.Exit(status)
} | |
c20715 | os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
scripts: make([][]byte, 0),
vars: make([]string, 0),
funcs: make(map[string]func([]string)),
}, nil
} | |
c20716 | = append(c.vars, os.Environ()...)
} | |
c20717 | err
}
c.Lock()
defer c.Unlock()
c.scripts = append(c.scripts, data)
return nil
} | |
c20718 | {
c.Lock()
defer c.Unlock()
c.vars = append(c.vars, name+"="+value)
} | |
c20719 |
defer c.Unlock()
c.funcs[name] = fn
} | |
c20720 | if cmd == args[i+1] {
c.funcs[cmd](args[i+2:])
return true
}
}
return false
}
}
return false
} | |
c20721 | Asset(" + name + "): " + err.Error())
}
return a
} | |
c20722 | errCode := C.SecTrustedApplicationCreateFromPath(trustedApplicationCStr, &trustedApplicationRef)
err := checkError(errCode)
if err != nil {
return 0, err
}
return C.CFTypeRef(trustedApplicationRef), nil
} | |
c20723 | {
return createAccess(a.Label, a.TrustedApplications)
} | |
c20724 | {
k.attr[AccessKey] = a
} else {
delete(k.attr, AccessKey)
}
} | |
c20725 | C.SecKeychainItemDelete(C.SecKeychainItemRef(ref))
return checkError(errCode)
} | |
c20726 | return newKeychain(path, password, false)
} | |
c20727 | status C.SecKeychainStatus
return checkError(C.SecKeychainGetStatus(kref, &status))
} | |
c20728 | checkError(C.SecKeychainOpen(pathName, &kref)); err != nil {
return 0, err
}
return kref, nil
} | |
c20729 | return err
}
passwordRef := C.CString(password)
defer C.free(unsafe.Pointer(passwordRef))
return checkError(C.SecKeychainUnlock(kref, C.UInt32(len(password)), unsafe.Pointer(passwordRef), C.Boolean(1)))
} | |
c20730 | return err
}
return checkError(C.SecKeychainLock(kref))
} | |
c20731 | openKeychainRef(kc.path)
return C.CFTypeRef(keyRef), err
} | |
c20732 | converted before
for _, ref := range refs {
if ref != 0 {
Release(ref)
}
}
return 0, err
}
}
return C.CFTypeRef(ArrayToCFArray(refs)), nil
} | |
c20733 | k.attr[MatchSearchListKey] = keychainArray(karr)
} | |
c20734 | string) error {
item := keychain.NewGenericPassword(service, account, label, []byte(password), accessGroup)
return keychain.AddItem(item)
} | |
c20735 | item.SetAccount(account)
item.SetAccessGroup(accessGroup)
return keychain.DeleteItem(item)
} | |
c20736 | if err != nil {
return nil, errors.Wrap(err, "failed to unmarshal prompt result")
}
if result.Dismissed {
return nil, PromptDismissedError{errors.New("prompt dismissed")}
}
return &result.Paths, nil
case <-time.After(30 * time.Second):
return nil, errors.New("prompt timed out")
}
}
} | |
c20737 | absoluteTimeToUnix(abs)
return time.Unix(s, ns)
} | |
c20738 | C.GoBytes(unsafe.Pointer(C.CFDataGetBytePtr(cfData)), C.int(C.CFDataGetLength(cfData))), nil
} | |
c20739 | maxBufLen)
var usedBufLen C.CFIndex
_ = C.CFStringGetBytes(s, C.CFRange{0, length}, C.kCFStringEncodingUTF8, C.UInt8(0), C.false, (*C.UInt8)(&buf[0]), maxBufLen, &usedBufLen)
return string(buf[:usedBufLen])
} | |
c20740 | Release(C.CFTypeRef(typeDesc))
return CFStringToString(typeDesc)
} | |
c20741 | nil, err
}
return b, nil
} else if typeID == C.CFNumberGetTypeID() {
return CFNumberToInterface(C.CFNumberRef(ref)), nil
} else if typeID == C.CFBooleanGetTypeID() {
if C.CFBooleanGetValue(C.CFBooleanRef(ref)) != 0 {
return true, nil
}
return false, nil
}
return nil, fmt.Errorf("Invalid type: %s", ... | |
c20742 | length)
if _, err := randRead(buf); err != nil {
return nil, err
}
return buf, nil
} | |
c20743 | = make(map[C.CFTypeRef]uintptr, count)
for i := C.CFIndex(0); i < count; i++ {
k := keys[i]
v := values[i]
m[k] = uintptr(v)
}
}
return
} | |
c20744 | = make([]C.CFTypeRef, count)
C.CFArrayGetValues(cfArray, C.CFRange{0, count}, (*unsafe.Pointer)(&a[0]))
}
return
} | |
c20745 | k.attr[SecClassKey] = secClassTypeRef[sc]
} | |
c20746 | k.attr[key] = s
} else {
delete(k.attr, key)
}
} | |
c20747 | {
k.attr[DataKey] = b
} else {
delete(k.attr, DataKey)
}
} | |
c20748 | = syncTypeRef[sync]
} else {
delete(k.attr, SynchronizableKey)
}
} | |
c20749 | = accessibleTypeRef[accessible]
} else {
delete(k.attr, AccessibleKey)
}
} | |
c20750 | = matchTypeRef[matchLimit]
} else {
delete(k.attr, MatchLimitKey)
}
} | |
c20751 |
item.SetAccount(account)
item.SetLabel(label)
item.SetData(data)
item.SetAccessGroup(accessGroup)
return item
} | |
c20752 | defer Release(C.CFTypeRef(cfDict))
errCode := C.SecItemAdd(cfDict, nil)
err = checkError(errCode)
return err
} | |
c20753 | defer Release(C.CFTypeRef(cfDictUpdate))
errCode := C.SecItemUpdate(cfDict, cfDictUpdate)
err = checkError(errCode)
return err
} | |
c20754 |
item.SetSecClass(SecClassGenericPassword)
item.SetService(service)
item.SetAccount(account)
return DeleteItem(item)
} | |
c20755 | }
defer Release(C.CFTypeRef(cfDict))
errCode := C.SecItemDelete(cfDict)
return checkError(errCode)
} | |
c20756 |
}
accounts := make([]string, 0, len(results))
for _, r := range results {
accounts = append(accounts, r.Account)
}
return accounts, nil
} | |
c20757 |
query.SetAccessGroup(accessGroup)
query.SetMatchLimit(MatchLimitOne)
query.SetReturnData(true)
results, err := QueryItem(query)
if err != nil {
return nil, err
}
if len(results) > 1 {
return nil, fmt.Errorf("Too many results")
}
if len(results) == 1 {
return results[0].Data, nil
}
return nil, nil
} | |
c20758 | return nil, createErr
}
defer C.CFRelease(C.CFTypeRef(trustedApplicationRef))
trustedApplicationsRefs = append(trustedApplicationsRefs, trustedApplicationRef)
}
trustedApplicationsArray = ArrayToCFArray(trustedApplicationsRefs)
defer C.CFRelease(C.CFTypeRef(trustedApplicationsArray))
}
var access ... | |
c20759 | &resultsRef)
if Error(errCode) == ErrorItemNotFound {
return nil, nil
}
err = checkError(errCode)
if err != nil {
return nil, err
}
return resultsRef, nil
} | |
c20760 | convertResult(C.CFDictionaryRef(resultsRef))
if err != nil {
return nil, err
}
results = append(results, *item)
} else if typeID == C.CFDataGetTypeID() {
b, err := CFDataToBytes(C.CFDataRef(resultsRef))
if err != nil {
return nil, err
}
item := QueryResult{Data: b}
results = append(results, item... | |
c20761 | rpc.ClientCodec {
return NewCodec(true, true, conn)
} | |
c20762 | rpc.ServerCodec {
return NewCodec(true, true, conn)
} | |
c20763 | NewCodecFromHandle(bufReads, bufWrites, conn, msgpackHandle)
} | |
c20764 | }
if bufWrites {
cc.bufW = bufio.NewWriter(conn)
cc.enc = codec.NewEncoder(cc.bufW, h)
} else {
cc.enc = codec.NewEncoder(cc.conn, h)
}
return cc
} | |
c20765 | {
buf.WriteByte(' ')
buf.WriteString(keyval[i])
buf.WriteByte('/')
buf.WriteString(keyval[i+1])
}
return buf.String()[1:]
} | |
c20766 | of
// simply making Unavailable a non-retried code elsewhere.
if strings.Contains(err.Error(), "x509: certificate signed by unknown authority") {
return err
}
if retryer == nil {
if r := settings.Retry(); r != nil {
retryer = r
} else {
return err
}
}
if d, ok := retryer.Retry(err); !ok... | |
c20767 |
// https://www.awsarchitectureblog.com/2015/03/backoff.html argues that
// that is the best strategy.
d := time.Duration(1 + rand.Int63n(int64(bo.cur)))
bo.cur = time.Duration(float64(bo.cur) * bo.Multiplier)
if bo.cur > bo.Max {
bo.cur = bo.Max
}
return d
} | |
c20768 | {
return grpcOpt(append([]grpc.CallOption(nil), opt...))
} | |
c20769 | close(sem)
}()
select {
case <-sem:
return locker.Unlock()
case <-time.After(locker.opts.LockTimeout):
return ErrLockDurationExceeded
}
} | |
c20770 |
if opts != nil {
o = *opts
}
o.normalize()
return &Locker{client: client, key: key, opts: o}
} | |
c20771 |
locked := l.token != ""
l.mutex.Unlock()
return locked
} | |
c20772 |
defer l.mutex.Unlock()
if l.token != "" {
return l.refresh(ctx)
}
return l.create(ctx)
} | |
c20773 |
l.mutex.Unlock()
return err
} | |
c20774 | fmt.Errorf("field '%v' does not found in record %+v", name, *entry)
}
return
} | |
c20775 | == nil {
value, err = strconv.ParseFloat(tmp, 64)
}
return
} | |
c20776 | entry.fields[name] = value
} | |
c20777 | strconv.FormatFloat(value, 'f', 2, 64))
} | |
c20778 | strconv.FormatUint(uint64(value), 10))
} | |
c20779 | merge.fields {
entry.SetField(name, value)
}
} | |
c20780 | }
key = append(key, fmt.Sprintf("'%v'=%v", name, value))
}
return strings.Join(key, ";")
} | |
c20781 | value, _ := entry.Field(name)
partial.SetField(name, value)
}
return partial
} | |
c20782 | NewParserReader(logFile, NewParser(format))
} | |
c20783 | *Reader {
return &Reader{
file: logFile,
parser: parser,
}
} | |
c20784 | parser, err := NewNginxParser(nginxConf, formatName)
if err != nil {
return nil, err
}
reader = &Reader{
file: logFile,
parser: parser,
}
return
} | |
c20785 | = MapReduce(r.file, r.parser, new(ReadAll))
}
entry, ok := <-r.entries
if !ok {
err = io.EOF
}
return
} | |
c20786 | preparedFormat, fmt.Sprintf("${1}${3}%s$$${2}${3}", placeholder),
)
}
// Second replace each fileds to regexp grouping
quotedFormat := regexp.QuoteMeta(preparedFormat + " ")
re := regexp.MustCompile(`\\\$([A-Za-z0-9_]+)(?:\\\$[A-Za-z0-9_])*(\\?([^$\\A-Za-z0-9_]))`).ReplaceAllString(
quotedFormat, "(?P<$1>[^$... | |
c20787 | // Iterate over subexp foung and fill the map record
entry = NewEmptyEntry()
for i, name := range re.SubexpNames() {
if i == 0 {
continue
}
entry.SetField(name, fields[i])
}
return
} | |
c20788 | formatDef == nil {
continue
}
found = true
line = formatDef[1]
} else {
line = scanner.Text()
}
// Look for a definition end
re = regexp.MustCompile(`^\s*(.*?)\s*(;|$)`)
lineSplit := re.FindStringSubmatch(line)
if l := len(lineSplit[1]); l > 2 {
format += lineSplit[1][1 : l-1]
}
if l... | |
c20789 | entries <- entry
} else {
handleError(err)
}
// Increment semaphore to allow new mapper workers to spawn
sem <- true
}()
}
// Wait for all mappers to complete, then send a quit signal
wg.Wait()
close(entries)
}(cap(entries))
// Run reducer routine.
var output = make(chan *Entry)
go... | |
c20790 | nil {
// TODO handle error
return
}
if i.withinBounds(t) {
validEntry = entry
}
return
} | |
c20791 | i.Filter(entry); valid != nil {
output <- valid
}
}
close(output)
} | |
c20792 | *Entry) {
for entry := range input {
output <- entry
}
close(output)
} | |
c20793 | }
entry := NewEmptyEntry()
entry.SetUintField("count", count)
output <- entry
close(output)
} | |
c20794 | val, err := entry.FloatField(name)
if err == nil {
sum[name] += val
}
}
}
entry := NewEmptyEntry()
for name, val := range sum {
entry.SetFloatField(name, val)
}
output <- entry
close(output)
} | |
c20795 | append(chain.filters, f)
} else {
chain.reducers = append(chain.reducers, r)
}
}
return chain
} | |
c20796 |
// Read reducer master input channel
for entry := range input {
for _, f := range r.filters {
entry = f.Filter(entry)
if entry == nil {
break
}
}
// Publish input entry for each sub-reducers to process
if entry != nil {
for _, sub := range subInput {
sub <- entry
}
}
}
for _, ch :=... | |
c20797 | *GroupBy {
return &GroupBy{
Fields: fields,
reducers: reducers,
}
} | |
c20798 | if _, ok := subInput[key]; !ok {
subInput[key] = make(chan *Entry, cap(input))
subOutput[key] = make(chan *Entry, cap(output)+1)
subOutput[key] <- entry.Partial(r.Fields)
go NewChain(r.reducers...).Reduce(subInput[key], subOutput[key])
}
subInput[key] <- entry
}
for _, ch := range subInput {
close(... | |
c20799 | if shouldPool {
returnToPool(vn.vec)
}
vn.vec = nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.