id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c12800 |
if err == io.EOF {
break
}
if argv != nil {
argv(string(chop(arg)))
}
}
if env == nil {
return nil
}
delim := []byte{61} // "="
for {
line, err := bbuf.ReadBytes(0)
if err == io.EOF || line[0] == 0 {
break
}
pair := bytes.SplitN(chop(line), delim, 2)
env(string(pair[0]), string(pai... | |
c12801 | uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)),
uintptr(unsafe.Pointer(new)), uintptr(newlen))
if e1 != 0 {
err = e1
}
return
} | |
c12802 | := listener.bind()
return listener, err
} | |
c12803 |
continue
}
msgs, _ := syscall.ParseNetlinkMessage(buf[:nr])
for _, m := range msgs {
if m.Header.Type == syscall.NLMSG_DONE {
w.handleEvent(m.Data)
}
}
}
} | |
c12804 | w.watchesMutex.Unlock()
if watch, ok := w.watches[pid]; ok {
return (watch.flags & event) == event
}
return false
} | |
c12805 | Groups: _CN_IDX_PROC,
}
err = syscall.Bind(listener.sock, listener.addr)
if err != nil {
return err
}
return listener.send(_PROC_CN_MCAST_LISTEN)
} | |
c12806 | syscall.Close(listener.sock)
return err
} | |
c12807 | >>= 10
if size >= 973 {
o++
continue
}
if size < 9 || (size == 9 && remain < 973) {
remain = ((remain * 5) + 256) / 512
if remain >= 10 {
size++
remain = 0
}
fmt.Fprintf(w, "%d.%d%s", size, remain, ord[o])
break
}
if remain >= 512 {
size++
}
fmt.Fprintf(w, "%3d%s", si... | |
c12808 | := map[rune]string{}
for s, r := range def.Symbols() {
out[r] = s
}
return out
} | |
c12809 | }); ok {
return nr.Name()
}
return ""
} | |
c12810 | tokens = append(tokens, token)
if token.Type == EOF {
return tokens, nil
}
}
} | |
c12811 |
return Token{Type: r, Value: string(r)}
} | |
c12812 | {
return nil, fmt.Errorf("lexer does not support symbol %q", symbol)
}
table[rn] = true
}
return table, nil
} | |
c12813 | return peeking
}
return &lookaheadLexer{Lexer: lexer}
} | |
c12814 | p.apply = append(p.apply, &contextFieldSet{pos, strct, field, fieldValue})
} | |
c12815 | apply.fieldValue); err != nil {
return err
}
}
p.apply = nil
return nil
} | |
c12816 | append(p.apply, branch.apply...)
p.rewinder = branch.rewinder
} | |
c12817 | branch.rewinder = p.rewinder.Lookahead()
return branch
} | |
c12818 |
p.Accept(branch)
return true
}
return false
} | |
c12819 | := &rewinder{}
*clone = *r
clone.limit = clone.cursor
return clone
} | |
c12820 | Lexer {
return lexWithScanner(r, scan)
} | |
c12821 | mapper: mapper,
symbols: symbols,
})
return nil
}
} | |
c12822 | (lexer.Token, error) {
token.Value = strings.ToUpper(token.Value)
return token, nil
}, types...)
} | |
c12823 |
return lexer.Token{}, DropToken
}, types...)
} | |
c12824 |
p.next()
x = &Option{pos, p.parseExpression()}
p.expect(']')
case '{':
p.next()
x = &Repetition{pos, p.parseExpression()}
p.expect('}')
}
return x
} | |
c12825 | {
var p parser
grammar := p.parse(filename, src)
return grammar, p.errors.Err()
} | |
c12826 | begin, end := beginEnd(n)
set := &rangeSet{
pos: n.Pos(),
include: [2]rune{begin, end},
}
for next := n.Exclude; next != nil; {
switch n := next.(type) {
case *internal.Range:
begin, end := beginEnd(n)
set.exclude = append(set.exclude, [2]rune{begin, end})
next = n.Exclude
case *i... | |
c12827 | }
return nil
case *internal.Option:
return validate(grammar, n.Body)
case *internal.Range:
if utf8.RuneCountInString(n.Begin.String) != 1 {
return lexer.Errorf(lexer.Position(n.Pos()), "start of range must be a single rune")
}
if utf8.RuneCountInString(n.End.String) != 1 {
return lexer.Errorf(lexer... | |
c12828 |
return nil, err
}
return lexer.ConsumeAll(lex)
} | |
c12829 | {
p.lex = def
return nil
}
} | |
c12830 |
p.useLookahead = n
return nil
}
} | |
c12831 | tokens {
p.caseInsensitive[token] = true
}
return nil
}
} | |
c12832 | }
for _, idx := range children {
out = append(out, append(f.Index, idx...))
}
} else if fieldLexerTag(f) != "" {
out = append(out, f.Index)
}
}
return
} | |
c12833 | return slexer.Field().Name })
e, err := g.parseDisjunction(slexer)
if err != nil {
return nil, err
}
if e == nil {
return nil, fmt.Errorf("no grammar found in %s", t)
}
if token, _ := slexer.Peek(); !token.EOF() {
return nil, fmt.Errorf("unexpected input %q", token.Value)
}
out.expr = e
retu... | |
c12834 | err != nil {
return nil, err
}
if token.Value == ":" && (token.Type == scanner.Char || token.Type == ':') {
_, _ = lex.Next()
token, err = lex.Next()
if err != nil {
return nil, err
}
if token.Type != scanner.Ident {
return nil, fmt.Errorf("expected identifier for literal type constraint but got %q... | |
c12835 | = r.runes[r.cursor:]
r.cursor = 0
r.oldPos = r.pos
} | |
c12836 | 0, err
}
r.runes = append(r.runes, rn)
return rn, nil
} | |
c12837 | return nil, err
}
program.init()
return program, nil
} | |
c12838 | // Optional part failed to match.
if ctx.Stop(branch) {
return out, err
}
break
} else {
ctx.Accept(branch)
}
if v == nil {
break
}
}
if i >= MaxIterations {
t, _ := ctx.Peek(0)
panic(lexer.Errorf(t.Pos, "too many iterations of %s (> %d)", r, MaxIterations))
}
if out == nil {
out ... | |
c12839 | v.String(), err)
}
v = reflect.New(t).Elem()
v.SetUint(n)
case reflect.Bool:
v = reflect.ValueOf(true)
case reflect.Float32, reflect.Float64:
n, err := strconv.ParseFloat(v.String(), sizeOfKind(kind))
if err != nil {
return nil, fmt.Errorf("invalid integer %q: %s", v.String(), err)
}
... | |
c12840 | *Error {
return &Error{
Message: fmt.Sprintf(format, args...),
Pos: pos,
}
} | |
c12841 | return fmt.Sprintf("%s:%d:%d: %s", filename, e.Pos.Line, e.Pos.Column, e.Message)
} | |
c12842 | ok := value.(error); !ok {
pr.Resolve(value)
} else {
pr.Reject(e)
}
return pr.Future
} | |
c12843 | := make([]*Future, len(acts))
for i, act := range acts {
fs[i] = Start(act)
}
fu = whenAllFuture(fs...)
return
} | |
c12844 | //errs := make([]error, 0, 1)
//errs = append(errs, v.(error))
e := newAggregateError1("Error appears in WhenAll:", v)
wf.Reject(e)
}
}).OnCancel(func() {
if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
//try to cancel all futures
cancelOthers(j)
wf.Cancel()
... | |
c12845 | this.pipePromise
} else {
return this.pipeFailTask, this.pipePromise
}
} | |
c12846 | RESULT_CANCELLED {
return true
} else {
return false
}
} | |
c12847 | mm * 1000 * 1000
}
go func() {
<-time.After((time.Duration)(mm) * time.Nanosecond)
this.Cancel()
}()
return this
} | |
c12848 |
this.OnComplete(func(v interface{}) {
c <- this.loadResult()
}).OnCancel(func() {
c <- this.loadResult()
})
return c
} | |
c12849 |
r := atomic.LoadPointer(&this.val)
return (*futureVal)(r)
} | |
c12850 | issue in this case because address of all objects are different.
if atomic.CompareAndSwapPointer(&this.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
//Close chEnd then all Get() and GetOrTimeout() will be unblocked
close(this.final)
//call callback functions and start the Promise pipeline
if len(v.... | |
c12851 | operation.
if atomic.CompareAndSwapPointer(&this.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
break
}
} else {
if (t == CALLBACK_DONE && r.Typ == RESULT_SUCCESS) ||
(t == CALLBACK_FAIL && r.Typ == RESULT_FAILURE) ||
(t == CALLBACK_ALWAYS && r.Typ != RESULT_CANCELLED) {
callbackFunc := ... | |
c12852 | := &Promise{
&Future{
rand.Int(),
make(chan struct{}),
unsafe.Pointer(val),
},
}
return f
} | |
c12853 | Rules{r, Handle(h)}.Eval
} | |
c12854 | r.Handle(events.Handler(h))
} | |
c12855 | error) {
if r == nil {
return nil
}
_, _, err = r(ctx, e, nil, ChainIdentity)
return
} | |
c12856 |
return Rule(rs.Eval).HandleEvent(ctx, e)
} | |
c12857 |
return fmt.Sprintf("%s (and %d more errors)", es[0], len(es)-1)
}
} | |
c12858 | == nil {
if list, ok := a.(ErrorList); ok {
return flatten(list).Err()
}
return a
}
return Error(a, b)
} | |
c12859 | nil {
_, ok := err.(ErrorList)
return ok
}
return false
} | |
c12860 | := md.minDetectorCyclePeriod
md.minDetectorCyclePeriod = d
return MinCyclePeriod(old)
}
} | |
c12861 | return connect2(zkHosts, zkPath)
}
return client, nil
}
// apply options last so that they can override default behavior
for _, opt := range options {
opt(detector)
}
log.V(2).Infoln("Created new detector to watch", zkHosts, zkPath)
return detector, nil
} | |
c12862 | r != nil {
log.Errorf("recovered from client panic: %v", r)
}
}()
f()
} | |
c12863 | just consume resources and generate misleading log messages.
if !atomic.CompareAndSwapInt32(&md.ignoreInstalled, 0, 1) {
log.V(3).Infoln("ignoreChanged listener already installed")
return
}
f = ignoreChanged
}
log.V(3).Infoln("spawning detect()")
go md.detect(f)
return nil
} | |
c12864 |
controller.LiftErrors().DropOnError(),
).Handle(events.Handlers{
scheduler.Event_FAILURE: logger.HandleF(failure),
scheduler.Event_OFFERS: trackOffersReceived(state).HandleF(resourceOffers(state)),
scheduler.Event_UPDATE: controller.AckStatusUpdates(state.cli).AndThen().HandleF(statusUpdate(state)),
sched... | |
c12865 | (context.Context, *scheduler.Event, error) {
log.Printf("%+v\n", *e)
return ch(ctx, e, err)
}
} | |
c12866 |
}
harness := xmetrics.NewHarness(metricsAPI.eventReceivedCount, metricsAPI.eventErrorCount, timed, clock)
return eventrules.Metrics(harness, nil)
} | |
c12867 |
}
harness := xmetrics.NewHarness(metricsAPI.callCount, metricsAPI.callErrorCount, timed, clock)
return callrules.Metrics(harness, nil)
} | |
c12868 |
if message, ok := messages[c.GetType()]; ok {
log.Println(message)
}
return ch(ctx, c, r, err)
}
} | |
c12869 | auth.AuthenticateeFunc(func(ctx context.Context, handler callback.Handler) error {
ctx, auth := newAuthenticatee(ctx, config)
auth.authenticate(ctx, ip.Server())
select {
case <-ctx.Done():
return auth.discard(ctx)
case <-auth.done:
return auth.err
}
}), nil
} | |
c12870 | []struct {
f handlerFn
m proto.Message
}{
{self.mechanisms, &mesos.AuthenticationMechanismsMessage{}},
{self.step, &mesos.AuthenticationStepMessage{}},
{self.completed, &mesos.AuthenticationCompletedMessage{}},
{self.failed, &mesos.AuthenticationFailedMessage{}},
{self.errored, &mesos.AuthenticationErro... | |
c12871 | addr.To4(); ip != nil {
break
}
}
if ip == nil {
// no ipv4? best guess, just take the first addr
if len(ips) > 0 {
ip = ips[0]
log.Warningf("failed to find an IPv4 address for '%v', best guess is '%v'", hostname, ip)
} else {
return "", fmt.Errorf("failed to determine IP addr... | |
c12872 | {
return NewHttpWithBindingAddress(upid, nil, opts...)
} | |
c12873 | err := m.tr.Send(ctx, wrapped)
err = rf(ctx, wrapped, err)
if err != nil {
m.reportError("send", wrapped, err)
}
})
select {
case <-ctx.Done():
return ctx.Err()
case m.sendingQueue <- d:
return nil
}
} | |
c12874 | need to coordinate
// access to m.upid in that case. probably better off with a state machine instead of
// what we have now.
go func() {
select {
case err := <-errChan:
if err != nil {
//TODO(jdef) should the driver abort in this case? probably
//since this messenger will never attempt to re-establi... | |
c12875 | err2 != nil && err2 != errTerminal {
log.Warningf("failed to stop the transporter: %v\n", err2)
err = err2
}
})
return
} | |
c12876 | msgName = fmt.Sprintf("%v.%v", "mesos.internal", reflect.TypeOf(msg).Elem().Name())
}
return msgName
} | |
c12877 | range xs {
rs[i].Begin, rs[i].End = xs[i], xs[i]
}
return rs.Squash()
} | |
c12878 | += 1 + (rs[i].End - rs[i].Begin)
}
return sz
} | |
c12879 | append(squashed, rs[i])
case max <= rs[i].End: // overlap or continuity: squash
squashed[len(squashed)-1].End = rs[i].End
}
}
return squashed
} | |
c12880 | 1
case n > rs[m].End:
lo = m + 1
default:
return m
}
}
return -1
} | |
c12881 | == n: // decrement upper bound
pn = append(pn, Value_Range{rs[i].Begin, rs[i].End - 1})
default: // split
pn = append(pn, Value_Range{rs[i].Begin, n - 1}, Value_Range{n + 1, rs[i].End})
}
return append(pn, rs[i+1:]...), true
} | |
c12882 | Value_Range{removal.End + 1, r.End},
)
continue
}
// add the full range if there's no intersection
if r.End < removal.Begin || r.Begin > removal.End {
ranges = append(ranges, r)
continue
}
// trim if the range does intersect
if r.End > removal.End {
ranges = append(ranges, Value_Range{rem... | |
c12883 | _, b := range y {
if a.Begin >= b.Begin && a.End <= b.End {
matched = true
break
}
}
if !matched {
return 1
}
}
return -1
} | |
c12884 | defer providerLock.Unlock()
provider, ok = authenticateeProviders[name]
return
} | |
c12885 | DefaultErrorMapper,
}
c.buildRequestFunc = c.buildRequest
c.handleResponse = c.HandleResponse
c.With(opts...)
return c
} | |
c12886 | per-request options
for _, o := range opts {
if o != nil {
o(req)
}
}
} | |
c12887 | Opts(opts).Merged().Apply(c)
} | |
c12888 | encoding.Marshaler) (mesos.Response, error) {
return c.Do(m, opts...)
})
} | |
c12889 |
req, err := http.NewRequest("POST", c.url, &body)
if err != nil {
return nil, err
}
helper := HTTPRequestHelper{req}
return helper.
withOptions(c.requestOpts, opt).
withHeaders(c.header).
withHeader("Content-Type", c.codec.Type.ContentType()).
withHeader("Accept", c.codec.Type.ContentType()).
withOpt... | |
c12890 | nil, err
}
result.Decoder = c.codec.NewDecoder(sf.NewSource(res.Body))
case http.StatusAccepted:
debug.Log("request Accepted")
// noop; no decoder for these types of calls
defer res.Body.Close()
_, err = io.Copy(ioutil.Discard, res.Body)
return nil, err
default:
debug.Log("unexpected HTTP status"... | |
c12891 | return c.Send(client.RequestSingleton(m), client.ResponseClassAuto, opt...)
} | |
c12892 | c.errorMapper = em
return ErrorMapper(old)
}
} | |
c12893 | c.url = rawurl
return Endpoint(old)
}
} | |
c12894 |
c.do = f(c.do)
return Do(old)
}
} | |
c12895 | c.do = do
return Do(old)
}
} | |
c12896 | c.codec = codec
return Codec(old)
}
} | |
c12897 | found {
c.header[k] = old
} else {
c.header.Del(k)
}
return DefaultHeader(k, v)
}
}
} | |
c12898 | c.handleResponse = f
return HandleResponse(old)
}
} | |
c12899 | c.requestOpts...)
c.requestOpts = opts
return RequestOptions(old...)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.