id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c17400 | ctx.Value(contextKey{}).(lager.Logger)
if !ok {
return &discardLogger{}
}
return l
} | |
c17401 | return FromContext(ctx).Session(task, data...)
} | |
c17402 | FromContext(ctx).WithData(data)
} | |
c17403 |
if !exists {
lock = new(sync.Mutex)
allLocks.keys[bucketIndex][key] = lock
}
lock.Lock()
return lock
} | |
c17404 | NewHTTPCache(config.CacheKeyTemplate),
URLLocks: NewURLLock(),
Next: Next,
}
} | |
c17405 | {
f.Flush()
}
return nil
} | |
c17406 | key,
isPublic: isPublic,
expiration: expiration,
Request: request,
Response: response,
}
} | |
c17407 | {
if !e.isPublic {
return e.writePrivateResponse(w)
}
return e.writePublicResponse(w)
} | |
c17408 |
if err != nil {
return nil, err
}
return &FileStorage{
file: file,
subscription: NewSubscription(),
}, nil
} | |
c17409 | defer f.subscription.NotifyAll(0)
return f.file.Sync()
} | |
c17410 | // Wait until every subscriber ends waiting every result
return os.Remove(f.file.Name())
} | |
c17411 | f.subscription.Close()
return f.file.Close()
} | |
c17412 | newFile,
subscription: f.subscription.NewSubscriber(),
unsubscribe: f.subscription.RemoveSubscriber,
}, nil
} | |
c17413 | r.unsubscribe(r.subscription)
return err
} | |
c17414 | })
c.OnStartup(func() error {
if config.Path == "" {
return nil
}
return os.MkdirAll(config.Path, 0600)
})
return nil
} | |
c17415 | bool, 1),
bodyLock: new(sync.RWMutex),
closedLock: new(sync.RWMutex),
headersLock: new(sync.RWMutex),
}
r.bodyLock.Lock()
r.closedLock.Lock()
r.headersLock.Lock()
return r
} | |
c17416 |
if b == nil {
b = []byte(str)
}
m.Set("Content-Type", http.DetectContentType(b))
}
rw.WriteHeader(200)
} | |
c17417 | {
rw.firstByteSent = true
rw.WaitBody()
}
if rw.body != nil {
return rw.body.Write(buf)
}
return 0, errors.New("No storage")
} | |
c17418 | rw.body == nil {
return nil
}
return rw.body.Clean()
} | |
c17419 | := c.Get(key).(sessions.Store)
return store.Get(c.Request(), name)
} | |
c17420 | {
c := DefaultConfig
c.Store = store
return MiddlewareWithConfig(c)
} | |
c17421 | {
c := DefaultConfig
c.Enforcer = ce
return MiddlewareWithConfig(c)
} | |
c17422 | !ok {
s.ChannelStats[channel] = make(eventIDStat)
}
s.ChannelStats[channel][eventID]++
s.EventCount++
s.Unlock()
} | |
c17423 |
fmt.Printf("%s,%d,%d\n", c, eid, cnt)
}
}
//fmt.Printf("Total Events: %d\n", s.EventCount)
} | |
c17424 | reader := bytes.NewReader(c.Data)
c.ParseChunkHeader(reader)
if err = c.Header.Validate(); err != nil {
return c, err
}
// Go to after Header
evtx.GoToSeeker(reader, int64(c.Header.SizeHeader))
c.ParseStringTable(reader)
err = c.ParseTemplateTable(reader)
if err != nil {
return c, err
}
err = c.ParseEven... | |
c17425 | Chunk @ Offset: %d (0x%08[1]x)", offset)
chunk, err := fetchChunkFromReader(dup, offset)
if err != nil {
log.LogError(err)
}
for e := range chunk.Events() {
printEvent(e)
}
chunkCnt++
if limit > 0 && chunkCnt >= limit {
break
}
log.Debug("End of the loop")
}
} | |
c17426 |
if time.Time(start) != defaultTime {
if t.Before(time.Time(start)) {
return
}
}
// If after stop we do not print
if time.Time(stop) != defaultTime {
if t.After(time.Time(stop)) {
return
}
}
if timestamp {
if err == nil {
fmt.Printf("%d: %s\n", t.Unix(), string(evtx.ToJSON(e)))
... | |
c17427 | return
}
ef.file = file
ef.ParseFileHeader()
return
} | |
c17428 | encoding.Unmarshal(ef.file, &ef.Header, Endianness)
if err != nil {
panic(err)
}
} | |
c17429 | after Header
GoToSeeker(reader, int64(c.Header.SizeHeader))
c.ParseStringTable(reader)
if err := c.ParseTemplateTable(reader); err != nil {
return c, err
}
if err := c.ParseEventOffsets(reader); err != nil {
return c, err
}
return c, nil
} | |
c17430 | only the Chunks whose EventRecordIds have not been treated yet
if markedChunks.Contains(chunk.Header.FirstEventRecID) && markedChunks.Contains(chunk.Header.LastEventRecID) {
continue
}
switch {
case err != nil && err != io.EOF:
panic(err)
case err == nil:
markedChunks.Add(chunk.Heade... | |
c17431 | defer close(cgem)
chanQueue := make(chan (chan *GoEvtxMap), jobs)
go func() {
defer close(chanQueue)
// this chan ends only when value is put into stop
for pc := range ef.monitorChunks(stop, sleepTime) {
// We have to create a copy here because otherwise cpc.EventsChan() fails
// I guess that beca... | |
c17432 | []byte(fmt.Sprintf("\"%s\"", time.Time(u).UTC().Format(time.RFC3339Nano))), nil
} | |
c17433 | if ch.OffsetLastRec >= ChunkSize {
return fmt.Errorf("Last event offset exceed size of chunk")
}
return nil
} | |
c17434 | := encoding.Unmarshal(reader, &c.Header, Endianness)
if err != nil {
panic(err)
}
} | |
c17435 | c.Header.NumFirstRecLog < other.Header.NumFirstRecLog
} | |
c17436 | if err != nil {
if !ModeCarving {
panic(err)
}
}
c.StringTable[strOffset] = cs
}
}
return
} | |
c17437 | TemplateInstance token and make it easily parsable by binxml.Parse
GoToSeeker(reader, int64(templateDataOffset))
tdd := TemplateDefinitionData{}
err := tdd.Parse(reader)
if err != nil {
//panic(err)
log.DebugDontPanic(err)
return err
}
c.TemplateTable[templateDataOffset] = tdd
GoToSeek... | |
c17438 | err = eh.Validate(); err != nil {
// we bruteforce in carving mode
if ModeCarving {
offsetEvent++
continue
}
return err
}
offsetEvent += eh.Size
c.EventOffsets = append(c.EventOffsets, offsetEvent)
}
return nil
} | |
c17439 | panic(err)
}
err = encoding.Unmarshal(reader, &e.ID, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.Timestamp, Endianness)
if err != nil {
panic(err)
}*/
return e
} | |
c17440 | }
// We jump to the right offset
GoToSeeker(reader, int64(e.NameOffset))
err = e.Name.Parse(reader)
// We restore our position
GoToSeeker(reader, o)
return err
} | |
c17441 |
case map[string]interface{}:
p := GoEvtxMap(i.(map[string]interface{}))
np := (*path)[1:]
return p.Get(&np)
}
}
}
return nil, &ErrEvtxEltNotFound{*path}
} | |
c17442 |
return s, nil
}
return "", fmt.Errorf("Bad type expect string got %T", (*pE))
} | |
c17443 | }
b, err := strconv.ParseBool(s)
if err != nil {
return false, err
}
return b, err
} | |
c17444 | }
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
return 0, err
}
return i, nil
} | |
c17445 | != nil {
return 0, &ErrEvtxEltNotFound{*path}
}
u, err := strconv.ParseUint(s, 10, 64)
if err != nil {
return 0, err
}
return u, nil
} | |
c17446 | return time.Time((*t).(UTCTime)), nil
case string:
return time.Parse(time.RFC3339Nano, (*t).(string))
default:
return time.Time{}, fmt.Errorf("Cannot convert %T to time.Time", *t)
}
} | |
c17447 | != nil {
return false
}
return reflect.DeepEqual(*t, i)
} | |
c17448 | is {
if reflect.DeepEqual(i, *t) {
return true
}
}
return false
} | |
c17449 | err != nil {
return false
}
return pattern.MatchString(s)
} | |
c17450 | switch i.(type) {
case GoEvtxMap:
p := i.(GoEvtxMap)
np := (*path)[1:]
return p.Set(&np, new)
case map[string]interface{}:
p := GoEvtxMap(i.(map[string]interface{}))
np := (*path)[1:]
return p.Set(&np, new)
}
}
return &ErrEvtxEltNotFound{*path}
} | |
c17451 | ge.(type) {
case GoEvtxMap:
p := ge.(GoEvtxMap)
p.Del(path[1:]...)
}
}
}
} | |
c17452 | event is embedded into a
// chunk
if h.Size >= ChunkSize {
return fmt.Errorf("Too big event")
}
// An event cannot be smaller than its header since the event size include the
// size of the header
if h.Size < EventHeaderSize {
return fmt.Errorf("Too small event")
}
return nil
} | |
c17453 | not a BinXMLFragment a panic will be raised
fragment, ok := element.(*Fragment)
switch {
case !ok && ModeCarving:
return
case !ok:
// Way to raise panic
_ = element.(*Fragment)
}
return fragment.GoEvtxMap(), err
} | |
c17454 | index.Cols = append(index.Cols, col)
}
} | |
c17455 | name, indexType, make([]string, 0)}
} | |
c17456 | st = SQLType{Text, 0, 0}
}
case reflect.Bool:
st = SQLType{Bool, 0, 0}
case reflect.String:
st = SQLType{Varchar, 255, 0}
case reflect.Struct:
if t.ConvertibleTo(TimeType) {
st = SQLType{DateTime, 0, 0}
} else {
// TODO need to handle association struct
st = SQLType{Text, 0, 0}
}
case reflect.... | |
c17457 | Varchar, NVarchar, TinyText, Text, NText, MediumText, LongText, Enum, Set, Uuid, Clob, SysName:
return reflect.TypeOf("")
case TinyBlob, Blob, LongBlob, Bytea, Binary, MediumBlob, VarBinary, UniqueIdentifier:
return reflect.TypeOf([]byte{})
case Bool:
return reflect.TypeOf(true)
case DateTime, Date, Time, Tim... | |
c17458 | reflect.Indirect(reflect.ValueOf(bean))
return col.ValueOfV(&dataStruct)
} | |
c17459 | if fieldValue.Kind() == reflect.Struct {
fieldValue = fieldValue.FieldByName(fieldPath[i+1])
} else if fieldValue.Kind() == reflect.Ptr {
if fieldValue.IsNil() {
fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
}
fieldValue = fieldValue.Elem().FieldByName(fieldPath[i+1])
} else {
return ni... | |
c17460 |
for i, name := range table.PrimaryKeys {
columns[i] = table.GetColumn(name)
}
return columns
} | |
c17461 |
table.columnsMap[colName] = []*Column{col}
}
if col.IsPrimaryKey {
table.PrimaryKeys = append(table.PrimaryKeys, col.Name)
}
if col.IsAutoIncrement {
table.AutoIncrement = col.Name
}
if col.IsCreated {
table.Created[col.Name] = true
}
if col.IsUpdated {
table.Updated = col.Name
}
if col.IsDeleted ... | |
c17462 | *Index) {
table.Indexes[index.Name] = index
} | |
c17463 | NewCacheMapper(&SnakeMapper{}),
reflectCache: make(map[reflect.Type]*cacheStruct),
}, nil
} | |
c17464 | reflectCache: make(map[reflect.Type]*cacheStruct),
}
} | |
c17465 | := db.DB.QueryContext(ctx, query, args...)
if err != nil {
if rows != nil {
rows.Close()
}
return nil, err
}
return &Rows{rows, db}, nil
} | |
c17466 | return db.QueryContext(context.Background(), query, args...)
} | |
c17467 |
return err
}
newDest := make([]interface{}, len(cols))
var i = 0
for _, vvv := range vvvs {
for j := 0; j < vvv.NumField(); j++ {
newDest[i] = vvv.Field(j).Addr().Interface()
i = i + 1
}
}
return rs.Rows.Scan(newDest...)
} | |
c17468 | newDest[j] = vvv.Index(j).Addr().Interface()
}
}
err = rs.Rows.Scan(newDest...)
if err != nil {
return err
}
srcLen := vvv.Len()
for i := srcLen; i < len(cols); i++ {
vvv = reflect.Append(vvv, reflect.ValueOf(newDest[i]).Elem())
}
return nil
} | |
c17469 | panic("core: Register dialect is nil")
}
dialects[strings.ToLower(string(dbName))] = dialectFunc // !nashtsai! allow override dialect
} | |
c17470 | dialects[strings.ToLower(string(dbName))]; ok {
return d()
}
return nil
} | |
c17471 | visitor{Visitor: v}.visit(nil, n)
} | |
c17472 | return MapsAreEqual(left.tcoll.(MapItemList), right.tcoll.(MapItemList))
case TSet:
return SetsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
case TList:
return ListsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
default:
return false
}
} | |
c17473 | range leftFields {
if rvalue, ok := rightFields[i]; !ok {
return false
} else if !ValuesAreEqual(lvalue, rvalue) {
return false
}
}
return true
} | |
c17474 | right.Size() {
return false
}
if isHashable(left.ValueType()) {
return setsArEqualHashable(left.Size(), left, right)
}
return setsAreEqualUnhashable(left.Size(), left, right)
} | |
c17475 | }
if isHashable(left.KeyType()) {
return mapsAreEqualHashable(left.Size(), left, right)
}
return mapsAreEqualUnhashable(left.Size(), left, right)
} | |
c17476 | lv := range leftItems {
rv := rightItems[i]
if !ValuesAreEqual(lv, rv) {
return false
}
}
return true
} | |
c17477 | err != nil {
return nil, compileError{
Target: src.Name,
Line: src.Line,
Reason: err,
}
}
return &TypedefSpec{
Name: src.Name,
File: file,
Target: typ,
Annotations: annotations,
Doc: src.Doc,
}, nil
} | |
c17478 |
}
var err error
t.Target, err = t.Target.Link(scope)
if err == nil {
t.root = RootTypeSpec(t.Target)
}
return t, err
} | |
c17479 | error {
return f(t.Target)
} | |
c17480 | {
return lex.program, nil
}
return nil, lex.err
} | |
c17481 | nil {
return err
}
if err := bw.writeInt32(e.SeqID); err != nil {
return err
}
return bw.WriteValue(e.Value)
} | |
c17482 |
case *compile.StructSpec:
return structure(g, s)
case *compile.TypedefSpec:
return typedef(g, s)
default:
panic(fmt.Sprintf("%q is not a defined type", spec.ThriftName()))
}
} | |
c17483 | {
return true
}
switch spec.(type) {
case *compile.MapSpec, *compile.ListSpec, *compile.SetSpec:
return true
default:
return false
}
} | |
c17484 | field is not required and the type
// isn't a reference type.
name = "*" + name
}
return name, nil
} | |
c17485 | * prefix for everything but map, string, and list.
return "*" + ref, nil
}
return ref, nil
} | |
c17486 | if err != nil {
return "", err
}
return "[]" + v, nil
case *compile.SetSpec:
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
// not annotated to be slice and hashable value type
if setUsesMap(s) {
return fmt.Sprintf("map[%s]struct{}", v), nil
}
return fmt.Sprintf("[... | |
c17487 |
includedScope, err := getIncludedScope(scope, mname)
if err != nil {
return nil, referenceError{
Target: src.Name,
Line: src.Line,
ScopeName: scope.GetName(),
Reason: err,
}
}
return resolveService(ast.ServiceReference{Name: iname}, includedScope)
} | |
c17488 | s.parentSrc.Line,
ScopeName: scope.GetName(),
Reason: err,
},
}
}
if err := parent.Link(scope); err != nil {
return compileError{Target: s.Name, Reason: err}
}
s.Parent = parent
s.parentSrc = nil
}
for _, function := range s.Functions {
if err := function.Link(scope); err != ni... | |
c17489 | f.ResultSpec.Link(scope); err != nil {
return compileError{Target: f.Name, Reason: err}
}
}
return nil
} | |
c17490 | {
if f.OneWay {
return wire.OneWay
}
return wire.Call
} | |
c17491 | FieldGroup(as).Link(scope)
} | |
c17492 | }
// verify that everything listed under throws is an exception.
for _, exception := range rs.Exceptions {
spec, ok := exception.Type.(*StructSpec)
if !ok || spec.Type != ast.ExceptionType {
return notAnExceptionError{
FieldName: exception.ThriftName(),
TypeName: spec.ThriftName(),
}
}
}
ret... | |
c17493 |
return other.Compare(&r.Begin) >= 0 && other.Compare(&r.End) < 0
} | |
c17494 | fieldValue = "*" + fieldValue
}
return z.zapMarshaler(g, spec, fieldValue)
} | |
c17495 | error {
if err := c.link(m); err != nil {
return compileError{
Target: m.ThriftPath,
Reason: err,
}
}
return nil
})
return m, err
} | |
c17496 | Types: make(map[string]TypeSpec),
Services: make(map[string]*ServiceSpec),
}
m.Raw = s
c.Modules[p] = m
// the module is added to the map before processing includes to break
// cyclic includes.
if err := c.gather(m, prog); err != nil {
return nil, fileCompileError{Path: p, Reason: err}
}
return m... | |
c17497 |
incM, err := c.load(ipath)
if err != nil {
return nil, includeError{Include: include, Reason: err}
}
return &IncludedModule{Name: fileBaseName(include.Path), Module: incM}, nil
} | |
c17498 | <zapEncodeBegin .Type.ValueSpec ->
<$enc>.Append<zapEncoder .Type.ValueSpec>(<zapMarshaler .Type.ValueSpec $v>)
<- zapEncodeEnd .Type.ValueSpec>
}
return err
}
`, struct {
Name string
Type *compile.ListSpec
}{
Name: name,
Type: spec,
},
); err != nil {
return "", err
}
ret... | |
c17499 | := ServiceGenerator_Generate_Helper.WrapResponse(
h.impl.Generate(args.Request),
)
if err != nil {
return wire.Value{}, err
}
return result.ToWire()
default:
return wire.Value{}, envelope.ErrUnknownMethod(name)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.