_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14600 | notILike | train | func notILike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, true)
} | go | {
"resource": ""
} |
q14601 | checkLikeExp | train | func checkLikeExp(op BooleanOperation, lhs Expression, val interface{}, invert bool) BooleanExpression {
rhs := val
switch val.(type) {
case *regexp.Regexp:
if op == LIKE_OP {
op = REGEXP_LIKE_OP
} else if op == I_LIKE_OP {
op = REGEXP_I_LIKE_OP
}
rhs = val.(*regexp.Regexp).String()
}
if invert {
o... | go | {
"resource": ""
} |
q14602 | between | train | func between(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: BETWEEN_OP, lhs: lhs, rhs: rhs}
} | go | {
"resource": ""
} |
q14603 | notBetween | train | func notBetween(lhs Expression, rhs RangeVal) RangeExpression {
return ranged{op: NBETWEEN_OP, lhs: lhs, rhs: rhs}
} | go | {
"resource": ""
} |
q14604 | aliased | train | func aliased(exp Expression, alias interface{}) AliasedExpression {
switch v := alias.(type) {
case string:
return aliasExpression{aliased: exp, alias: I(v)}
case IdentifierExpression:
return aliasExpression{aliased: exp, alias: v}
default:
panic(fmt.Sprintf("Cannot create alias from %+v", v))
}
} | go | {
"resource": ""
} |
q14605 | asc | train | func asc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_ASC, nullSortType: NO_NULLS}
} | go | {
"resource": ""
} |
q14606 | desc | train | func desc(exp Expression) OrderedExpression {
return orderedExpression{sortExpression: exp, direction: SORT_DESC, nullSortType: NO_NULLS}
} | go | {
"resource": ""
} |
q14607 | Func | train | func Func(name string, args ...interface{}) SqlFunctionExpression {
return sqlFunctionExpression{name: name, args: args}
} | go | {
"resource": ""
} |
q14608 | colFunc | train | func colFunc(name string, col interface{}) SqlFunctionExpression {
if s, ok := col.(string); ok {
col = I(s)
}
return Func(name, col)
} | go | {
"resource": ""
} |
q14609 | With | train | func With(recursive bool, name string, subQuery SqlExpression) CommonTableExpression {
return commonExpr{recursive: recursive, name: Literal(name), subQuery: subQuery}
} | go | {
"resource": ""
} |
q14610 | Join | train | func (me *Dataset) Join(table Expression, condition joinExpression) *Dataset {
return me.InnerJoin(table, condition)
} | go | {
"resource": ""
} |
q14611 | InnerJoin | train | func (me *Dataset) InnerJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(INNER_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14612 | FullOuterJoin | train | func (me *Dataset) FullOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_OUTER_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14613 | RightOuterJoin | train | func (me *Dataset) RightOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_OUTER_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14614 | LeftOuterJoin | train | func (me *Dataset) LeftOuterJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_OUTER_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14615 | FullJoin | train | func (me *Dataset) FullJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(FULL_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14616 | RightJoin | train | func (me *Dataset) RightJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(RIGHT_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14617 | LeftJoin | train | func (me *Dataset) LeftJoin(table Expression, condition joinExpression) *Dataset {
return me.joinTable(LEFT_JOIN, table, condition)
} | go | {
"resource": ""
} |
q14618 | NaturalJoin | train | func (me *Dataset) NaturalJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_JOIN, table, nil)
} | go | {
"resource": ""
} |
q14619 | NaturalLeftJoin | train | func (me *Dataset) NaturalLeftJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_LEFT_JOIN, table, nil)
} | go | {
"resource": ""
} |
q14620 | NaturalRightJoin | train | func (me *Dataset) NaturalRightJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_RIGHT_JOIN, table, nil)
} | go | {
"resource": ""
} |
q14621 | NaturalFullJoin | train | func (me *Dataset) NaturalFullJoin(table Expression) *Dataset {
return me.joinTable(NATURAL_FULL_JOIN, table, nil)
} | go | {
"resource": ""
} |
q14622 | CrossJoin | train | func (me *Dataset) CrossJoin(table Expression) *Dataset {
return me.joinTable(CROSS_JOIN, table, nil)
} | go | {
"resource": ""
} |
q14623 | joinTable | train | func (me *Dataset) joinTable(joinType JoinType, table Expression, condition joinExpression) *Dataset {
ret := me.copy()
isConditioned := conditioned_join_types[joinType]
ret.clauses.Joins = append(ret.clauses.Joins, JoiningClause{JoinType: joinType, IsConditioned: isConditioned, Table: table, Condition: condition})
... | go | {
"resource": ""
} |
q14624 | Where | train | func (me *Dataset) Where(expressions ...Expression) *Dataset {
expLen := len(expressions)
if expLen > 0 {
ret := me.copy()
if ret.clauses.Where == nil {
ret.clauses.Where = And(expressions...)
} else {
ret.clauses.Where = ret.clauses.Where.Append(expressions...)
}
return ret
}
return me
} | go | {
"resource": ""
} |
q14625 | ClearWhere | train | func (me *Dataset) ClearWhere() *Dataset {
ret := me.copy()
ret.clauses.Where = nil
return ret
} | go | {
"resource": ""
} |
q14626 | GroupBy | train | func (me *Dataset) GroupBy(groupBy ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.GroupBy = cols(groupBy...)
return ret
} | go | {
"resource": ""
} |
q14627 | Order | train | func (me *Dataset) Order(order ...OrderedExpression) *Dataset {
ret := me.copy()
ret.clauses.Order = orderList(order...)
return ret
} | go | {
"resource": ""
} |
q14628 | OrderAppend | train | func (me *Dataset) OrderAppend(order ...OrderedExpression) *Dataset {
if me.clauses.Order == nil {
return me.Order(order...)
} else {
ret := me.copy()
ret.clauses.Order = ret.clauses.Order.Append(orderList(order...).Columns()...)
return ret
}
return me
} | go | {
"resource": ""
} |
q14629 | ClearOrder | train | func (me *Dataset) ClearOrder() *Dataset {
ret := me.copy()
ret.clauses.Order = nil
return ret
} | go | {
"resource": ""
} |
q14630 | Limit | train | func (me *Dataset) Limit(limit uint) *Dataset {
ret := me.copy()
if limit > 0 {
ret.clauses.Limit = limit
} else {
ret.clauses.Limit = nil
}
return ret
} | go | {
"resource": ""
} |
q14631 | LimitAll | train | func (me *Dataset) LimitAll() *Dataset {
ret := me.copy()
ret.clauses.Limit = Literal("ALL")
return ret
} | go | {
"resource": ""
} |
q14632 | Offset | train | func (me *Dataset) Offset(offset uint) *Dataset {
ret := me.copy()
ret.clauses.Offset = offset
return ret
} | go | {
"resource": ""
} |
q14633 | Intersect | train | func (me *Dataset) Intersect(other *Dataset) *Dataset {
ret := me.compoundFromSelf()
ret.clauses.Compounds = append(ret.clauses.Compounds, Intersect(other.compoundFromSelf()))
return ret
} | go | {
"resource": ""
} |
q14634 | compoundFromSelf | train | func (me *Dataset) compoundFromSelf() *Dataset {
if me.clauses.Order != nil || me.clauses.Limit != nil {
return me.FromSelf()
}
return me.copy()
} | go | {
"resource": ""
} |
q14635 | Returning | train | func (me *Dataset) Returning(returning ...interface{}) *Dataset {
ret := me.copy()
ret.clauses.Returning = cols(returning...)
return ret
} | go | {
"resource": ""
} |
q14636 | As | train | func (me *Dataset) As(alias string) *Dataset {
ret := me.copy()
ret.clauses.Alias = I(alias)
return ret
} | go | {
"resource": ""
} |
q14637 | selectSqlWriteTo | train | func (me *Dataset) selectSqlWriteTo(buf *SqlBuilder) error {
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return err
}
if me.clauses.SelectDistinct != nil {
if err := me.adapter.SelectDistinctSql(buf, me.clauses.SelectDistinct); err != nil {
return err
}
} else {
if er... | go | {
"resource": ""
} |
q14638 | ProductName | train | func ProductName() string {
productName := lookup(lang, "adjectives", true) + " " + lookup(lang, "nouns", true)
if r.Intn(2) == 1 {
productName = lookup(lang, "adjectives", true) + " " + productName
}
return productName
} | go | {
"resource": ""
} |
q14639 | Model | train | func Model() string {
seps := []string{"", " ", "-"}
return CharactersN(r.Intn(3)+1) + seps[r.Intn(len(seps))] + Digits()
} | go | {
"resource": ""
} |
q14640 | UserName | train | func UserName() string {
gender := randGender()
switch r.Intn(3) {
case 0:
return lookup("en", gender+"_first_names", false) + lookup(lang, gender+"_last_names", false)
case 1:
return Character() + lookup(lang, gender+"_last_names", false)
default:
return strings.Replace(WordsN(r.Intn(3)+1), " ", "_", -1)
}... | go | {
"resource": ""
} |
q14641 | IPv4 | train | func IPv4() string {
size := 4
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To4().String()
} | go | {
"resource": ""
} |
q14642 | IPv6 | train | func IPv6() string {
size := 16
ip := make([]byte, size)
for i := 0; i < size; i++ {
ip[i] = byte(r.Intn(256))
}
return net.IP(ip).To16().String()
} | go | {
"resource": ""
} |
q14643 | DigitsN | train | func DigitsN(n int) string {
digits := make([]rune, n)
for i := 0; i < n; i++ {
digits[i] = numeric[r.Intn(len(numeric))]
}
return string(digits)
} | go | {
"resource": ""
} |
q14644 | CreditCardNum | train | func CreditCardNum(vendor string) string {
if vendor != "" {
vendor = strings.ToLower(vendor)
} else {
var vendors []string
for v := range creditCards {
vendors = append(vendors, v)
}
vendor = vendors[r.Intn(len(vendors))]
}
card := creditCards[vendor]
prefix := strconv.Itoa(card.prefixes[r.Intn(len(c... | go | {
"resource": ""
} |
q14645 | City | train | func City() string {
city := lookup(lang, "cities", true)
switch r.Intn(5) {
case 0:
return join(cityPrefix(), city)
case 1:
return join(city, citySuffix())
default:
return city
}
} | go | {
"resource": ""
} |
q14646 | CharactersN | train | func CharactersN(n int) string {
var chars []string
for i := 0; i < n; i++ {
chars = append(chars, Character())
}
return strings.Join(chars, "")
} | go | {
"resource": ""
} |
q14647 | WordsN | train | func WordsN(n int) string {
words := make([]string, n)
for i := 0; i < n; i++ {
words[i] = Word()
}
return strings.Join(words, " ")
} | go | {
"resource": ""
} |
q14648 | Sentence | train | func Sentence() string {
var words []string
for i := 0; i < 3+r.Intn(12); i++ {
word := Word()
if r.Intn(5) == 0 {
word += ","
}
words = append(words, Word())
}
sentence := strings.Join(words, " ")
if r.Intn(8) == 0 {
sentence += "!"
} else {
sentence += "."
}
return sentence
} | go | {
"resource": ""
} |
q14649 | SentencesN | train | func SentencesN(n int) string {
sentences := make([]string, n)
for i := 0; i < n; i++ {
sentences[i] = Sentence()
}
return strings.Join(sentences, " ")
} | go | {
"resource": ""
} |
q14650 | ParagraphsN | train | func ParagraphsN(n int) string {
var paragraphs []string
for i := 0; i < n; i++ {
paragraphs = append(paragraphs, Paragraph())
}
return strings.Join(paragraphs, "\t")
} | go | {
"resource": ""
} |
q14651 | Year | train | func Year(from, to int) int {
n := r.Intn(to-from) + 1
return from + n
} | go | {
"resource": ""
} |
q14652 | GetLangs | train | func GetLangs() []string {
var langs []string
for k, v := range data {
if v.isDir && k != "/" && k != "/data" {
langs = append(langs, strings.Replace(k, "/data/", "", 1))
}
}
return langs
} | go | {
"resource": ""
} |
q14653 | SetLang | train | func SetLang(newLang string) error {
found := false
for _, l := range availLangs {
if newLang == l {
found = true
break
}
}
if !found {
return ErrNoLanguageFn(newLang)
}
lang = newLang
return nil
} | go | {
"resource": ""
} |
q14654 | JobTitle | train | func JobTitle() string {
job := lookup(lang, "jobs", true)
return strings.Replace(job, "#{N}", jobTitleSuffix(), 1)
} | go | {
"resource": ""
} |
q14655 | ProcessLogxiFormatEnv | train | func ProcessLogxiFormatEnv(env string) {
logxiFormat = env
m := parseKVList(logxiFormat, ",")
formatterFormat := ""
tFormat := ""
for key, value := range m {
switch key {
default:
formatterFormat = key
case "t":
tFormat = value
case "pretty":
isPretty = value != "false" && value != "0"
case "max... | go | {
"resource": ""
} |
q14656 | ProcessLogxiEnv | train | func ProcessLogxiEnv(env string) {
logxiEnable := env
if logxiEnable == "" {
logxiEnable = defaultLogxiEnv
}
logxiNameLevelMap = map[string]int{}
m := parseKVList(logxiEnable, ",")
if m == nil {
logxiNameLevelMap["*"] = defaultLevel
}
for key, value := range m {
if strings.HasPrefix(key, "-") {
// LOG... | go | {
"resource": ""
} |
q14657 | ProcessLogxiColorsEnv | train | func ProcessLogxiColorsEnv(env string) {
colors := env
if colors == "" {
colors = defaultLogxiColorsEnv
} else if colors == "*=off" {
// disable all colors
disableColors = true
}
theme = parseTheme(colors)
} | go | {
"resource": ""
} |
q14658 | Format | train | func (jf *JSONFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
const lead = `", "`
const colon = `":"`
buf.WriteString(`{"`)
buf.WriteString(KeyMap.Time)
buf.WriteString(`":"`)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteStrin... | go | {
"resource": ""
} |
q14659 | RegisterFormatFactory | train | func RegisterFormatFactory(kind string, fn CreateFormatterFunc) {
if kind == "" {
panic("kind is empty string")
}
if fn == nil {
panic("creator is nil")
}
formatterCreators[kind] = fn
} | go | {
"resource": ""
} |
q14660 | NewHappyDevFormatter | train | func NewHappyDevFormatter(name string) *HappyDevFormatter {
jf := NewJSONFormatter(name)
return &HappyDevFormatter{
name: name,
jsonFormatter: jf,
}
} | go | {
"resource": ""
} |
q14661 | writeString | train | func (hd *HappyDevFormatter) writeString(buf bufferWriter, s string) {
buf.WriteString(s)
hd.col += len(s)
} | go | {
"resource": ""
} |
q14662 | NewLogger | train | func NewLogger(writer io.Writer, name string) Logger {
formatter, err := createFormatter(name, logxiFormat)
if err != nil {
panic("Could not create formatter")
}
return NewLogger3(writer, name, formatter)
} | go | {
"resource": ""
} |
q14663 | NewLogger3 | train | func NewLogger3(writer io.Writer, name string, formatter Formatter) Logger {
var level int
if name != "__logxi" {
// if err is returned, then it means the log is disabled
level = getLogLevel(name)
if level == LevelOff {
return NullLog
}
}
log := &DefaultLogger{
formatter: formatter,
writer: write... | go | {
"resource": ""
} |
q14664 | Trace | train | func (l *DefaultLogger) Trace(msg string, args ...interface{}) {
l.Log(LevelTrace, msg, args)
} | go | {
"resource": ""
} |
q14665 | Debug | train | func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
l.Log(LevelDebug, msg, args)
} | go | {
"resource": ""
} |
q14666 | Info | train | func (l *DefaultLogger) Info(msg string, args ...interface{}) {
l.Log(LevelInfo, msg, args)
} | go | {
"resource": ""
} |
q14667 | Warn | train | func (l *DefaultLogger) Warn(msg string, args ...interface{}) error {
if l.IsWarn() {
defer l.Log(LevelWarn, msg, args)
for _, arg := range args {
if err, ok := arg.(error); ok {
return err
}
}
return nil
}
return nil
} | go | {
"resource": ""
} |
q14668 | Error | train | func (l *DefaultLogger) Error(msg string, args ...interface{}) error {
return l.extractLogError(LevelError, msg, args)
} | go | {
"resource": ""
} |
q14669 | Fatal | train | func (l *DefaultLogger) Fatal(msg string, args ...interface{}) {
l.extractLogError(LevelFatal, msg, args)
defer panic("Exit due to fatal error: ")
} | go | {
"resource": ""
} |
q14670 | Log | train | func (l *DefaultLogger) Log(level int, msg string, args []interface{}) {
// log if the log level (warn=4) >= level of message (err=3)
if l.level < level || silent {
return
}
l.formatter.Format(l.writer, level, msg, args)
} | go | {
"resource": ""
} |
q14671 | NewTextFormatter | train | func NewTextFormatter(name string) *TextFormatter {
timeLabel := KeyMap.Time + AssignmentChar
levelLabel := Separator + KeyMap.Level + AssignmentChar
messageLabel := Separator + KeyMap.Message + AssignmentChar
nameLabel := Separator + KeyMap.Name + AssignmentChar
pidLabel := Separator + KeyMap.PID + AssignmentChar... | go | {
"resource": ""
} |
q14672 | Format | train | func (tf *TextFormatter) Format(writer io.Writer, level int, msg string, args []interface{}) {
buf := pool.Get()
defer pool.Put(buf)
buf.WriteString(tf.timeLabel)
buf.WriteString(time.Now().Format(timeFormat))
buf.WriteString(tf.itoaLevelMap[level])
buf.WriteString(msg)
var lenArgs = len(args)
if lenArgs > 0 {
... | go | {
"resource": ""
} |
q14673 | ReadAtoms | train | func ReadAtoms(r io.ReadSeeker) (Metadata, error) {
m := metadataMP4{
data: make(map[string]interface{}),
fileType: UnknownFileType,
}
err := m.readAtoms(r)
return m, err
} | go | {
"resource": ""
} |
q14674 | SumAtoms | train | func SumAtoms(r io.ReadSeeker) (string, error) {
for {
var size uint32
err := binary.Read(r, binary.BigEndian, &size)
if err != nil {
if err == io.EOF {
return "", fmt.Errorf("reached EOF before audio data")
}
return "", err
}
name, err := readString(r, 4)
if err != nil {
return "", err
... | go | {
"resource": ""
} |
q14675 | String | train | func (t Comm) String() string {
if t.Language != "" {
return fmt.Sprintf("Text{Lang: '%v', Description: '%v', %v lines}",
t.Language, t.Description, strings.Count(t.Text, "\n"))
}
return fmt.Sprintf("Text{Description: '%v', %v}", t.Description, t.Text)
} | go | {
"resource": ""
} |
q14676 | String | train | func (p Picture) String() string {
return fmt.Sprintf("Picture{Ext: %v, MIMEType: %v, Type: %v, Description: %v, Data.Size: %v}",
p.Ext, p.MIMEType, p.Type, p.Description, len(p.Data))
} | go | {
"resource": ""
} |
q14677 | ReadID3v1Tags | train | func ReadID3v1Tags(r io.ReadSeeker) (Metadata, error) {
_, err := r.Seek(-128, io.SeekEnd)
if err != nil {
return nil, err
}
if tag, err := readString(r, 3); err != nil {
return nil, err
} else if tag != "TAG" {
return nil, ErrNotID3v1
}
title, err := readString(r, 30)
if err != nil {
return nil, err
... | go | {
"resource": ""
} |
q14678 | Identify | train | func Identify(r io.ReadSeeker) (format Format, fileType FileType, err error) {
b, err := readBytes(r, 11)
if err != nil {
return
}
_, err = r.Seek(-11, io.SeekCurrent)
if err != nil {
err = fmt.Errorf("could not seek back to original position: %v", err)
return
}
switch {
case string(b[0:4]) == "fLaC":
... | go | {
"resource": ""
} |
q14679 | readID3v2Header | train | func readID3v2Header(r io.Reader) (h *id3v2Header, offset int, err error) {
offset = 10
b, err := readBytes(r, offset)
if err != nil {
return nil, 0, fmt.Errorf("expected to read 10 bytes (ID3v2Header): %v", err)
}
if string(b[0:3]) != "ID3" {
return nil, 0, fmt.Errorf("expected to read \"ID3\"")
}
b = b[3... | go | {
"resource": ""
} |
q14680 | Read | train | func (r *unsynchroniser) Read(p []byte) (int, error) {
b := make([]byte, 1)
i := 0
for i < len(p) {
if n, err := r.Reader.Read(b); err != nil || n == 0 {
return i, err
}
if r.ff && b[0] == 0x00 {
r.ff = false
continue
}
p[i] = b[0]
i++
r.ff = (b[0] == 0xFF)
}
return i, nil
} | go | {
"resource": ""
} |
q14681 | id3v2genre | train | func id3v2genre(genre string) string {
c := true
for c {
orig := genre
if match := id3v2genreRe.FindStringSubmatch(genre); len(match) > 0 {
if genreID, err := strconv.Atoi(match[2]); err == nil {
if genreID < len(id3v2Genres) {
genre = id3v2Genres[genreID]
if match[1] != "" {
genre = string... | go | {
"resource": ""
} |
q14682 | ReadFLACTags | train | func ReadFLACTags(r io.ReadSeeker) (Metadata, error) {
flac, err := readString(r, 4)
if err != nil {
return nil, err
}
if flac != "fLaC" {
return nil, errors.New("expected 'fLaC'")
}
m := &metadataFLAC{
newMetadataVorbis(),
}
for {
last, err := m.readFLACMetadataBlock(r)
if err != nil {
return ni... | go | {
"resource": ""
} |
q14683 | set | train | func (i Info) set(t, v string) {
if _, ok := tags[t]; ok {
i[t] = v
return
}
for k, tt := range tags {
if tt == t {
i[k] = v
return
}
}
} | go | {
"resource": ""
} |
q14684 | NewPlugin | train | func NewPlugin(name string, fn LogFunc) *Plugin {
return &Plugin{name: name, logFn: fn}
} | go | {
"resource": ""
} |
q14685 | String | train | func (l LogType) String() string {
var typeString string
switch l {
case LogTypeString:
typeString = "string"
case LogTypeSnapshot:
typeString = "snapshot"
case LogTypeHealth:
typeString = "health"
case LogTypeInit:
typeString = "init"
case LogTypeStatus:
typeString = "status"
default:
typeString = ... | go | {
"resource": ""
} |
q14686 | Open | train | func Open(path string, timeout time.Duration) (*thrift.TSocket, error) {
conn, err := winio.DialPipe(path, &timeout)
if err != nil {
return nil, errors.Wrapf(err, "dialing pipe '%s'", path)
}
return thrift.NewTSocketFromConnTimeout(conn, timeout), nil
} | go | {
"resource": ""
} |
q14687 | Accept | train | func (p *TServerPipe) Accept() (thrift.TTransport, error) {
p.mu.RLock()
interrupted := p.interrupted
listener := p.listener
p.mu.RUnlock()
if interrupted {
return nil, errors.New("transport interrupted")
}
conn, err := listener.Accept()
if err != nil {
return nil, thrift.NewTTransportExceptionFromError(e... | go | {
"resource": ""
} |
q14688 | NewExtensionManagerServer | train | func NewExtensionManagerServer(name string, sockPath string, opts ...ServerOption) (*ExtensionManagerServer, error) {
// Initialize nested registry maps
registry := make(map[string](map[string]OsqueryPlugin))
for reg, _ := range validRegistryNames {
registry[reg] = make(map[string]OsqueryPlugin)
}
manager := &E... | go | {
"resource": ""
} |
q14689 | RegisterPlugin | train | func (s *ExtensionManagerServer) RegisterPlugin(plugins ...OsqueryPlugin) {
s.mutex.Lock()
defer s.mutex.Unlock()
for _, plugin := range plugins {
if !validRegistryNames[plugin.RegistryName()] {
panic("invalid registry name: " + plugin.RegistryName())
}
s.registry[plugin.RegistryName()][plugin.Name()] = plu... | go | {
"resource": ""
} |
q14690 | Run | train | func (s *ExtensionManagerServer) Run() error {
errc := make(chan error)
go func() {
errc <- s.Start()
}()
// Watch for the osquery process going away. If so, initiate shutdown.
go func() {
for {
time.Sleep(s.pingInterval)
status, err := s.serverClient.Ping()
if err != nil {
errc <- errors.Wrap(e... | go | {
"resource": ""
} |
q14691 | Ping | train | func (s *ExtensionManagerServer) Ping(ctx context.Context) (*osquery.ExtensionStatus, error) {
return &osquery.ExtensionStatus{Code: 0, Message: "OK"}, nil
} | go | {
"resource": ""
} |
q14692 | Call | train | func (s *ExtensionManagerServer) Call(ctx context.Context, registry string, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
subreg, ok := s.registry[registry]
if !ok {
return &osquery.ExtensionResponse{
Status: &osquery.ExtensionStatus{
Code: 1,
Message: "Unk... | go | {
"resource": ""
} |
q14693 | Shutdown | train | func (s *ExtensionManagerServer) Shutdown(ctx context.Context) error {
s.mutex.Lock()
defer s.mutex.Unlock()
if s.server != nil {
server := s.server
s.server = nil
// Stop the server asynchronously so that the current request
// can complete. Otherwise, this is vulnerable to deadlock if a
// shutdown reque... | go | {
"resource": ""
} |
q14694 | waitStarted | train | func (s *ExtensionManagerServer) waitStarted() {
for {
s.mutex.Lock()
started := s.started
s.mutex.Unlock()
if started {
time.Sleep(10 * time.Millisecond)
break
}
}
} | go | {
"resource": ""
} |
q14695 | NewPlugin | train | func NewPlugin(name string, fn GenerateConfigsFunc) *Plugin {
return &Plugin{name: name, generate: fn}
} | go | {
"resource": ""
} |
q14696 | Open | train | func Open(sockPath string, timeout time.Duration) (*thrift.TSocket, error) {
addr, err := net.ResolveUnixAddr("unix", sockPath)
if err != nil {
return nil, errors.Wrapf(err, "resolving socket path '%s'", sockPath)
}
// the timeout parameter is passed to thrift, which passes it to net.DialTimeout
// but it looks... | go | {
"resource": ""
} |
q14697 | NewClient | train | func NewClient(path string, timeout time.Duration) (*ExtensionManagerClient, error) {
trans, err := transport.Open(path, timeout)
if err != nil {
return nil, err
}
client := osquery.NewExtensionManagerClientFactory(
trans,
thrift.NewTBinaryProtocolFactoryDefault(),
)
return &ExtensionManagerClient{client,... | go | {
"resource": ""
} |
q14698 | Close | train | func (c *ExtensionManagerClient) Close() {
if c.transport != nil && c.transport.IsOpen() {
c.transport.Close()
}
} | go | {
"resource": ""
} |
q14699 | Ping | train | func (c *ExtensionManagerClient) Ping() (*osquery.ExtensionStatus, error) {
return c.Client.Ping(context.Background())
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.