_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q30500 | startHttpPayload | train | func (fw *PaloAlto) startHttpPayload(ctx context.Context, info map[string]string, timeout int) string {
// PaloAlto XML API expects the timeout in minutes
timeout = timeout / 60
t := template.New("PaloAlto.startHttp")
t.Parse(`
<uid-message>
<version>1.0</version>
<type>update</type>
<payload>
<login>
... | go | {
"resource": ""
} |
q30501 | Stop | train | func (fw *PaloAlto) Stop(ctx context.Context, info map[string]string) (bool, error) {
if fw.Transport == "syslog" {
log.LoggerWContext(ctx).Warn("SSO Stop isn't supported on PaloAlto when using the syslog transport. You should use the HTTP transport if you require it.")
return false, nil
} else {
log.LoggerWCon... | go | {
"resource": ""
} |
q30502 | stopHttp | train | func (fw *PaloAlto) stopHttp(ctx context.Context, info map[string]string) (bool, error) {
resp, err := fw.getHttpClient(ctx).PostForm("https://"+fw.PfconfigHashNS+":"+fw.Port+"/api/?type=user-id&vsys=vsys"+fw.Vsys+"&action=set&key="+fw.Password,
url.Values{"cmd": {fw.stopHttpPayload(ctx, info)}})
if err != nil {
... | go | {
"resource": ""
} |
q30503 | BearerRequestIsAuthorized | train | func (tam *TokenAuthorizationMiddleware) BearerRequestIsAuthorized(ctx context.Context, r *http.Request) (bool, error) {
token := tam.TokenFromBearerRequest(ctx, r)
xptid := r.Header.Get("X-PacketFence-Tenant-Id")
tokenInfo, _ := tam.tokenBackend.TokenInfoForToken(token)
if tokenInfo == nil {
return false, erro... | go | {
"resource": ""
} |
q30504 | IsAuthorized | train | func (tam *TokenAuthorizationMiddleware) IsAuthorized(ctx context.Context, method, path string, tenantId int, tokenInfo *TokenInfo) (bool, error) {
if tokenInfo == nil {
return false, errors.New("Invalid token info")
}
authAdminRoles, err := tam.isAuthorizedAdminActions(ctx, method, path, tokenInfo.AdminActions()... | go | {
"resource": ""
} |
q30505 | ServeHTTP | train | func (h Headers) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
replacer := httpserver.NewReplacer(r, nil, "")
rww := &responseWriterWrapper{w: w}
for _, rule := range h.Rules {
if httpserver.Path(r.URL.Path).Matches(rule.Path) {
for name := range rule.Headers {
// One can either delete a... | go | {
"resource": ""
} |
q30506 | targetStrip | train | func targetStrip(name string, targetStrip int) string {
if targetStrip == 0 {
return name
}
offset, end := 0, false
for i := 0; i < targetStrip; i++ {
offset, end = dns.NextLabel(name, offset)
}
if end {
// We overshot the name, use the orignal one.
offset = 0
}
name = name[offset:]
return name
} | go | {
"resource": ""
} |
q30507 | Start | train | func (mfw *MockFW) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
log.LoggerWContext(ctx).Info("Sending SSO through mocked Firewall SSO")
return true, nil
} | go | {
"resource": ""
} |
q30508 | Stop | train | func (mfw *MockFW) Stop(ctx context.Context, info map[string]string) (bool, error) {
log.LoggerWContext(ctx).Info("Sending SSO through mocked Firewall SSO")
return true, nil
} | go | {
"resource": ""
} |
q30509 | NewLogger | train | func (l LoggerStruct) NewLogger() LoggerStruct {
new := LoggerStruct{}
new.logger = l.logger.New()
new.handler = l.handler
new.inDebug = l.inDebug
new.processPid = l.processPid
return new
} | go | {
"resource": ""
} |
q30510 | LoggerAddHandler | train | func LoggerAddHandler(ctx context.Context, f func(*log.Record) error) context.Context {
logger := loggerFromContext(ctx)
loggerHandler := log.MultiHandler(logger.handler, log.FuncHandler(f))
logger.SetHandler(loggerHandler)
return context.WithValue(ctx, LoggerKey, logger)
} | go | {
"resource": ""
} |
q30511 | initContextLogger | train | func initContextLogger(ctx context.Context) context.Context {
logger := newLoggerStruct()
output := sharedutils.EnvOrDefault("LOG_OUTPUT", "syslog")
if output == "syslog" {
syslogBackend, err := log.SyslogHandler(syslog.LOG_INFO, ProcessName, log.LogfmtFormat())
sharedutils.CheckError(err)
logger.SetHandler(s... | go | {
"resource": ""
} |
q30512 | loggerFromContext | train | func loggerFromContext(ctx context.Context) LoggerStruct {
loggerInt := ctx.Value(LoggerKey)
var logger LoggerStruct
logger = loggerInt.(LoggerStruct)
return logger
} | go | {
"resource": ""
} |
q30513 | LoggerNewContext | train | func LoggerNewContext(ctx context.Context) context.Context {
ctx = initContextLogger(ctx)
ctx = context.WithValue(ctx, AdditionnalLogElementsKey, ordered_map.NewOrderedMap())
return ctx
} | go | {
"resource": ""
} |
q30514 | TranferLogContext | train | func TranferLogContext(sourceCtx context.Context, destCtx context.Context) context.Context {
destCtx = context.WithValue(destCtx, LoggerKey, sourceCtx.Value(LoggerKey))
destCtx = context.WithValue(destCtx, AdditionnalLogElementsKey, sharedutils.CopyOrderedMap(sourceCtx.Value(AdditionnalLogElementsKey).(*ordered_map.O... | go | {
"resource": ""
} |
q30515 | LoggerNewRequest | train | func LoggerNewRequest(ctx context.Context) context.Context {
u, _ := uuid.NewUUID()
uStr := u.String()
ctx = context.WithValue(ctx, RequestUuidKey, uStr)
return ctx
} | go | {
"resource": ""
} |
q30516 | Die | train | func Die(msg string, args ...interface{}) {
Logger().Crit(msg, args...)
panic(msg)
} | go | {
"resource": ""
} |
q30517 | NewTCP | train | func NewTCP(address string) *TCP {
s := &TCP{address: address}
s.frames = make([][]byte, 0, 13) // 13 messages buffer
return s
} | go | {
"resource": ""
} |
q30518 | Flush | train | func (s *TCP) Flush() error {
defer func() {
s.frames = s.frames[:0]
}()
c, err := net.DialTimeout("tcp", s.address, time.Second)
if err != nil {
return err
}
enc, err := fs.NewEncoder(c, &fs.EncoderOptions{
ContentType: []byte("protobuf:dnstap.Dnstap"),
Bidirectional: true,
})
if err != nil {
retur... | go | {
"resource": ""
} |
q30519 | get | train | func (e *Etcd) get(path string, recursive bool) (*etcdc.Response, error) {
hash := cache.Hash([]byte(path))
resp, err := e.Inflight.Do(hash, func() (interface{}, error) {
ctx, cancel := context.WithTimeout(e.Ctx, etcdTimeout)
defer cancel()
r, e := e.Client.Get(ctx, path, &etcdc.GetOptions{Sort: false, Recurs... | go | {
"resource": ""
} |
q30520 | getRequestBody | train | func (fw *JSONRPC) getRequestBody(action string, info map[string]string, timeout int) ([]byte, error) {
args := &JSONRPC_Args{
User: info["username"],
MAC: info["mac"],
IP: info["ip"],
Role: info["role"],
Timeout: timeout,
}
body, err := json2.EncodeClientRequest(action, args)
return body, ... | go | {
"resource": ""
} |
q30521 | makeRpcRequest | train | func (fw *JSONRPC) makeRpcRequest(ctx context.Context, action string, info map[string]string, timeout int) error {
body, err := fw.getRequestBody(action, info, timeout)
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Cannot encode JSON-RPC call: %s", err))
return err
}
req, err := http.NewRequest("P... | go | {
"resource": ""
} |
q30522 | Start | train | func (fw *JSONRPC) Start(ctx context.Context, info map[string]string, timeout int) (bool, error) {
err := fw.makeRpcRequest(ctx, "Start", info, timeout)
return err == nil, err
} | go | {
"resource": ""
} |
q30523 | Stop | train | func (fw *JSONRPC) Stop(ctx context.Context, info map[string]string) (bool, error) {
err := fw.makeRpcRequest(ctx, "Stop", info, 0)
return err == nil, err
} | go | {
"resource": ""
} |
q30524 | NewProxy | train | func NewProxy(ctx context.Context) *Proxy {
var p Proxy
passThrough = newProxyPassthrough(ctx)
passThrough.readConfig(ctx)
return &p
} | go | {
"resource": ""
} |
q30525 | checkEndpointList | train | func (p *Proxy) checkEndpointList(ctx context.Context, e string) bool {
if p.endpointBlackList == nil && p.endpointWhiteList == nil {
return true
}
for _, rgx := range p.endpointBlackList {
if rgx.MatchString(e) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q30526 | Configure | train | func (p *Proxy) Configure(ctx context.Context, port string) {
p.addToEndpointList(ctx, "localhost")
p.addToEndpointList(ctx, "127.0.0.1")
} | go | {
"resource": ""
} |
q30527 | addFqdnToList | train | func (p *passthrough) addFqdnToList(ctx context.Context, r string) error {
rgx, err := regexp.Compile(r)
if err == nil {
p.mutex.Lock()
p.proxypassthrough = append(p.proxypassthrough, rgx)
p.mutex.Unlock()
}
return err
} | go | {
"resource": ""
} |
q30528 | checkProxyPassthrough | train | func (p *passthrough) checkProxyPassthrough(ctx context.Context, e string) bool {
if p.proxypassthrough == nil {
return false
}
for _, rgx := range p.proxypassthrough {
if rgx.MatchString(e) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q30529 | Write | train | func (l *Logger) Write(p []byte) (n int, err error) {
l.mu.Lock()
defer l.mu.Unlock()
writeLen := int64(len(p))
if writeLen > l.max() {
return 0, fmt.Errorf(
"write length %d exceeds maximum file size %d", writeLen, l.max(),
)
}
if l.file == nil {
if err = l.openExistingOrNew(len(p)); err != nil {
r... | go | {
"resource": ""
} |
q30530 | Rotate | train | func (l *Logger) Rotate() error {
l.mu.Lock()
defer l.mu.Unlock()
return l.rotate()
} | go | {
"resource": ""
} |
q30531 | openExistingOrNew | train | func (l *Logger) openExistingOrNew(writeLen int) error {
l.mill()
filename := l.filename()
info, err := os_Stat(filename)
if os.IsNotExist(err) {
return l.openNew()
}
if err != nil {
return fmt.Errorf("error getting log file info: %s", err)
}
if info.Size()+int64(writeLen) >= l.max() {
return l.rotate()... | go | {
"resource": ""
} |
q30532 | filename | train | func (l *Logger) filename() string {
if l.Filename != "" {
return l.Filename
}
name := filepath.Base(os.Args[0]) + "-lumberjack.log"
return filepath.Join(os.TempDir(), name)
} | go | {
"resource": ""
} |
q30533 | millRunOnce | train | func (l *Logger) millRunOnce() error {
if l.MaxBackups == 0 && l.MaxAge == 0 && !l.Compress {
return nil
}
files, err := l.oldLogFiles()
if err != nil {
return err
}
var compress, remove []logInfo
if l.MaxBackups > 0 && l.MaxBackups < len(files) {
preserved := make(map[string]bool)
var remaining []log... | go | {
"resource": ""
} |
q30534 | mill | train | func (l *Logger) mill() {
l.startMill.Do(func() {
l.millCh = make(chan bool, 1)
go l.millRun()
})
select {
case l.millCh <- true:
default:
}
} | go | {
"resource": ""
} |
q30535 | oldLogFiles | train | func (l *Logger) oldLogFiles() ([]logInfo, error) {
files, err := ioutil.ReadDir(l.dir())
if err != nil {
return nil, fmt.Errorf("can't read log file directory: %s", err)
}
logFiles := []logInfo{}
prefix, ext := l.prefixAndExt()
for _, f := range files {
if f.IsDir() {
continue
}
if t, err := l.timeF... | go | {
"resource": ""
} |
q30536 | timeFromName | train | func (l *Logger) timeFromName(filename, prefix, ext string) (time.Time, error) {
if !strings.HasPrefix(filename, prefix) {
return time.Time{}, errors.New("mismatched prefix")
}
if !strings.HasSuffix(filename, ext) {
return time.Time{}, errors.New("mismatched extension")
}
ts := filename[len(prefix) : len(filen... | go | {
"resource": ""
} |
q30537 | max | train | func (l *Logger) max() int64 {
if l.MaxSize == 0 {
return int64(defaultMaxSize * megabyte)
}
return int64(l.MaxSize) * int64(megabyte)
} | go | {
"resource": ""
} |
q30538 | prefixAndExt | train | func (l *Logger) prefixAndExt() (prefix, ext string) {
filename := filepath.Base(l.filename())
ext = filepath.Ext(filename)
prefix = filename[:len(filename)-len(ext)] + "-"
return prefix, ext
} | go | {
"resource": ""
} |
q30539 | compressLogFile | train | func compressLogFile(src, dst string) (err error) {
f, err := os.Open(src)
if err != nil {
return fmt.Errorf("failed to open log file: %v", err)
}
defer f.Close()
fi, err := os_Stat(src)
if err != nil {
return fmt.Errorf("failed to stat log file: %v", err)
}
if err := chown(dst, fi); err != nil {
return... | go | {
"resource": ""
} |
q30540 | Get | train | func (c *BigCache) Get(key string) ([]byte, error) {
hashedKey := c.hash.Sum64(key)
shard := c.getShard(hashedKey)
return shard.get(key, hashedKey)
} | go | {
"resource": ""
} |
q30541 | Set | train | func (c *BigCache) Set(key string, entry []byte) error {
hashedKey := c.hash.Sum64(key)
shard := c.getShard(hashedKey)
return shard.set(key, hashedKey, entry)
} | go | {
"resource": ""
} |
q30542 | Delete | train | func (c *BigCache) Delete(key string) error {
hashedKey := c.hash.Sum64(key)
shard := c.getShard(hashedKey)
return shard.del(key, hashedKey)
} | go | {
"resource": ""
} |
q30543 | Reset | train | func (c *BigCache) Reset() error {
for _, shard := range c.shards {
shard.reset(c.config)
}
return nil
} | go | {
"resource": ""
} |
q30544 | Len | train | func (c *BigCache) Len() int {
var len int
for _, shard := range c.shards {
len += shard.len()
}
return len
} | go | {
"resource": ""
} |
q30545 | Capacity | train | func (c *BigCache) Capacity() int {
var len int
for _, shard := range c.shards {
len += shard.capacity()
}
return len
} | go | {
"resource": ""
} |
q30546 | Stats | train | func (c *BigCache) Stats() Stats {
var s Stats
for _, shard := range c.shards {
tmp := shard.getStats()
s.Hits += tmp.Hits
s.Misses += tmp.Misses
s.DelHits += tmp.DelHits
s.DelMisses += tmp.DelMisses
s.Collisions += tmp.Collisions
}
return s
} | go | {
"resource": ""
} |
q30547 | DefaultConfig | train | func DefaultConfig(eviction time.Duration) Config {
return Config{
Shards: 1024,
LifeWindow: eviction,
CleanWindow: 0,
MaxEntriesInWindow: 1000 * 10 * 60,
MaxEntrySize: 500,
Verbose: true,
Hasher: newDefaultHasher(),
HardMaxCacheSize: 0,
Logge... | go | {
"resource": ""
} |
q30548 | initialShardSize | train | func (c Config) initialShardSize() int {
return max(c.MaxEntriesInWindow/c.Shards, minimumEntriesInShard)
} | go | {
"resource": ""
} |
q30549 | maximumShardSize | train | func (c Config) maximumShardSize() int {
maxShardSize := 0
if c.HardMaxCacheSize > 0 {
maxShardSize = convertMBToBytes(c.HardMaxCacheSize) / c.Shards
}
return maxShardSize
} | go | {
"resource": ""
} |
q30550 | OnRemoveFilterSet | train | func (c Config) OnRemoveFilterSet(reasons ...RemoveReason) Config {
c.onRemoveFilter = 0
for i := range reasons {
c.onRemoveFilter |= 1 << uint(reasons[i])
}
return c
} | go | {
"resource": ""
} |
q30551 | statsIndexHandler | train | func statsIndexHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
getCacheStatsHandler(w, r)
default:
w.WriteHeader(http.StatusMethodNotAllowed)
}
})
} | go | {
"resource": ""
} |
q30552 | getCacheStatsHandler | train | func getCacheStatsHandler(w http.ResponseWriter, r *http.Request) {
target, err := json.Marshal(cache.Stats())
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
log.Printf("cannot marshal cache stats. error: %s", err)
return
}
// since we're sending a struct, make it easy for consumers to interfac... | go | {
"resource": ""
} |
q30553 | serviceLoader | train | func serviceLoader(h http.Handler, svcs ...service) http.Handler {
for _, svc := range svcs {
h = svc(h)
}
return h
} | go | {
"resource": ""
} |
q30554 | requestMetrics | train | func requestMetrics(l *log.Logger) service {
return func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
h.ServeHTTP(w, r)
l.Printf("%s request to %s took %vns.", r.Method, r.URL.Path, time.Now().Sub(start).Nanoseconds())
})
}
} | go | {
"resource": ""
} |
q30555 | SetNext | train | func (it *EntryInfoIterator) SetNext() bool {
it.mutex.Lock()
it.valid = false
it.currentIndex++
if it.elementsCount > it.currentIndex {
it.valid = true
it.mutex.Unlock()
return true
}
for i := it.currentShard + 1; i < it.cache.config.Shards; i++ {
it.elements, it.elementsCount = it.cache.shards[i].cop... | go | {
"resource": ""
} |
q30556 | Value | train | func (it *EntryInfoIterator) Value() (EntryInfo, error) {
it.mutex.Lock()
if !it.valid {
it.mutex.Unlock()
return emptyEntryInfo, ErrInvalidIteratorState
}
entry, err := it.cache.shards[it.currentShard].getEntry(int(it.elements[it.currentIndex]))
if err != nil {
it.mutex.Unlock()
return emptyEntryInfo, ... | go | {
"resource": ""
} |
q30557 | getCacheHandler | train | func getCacheHandler(w http.ResponseWriter, r *http.Request) {
target := r.URL.Path[len(cachePath):]
if target == "" {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("can't get a key if there is no key."))
log.Print("empty request.")
return
}
entry, err := cache.Get(target)
if err != nil {
errMsg :=... | go | {
"resource": ""
} |
q30558 | deleteCacheHandler | train | func deleteCacheHandler(w http.ResponseWriter, r *http.Request) {
target := r.URL.Path[len(cachePath):]
if err := cache.Delete(target); err != nil {
if strings.Contains((err).Error(), "not found") {
w.WriteHeader(http.StatusNotFound)
log.Printf("%s not found.", target)
return
}
w.WriteHeader(http.Statu... | go | {
"resource": ""
} |
q30559 | Sum64 | train | func (f fnv64a) Sum64(key string) uint64 {
var hash uint64 = offset64
for i := 0; i < len(key); i++ {
hash ^= uint64(key[i])
hash *= prime64
}
return hash
} | go | {
"resource": ""
} |
q30560 | NewBytesQueue | train | func NewBytesQueue(initialCapacity int, maxCapacity int, verbose bool) *BytesQueue {
return &BytesQueue{
array: make([]byte, initialCapacity),
capacity: initialCapacity,
maxCapacity: maxCapacity,
headerBuffer: make([]byte, headerEntrySize),
tail: leftMarginIndex,
head: ... | go | {
"resource": ""
} |
q30561 | Reset | train | func (q *BytesQueue) Reset() {
// Just reset indexes
q.tail = leftMarginIndex
q.head = leftMarginIndex
q.rightMargin = leftMarginIndex
q.count = 0
} | go | {
"resource": ""
} |
q30562 | Push | train | func (q *BytesQueue) Push(data []byte) (int, error) {
dataLen := len(data)
if q.availableSpaceAfterTail() < dataLen+headerEntrySize {
if q.availableSpaceBeforeHead() >= dataLen+headerEntrySize {
q.tail = leftMarginIndex
} else if q.capacity+headerEntrySize+dataLen >= q.maxCapacity && q.maxCapacity > 0 {
re... | go | {
"resource": ""
} |
q30563 | Pop | train | func (q *BytesQueue) Pop() ([]byte, error) {
data, size, err := q.peek(q.head)
if err != nil {
return nil, err
}
q.head += headerEntrySize + size
q.count--
if q.head == q.rightMargin {
q.head = leftMarginIndex
if q.tail == q.rightMargin {
q.tail = leftMarginIndex
}
q.rightMargin = q.tail
}
retur... | go | {
"resource": ""
} |
q30564 | Peek | train | func (q *BytesQueue) Peek() ([]byte, error) {
data, _, err := q.peek(q.head)
return data, err
} | go | {
"resource": ""
} |
q30565 | Get | train | func (q *BytesQueue) Get(index int) ([]byte, error) {
data, _, err := q.peek(index)
return data, err
} | go | {
"resource": ""
} |
q30566 | peekCheckErr | train | func (q *BytesQueue) peekCheckErr(index int) error {
if q.count == 0 {
return errEmptyQueue
}
if index <= 0 {
return errInvalidIndex
}
if index+headerEntrySize >= len(q.array) {
return errIndexOutOfBounds
}
return nil
} | go | {
"resource": ""
} |
q30567 | NewLogFile | train | func NewLogFile(name string, file *os.File) (*LogFile, error) {
rw := &LogFile{
file: file,
name: name,
}
if file == nil {
if err := rw.Rotate(); err != nil {
return nil, err
}
}
return rw, nil
} | go | {
"resource": ""
} |
q30568 | Rotate | train | func (l *LogFile) Rotate() error {
// rename dest file if it already exists.
if _, err := os.Stat(l.name); err == nil {
name := l.name + "." + time.Now().Format(time.RFC3339)
if err = os.Rename(l.name, name); err != nil {
return err
}
}
// create new file.
file, err := os.Create(l.name)
if err != nil {
... | go | {
"resource": ""
} |
q30569 | CreatePidFile | train | func CreatePidFile(name string, perm os.FileMode) (lock *LockFile, err error) {
if lock, err = OpenLockFile(name, perm); err != nil {
return
}
if err = lock.Lock(); err != nil {
lock.Remove()
return
}
if err = lock.WritePid(); err != nil {
lock.Remove()
}
return
} | go | {
"resource": ""
} |
q30570 | OpenLockFile | train | func OpenLockFile(name string, perm os.FileMode) (lock *LockFile, err error) {
var file *os.File
if file, err = os.OpenFile(name, os.O_RDWR|os.O_CREATE, perm); err == nil {
lock = &LockFile{file}
}
return
} | go | {
"resource": ""
} |
q30571 | ReadPidFile | train | func ReadPidFile(name string) (pid int, err error) {
var file *os.File
if file, err = os.OpenFile(name, os.O_RDONLY, 0640); err != nil {
return
}
defer file.Close()
lock := &LockFile{file}
pid, err = lock.ReadPid()
return
} | go | {
"resource": ""
} |
q30572 | WritePid | train | func (file *LockFile) WritePid() (err error) {
if _, err = file.Seek(0, os.SEEK_SET); err != nil {
return
}
var fileLen int
if fileLen, err = fmt.Fprint(file, os.Getpid()); err != nil {
return
}
if err = file.Truncate(int64(fileLen)); err != nil {
return
}
err = file.Sync()
return
} | go | {
"resource": ""
} |
q30573 | ReadPid | train | func (file *LockFile) ReadPid() (pid int, err error) {
if _, err = file.Seek(0, os.SEEK_SET); err != nil {
return
}
_, err = fmt.Fscan(file, &pid)
return
} | go | {
"resource": ""
} |
q30574 | Remove | train | func (file *LockFile) Remove() error {
defer file.Close()
if err := file.Unlock(); err != nil {
return err
}
return os.Remove(file.Name())
} | go | {
"resource": ""
} |
q30575 | AddCommand | train | func AddCommand(f Flag, sig os.Signal, handler SignalHandlerFunc) {
if f != nil {
AddFlag(f, sig)
}
if handler != nil {
SetSigHandler(handler, sig)
}
} | go | {
"resource": ""
} |
q30576 | SendCommands | train | func SendCommands(p *os.Process) (err error) {
for _, sig := range signals() {
if err = p.Signal(sig); err != nil {
return
}
}
return
} | go | {
"resource": ""
} |
q30577 | ActiveFlags | train | func ActiveFlags() (ret []Flag) {
ret = make([]Flag, 0, 1)
for f := range flags {
if f.IsSet() {
ret = append(ret, f)
}
}
return
} | go | {
"resource": ""
} |
q30578 | SetSigHandler | train | func SetSigHandler(handler SignalHandlerFunc, signals ...os.Signal) {
for _, sig := range signals {
handlers[sig] = handler
}
} | go | {
"resource": ""
} |
q30579 | ServeSignals | train | func ServeSignals() (err error) {
signals := make([]os.Signal, 0, len(handlers))
for sig := range handlers {
signals = append(signals, sig)
}
ch := make(chan os.Signal, 8)
signal.Notify(ch, signals...)
for sig := range ch {
err = handlers[sig](sig)
if err != nil {
break
}
}
signal.Stop(ch)
if er... | go | {
"resource": ""
} |
q30580 | Search | train | func (d *Context) Search() (daemon *os.Process, err error) {
return d.search()
} | go | {
"resource": ""
} |
q30581 | sanitizeExpectedValue | train | func sanitizeExpectedValue(i interface{}) interface{} {
if e, ok := i.(float64); ok {
return int(e)
}
if e, ok := i.(map[interface{}]interface{}); ok {
out := make(map[string]interface{})
for k, v := range e {
ks, ok := k.(string)
if !ok {
panic(fmt.Sprintf("Matcher key type not string: %T\n\n", k))
... | go | {
"resource": ""
} |
q30582 | detectPackage | train | func (sys *System) detectPackage(c *cli.Context) {
p := c.GlobalString("package")
if p != "deb" && p != "apk" && p != "pacman" && p != "rpm" {
p = DetectPackageManager()
}
switch p {
case "deb":
sys.NewPackage = NewDebPackage
case "apk":
sys.NewPackage = NewAlpinePackage
case "pacman":
sys.NewPackage = N... | go | {
"resource": ""
} |
q30583 | detectService | train | func (sys *System) detectService() {
switch DetectService() {
case "upstart":
sys.NewService = NewServiceUpstart
case "systemd":
sys.NewService = NewServiceSystemd
case "alpineinit":
sys.NewService = NewAlpineServiceInit
default:
sys.NewService = NewServiceInit
}
} | go | {
"resource": ""
} |
q30584 | HasCommand | train | func HasCommand(cmd string) bool {
if _, err := exec.LookPath(cmd); err == nil {
return true
}
return false
} | go | {
"resource": ""
} |
q30585 | ReadJSON | train | func ReadJSON(filePath string) GossConfig {
file, err := ioutil.ReadFile(filePath)
if err != nil {
fmt.Printf("File error: %v\n", err)
os.Exit(1)
}
return ReadJSONData(file, false)
} | go | {
"resource": ""
} |
q30586 | ReadJSONData | train | func ReadJSONData(data []byte, detectFormat bool) GossConfig {
if TemplateFilter != nil {
data = TemplateFilter(data)
if debug {
fmt.Println("DEBUG: file after text/template render")
fmt.Println(string(data))
}
}
format := OutStoreFormat
if detectFormat == true {
format = getStoreFormatFromData(data)
... | go | {
"resource": ""
} |
q30587 | RenderJSON | train | func RenderJSON(c *cli.Context) string {
filePath := c.GlobalString("gossfile")
varsFile := c.GlobalString("vars")
debug = c.Bool("debug")
TemplateFilter = NewTemplateFilter(varsFile)
path := filepath.Dir(filePath)
OutStoreFormat = getStoreFormatFromFileName(filePath)
gossConfig := mergeJSONData(ReadJSON(filePat... | go | {
"resource": ""
} |
q30588 | Outputers | train | func Outputers() []string {
outputersMu.Lock()
defer outputersMu.Unlock()
var list []string
for name := range outputers {
list = append(list, name)
}
sort.Strings(list)
return list
} | go | {
"resource": ""
} |
q30589 | LookupHost | train | func LookupHost(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
a, _ := LookupA(host, server, c, m)
aaaa, _ := LookupAAAA(host, server, c, m)
addrs = append(a, aaaa...)
return
} | go | {
"resource": ""
} |
q30590 | LookupCNAME | train | func LookupCNAME(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeCNAME)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.CNAME); ok {
a... | go | {
"resource": ""
} |
q30591 | LookupMX | train | func LookupMX(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeMX)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.MX); ok {
mxstring :... | go | {
"resource": ""
} |
q30592 | LookupNS | train | func LookupNS(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeNS)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.NS); ok {
addrs = ap... | go | {
"resource": ""
} |
q30593 | LookupSRV | train | func LookupSRV(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeSRV)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.SRV); ok {
prio :=... | go | {
"resource": ""
} |
q30594 | LookupTXT | train | func LookupTXT(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeTXT)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.TXT); ok {
addrs =... | go | {
"resource": ""
} |
q30595 | LookupPTR | train | func LookupPTR(addr string, server string, c *dns.Client, m *dns.Msg) (name []string, err error) {
reverse, err := dns.ReverseAddr(addr)
if err != nil {
return nil, err
}
m.SetQuestion(reverse, dns.TypePTR)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for ... | go | {
"resource": ""
} |
q30596 | LookupCAA | train | func LookupCAA(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeCAA)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.CAA); ok {
flag :=... | go | {
"resource": ""
} |
q30597 | Stories | train | func (time *Timeline) Stories() (*Tray, error) {
body, err := time.inst.sendSimpleRequest(urlStories)
if err == nil {
tray := &Tray{}
err = json.Unmarshal(body, tray)
if err != nil {
return nil, err
}
tray.set(time.inst, urlStories)
return tray, nil
}
return nil, err
} | go | {
"resource": ""
} |
q30598 | New | train | func New(username, password string) *Instagram {
// this call never returns error
jar, _ := cookiejar.New(nil)
inst := &Instagram{
user: username,
pass: password,
dID: generateDeviceID(
generateMD5Hash(username + password),
),
uuid: generateUUID(), // both uuid must be differents
pid: generateUUID(),... | go | {
"resource": ""
} |
q30599 | SetProxy | train | func (inst *Instagram) SetProxy(url string, insecure bool) error {
uri, err := neturl.Parse(url)
if err == nil {
inst.c.Transport = &http.Transport{
Proxy: http.ProxyURL(uri),
TLSClientConfig: &tls.Config{
InsecureSkipVerify: insecure,
},
}
}
return err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.