_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q180200 | GenerateKeyPair | test | func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error) {
return GenerateKeyPairWithReader(typ, bits, rand.Reader)
} | go | {
"resource": ""
} |
q180201 | GenerateKeyPairWithReader | test | func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error) {
switch typ {
case RSA:
return GenerateRSAKeyPair(bits, src)
case Ed25519:
return GenerateEd25519Key(src)
case Secp256k1:
return GenerateSecp256k1Key(src)
case ECDSA:
return GenerateECDSAKeyPair(src)
default:
return nil, nil, ErrBadKeyType
}
} | go | {
"resource": ""
} |
q180202 | GenerateEKeyPair | test | func GenerateEKeyPair(curveName string) ([]byte, GenSharedKey, error) {
var curve elliptic.Curve
switch curveName {
case "P-256":
curve = elliptic.P256()
case "P-384":
curve = elliptic.P384()
case "P-521":
curve = elliptic.P521()
}
priv, x, y, err := elliptic.GenerateKey(curve, rand.Reader)
if err != nil {
return nil, nil, err
}
pubKey := elliptic.Marshal(curve, x, y)
done := func(theirPub []byte) ([]byte, error) {
// Verify and unpack node's public key.
x, y := elliptic.Unmarshal(curve, theirPub)
if x == nil {
return nil, fmt.Errorf("malformed public key: %d %v", len(theirPub), theirPub)
}
if !curve.IsOnCurve(x, y) {
return nil, errors.New("invalid public key")
}
// Generate shared secret.
secret, _ := curve.ScalarMult(x, y, priv)
return secret.Bytes(), nil
}
return pubKey, done, nil
} | go | {
"resource": ""
} |
q180203 | UnmarshalPublicKey | test | func UnmarshalPublicKey(data []byte) (PubKey, error) {
pmes := new(pb.PublicKey)
err := proto.Unmarshal(data, pmes)
if err != nil {
return nil, err
}
um, ok := PubKeyUnmarshallers[pmes.GetType()]
if !ok {
return nil, ErrBadKeyType
}
return um(pmes.GetData())
} | go | {
"resource": ""
} |
q180204 | MarshalPublicKey | test | func MarshalPublicKey(k PubKey) ([]byte, error) {
pbmes := new(pb.PublicKey)
pbmes.Type = k.Type()
data, err := k.Raw()
if err != nil {
return nil, err
}
pbmes.Data = data
return proto.Marshal(pbmes)
} | go | {
"resource": ""
} |
q180205 | UnmarshalPrivateKey | test | func UnmarshalPrivateKey(data []byte) (PrivKey, error) {
pmes := new(pb.PrivateKey)
err := proto.Unmarshal(data, pmes)
if err != nil {
return nil, err
}
um, ok := PrivKeyUnmarshallers[pmes.GetType()]
if !ok {
return nil, ErrBadKeyType
}
return um(pmes.GetData())
} | go | {
"resource": ""
} |
q180206 | MarshalPrivateKey | test | func MarshalPrivateKey(k PrivKey) ([]byte, error) {
pbmes := new(pb.PrivateKey)
pbmes.Type = k.Type()
data, err := k.Raw()
if err != nil {
return nil, err
}
pbmes.Data = data
return proto.Marshal(pbmes)
} | go | {
"resource": ""
} |
q180207 | KeyEqual | test | func KeyEqual(k1, k2 Key) bool {
if k1 == k2 {
return true
}
b1, err1 := k1.Bytes()
b2, err2 := k2.Bytes()
return bytes.Equal(b1, b2) && err1 == err2
} | go | {
"resource": ""
} |
q180208 | GenerateECDSAKeyPair | test | func GenerateECDSAKeyPair(src io.Reader) (PrivKey, PubKey, error) {
return GenerateECDSAKeyPairWithCurve(ECDSACurve, src)
} | go | {
"resource": ""
} |
q180209 | GenerateECDSAKeyPairWithCurve | test | func GenerateECDSAKeyPairWithCurve(curve elliptic.Curve, src io.Reader) (PrivKey, PubKey, error) {
priv, err := ecdsa.GenerateKey(curve, src)
if err != nil {
return nil, nil, err
}
return &ECDSAPrivateKey{priv}, &ECDSAPublicKey{&priv.PublicKey}, nil
} | go | {
"resource": ""
} |
q180210 | ECDSAKeyPairFromKey | test | func ECDSAKeyPairFromKey(priv *ecdsa.PrivateKey) (PrivKey, PubKey, error) {
if priv == nil {
return nil, nil, ErrNilPrivateKey
}
return &ECDSAPrivateKey{priv}, &ECDSAPublicKey{&priv.PublicKey}, nil
} | go | {
"resource": ""
} |
q180211 | UnmarshalECDSAPrivateKey | test | func UnmarshalECDSAPrivateKey(data []byte) (PrivKey, error) {
priv, err := x509.ParseECPrivateKey(data)
if err != nil {
return nil, err
}
return &ECDSAPrivateKey{priv}, nil
} | go | {
"resource": ""
} |
q180212 | UnmarshalECDSAPublicKey | test | func UnmarshalECDSAPublicKey(data []byte) (PubKey, error) {
pubIfc, err := x509.ParsePKIXPublicKey(data)
if err != nil {
return nil, err
}
pub, ok := pubIfc.(*ecdsa.PublicKey)
if !ok {
return nil, ErrNotECDSAPubKey
}
return &ECDSAPublicKey{pub}, nil
} | go | {
"resource": ""
} |
q180213 | Equals | test | func (ePriv *ECDSAPrivateKey) Equals(o Key) bool {
oPriv, ok := o.(*ECDSAPrivateKey)
if !ok {
return false
}
return ePriv.priv.D.Cmp(oPriv.priv.D) == 0
} | go | {
"resource": ""
} |
q180214 | Sign | test | func (ePriv *ECDSAPrivateKey) Sign(data []byte) ([]byte, error) {
hash := sha256.Sum256(data)
r, s, err := ecdsa.Sign(rand.Reader, ePriv.priv, hash[:])
if err != nil {
return nil, err
}
return asn1.Marshal(ECDSASig{
R: r,
S: s,
})
} | go | {
"resource": ""
} |
q180215 | Equals | test | func (ePub *ECDSAPublicKey) Equals(o Key) bool {
oPub, ok := o.(*ECDSAPublicKey)
if !ok {
return false
}
return ePub.pub.X != nil && ePub.pub.Y != nil && oPub.pub.X != nil && oPub.pub.Y != nil &&
0 == ePub.pub.X.Cmp(oPub.pub.X) && 0 == ePub.pub.Y.Cmp(oPub.pub.Y)
} | go | {
"resource": ""
} |
q180216 | Verify | test | func (ePub *ECDSAPublicKey) Verify(data, sigBytes []byte) (bool, error) {
sig := new(ECDSASig)
if _, err := asn1.Unmarshal(sigBytes, sig); err != nil {
return false, err
}
if sig == nil {
return false, ErrNilSig
}
hash := sha256.Sum256(data)
return ecdsa.Verify(ePub.pub, hash[:], sig.R, sig.S), nil
} | go | {
"resource": ""
} |
q180217 | GenerateSecp256k1Key | test | func GenerateSecp256k1Key(src io.Reader) (PrivKey, PubKey, error) {
privk, err := btcec.NewPrivateKey(btcec.S256())
if err != nil {
return nil, nil, err
}
k := (*Secp256k1PrivateKey)(privk)
return k, k.GetPublic(), nil
} | go | {
"resource": ""
} |
q180218 | UnmarshalSecp256k1PrivateKey | test | func UnmarshalSecp256k1PrivateKey(data []byte) (PrivKey, error) {
if len(data) != btcec.PrivKeyBytesLen {
return nil, fmt.Errorf("expected secp256k1 data size to be %d", btcec.PrivKeyBytesLen)
}
privk, _ := btcec.PrivKeyFromBytes(btcec.S256(), data)
return (*Secp256k1PrivateKey)(privk), nil
} | go | {
"resource": ""
} |
q180219 | UnmarshalSecp256k1PublicKey | test | func UnmarshalSecp256k1PublicKey(data []byte) (PubKey, error) {
k, err := btcec.ParsePubKey(data, btcec.S256())
if err != nil {
return nil, err
}
return (*Secp256k1PublicKey)(k), nil
} | go | {
"resource": ""
} |
q180220 | Equals | test | func (k *Secp256k1PrivateKey) Equals(o Key) bool {
sk, ok := o.(*Secp256k1PrivateKey)
if !ok {
return false
}
return k.D.Cmp(sk.D) == 0
} | go | {
"resource": ""
} |
q180221 | Sign | test | func (k *Secp256k1PrivateKey) Sign(data []byte) ([]byte, error) {
hash := sha256.Sum256(data)
sig, err := (*btcec.PrivateKey)(k).Sign(hash[:])
if err != nil {
return nil, err
}
return sig.Serialize(), nil
} | go | {
"resource": ""
} |
q180222 | Equals | test | func (k *Secp256k1PublicKey) Equals(o Key) bool {
sk, ok := o.(*Secp256k1PublicKey)
if !ok {
return false
}
return (*btcec.PublicKey)(k).IsEqual((*btcec.PublicKey)(sk))
} | go | {
"resource": ""
} |
q180223 | Verify | test | func (k *Secp256k1PublicKey) Verify(data []byte, sigStr []byte) (bool, error) {
sig, err := btcec.ParseDERSignature(sigStr, btcec.S256())
if err != nil {
return false, err
}
hash := sha256.Sum256(data)
return sig.Verify(hash[:], (*btcec.PublicKey)(k)), nil
} | go | {
"resource": ""
} |
q180224 | Raw | test | func (k *Ed25519PrivateKey) Raw() ([]byte, error) {
// The Ed25519 private key contains two 32-bytes curve points, the private
// key and the public key.
// It makes it more efficient to get the public key without re-computing an
// elliptic curve multiplication.
buf := make([]byte, len(k.k))
copy(buf, k.k)
return buf, nil
} | go | {
"resource": ""
} |
q180225 | Sign | test | func (k *Ed25519PrivateKey) Sign(msg []byte) ([]byte, error) {
return ed25519.Sign(k.k, msg), nil
} | go | {
"resource": ""
} |
q180226 | Equals | test | func (k *Ed25519PublicKey) Equals(o Key) bool {
edk, ok := o.(*Ed25519PublicKey)
if !ok {
return false
}
return bytes.Equal(k.k, edk.k)
} | go | {
"resource": ""
} |
q180227 | Verify | test | func (k *Ed25519PublicKey) Verify(data []byte, sig []byte) (bool, error) {
return ed25519.Verify(k.k, data, sig), nil
} | go | {
"resource": ""
} |
q180228 | UnmarshalEd25519PublicKey | test | func UnmarshalEd25519PublicKey(data []byte) (PubKey, error) {
if len(data) != 32 {
return nil, errors.New("expect ed25519 public key data size to be 32")
}
return &Ed25519PublicKey{
k: ed25519.PublicKey(data),
}, nil
} | go | {
"resource": ""
} |
q180229 | UnmarshalEd25519PrivateKey | test | func UnmarshalEd25519PrivateKey(data []byte) (PrivKey, error) {
switch len(data) {
case ed25519.PrivateKeySize + ed25519.PublicKeySize:
// Remove the redundant public key. See issue #36.
redundantPk := data[ed25519.PrivateKeySize:]
pk := data[ed25519.PrivateKeySize-ed25519.PublicKeySize : ed25519.PrivateKeySize]
if !bytes.Equal(pk, redundantPk) {
return nil, errors.New("expected redundant ed25519 public key to be redundant")
}
// No point in storing the extra data.
newKey := make([]byte, ed25519.PrivateKeySize)
copy(newKey, data[:ed25519.PrivateKeySize])
data = newKey
case ed25519.PrivateKeySize:
default:
return nil, fmt.Errorf(
"expected ed25519 data size to be %d or %d, got %d",
ed25519.PrivateKeySize,
ed25519.PrivateKeySize+ed25519.PublicKeySize,
len(data),
)
}
return &Ed25519PrivateKey{
k: ed25519.PrivateKey(data),
}, nil
} | go | {
"resource": ""
} |
q180230 | EditScriptForStrings | test | func EditScriptForStrings(source []rune, target []rune, op Options) EditScript {
return backtrace(len(source), len(target),
MatrixForStrings(source, target, op), op)
} | go | {
"resource": ""
} |
q180231 | EditScriptForMatrix | test | func EditScriptForMatrix(matrix [][]int, op Options) EditScript {
return backtrace(len(matrix)-1, len(matrix[0])-1, matrix, op)
} | go | {
"resource": ""
} |
q180232 | WriteMatrix | test | func WriteMatrix(source []rune, target []rune, matrix [][]int, writer io.Writer) {
fmt.Fprintf(writer, " ")
for _, targetRune := range target {
fmt.Fprintf(writer, " %c", targetRune)
}
fmt.Fprintf(writer, "\n")
fmt.Fprintf(writer, " %2d", matrix[0][0])
for j, _ := range target {
fmt.Fprintf(writer, " %2d", matrix[0][j+1])
}
fmt.Fprintf(writer, "\n")
for i, sourceRune := range source {
fmt.Fprintf(writer, "%c %2d", sourceRune, matrix[i+1][0])
for j, _ := range target {
fmt.Fprintf(writer, " %2d", matrix[i+1][j+1])
}
fmt.Fprintf(writer, "\n")
}
} | go | {
"resource": ""
} |
q180233 | New | test | func New(path string) (Lockfile, error) {
if !filepath.IsAbs(path) {
return Lockfile(""), ErrNeedAbsPath
}
return Lockfile(path), nil
} | go | {
"resource": ""
} |
q180234 | GetOwner | test | func (l Lockfile) GetOwner() (*os.Process, error) {
name := string(l)
// Ok, see, if we have a stale lockfile here
content, err := ioutil.ReadFile(name)
if err != nil {
return nil, err
}
// try hard for pids. If no pid, the lockfile is junk anyway and we delete it.
pid, err := scanPidLine(content)
if err != nil {
return nil, err
}
running, err := isRunning(pid)
if err != nil {
return nil, err
}
if running {
proc, err := os.FindProcess(pid)
if err != nil {
return nil, err
}
return proc, nil
}
return nil, ErrDeadOwner
} | go | {
"resource": ""
} |
q180235 | TryLock | test | func (l Lockfile) TryLock() error {
name := string(l)
// This has been checked by New already. If we trigger here,
// the caller didn't use New and re-implemented it's functionality badly.
// So panic, that he might find this easily during testing.
if !filepath.IsAbs(name) {
panic(ErrNeedAbsPath)
}
tmplock, err := ioutil.TempFile(filepath.Dir(name), filepath.Base(name)+".")
if err != nil {
return err
}
cleanup := func() {
_ = tmplock.Close()
_ = os.Remove(tmplock.Name())
}
defer cleanup()
if err := writePidLine(tmplock, os.Getpid()); err != nil {
return err
}
// EEXIST and similiar error codes, caught by os.IsExist, are intentionally ignored,
// as it means that someone was faster creating this link
// and ignoring this kind of error is part of the algorithm.
// The we will probably fail the pid owner check later, if this process is still alive.
// We cannot ignore ALL errors, since failure to support hard links, disk full
// as well as many other errors can happen to a filesystem operation
// and we really want to abort on those.
if err := os.Link(tmplock.Name(), name); err != nil {
if !os.IsExist(err) {
return err
}
}
fiTmp, err := os.Lstat(tmplock.Name())
if err != nil {
return err
}
fiLock, err := os.Lstat(name)
if err != nil {
// tell user that a retry would be a good idea
if os.IsNotExist(err) {
return ErrNotExist
}
return err
}
// Success
if os.SameFile(fiTmp, fiLock) {
return nil
}
proc, err := l.GetOwner()
switch err {
default:
// Other errors -> defensively fail and let caller handle this
return err
case nil:
if proc.Pid != os.Getpid() {
return ErrBusy
}
case ErrDeadOwner, ErrInvalidPid:
// cases we can fix below
}
// clean stale/invalid lockfile
err = os.Remove(name)
if err != nil {
// If it doesn't exist, then it doesn't matter who removed it.
if !os.IsNotExist(err) {
return err
}
}
// now that the stale lockfile is gone, let's recurse
return l.TryLock()
} | go | {
"resource": ""
} |
q180236 | Unlock | test | func (l Lockfile) Unlock() error {
proc, err := l.GetOwner()
switch err {
case ErrInvalidPid, ErrDeadOwner:
return ErrRogueDeletion
case nil:
if proc.Pid == os.Getpid() {
// we really own it, so let's remove it.
return os.Remove(string(l))
}
// Not owned by me, so don't delete it.
return ErrRogueDeletion
default:
// This is an application error or system error.
// So give a better error for logging here.
if os.IsNotExist(err) {
return ErrRogueDeletion
}
// Other errors -> defensively fail and let caller handle this
return err
}
} | go | {
"resource": ""
} |
q180237 | NewBase | test | func NewBase(configs ...baseConfigFunc) *Base {
b := &Base{
clock: glock.NewRealClock(),
config: NewConfig(),
logLevel: LevelDebug,
sequence: 0,
BaseAttrs: NewAttrs(),
loggers: make([]Logger, 0),
hookPreQueue: make([]HookPreQueue, 0),
}
for _, f := range configs {
f(b)
}
return b
} | go | {
"resource": ""
} |
q180238 | SetFallbackLogger | test | func (b *Base) SetFallbackLogger(logger Logger) error {
if logger == nil {
if b.fallbackLogger != nil && b.fallbackLogger.IsInitialized() {
b.fallbackLogger.ShutdownLogger()
}
b.fallbackLogger = nil
return nil
}
if !logger.IsInitialized() {
err := logger.InitLogger()
if err != nil {
return err
}
}
// Shut down any old logger we might already have a reference to
if b.fallbackLogger != nil && b.fallbackLogger.IsInitialized() {
b.fallbackLogger.ShutdownLogger()
}
b.fallbackLogger = logger
return nil
} | go | {
"resource": ""
} |
q180239 | AddLogger | test | func (b *Base) AddLogger(logger Logger) error {
if b.IsInitialized() && !logger.IsInitialized() {
err := logger.InitLogger()
if err != nil {
return err
}
} else if !b.IsInitialized() && logger.IsInitialized() {
err := logger.ShutdownLogger()
if err != nil {
return err
}
}
b.loggers = append(b.loggers, logger)
if hook, ok := logger.(HookPreQueue); ok {
b.hookPreQueue = append(b.hookPreQueue, hook)
}
logger.SetBase(b)
return nil
} | go | {
"resource": ""
} |
q180240 | LogWithTime | test | func (b *Base) LogWithTime(level LogLevel, ts time.Time, m *Attrs, msg string, a ...interface{}) error {
if !b.shouldLog(level) {
return nil
}
if !b.isInitialized {
return ErrNotInitialized
}
if len(b.config.FilenameAttr) > 0 || len(b.config.LineNumberAttr) > 0 {
file, line := getCallerInfo()
if m == nil {
m = NewAttrs()
}
if len(b.config.FilenameAttr) > 0 {
m.SetAttr(b.config.FilenameAttr, file)
}
if len(b.config.LineNumberAttr) > 0 {
m.SetAttr(b.config.LineNumberAttr, line)
}
}
if len(b.config.SequenceAttr) > 0 {
if m == nil {
m = NewAttrs()
}
seq := atomic.AddUint64(&b.sequence, 1)
m.SetAttr(b.config.SequenceAttr, seq)
}
nm := newMessage(ts, b, level, m, msg, a...)
for _, hook := range b.hookPreQueue {
err := hook.PreQueue(nm)
if err != nil {
return err
}
}
return b.queue.queueMessage(nm)
} | go | {
"resource": ""
} |
q180241 | Log | test | func (b *Base) Log(level LogLevel, m *Attrs, msg string, a ...interface{}) error {
return b.LogWithTime(level, b.clock.Now(), m, msg, a...)
} | go | {
"resource": ""
} |
q180242 | Warnm | test | func (b *Base) Warnm(m *Attrs, msg string, a ...interface{}) error {
return b.Warningm(m, msg, a...)
} | go | {
"resource": ""
} |
q180243 | NewTemplateWithFuncMap | test | func NewTemplateWithFuncMap(tpl string, funcMap template.FuncMap) (*Template, error) {
var levels = []LogLevel{LevelNone, LevelDebug, LevelInfo, LevelWarning, LevelError, LevelFatal}
tpls := make(map[LogLevel]*template.Template, 0)
for _, level := range levels {
// If color is overridden, we need to ensure that {{reset}} resets for all levels.
_, forceReset := funcMap["color"]
fMap := getFuncMap(level, forceReset)
for name, f := range funcMap {
fMap[name] = f
}
parsedTpl, err := template.New(getLevelName(level)).
Funcs(fMap).
Parse(tpl)
if err != nil {
return nil, err
}
tpls[level] = parsedTpl
}
newTpl := &Template{
tpls: tpls,
}
return newTpl, nil
} | go | {
"resource": ""
} |
q180244 | Execute | test | func (t *Template) Execute(msg *TemplateMsg, colorize bool) (string, error) {
tplLevel := msg.Level
if !colorize {
tplLevel = LevelNone
}
var buf bytes.Buffer
execTpl := t.tpls[tplLevel]
if execTpl == nil {
return "", ErrUnknownLevel
}
err := execTpl.Execute(&buf, msg)
if err != nil {
return "", err
}
return buf.String(), nil
} | go | {
"resource": ""
} |
q180245 | NewTemplateMsg | test | func NewTemplateMsg(timestamp time.Time, level LogLevel, m map[string]interface{}, msg string) *TemplateMsg {
msgAttrs := m
if msgAttrs == nil {
msgAttrs = make(map[string]interface{})
}
tplMsg := &TemplateMsg{
Timestamp: timestamp,
Message: msg,
Level: level,
LevelName: level.String(),
Attrs: msgAttrs,
}
return tplMsg
} | go | {
"resource": ""
} |
q180246 | NewLogAdapterFor | test | func NewLogAdapterFor(base WrappableLogger, attrs *Attrs) *LogAdapter {
if attrs == nil {
attrs = NewAttrs()
}
return &LogAdapter{
base: base,
attrs: attrs,
}
} | go | {
"resource": ""
} |
q180247 | SetAttr | test | func (la *LogAdapter) SetAttr(key string, value interface{}) {
la.attrs.SetAttr(key, value)
} | go | {
"resource": ""
} |
q180248 | LogWithTime | test | func (la *LogAdapter) LogWithTime(level LogLevel, ts time.Time, attrs *Attrs, msg string, a ...interface{}) error {
if la.logLevel != nil && level > *la.logLevel {
return nil
}
mergedAttrs := la.attrs.clone()
mergedAttrs.MergeAttrs(attrs)
return la.base.LogWithTime(level, ts, mergedAttrs, msg, a...)
} | go | {
"resource": ""
} |
q180249 | Log | test | func (la *LogAdapter) Log(level LogLevel, attrs *Attrs, msg string, a ...interface{}) error {
if la.logLevel != nil && level > *la.logLevel {
return nil
}
mergedAttrs := la.attrs.clone()
mergedAttrs.MergeAttrs(attrs)
return la.base.Log(level, mergedAttrs, msg, a...)
} | go | {
"resource": ""
} |
q180250 | Dbgm | test | func (la *LogAdapter) Dbgm(m *Attrs, msg string, a ...interface{}) error {
return la.Debugm(m, msg, a...)
} | go | {
"resource": ""
} |
q180251 | NewAttrsFromMap | test | func NewAttrsFromMap(attrs map[string]interface{}) *Attrs {
newAttrs := NewAttrs()
for attrKey, attrVal := range attrs {
newAttrs.SetAttr(attrKey, attrVal)
}
return newAttrs
} | go | {
"resource": ""
} |
q180252 | NewAttrsFromAttrs | test | func NewAttrsFromAttrs(attrs ...*Attrs) *Attrs {
newAttrs := NewAttrs()
for _, attr := range attrs {
newAttrs.MergeAttrs(attr)
}
return newAttrs
} | go | {
"resource": ""
} |
q180253 | MergeAttrs | test | func (a *Attrs) MergeAttrs(attrs *Attrs) {
if attrs == nil {
return
}
a.attrsLock.Lock()
defer a.attrsLock.Unlock()
for hash, val := range attrs.attrs {
a.attrs[hash] = val
}
} | go | {
"resource": ""
} |
q180254 | SetAttr | test | func (a *Attrs) SetAttr(key string, value interface{}) *Attrs {
a.attrsLock.Lock()
defer a.attrsLock.Unlock()
valVal := reflect.ValueOf(value)
switch valVal.Kind() {
case reflect.Func:
value = valVal.Type().String()
}
hash := getAttrHash(key)
a.attrs[hash] = value
return a
} | go | {
"resource": ""
} |
q180255 | GetAttr | test | func (a *Attrs) GetAttr(key string) interface{} {
a.attrsLock.RLock()
defer a.attrsLock.RUnlock()
return a.attrs[getAttrHash(key)]
} | go | {
"resource": ""
} |
q180256 | RemoveAttr | test | func (a *Attrs) RemoveAttr(key string) {
a.attrsLock.Lock()
defer a.attrsLock.Unlock()
delete(a.attrs, getAttrHash(key))
} | go | {
"resource": ""
} |
q180257 | Attrs | test | func (a *Attrs) Attrs() map[string]interface{} {
a.attrsLock.RLock()
defer a.attrsLock.RUnlock()
attrs := make(map[string]interface{})
for hash, val := range a.attrs {
key, _ := getHashAttr(hash)
attrs[key] = val
}
return attrs
} | go | {
"resource": ""
} |
q180258 | Debugm | test | func Debugm(m *Attrs, msg string, a ...interface{}) error {
return curDefault.Debugm(m, msg, a...)
} | go | {
"resource": ""
} |
q180259 | Infom | test | func Infom(m *Attrs, msg string, a ...interface{}) error {
return curDefault.Infom(m, msg, a...)
} | go | {
"resource": ""
} |
q180260 | Warningm | test | func Warningm(m *Attrs, msg string, a ...interface{}) error {
return curDefault.Warningm(m, msg, a...)
} | go | {
"resource": ""
} |
q180261 | Errm | test | func Errm(m *Attrs, msg string, a ...interface{}) error {
return Errorm(m, msg, a...)
} | go | {
"resource": ""
} |
q180262 | Errorm | test | func Errorm(m *Attrs, msg string, a ...interface{}) error {
return curDefault.Errorm(m, msg, a...)
} | go | {
"resource": ""
} |
q180263 | Fatalm | test | func Fatalm(m *Attrs, msg string, a ...interface{}) error {
return curDefault.Fatalm(m, msg, a...)
} | go | {
"resource": ""
} |
q180264 | Dief | test | func Dief(exitCode int, msg string, a ...interface{}) {
curDefault.Dief(exitCode, msg, a...)
} | go | {
"resource": ""
} |
q180265 | Diem | test | func Diem(exitCode int, m *Attrs, msg string, a ...interface{}) {
curDefault.Diem(exitCode, m, msg, a...)
} | go | {
"resource": ""
} |
q180266 | ToLogLevel | test | func ToLogLevel(level string) (LogLevel, error) {
lowLevel := strings.ToLower(level)
switch lowLevel {
case "dbg":
fallthrough
case "debug":
return LevelDebug, nil
case "info":
return LevelInfo, nil
case "warn":
fallthrough
case "warning":
return LevelWarning, nil
case "err":
fallthrough
case "error":
return LevelError, nil
case "fatal":
return LevelFatal, nil
case "none":
return LevelNone, nil
}
return 0, ErrUnknownLevel
} | go | {
"resource": ""
} |
q180267 | CallErr | test | func CallErr(f func() error) error {
checkRun()
errChan := make(chan error)
callQueue <- func() {
errChan <- f()
}
return <-errChan
} | go | {
"resource": ""
} |
q180268 | New | test | func New(opts ...Option) (*StackdriverHook, error) {
var err error
sh := &StackdriverHook{
levels: logrus.AllLevels,
}
// apply opts
for _, o := range opts {
err = o(sh)
if err != nil {
return nil, err
}
}
// check service, resource, logName set
if sh.service == nil && sh.agentClient == nil {
return nil, errors.New("no stackdriver service was provided")
}
if sh.resource == nil && sh.agentClient == nil {
return nil, errors.New("the monitored resource was not provided")
}
if sh.projectID == "" && sh.agentClient == nil {
return nil, errors.New("the project id was not provided")
}
// set default project name
if sh.logName == "" {
err = LogName(DefaultName)(sh)
if err != nil {
return nil, err
}
}
// If error reporting log name not set, set it to log name
// plus string suffix
if sh.errorReportingLogName == "" {
sh.errorReportingLogName = sh.logName + "_errors"
}
return sh, nil
} | go | {
"resource": ""
} |
q180269 | Fire | test | func (sh *StackdriverHook) Fire(entry *logrus.Entry) error {
sh.waitGroup.Add(1)
go func(entry *logrus.Entry) {
defer sh.waitGroup.Done()
var httpReq *logging.HttpRequest
// convert entry data to labels
labels := make(map[string]string, len(entry.Data))
for k, v := range entry.Data {
switch x := v.(type) {
case string:
labels[k] = x
case *http.Request:
httpReq = &logging.HttpRequest{
Referer: x.Referer(),
RemoteIp: x.RemoteAddr,
RequestMethod: x.Method,
RequestUrl: x.URL.String(),
UserAgent: x.UserAgent(),
}
case *logging.HttpRequest:
httpReq = x
default:
labels[k] = fmt.Sprintf("%v", v)
}
}
// write log entry
if sh.agentClient != nil {
sh.sendLogMessageViaAgent(entry, labels, httpReq)
} else {
sh.sendLogMessageViaAPI(entry, labels, httpReq)
}
}(sh.copyEntry(entry))
return nil
} | go | {
"resource": ""
} |
q180270 | Levels | test | func Levels(levels ...logrus.Level) Option {
return func(sh *StackdriverHook) error {
sh.levels = levels
return nil
}
} | go | {
"resource": ""
} |
q180271 | ProjectID | test | func ProjectID(projectID string) Option {
return func(sh *StackdriverHook) error {
sh.projectID = projectID
return nil
}
} | go | {
"resource": ""
} |
q180272 | EntriesService | test | func EntriesService(service *logging.EntriesService) Option {
return func(sh *StackdriverHook) error {
sh.service = service
return nil
}
} | go | {
"resource": ""
} |
q180273 | LoggingService | test | func LoggingService(service *logging.Service) Option {
return func(sh *StackdriverHook) error {
sh.service = service.Entries
return nil
}
} | go | {
"resource": ""
} |
q180274 | ErrorService | test | func ErrorService(errorService *errorReporting.Service) Option {
return func(sh *StackdriverHook) error {
sh.errorService = errorService
return nil
}
} | go | {
"resource": ""
} |
q180275 | HTTPClient | test | func HTTPClient(client *http.Client) Option {
return func(sh *StackdriverHook) error {
// create logging service
l, err := logging.New(client)
if err != nil {
return err
}
// create error reporting service
e, err := errorReporting.New(client)
if err != nil {
return err
} else {
ErrorService(e)
}
return LoggingService(l)(sh)
}
} | go | {
"resource": ""
} |
q180276 | MonitoredResource | test | func MonitoredResource(resource *logging.MonitoredResource) Option {
return func(sh *StackdriverHook) error {
sh.resource = resource
return nil
}
} | go | {
"resource": ""
} |
q180277 | ErrorReportingLogName | test | func ErrorReportingLogName(name string) Option {
return func(sh *StackdriverHook) error {
sh.errorReportingLogName = name
return nil
}
} | go | {
"resource": ""
} |
q180278 | Labels | test | func Labels(labels map[string]string) Option {
return func(sh *StackdriverHook) error {
sh.labels = labels
return nil
}
} | go | {
"resource": ""
} |
q180279 | PartialSuccess | test | func PartialSuccess(enabled bool) Option {
return func(sh *StackdriverHook) error {
sh.partialSuccess = enabled
return nil
}
} | go | {
"resource": ""
} |
q180280 | GoogleComputeCredentials | test | func GoogleComputeCredentials(serviceAccount string) Option {
return func(sh *StackdriverHook) error {
var err error
// get compute metadata scopes associated with the service account
scopes, err := metadata.Scopes(serviceAccount)
if err != nil {
return err
}
// check if all the necessary scopes are provided
for _, s := range requiredScopes {
if !sliceContains(scopes, s) {
// NOTE: if you are seeing this error, you probably need to
// recreate your compute instance with the correct scope
//
// as of August 2016, there is not a way to add a scope to an
// existing compute instance
return fmt.Errorf("missing required scope %s in compute metadata", s)
}
}
return HTTPClient(&http.Client{
Transport: &oauth2.Transport{
Source: google.ComputeTokenSource(serviceAccount),
},
})(sh)
}
} | go | {
"resource": ""
} |
q180281 | NewEncoder | test | func (c Codec) NewEncoder(w io.Writer) *Encoder {
return NewEncoder(c.NewEmitter(w))
} | go | {
"resource": ""
} |
q180282 | NewDecoder | test | func (c Codec) NewDecoder(r io.Reader) *Decoder {
return NewDecoder(c.NewParser(r))
} | go | {
"resource": ""
} |
q180283 | NewStreamEncoder | test | func (c Codec) NewStreamEncoder(w io.Writer) *StreamEncoder {
return NewStreamEncoder(c.NewEmitter(w))
} | go | {
"resource": ""
} |
q180284 | NewStreamDecoder | test | func (c Codec) NewStreamDecoder(r io.Reader) *StreamDecoder {
return NewStreamDecoder(c.NewParser(r))
} | go | {
"resource": ""
} |
q180285 | Register | test | func (reg *Registry) Register(mimetype string, codec Codec) {
defer reg.mutex.Unlock()
reg.mutex.Lock()
if reg.codecs == nil {
reg.codecs = make(map[string]Codec)
}
reg.codecs[mimetype] = codec
} | go | {
"resource": ""
} |
q180286 | Unregister | test | func (reg *Registry) Unregister(mimetype string) {
defer reg.mutex.Unlock()
reg.mutex.Lock()
delete(reg.codecs, mimetype)
} | go | {
"resource": ""
} |
q180287 | Lookup | test | func (reg *Registry) Lookup(mimetype string) (codec Codec, ok bool) {
reg.mutex.RLock()
codec, ok = reg.codecs[mimetype]
reg.mutex.RUnlock()
return
} | go | {
"resource": ""
} |
q180288 | Codecs | test | func (reg *Registry) Codecs() (codecs map[string]Codec) {
codecs = make(map[string]Codec)
reg.mutex.RLock()
for mimetype, codec := range reg.codecs {
codecs[mimetype] = codec
}
reg.mutex.RUnlock()
return
} | go | {
"resource": ""
} |
q180289 | Type | test | func (e *Error) Type() string {
s := e.Error()
if i := strings.IndexByte(s, ' '); i < 0 {
s = ""
} else {
s = s[:i]
for _, c := range s {
if !unicode.IsUpper(c) {
s = ""
break
}
}
}
return s
} | go | {
"resource": ""
} |
q180290 | Install | test | func Install(typ reflect.Type, adapter Adapter) {
if adapter.Encode == nil {
panic("objconv: the encoder function of an adapter cannot be nil")
}
if adapter.Decode == nil {
panic("objconv: the decoder function of an adapter cannot be nil")
}
adapterMutex.Lock()
adapterStore[typ] = adapter
adapterMutex.Unlock()
// We have to clear the struct cache because it may now have become invalid.
// Because installing adapters is done in the package initialization phase
// it's unlikely that any encoding or decoding operations are taking place
// at this time so there should be no performance impact of clearing the
// cache.
structCache.clear()
} | go | {
"resource": ""
} |
q180291 | AdapterOf | test | func AdapterOf(typ reflect.Type) (a Adapter, ok bool) {
adapterMutex.RLock()
a, ok = adapterStore[typ]
adapterMutex.RUnlock()
return
} | go | {
"resource": ""
} |
q180292 | AppendDuration | test | func AppendDuration(b []byte, d time.Duration) []byte {
// Largest time is 2540400h10m10.000000000s
var buf [32]byte
w := len(buf)
u := uint64(d)
neg := d < 0
if neg {
u = -u
}
if u < uint64(time.Second) {
// Special case: if duration is smaller than a second,
// use smaller units, like 1.2ms
var prec int
w--
buf[w] = 's'
w--
switch {
case u == 0:
return append(b, '0', 's')
case u < uint64(time.Microsecond):
// print nanoseconds
prec = 0
buf[w] = 'n'
case u < uint64(time.Millisecond):
// print microseconds
prec = 3
// U+00B5 'µ' micro sign == 0xC2 0xB5
w-- // Need room for two bytes.
copy(buf[w:], "µ")
default:
// print milliseconds
prec = 6
buf[w] = 'm'
}
w, u = fmtFrac(buf[:w], u, prec)
w = fmtInt(buf[:w], u)
} else {
w--
buf[w] = 's'
w, u = fmtFrac(buf[:w], u, 9)
// u is now integer seconds
w = fmtInt(buf[:w], u%60)
u /= 60
// u is now integer minutes
if u > 0 {
w--
buf[w] = 'm'
w = fmtInt(buf[:w], u%60)
u /= 60
// u is now integer hours
// Stop at hours because days can be different lengths.
if u > 0 {
w--
buf[w] = 'h'
w = fmtInt(buf[:w], u)
}
}
}
if neg {
w--
buf[w] = '-'
}
return append(b, buf[w:]...)
} | go | {
"resource": ""
} |
q180293 | fmtInt | test | func fmtInt(buf []byte, v uint64) int {
w := len(buf)
if v == 0 {
w--
buf[w] = '0'
} else {
for v > 0 {
w--
buf[w] = byte(v%10) + '0'
v /= 10
}
}
return w
} | go | {
"resource": ""
} |
q180294 | NewDecoder | test | func NewDecoder(r io.Reader) *objconv.Decoder {
return objconv.NewDecoder(NewParser(r))
} | go | {
"resource": ""
} |
q180295 | NewStreamDecoder | test | func NewStreamDecoder(r io.Reader) *objconv.StreamDecoder {
return objconv.NewStreamDecoder(NewParser(r))
} | go | {
"resource": ""
} |
q180296 | Unmarshal | test | func Unmarshal(b []byte, v interface{}) error {
u := unmarshalerPool.Get().(*unmarshaler)
u.reset(b)
err := (objconv.Decoder{Parser: u}).Decode(v)
u.reset(nil)
unmarshalerPool.Put(u)
return err
} | go | {
"resource": ""
} |
q180297 | String | test | func (t Type) String() string {
switch t {
case Nil:
return "nil"
case Bool:
return "bool"
case Int:
return "int"
case Uint:
return "uint"
case Float:
return "float"
case String:
return "string"
case Bytes:
return "bytes"
case Time:
return "time"
case Duration:
return "duration"
case Error:
return "error"
case Array:
return "array"
case Map:
return "map"
default:
return "<type>"
}
} | go | {
"resource": ""
} |
q180298 | zeroValueOf | test | func zeroValueOf(t reflect.Type) reflect.Value {
zeroMutex.RLock()
v, ok := zeroCache[t]
zeroMutex.RUnlock()
if !ok {
v = reflect.Zero(t)
zeroMutex.Lock()
zeroCache[t] = v
zeroMutex.Unlock()
}
return v
} | go | {
"resource": ""
} |
q180299 | NewValueParser | test | func NewValueParser(v interface{}) *ValueParser {
return &ValueParser{
stack: []reflect.Value{reflect.ValueOf(v)},
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.