_id
stringlengths 86
170
| text
stringlengths 54
39.3k
|
|---|---|
https://github.com/containers/image/blob/da9ab3561ad2031aeb5e036b7cf2755d4e246fec/docker/docker_client.go#L625-L628
|
func (c *dockerClient) detectProperties(ctx context.Context) error {
c.detectPropertiesOnce.Do(func() { c.detectPropertiesError = c.detectPropertiesHelper(ctx) })
return c.detectPropertiesError
}
|
https://github.com/pachyderm/pachyderm/blob/94fb2d536cb6852a77a49e8f777dc9c1bde2c723/src/client/auth/auth.go#L165-L172
|
func IsErrNotAuthorized(err error) bool {
if err == nil {
return false
}
// TODO(msteffen) This is unstructured because we have no way to propagate
// structured errors across GRPC boundaries. Fix
return strings.Contains(err.Error(), errNotAuthorizedMsg)
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/prow/deck/jobs/jobs.go#L132-L147
|
func (ja *JobAgent) GetProwJob(job, id string) (prowapi.ProwJob, error) {
if ja == nil {
return prowapi.ProwJob{}, fmt.Errorf("Prow job agent doesn't exist (are you running locally?)")
}
var j prowapi.ProwJob
ja.mut.Lock()
idMap, ok := ja.jobsIDMap[job]
if ok {
j, ok = idMap[id]
}
ja.mut.Unlock()
if !ok {
return prowapi.ProwJob{}, errProwjobNotFound
}
return j, nil
}
|
https://github.com/uber/tchannel-go/blob/3c9ced6d946fe2fec6c915703a533e966c09e07a/relay_messages.go#L171-L174
|
func (f lazyCallReq) SetTTL(d time.Duration) {
ttl := uint32(d / time.Millisecond)
binary.BigEndian.PutUint32(f.Payload[_ttlIndex:_ttlIndex+_ttlLen], ttl)
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/raft/rawnode.go#L186-L195
|
func (rn *RawNode) Step(m pb.Message) error {
// ignore unexpected local messages receiving over network
if IsLocalMsg(m.Type) {
return ErrStepLocalMsg
}
if pr := rn.raft.getProgress(m.From); pr != nil || !IsResponseMsg(m.Type) {
return rn.raft.Step(m)
}
return ErrStepPeerNotFound
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/storage/easyjson.go#L377-L381
|
func (v *TrackCacheStorageForOriginParams) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoStorage4(&r, v)
return r.Error()
}
|
https://github.com/containers/image/blob/da9ab3561ad2031aeb5e036b7cf2755d4e246fec/oci/archive/oci_src.go#L66-L69
|
func (s *ociArchiveImageSource) Close() error {
defer s.tempDirRef.deleteTempDir()
return s.unpackedSrc.Close()
}
|
https://github.com/lxc/lxd/blob/7a41d14e4c1a6bc25918aca91004d594774dcdd3/client/operations.go#L294-L301
|
func (op *remoteOperation) GetTarget() (*api.Operation, error) {
if op.targetOp == nil {
return nil, fmt.Errorf("No associated target operation")
}
opAPI := op.targetOp.Get()
return &opAPI, nil
}
|
https://github.com/mrd0ll4r/tbotapi/blob/edc257282178bb5cebbfcc41260ec04c1ec7ac19/outgoing.go#L624-L633
|
func NewInlineQueryResultPhoto(id, photoURL, thumbURL string) *InlineQueryResultPhoto {
return &InlineQueryResultPhoto{
InlineQueryResultBase: InlineQueryResultBase{
Type: PhotoResult,
ID: id,
},
PhotoURL: photoURL,
ThumbURL: thumbURL,
}
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/backgroundservice/easyjson.go#L308-L312
|
func (v EventRecordingStateChanged) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoBackgroundservice3(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/uber/tchannel-go/blob/3c9ced6d946fe2fec6c915703a533e966c09e07a/hyperbahn/discover.go#L32-L47
|
func (c *Client) Discover(serviceName string) ([]string, error) {
ctx, cancel := thrift.NewContext(time.Second)
defer cancel()
result, err := c.hyperbahnClient.Discover(ctx, &hyperbahn.DiscoveryQuery{ServiceName: serviceName})
if err != nil {
return nil, err
}
var hostPorts []string
for _, peer := range result.GetPeers() {
hostPorts = append(hostPorts, servicePeerToHostPort(peer))
}
return hostPorts, nil
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/adt/interval_tree.go#L420-L430
|
func (ivt *IntervalTree) find(ivl Interval) (ret *intervalNode) {
f := func(n *intervalNode) bool {
if n.iv.Ivl != ivl {
return true
}
ret = n
return false
}
ivt.root.visit(&ivl, f)
return ret
}
|
https://github.com/hooklift/govix/blob/063702285520a992b920fc1575e305dc9ffd6ffe/cddvd.go#L178-L190
|
func BusTypeFromID(ID string) vmx.BusType {
var bus vmx.BusType
switch {
case strings.HasPrefix(ID, string(vmx.IDE)):
bus = vmx.IDE
case strings.HasPrefix(ID, string(vmx.SCSI)):
bus = vmx.SCSI
case strings.HasPrefix(ID, string(vmx.SATA)):
bus = vmx.SATA
}
return bus
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/cdp/easyjson.go#L972-L976
|
func (v BackendNode) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoCdp3(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/fetch/fetch.go#L219-L221
|
func (p *ContinueWithAuthParams) Do(ctx context.Context) (err error) {
return cdp.Execute(ctx, CommandContinueWithAuth, p, nil)
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/css/easyjson.go#L923-L927
|
func (v *StopRuleUsageTrackingReturns) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss6(&r, v)
return r.Error()
}
|
https://github.com/opentracing/opentracing-go/blob/659c90643e714681897ec2521c60567dd21da733/ext/tags.go#L169-L171
|
func (tag stringTagName) Set(span opentracing.Span, value string) {
span.SetTag(string(tag), value)
}
|
https://github.com/rightscale/rsc/blob/96079a1ee7238dae9cbb7efa77dd94a479d217bd/gen/goav2gen/api.go#L46-L72
|
func (a *APIAnalyzer) Analyze() (*gen.APIDescriptor, error) {
api := gen.APIDescriptor{
Version: a.Version,
Resources: make(map[string]*gen.Resource),
Types: make(map[string]*gen.ObjectDataType),
}
a.api = &api
sortedVerbs := []string{"get", "post", "put", "delete"}
paths := []string{}
for path := range a.Doc.Paths {
paths = append(paths, path)
}
sort.Strings(paths)
for _, path := range paths {
endpointMap := a.Doc.Paths[path]
for _, verb := range sortedVerbs {
if ep, ok := endpointMap[verb]; ok {
a.AnalyzeEndpoint(verb, path, ep)
}
}
}
a.finalize()
return &api, nil
}
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/app.go#L1787-L1804
|
func appMetricEnvs(w http.ResponseWriter, r *http.Request, t auth.Token) error {
a, err := getAppFromContext(r.URL.Query().Get(":app"), r)
if err != nil {
return err
}
allowed := permission.Check(t, permission.PermAppReadMetric,
contextsForApp(&a)...,
)
if !allowed {
return permission.ErrUnauthorized
}
w.Header().Set("Content-Type", "application/json")
metricMap, err := a.MetricEnvs()
if err != nil {
return err
}
return json.NewEncoder(w).Encode(metricMap)
}
|
https://github.com/uber/tchannel-go/blob/3c9ced6d946fe2fec6c915703a533e966c09e07a/mex.go#L304-L343
|
func (mexset *messageExchangeSet) newExchange(ctx context.Context, framePool FramePool,
msgType messageType, msgID uint32, bufferSize int) (*messageExchange, error) {
if mexset.log.Enabled(LogLevelDebug) {
mexset.log.Debugf("Creating new %s message exchange for [%v:%d]", mexset.name, msgType, msgID)
}
mex := &messageExchange{
msgType: msgType,
msgID: msgID,
ctx: ctx,
recvCh: make(chan *Frame, bufferSize),
errCh: newErrNotifier(),
mexset: mexset,
framePool: framePool,
}
mexset.Lock()
addErr := mexset.addExchange(mex)
mexset.Unlock()
if addErr != nil {
logger := mexset.log.WithFields(
LogField{"msgID", mex.msgID},
LogField{"msgType", mex.msgType},
LogField{"exchange", mexset.name},
)
if addErr == errMexSetShutdown {
logger.Warn("Attempted to create new mex after mexset shutdown.")
} else if addErr == errDuplicateMex {
logger.Warn("Duplicate msg ID for active and new mex.")
}
return nil, addErr
}
mexset.onAdded()
// TODO(mmihic): Put into a deadline ordered heap so we can garbage collected expired exchanges
return mex, nil
}
|
https://github.com/ChrisTrenkamp/goxpath/blob/c385f95c6022e7756e91beac5f5510872f7dcb7d/goxpath.go#L102-L108
|
func (xp XPathExec) MustExec(t tree.Node, opts ...FuncOpts) tree.Result {
res, err := xp.Exec(t, opts...)
if err != nil {
panic(err)
}
return res
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/integration/cluster.go#L1126-L1149
|
func (m *member) Metric(metricName string) (string, error) {
cfgtls := transport.TLSInfo{}
tr, err := transport.NewTimeoutTransport(cfgtls, time.Second, time.Second, time.Second)
if err != nil {
return "", err
}
cli := &http.Client{Transport: tr}
resp, err := cli.Get(m.ClientURLs[0].String() + "/metrics")
if err != nil {
return "", err
}
defer resp.Body.Close()
b, rerr := ioutil.ReadAll(resp.Body)
if rerr != nil {
return "", rerr
}
lines := strings.Split(string(b), "\n")
for _, l := range lines {
if strings.HasPrefix(l, metricName) {
return strings.Split(l, " ")[1], nil
}
}
return "", nil
}
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/event.go#L112-L144
|
func eventCancel(w http.ResponseWriter, r *http.Request, t auth.Token) error {
uuid := r.URL.Query().Get(":uuid")
if !bson.IsObjectIdHex(uuid) {
msg := fmt.Sprintf("uuid parameter is not ObjectId: %s", uuid)
return &errors.HTTP{Code: http.StatusBadRequest, Message: msg}
}
objID := bson.ObjectIdHex(uuid)
e, err := event.GetByID(objID)
if err != nil {
return &errors.HTTP{Code: http.StatusNotFound, Message: err.Error()}
}
reason := InputValue(r, "reason")
if reason == "" {
return &errors.HTTP{Code: http.StatusBadRequest, Message: "reason is mandatory"}
}
scheme, err := permission.SafeGet(e.AllowedCancel.Scheme)
if err != nil {
return err
}
allowed := permission.Check(t, scheme, e.AllowedCancel.Contexts...)
if !allowed {
return permission.ErrUnauthorized
}
err = e.TryCancel(reason, t.GetUserName())
if err != nil {
if err == event.ErrNotCancelable {
return &errors.HTTP{Code: http.StatusBadRequest, Message: err.Error()}
}
return err
}
w.WriteHeader(http.StatusNoContent)
return nil
}
|
https://github.com/containers/image/blob/da9ab3561ad2031aeb5e036b7cf2755d4e246fec/docker/docker_client.go#L632-L652
|
func (c *dockerClient) getExtensionsSignatures(ctx context.Context, ref dockerReference, manifestDigest digest.Digest) (*extensionSignatureList, error) {
path := fmt.Sprintf(extensionsSignaturePath, reference.Path(ref.ref), manifestDigest)
res, err := c.makeRequest(ctx, "GET", path, nil, nil, v2Auth, nil)
if err != nil {
return nil, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, errors.Wrapf(client.HandleErrorResponse(res), "Error downloading signatures for %s in %s", manifestDigest, ref.ref.Name())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
var parsedBody extensionSignatureList
if err := json.Unmarshal(body, &parsedBody); err != nil {
return nil, errors.Wrapf(err, "Error decoding signature list")
}
return &parsedBody, nil
}
|
https://github.com/gin-contrib/location/blob/0462caccbb9cc0b222a2d75a64830c360c603798/location.go#L51-L65
|
func Get(c *gin.Context) *url.URL {
v, ok := c.Get(key)
if !ok {
return nil
}
vv, ok := v.(*url.URL)
if !ok {
return nil
}
return vv
}
|
https://github.com/gobuffalo/buffalo/blob/7f360181f4ccd79dcc9dcea2c904a4801f194f04/default_context.go#L164-L166
|
func (d *DefaultContext) Bind(value interface{}) error {
return binding.Exec(d.Request(), value)
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/page/page.go#L81-L83
|
func (p *BringToFrontParams) Do(ctx context.Context) (err error) {
return cdp.Execute(ctx, CommandBringToFront, nil, nil)
}
|
https://github.com/pachyderm/pachyderm/blob/94fb2d536cb6852a77a49e8f777dc9c1bde2c723/src/server/pkg/hashtree/path.go#L74-L87
|
func ValidatePath(path string) error {
path = clean(path)
match, _ := regexp.MatchString("^[ -~]+$", path)
if !match {
return fmt.Errorf("path (%v) invalid: only printable ASCII characters allowed", path)
}
if IsGlob(path) {
return fmt.Errorf("path (%v) invalid: globbing character (%v) not allowed in path", path, globRegex.FindString(path))
}
return nil
}
|
https://github.com/justinfx/gofileseq/blob/2555f296b4493d1825f5f6fab4aa0ff51a8306cd/exp/cpp/export/export.go#L633-L676
|
func FindSequencesOnDisk(path *C.char, opts C.FileOption) (FileSequences, uint64, Error) {
fileOpts := []fileseq.FileOption{}
if opts.hiddenFiles {
fileOpts = append(fileOpts, fileseq.HiddenFiles)
}
if opts.singleFiles {
fileOpts = append(fileOpts, fileseq.SingleFiles)
}
switch fileseq.PadStyle(opts.padStyle) {
case fileseq.PadStyleHash1:
fileOpts = append(fileOpts, fileseq.FileOptPadStyleHash1)
fmt.Println("pad style hash1")
case fileseq.PadStyleHash4:
fileOpts = append(fileOpts, fileseq.FileOptPadStyleHash4)
fmt.Println("pad style hash4")
}
gopath := C.GoString(path)
seqs, err := fileseq.FindSequencesOnDisk(gopath, fileOpts...)
// fmt.Printf("export.go::DEBUG:results: %v\n", seqs)
if err != nil {
return nil, 0, C.CString(err.Error())
}
num := uint64(len(seqs))
size := uint64(unsafe.Sizeof(C.uint64_t(0)))
list := C.malloc(C.size_t(num * size))
startPtr := uintptr(unsafe.Pointer(list))
for i, seq := range seqs {
id := sFileSeqs.Add(seq)
// fmt.Printf("export.go::DEBUG:id: %v\n", id)
ptr := unsafe.Pointer(startPtr + uintptr(size*uint64(i)))
*(*C.uint64_t)(ptr) = C.uint64_t(id)
}
return FileSequences(list), num, nil
}
|
https://github.com/kpango/glg/blob/68d2670cb2dbff047331daad841149a82ac37796/glg.go#L279-L289
|
func (g *Glg) SetLevelMode(level LEVEL, mode MODE) *Glg {
lev, ok := g.logger.Load(level)
if ok {
l := lev.(*logger)
l.mode = mode
l.updateMode()
g.logger.Store(level, l)
}
return g
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/boskos/mason/storage.go#L58-L69
|
func (s *Storage) GetConfig(name string) (common.ResourcesConfig, error) {
i, err := s.configs.Get(name)
if err != nil {
return common.ResourcesConfig{}, err
}
var conf common.ResourcesConfig
conf, err = common.ItemToResourcesConfig(i)
if err != nil {
return common.ResourcesConfig{}, err
}
return conf, nil
}
|
https://github.com/golang/appengine/blob/54a98f90d1c46b7731eb8fb305d2a321c30ef610/cmd/aebundler/aebundler.go#L322-L342
|
func readFile(filename string) (hasMain bool, err error) {
var src []byte
src, err = ioutil.ReadFile(filename)
if err != nil {
return
}
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, filename, src, 0)
for _, decl := range file.Decls {
funcDecl, ok := decl.(*ast.FuncDecl)
if !ok {
continue
}
if !isMain(funcDecl) {
continue
}
hasMain = true
break
}
return
}
|
https://github.com/lxc/lxd/blob/7a41d14e4c1a6bc25918aca91004d594774dcdd3/client/lxd_certificates.go#L34-L44
|
func (r *ProtocolLXD) GetCertificates() ([]api.Certificate, error) {
certificates := []api.Certificate{}
// Fetch the raw value
_, err := r.queryStruct("GET", "/certificates?recursion=1", nil, "", &certificates)
if err != nil {
return nil, err
}
return certificates, nil
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/mvcc/backend/batch_tx.go#L195-L197
|
func (t *batchTx) UnsafeForEach(bucketName []byte, visitor func(k, v []byte) error) error {
return unsafeForEach(t.tx, bucketName, visitor)
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/prow/spyglass/spyglass.go#L98-L125
|
func (s *Spyglass) Lenses(matchCache map[string][]string) []lenses.Lens {
ls := []lenses.Lens{}
for lensName, matches := range matchCache {
if len(matches) == 0 {
continue
}
lens, err := lenses.GetLens(lensName)
if err != nil {
logrus.WithField("lensName", lens).WithError(err).Error("Could not find artifact lens")
} else {
ls = append(ls, lens)
}
}
// Make sure lenses are rendered in order by ascending priority
sort.Slice(ls, func(i, j int) bool {
iconf := ls[i].Config()
jconf := ls[j].Config()
iname := iconf.Name
jname := jconf.Name
pi := iconf.Priority
pj := jconf.Priority
if pi == pj {
return iname < jname
}
return pi < pj
})
return ls
}
|
https://github.com/Knetic/govaluate/blob/9aa49832a739dcd78a5542ff189fb82c3e423116/evaluationStage.go#L488-L497
|
func comparatorTypeCheck(left interface{}, right interface{}) bool {
if isFloat64(left) && isFloat64(right) {
return true
}
if isString(left) && isString(right) {
return true
}
return false
}
|
https://github.com/t3rm1n4l/nitro/blob/937fe99f63a01a8bea7661c49e2f3f8af6541d7c/item.go#L108-L111
|
func ItemSize(p unsafe.Pointer) int {
itm := (*Item)(p)
return int(itemHeaderSize + uintptr(itm.dataLen))
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/server.go#L277-L619
|
func NewServer(cfg ServerConfig) (srv *EtcdServer, err error) {
st := v2store.New(StoreClusterPrefix, StoreKeysPrefix)
var (
w *wal.WAL
n raft.Node
s *raft.MemoryStorage
id types.ID
cl *membership.RaftCluster
)
if cfg.MaxRequestBytes > recommendedMaxRequestBytes {
if cfg.Logger != nil {
cfg.Logger.Warn(
"exceeded recommended requet limit",
zap.Uint("max-request-bytes", cfg.MaxRequestBytes),
zap.String("max-request-size", humanize.Bytes(uint64(cfg.MaxRequestBytes))),
zap.Int("recommended-request-bytes", recommendedMaxRequestBytes),
zap.String("recommended-request-size", humanize.Bytes(uint64(recommendedMaxRequestBytes))),
)
} else {
plog.Warningf("MaxRequestBytes %v exceeds maximum recommended size %v", cfg.MaxRequestBytes, recommendedMaxRequestBytes)
}
}
if terr := fileutil.TouchDirAll(cfg.DataDir); terr != nil {
return nil, fmt.Errorf("cannot access data directory: %v", terr)
}
haveWAL := wal.Exist(cfg.WALDir())
if err = fileutil.TouchDirAll(cfg.SnapDir()); err != nil {
if cfg.Logger != nil {
cfg.Logger.Fatal(
"failed to create snapshot directory",
zap.String("path", cfg.SnapDir()),
zap.Error(err),
)
} else {
plog.Fatalf("create snapshot directory error: %v", err)
}
}
ss := snap.New(cfg.Logger, cfg.SnapDir())
bepath := cfg.backendPath()
beExist := fileutil.Exist(bepath)
be := openBackend(cfg)
defer func() {
if err != nil {
be.Close()
}
}()
prt, err := rafthttp.NewRoundTripper(cfg.PeerTLSInfo, cfg.peerDialTimeout())
if err != nil {
return nil, err
}
var (
remotes []*membership.Member
snapshot *raftpb.Snapshot
)
switch {
case !haveWAL && !cfg.NewCluster:
if err = cfg.VerifyJoinExisting(); err != nil {
return nil, err
}
cl, err = membership.NewClusterFromURLsMap(cfg.Logger, cfg.InitialClusterToken, cfg.InitialPeerURLsMap)
if err != nil {
return nil, err
}
existingCluster, gerr := GetClusterFromRemotePeers(cfg.Logger, getRemotePeerURLs(cl, cfg.Name), prt)
if gerr != nil {
return nil, fmt.Errorf("cannot fetch cluster info from peer urls: %v", gerr)
}
if err = membership.ValidateClusterAndAssignIDs(cfg.Logger, cl, existingCluster); err != nil {
return nil, fmt.Errorf("error validating peerURLs %s: %v", existingCluster, err)
}
if !isCompatibleWithCluster(cfg.Logger, cl, cl.MemberByName(cfg.Name).ID, prt) {
return nil, fmt.Errorf("incompatible with current running cluster")
}
remotes = existingCluster.Members()
cl.SetID(types.ID(0), existingCluster.ID())
cl.SetStore(st)
cl.SetBackend(be)
id, n, s, w = startNode(cfg, cl, nil)
cl.SetID(id, existingCluster.ID())
case !haveWAL && cfg.NewCluster:
if err = cfg.VerifyBootstrap(); err != nil {
return nil, err
}
cl, err = membership.NewClusterFromURLsMap(cfg.Logger, cfg.InitialClusterToken, cfg.InitialPeerURLsMap)
if err != nil {
return nil, err
}
m := cl.MemberByName(cfg.Name)
if isMemberBootstrapped(cfg.Logger, cl, cfg.Name, prt, cfg.bootstrapTimeout()) {
return nil, fmt.Errorf("member %s has already been bootstrapped", m.ID)
}
if cfg.ShouldDiscover() {
var str string
str, err = v2discovery.JoinCluster(cfg.Logger, cfg.DiscoveryURL, cfg.DiscoveryProxy, m.ID, cfg.InitialPeerURLsMap.String())
if err != nil {
return nil, &DiscoveryError{Op: "join", Err: err}
}
var urlsmap types.URLsMap
urlsmap, err = types.NewURLsMap(str)
if err != nil {
return nil, err
}
if checkDuplicateURL(urlsmap) {
return nil, fmt.Errorf("discovery cluster %s has duplicate url", urlsmap)
}
if cl, err = membership.NewClusterFromURLsMap(cfg.Logger, cfg.InitialClusterToken, urlsmap); err != nil {
return nil, err
}
}
cl.SetStore(st)
cl.SetBackend(be)
id, n, s, w = startNode(cfg, cl, cl.MemberIDs())
cl.SetID(id, cl.ID())
case haveWAL:
if err = fileutil.IsDirWriteable(cfg.MemberDir()); err != nil {
return nil, fmt.Errorf("cannot write to member directory: %v", err)
}
if err = fileutil.IsDirWriteable(cfg.WALDir()); err != nil {
return nil, fmt.Errorf("cannot write to WAL directory: %v", err)
}
if cfg.ShouldDiscover() {
if cfg.Logger != nil {
cfg.Logger.Warn(
"discovery token is ignored since cluster already initialized; valid logs are found",
zap.String("wal-dir", cfg.WALDir()),
)
} else {
plog.Warningf("discovery token ignored since a cluster has already been initialized. Valid log found at %q", cfg.WALDir())
}
}
snapshot, err = ss.Load()
if err != nil && err != snap.ErrNoSnapshot {
return nil, err
}
if snapshot != nil {
if err = st.Recovery(snapshot.Data); err != nil {
if cfg.Logger != nil {
cfg.Logger.Panic("failed to recover from snapshot")
} else {
plog.Panicf("recovered store from snapshot error: %v", err)
}
}
if cfg.Logger != nil {
cfg.Logger.Info(
"recovered v2 store from snapshot",
zap.Uint64("snapshot-index", snapshot.Metadata.Index),
zap.String("snapshot-size", humanize.Bytes(uint64(snapshot.Size()))),
)
} else {
plog.Infof("recovered store from snapshot at index %d", snapshot.Metadata.Index)
}
if be, err = recoverSnapshotBackend(cfg, be, *snapshot); err != nil {
if cfg.Logger != nil {
cfg.Logger.Panic("failed to recover v3 backend from snapshot", zap.Error(err))
} else {
plog.Panicf("recovering backend from snapshot error: %v", err)
}
}
if cfg.Logger != nil {
s1, s2 := be.Size(), be.SizeInUse()
cfg.Logger.Info(
"recovered v3 backend from snapshot",
zap.Int64("backend-size-bytes", s1),
zap.String("backend-size", humanize.Bytes(uint64(s1))),
zap.Int64("backend-size-in-use-bytes", s2),
zap.String("backend-size-in-use", humanize.Bytes(uint64(s2))),
)
}
}
if !cfg.ForceNewCluster {
id, cl, n, s, w = restartNode(cfg, snapshot)
} else {
id, cl, n, s, w = restartAsStandaloneNode(cfg, snapshot)
}
cl.SetStore(st)
cl.SetBackend(be)
cl.Recover(api.UpdateCapability)
if cl.Version() != nil && !cl.Version().LessThan(semver.Version{Major: 3}) && !beExist {
os.RemoveAll(bepath)
return nil, fmt.Errorf("database file (%v) of the backend is missing", bepath)
}
default:
return nil, fmt.Errorf("unsupported bootstrap config")
}
if terr := fileutil.TouchDirAll(cfg.MemberDir()); terr != nil {
return nil, fmt.Errorf("cannot access member directory: %v", terr)
}
sstats := stats.NewServerStats(cfg.Name, id.String())
lstats := stats.NewLeaderStats(id.String())
heartbeat := time.Duration(cfg.TickMs) * time.Millisecond
srv = &EtcdServer{
readych: make(chan struct{}),
Cfg: cfg,
lgMu: new(sync.RWMutex),
lg: cfg.Logger,
errorc: make(chan error, 1),
v2store: st,
snapshotter: ss,
r: *newRaftNode(
raftNodeConfig{
lg: cfg.Logger,
isIDRemoved: func(id uint64) bool { return cl.IsIDRemoved(types.ID(id)) },
Node: n,
heartbeat: heartbeat,
raftStorage: s,
storage: NewStorage(w, ss),
},
),
id: id,
attributes: membership.Attributes{Name: cfg.Name, ClientURLs: cfg.ClientURLs.StringSlice()},
cluster: cl,
stats: sstats,
lstats: lstats,
SyncTicker: time.NewTicker(500 * time.Millisecond),
peerRt: prt,
reqIDGen: idutil.NewGenerator(uint16(id), time.Now()),
forceVersionC: make(chan struct{}),
AccessController: &AccessController{CORS: cfg.CORS, HostWhitelist: cfg.HostWhitelist},
}
serverID.With(prometheus.Labels{"server_id": id.String()}).Set(1)
srv.applyV2 = &applierV2store{store: srv.v2store, cluster: srv.cluster}
srv.be = be
minTTL := time.Duration((3*cfg.ElectionTicks)/2) * heartbeat
// always recover lessor before kv. When we recover the mvcc.KV it will reattach keys to its leases.
// If we recover mvcc.KV first, it will attach the keys to the wrong lessor before it recovers.
srv.lessor = lease.NewLessor(srv.getLogger(), srv.be, lease.LessorConfig{MinLeaseTTL: int64(math.Ceil(minTTL.Seconds())), CheckpointInterval: cfg.LeaseCheckpointInterval})
srv.kv = mvcc.New(srv.getLogger(), srv.be, srv.lessor, &srv.consistIndex)
if beExist {
kvindex := srv.kv.ConsistentIndex()
// TODO: remove kvindex != 0 checking when we do not expect users to upgrade
// etcd from pre-3.0 release.
if snapshot != nil && kvindex < snapshot.Metadata.Index {
if kvindex != 0 {
return nil, fmt.Errorf("database file (%v index %d) does not match with snapshot (index %d)", bepath, kvindex, snapshot.Metadata.Index)
}
if cfg.Logger != nil {
cfg.Logger.Warn(
"consistent index was never saved",
zap.Uint64("snapshot-index", snapshot.Metadata.Index),
)
} else {
plog.Warningf("consistent index never saved (snapshot index=%d)", snapshot.Metadata.Index)
}
}
}
newSrv := srv // since srv == nil in defer if srv is returned as nil
defer func() {
// closing backend without first closing kv can cause
// resumed compactions to fail with closed tx errors
if err != nil {
newSrv.kv.Close()
}
}()
srv.consistIndex.setConsistentIndex(srv.kv.ConsistentIndex())
tp, err := auth.NewTokenProvider(cfg.Logger, cfg.AuthToken,
func(index uint64) <-chan struct{} {
return srv.applyWait.Wait(index)
},
)
if err != nil {
if cfg.Logger != nil {
cfg.Logger.Warn("failed to create token provider", zap.Error(err))
} else {
plog.Errorf("failed to create token provider: %s", err)
}
return nil, err
}
srv.authStore = auth.NewAuthStore(srv.getLogger(), srv.be, tp, int(cfg.BcryptCost))
if num := cfg.AutoCompactionRetention; num != 0 {
srv.compactor, err = v3compactor.New(cfg.Logger, cfg.AutoCompactionMode, num, srv.kv, srv)
if err != nil {
return nil, err
}
srv.compactor.Run()
}
srv.applyV3Base = srv.newApplierV3Backend()
if err = srv.restoreAlarms(); err != nil {
return nil, err
}
srv.lessor.SetCheckpointer(func(ctx context.Context, cp *pb.LeaseCheckpointRequest) {
srv.raftRequestOnce(ctx, pb.InternalRaftRequest{LeaseCheckpoint: cp})
})
// TODO: move transport initialization near the definition of remote
tr := &rafthttp.Transport{
Logger: cfg.Logger,
TLSInfo: cfg.PeerTLSInfo,
DialTimeout: cfg.peerDialTimeout(),
ID: id,
URLs: cfg.PeerURLs,
ClusterID: cl.ID(),
Raft: srv,
Snapshotter: ss,
ServerStats: sstats,
LeaderStats: lstats,
ErrorC: srv.errorc,
}
if err = tr.Start(); err != nil {
return nil, err
}
// add all remotes into transport
for _, m := range remotes {
if m.ID != id {
tr.AddRemote(m.ID, m.PeerURLs)
}
}
for _, m := range cl.Members() {
if m.ID != id {
tr.AddPeer(m.ID, m.PeerURLs)
}
}
srv.r.transport = tr
return srv, nil
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/domdebugger/easyjson.go#L390-L394
|
func (v *RemoveXHRBreakpointParams) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoDomdebugger4(&r, v)
return r.Error()
}
|
https://github.com/taskcluster/taskcluster-client-go/blob/ef6acd428ae5844a933792ed6479d0e7dca61ef8/tcsecrets/tcsecrets.go#L171-L182
|
func (secrets *Secrets) List(continuationToken, limit string) (*SecretsList, error) {
v := url.Values{}
if continuationToken != "" {
v.Add("continuationToken", continuationToken)
}
if limit != "" {
v.Add("limit", limit)
}
cd := tcclient.Client(*secrets)
responseObject, _, err := (&cd).APICall(nil, "GET", "/secrets", new(SecretsList), v)
return responseObject.(*SecretsList), err
}
|
https://github.com/pachyderm/pachyderm/blob/94fb2d536cb6852a77a49e8f777dc9c1bde2c723/src/client/pfs.go#L1021-L1031
|
func (c APIClient) CopyFile(srcRepo, srcCommit, srcPath, dstRepo, dstCommit, dstPath string, overwrite bool) error {
if _, err := c.PfsAPIClient.CopyFile(c.Ctx(),
&pfs.CopyFileRequest{
Src: NewFile(srcRepo, srcCommit, srcPath),
Dst: NewFile(dstRepo, dstCommit, dstPath),
Overwrite: overwrite,
}); err != nil {
return grpcutil.ScrubGRPC(err)
}
return nil
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/pkg/ghclient/wrappers.go#L54-L82
|
func (c *Client) CreateIssue(org, repo, title, body string, labels, assignees []string) (*github.Issue, error) {
glog.Infof("CreateIssue(dry=%t) Title:%q, Labels:%q, Assignees:%q\n", c.dryRun, title, labels, assignees)
if c.dryRun {
return nil, nil
}
issue := &github.IssueRequest{
Title: &title,
Body: &body,
}
if len(labels) > 0 {
issue.Labels = &labels
}
if len(assignees) > 0 {
issue.Assignees = &assignees
}
var result *github.Issue
_, err := c.retry(
fmt.Sprintf("creating issue '%s'", title),
func() (*github.Response, error) {
var resp *github.Response
var err error
result, resp, err = c.issueService.Create(context.Background(), org, repo, issue)
return resp, err
},
)
return result, err
}
|
https://github.com/uber/tchannel-go/blob/3c9ced6d946fe2fec6c915703a533e966c09e07a/benchmark/tcp_raw_relay.go#L55-L59
|
func NewTCPRawRelay(dests []string) (Relay, error) {
return newTCPRelay(dests, func(_ bool, src, dst net.Conn) {
io.Copy(src, dst)
})
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/dom/dom.go#L865-L874
|
func (p *PushNodeByPathToFrontendParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
// execute
var res PushNodeByPathToFrontendReturns
err = cdp.Execute(ctx, CommandPushNodeByPathToFrontend, p, &res)
if err != nil {
return 0, err
}
return res.NodeID, nil
}
|
https://github.com/fossapps/pushy/blob/4c6045d7a1d3c310d61168ff1ccd5421d5c162f6/pushy.go#L16-L21
|
func Create(APIToken string, APIEndpoint string) *Pushy {
return &Pushy{
APIToken: APIToken,
APIEndpoint: APIEndpoint,
}
}
|
https://github.com/rightscale/rsc/blob/96079a1ee7238dae9cbb7efa77dd94a479d217bd/rl10/codegen_client.go#L1128-L1130
|
func (api *API) TSSPluginLocator(href string) *TSSPluginLocator {
return &TSSPluginLocator{Href(href), api}
}
|
https://github.com/opentracing/opentracing-go/blob/659c90643e714681897ec2521c60567dd21da733/span.go#L168-L189
|
func (ld *LogData) ToLogRecord() LogRecord {
var literalTimestamp time.Time
if ld.Timestamp.IsZero() {
literalTimestamp = time.Now()
} else {
literalTimestamp = ld.Timestamp
}
rval := LogRecord{
Timestamp: literalTimestamp,
}
if ld.Payload == nil {
rval.Fields = []log.Field{
log.String("event", ld.Event),
}
} else {
rval.Fields = []log.Field{
log.String("event", ld.Event),
log.Object("payload", ld.Payload),
}
}
return rval
}
|
https://github.com/kubicorn/kubicorn/blob/c4a4b80994b4333709c0f8164faabd801866b986/cmd/adopt.go#L24-L36
|
func AdoptCmd() *cobra.Command {
return &cobra.Command{
Use: "adopt",
Short: "Adopt a Kubernetes cluster into a Kubicorn state store",
Long: `Use this command to audit and adopt a Kubernetes cluster into a Kubicorn state store.
This command will query cloud resources and attempt to build a representation of the cluster in the Kubicorn API model.
Once the cluster has been adopted, a user can manage and scale their Kubernetes cluster with Kubicorn.`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("adopt called")
},
}
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/target/easyjson.go#L839-L843
|
func (v GetTargetInfoReturns) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoTarget8(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/xwb1989/sqlparser/blob/120387863bf27d04bc07db8015110a6e96d0146c/ast.go#L48-L59
|
func Parse(sql string) (Statement, error) {
tokenizer := NewStringTokenizer(sql)
if yyParse(tokenizer) != 0 {
if tokenizer.partialDDL != nil {
log.Printf("ignoring error parsing DDL '%s': %v", sql, tokenizer.LastError)
tokenizer.ParseTree = tokenizer.partialDDL
return tokenizer.ParseTree, nil
}
return nil, tokenizer.LastError
}
return tokenizer.ParseTree, nil
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/clientv3/balancer/resolver/endpoint/endpoint.go#L93-L95
|
func (e *ResolverGroup) Target(endpoint string) string {
return Target(e.id, endpoint)
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/prow/plugins/plugins.go#L156-L170
|
func NewAgent(configAgent *config.Agent, pluginConfigAgent *ConfigAgent, clientAgent *ClientAgent, logger *logrus.Entry) Agent {
prowConfig := configAgent.Config()
pluginConfig := pluginConfigAgent.Config()
return Agent{
GitHubClient: clientAgent.GitHubClient,
KubernetesClient: clientAgent.KubernetesClient,
ProwJobClient: clientAgent.ProwJobClient,
GitClient: clientAgent.GitClient,
SlackClient: clientAgent.SlackClient,
OwnersClient: clientAgent.OwnersClient,
Config: prowConfig,
PluginConfig: pluginConfig,
Logger: logger,
}
}
|
https://github.com/pachyderm/pachyderm/blob/94fb2d536cb6852a77a49e8f777dc9c1bde2c723/src/server/pkg/deploy/assets/assets.go#L1271-L1277
|
func AmazonIAMRoleSecret(region, bucket, distribution string) map[string][]byte {
return map[string][]byte{
"amazon-region": []byte(region),
"amazon-bucket": []byte(bucket),
"amazon-distribution": []byte(distribution),
}
}
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/auth.go#L73-L108
|
func createUser(w http.ResponseWriter, r *http.Request) error {
registrationEnabled, _ := config.GetBool("auth:user-registration")
if !registrationEnabled {
token := r.Header.Get("Authorization")
t, err := app.AuthScheme.Auth(token)
if err != nil {
return createDisabledErr
}
if !permission.Check(t, permission.PermUserCreate) {
return createDisabledErr
}
}
email := InputValue(r, "email")
password := InputValue(r, "password")
evt, err := event.New(&event.Opts{
Target: userTarget(email),
Kind: permission.PermUserCreate,
RawOwner: event.Owner{Type: event.OwnerTypeUser, Name: email},
CustomData: event.FormToCustomData(InputFields(r, "password")),
Allowed: event.Allowed(permission.PermUserReadEvents, permission.Context(permTypes.CtxUser, email)),
})
if err != nil {
return err
}
defer func() { evt.Done(err) }()
u := auth.User{
Email: email,
Password: password,
}
_, err = app.AuthScheme.Create(&u)
if err != nil {
return handleAuthError(err)
}
w.WriteHeader(http.StatusCreated)
return nil
}
|
https://github.com/containers/image/blob/da9ab3561ad2031aeb5e036b7cf2755d4e246fec/image/docker_schema1.go#L95-L97
|
func (m *manifestSchema1) Inspect(context.Context) (*types.ImageInspectInfo, error) {
return m.m.Inspect(nil)
}
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/api/service_instance.go#L540-L561
|
func servicePlans(w http.ResponseWriter, r *http.Request, t auth.Token) error {
serviceName := r.URL.Query().Get(":name")
s, err := getService(serviceName)
if err != nil {
return err
}
if s.IsRestricted {
allowed := permission.Check(t, permission.PermServiceReadPlans,
contextsForService(&s)...,
)
if !allowed {
return permission.ErrUnauthorized
}
}
requestID := requestIDHeader(r)
plans, err := service.GetPlansByService(s, requestID)
if err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(plans)
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/domdebugger/domdebugger.go#L128-L130
|
func (p *RemoveEventListenerBreakpointParams) Do(ctx context.Context) (err error) {
return cdp.Execute(ctx, CommandRemoveEventListenerBreakpoint, p, nil)
}
|
https://github.com/lxc/lxd/blob/7a41d14e4c1a6bc25918aca91004d594774dcdd3/lxd/endpoints/network.go#L27-L32
|
func (e *Endpoints) NetworkPrivateKey() []byte {
e.mu.RLock()
defer e.mu.RUnlock()
return e.cert.PrivateKey()
}
|
https://github.com/mikespook/possum/blob/56d7ebb6470b670001632b11be7fc089038f4dd7/helper.go#L50-L56
|
func WrapHTTPHandlerFunc(f http.HandlerFunc) HandlerFunc {
newF := func(ctx *Context) error {
f(ctx.Response, ctx.Request)
return nil
}
return newF
}
|
https://github.com/containers/image/blob/da9ab3561ad2031aeb5e036b7cf2755d4e246fec/docker/archive/transport.go#L29-L31
|
func (t archiveTransport) ParseReference(reference string) (types.ImageReference, error) {
return ParseReference(reference)
}
|
https://github.com/stellar/go-stellar-base/blob/79c570612c0b461db178aa8949d9f13cafc2a7c9/xdr/xdr_generated.go#L2210-L2245
|
func NewMemo(aType MemoType, value interface{}) (result Memo, err error) {
result.Type = aType
switch MemoType(aType) {
case MemoTypeMemoNone:
// void
case MemoTypeMemoText:
tv, ok := value.(string)
if !ok {
err = fmt.Errorf("invalid value, must be string")
return
}
result.Text = &tv
case MemoTypeMemoId:
tv, ok := value.(Uint64)
if !ok {
err = fmt.Errorf("invalid value, must be Uint64")
return
}
result.Id = &tv
case MemoTypeMemoHash:
tv, ok := value.(Hash)
if !ok {
err = fmt.Errorf("invalid value, must be Hash")
return
}
result.Hash = &tv
case MemoTypeMemoReturn:
tv, ok := value.(Hash)
if !ok {
err = fmt.Errorf("invalid value, must be Hash")
return
}
result.RetHash = &tv
}
return
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/heapprofiler/easyjson.go#L70-L74
|
func (v TakeHeapSnapshotParams) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoHeapprofiler(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/debugger/easyjson.go#L1618-L1622
|
func (v *SetBlackboxedRangesParams) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger16(&r, v)
return r.Error()
}
|
https://github.com/mgutz/str/blob/968bf66e3da857419e4f6e71b2d5c9ae95682dc4/funcsPZ.go#L36-L42
|
func PadLeft(s, c string, n int) string {
L := len(s)
if L > n {
return s
}
return strings.Repeat(c, (n-L)) + s
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/css/easyjson.go#L5895-L5899
|
func (v *EventStyleSheetChanged) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss52(&r, v)
return r.Error()
}
|
https://github.com/gobuffalo/buffalo/blob/7f360181f4ccd79dcc9dcea2c904a4801f194f04/genny/build/validate.go#L24-L63
|
func ValidateTemplates(walk packd.Walker, tvs []TemplateValidator) genny.RunFn {
if len(tvs) == 0 {
return func(r *genny.Runner) error {
return nil
}
}
return func(r *genny.Runner) error {
var errs []string
err := packd.SkipWalker(walk, packd.CommonSkipPrefixes, func(path string, file packd.File) error {
info, err := file.FileInfo()
if err != nil {
return err
}
if info.IsDir() {
return nil
}
f := genny.NewFile(path, file)
for _, tv := range tvs {
err := safe.Run(func() {
if err := tv(f); err != nil {
errs = append(errs, fmt.Sprintf("template error in file %s: %s", path, err.Error()))
}
})
if err != nil {
return err
}
}
return nil
})
if err != nil {
return err
}
if len(errs) == 0 {
return nil
}
return errors.New(strings.Join(errs, "\n"))
}
}
|
https://github.com/hashicorp/raft/blob/773bcaa2009bf059c5c06457b9fccd156d5e91e7/api.go#L695-L706
|
func (r *Raft) AddPeer(peer ServerAddress) Future {
if r.protocolVersion > 2 {
return errorFuture{ErrUnsupportedProtocol}
}
return r.requestConfigChange(configurationChangeRequest{
command: AddStaging,
serverID: ServerID(peer),
serverAddress: peer,
prevIndex: 0,
}, 0)
}
|
https://github.com/256dpi/fire/blob/fa66e74352b30b9a4c730f7b8dc773302941b0fb/flame/models.go#L214-L216
|
func (u *User) ValidPassword(password string) bool {
return bcrypt.CompareHashAndPassword(u.PasswordHash, []byte(password)) == nil
}
|
https://github.com/uber/tchannel-go/blob/3c9ced6d946fe2fec6c915703a533e966c09e07a/localip.go#L89-L95
|
func ListenIP() (net.IP, error) {
interfaces, err := net.Interfaces()
if err != nil {
return nil, err
}
return listenIP(interfaces)
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/pkg/transport/listener.go#L324-L330
|
func (info TLSInfo) cafiles() []string {
cs := make([]string, 0)
if info.TrustedCAFile != "" {
cs = append(cs, info.TrustedCAFile)
}
return cs
}
|
https://github.com/jhillyerd/enmime/blob/874cc30e023f36bd1df525716196887b0f04851b/encode.go#L131-L152
|
func (p *Part) encodeHeader(b *bufio.Writer) {
keys := make([]string, 0, len(p.Header))
for k := range p.Header {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
for _, v := range p.Header[k] {
encv := v
switch selectTransferEncoding([]byte(v), true) {
case teBase64:
encv = mime.BEncoding.Encode(utf8, v)
case teQuoted:
encv = mime.QEncoding.Encode(utf8, v)
}
// _ used to prevent early wrapping
wb := stringutil.Wrap(76, k, ":_", encv, "\r\n")
wb[len(k)+1] = ' '
b.Write(wb)
}
}
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/page/easyjson.go#L1384-L1388
|
func (v *SearchInResourceReturns) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage15(&r, v)
return r.Error()
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/cdp/types.go#L624-L626
|
func (t *MonotonicTime) UnmarshalEasyJSON(in *jlexer.Lexer) {
*t = MonotonicTime(MonotonicTimeEpoch.Add(time.Duration(in.Float64() * float64(time.Second))))
}
|
https://github.com/delicb/gstring/blob/77637d5e476b8e22d81f6a7bc5311a836dceb1c2/gstring.go#L123-L126
|
func Printm(format string, args map[string]interface{}) (n int, err error) {
f, a := gformat(format, args)
return fmt.Printf(f, a...)
}
|
https://github.com/lxc/lxd/blob/7a41d14e4c1a6bc25918aca91004d594774dcdd3/lxd/cluster/membership.go#L869-L894
|
func membershipCheckClusterStateForAccept(tx *db.ClusterTx, name string, address string, schema int, api int) error {
nodes, err := tx.Nodes()
if err != nil {
return errors.Wrap(err, "failed to fetch current cluster nodes")
}
if len(nodes) == 1 && nodes[0].Address == "0.0.0.0" {
return fmt.Errorf("clustering not enabled")
}
for _, node := range nodes {
if node.Name == name {
return fmt.Errorf("cluster already has node with name %s", name)
}
if node.Address == address {
return fmt.Errorf("cluster already has node with address %s", address)
}
if node.Schema != schema {
return fmt.Errorf("schema version mismatch: cluster has %d", node.Schema)
}
if node.APIExtensions != api {
return fmt.Errorf("API version mismatch: cluster has %d", node.APIExtensions)
}
}
return nil
}
|
https://github.com/segmentio/nsq-go/blob/ff4eef968f46eb580d9dba4f637c5dfb1e5b2208/cmd/nsq-to-http/main.go#L143-L156
|
func backoff(rand *rand.Rand, attempt int, min, max time.Duration) time.Duration {
if attempt <= 0 {
panic("tube.Backoff: attempt <= 0")
}
if min > max {
panic("tube.Backoff: min > max")
}
// Hardcoded backoff coefficient, maybe we'll make it configuration in the
// future?
const coeff = 2.0
return jitteredBackoff(rand, attempt, min, max, coeff)
}
|
https://github.com/tsuru/tsuru/blob/2f7fd515c5dc25a58aec80f0e497c49e49581b3e/cmd/tsurud/checker.go#L66-L83
|
func checkDocker() error {
if _, err := config.Get("docker"); err != nil {
return errors.New("Config error: you should configure docker.")
}
err := checkDockerBasicConfig()
if err != nil {
return err
}
err = checkScheduler()
if err != nil {
return err
}
err = checkRouter()
if err != nil {
return err
}
return checkCluster()
}
|
https://github.com/etcd-io/etcd/blob/616592d9ba993e3fe9798eef581316016df98906/etcdserver/etcdserverpb/gw/rpc.pb.gw.go#L897-L929
|
func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error {
mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
if cn, ok := w.(http.CloseNotifier); ok {
go func(done <-chan struct{}, closed <-chan bool) {
select {
case <-done:
case <-closed:
cancel()
}
}(ctx.Done(), cn.CloseNotify())
}
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Watch_Watch_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Watch_Watch_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
})
return nil
}
|
https://github.com/mrd0ll4r/tbotapi/blob/edc257282178bb5cebbfcc41260ec04c1ec7ac19/api.go#L265-L277
|
func (api *TelegramBotAPI) GetMe() (*UserResponse, error) {
resp := &UserResponse{}
_, err := api.c.get(getMe, resp)
if err != nil {
return nil, err
}
err = check(&resp.baseResponse)
if err != nil {
return nil, err
}
return resp, nil
}
|
https://github.com/pact-foundation/pact-go/blob/467dea56d27e154363e1975f6e9f4dbf66148e79/dsl/pact.go#L698-L706
|
func (p *Pact) VerifyMessageConsumer(t *testing.T, message *Message, handler MessageConsumer) error {
err := p.VerifyMessageConsumerRaw(message, handler)
if err != nil {
t.Errorf("VerifyMessageConsumer failed: %v", err)
}
return err
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/webaudio/types.go#L110-L112
|
func (t *ContextState) UnmarshalJSON(buf []byte) error {
return easyjson.Unmarshal(buf, t)
}
|
https://github.com/insionng/martini/blob/2d0ba5dc75fe9549c10e2f71927803a11e5e4957/render.go#L418-L434
|
func Renderer(options ...RenderOptions) Handler {
opt := prepareRenderOptions(options)
cs := prepareCharset(opt.Charset)
t := compile(opt)
return func(res http.ResponseWriter, req *http.Request, c Context) {
var tc *template.Template
if Env == Dev {
// recompile for easy development
tc = compile(opt)
} else {
// use a clone of the initial template
tc, _ = t.Clone()
}
//c.MapTo(&Render{res, req, tc, opt, cs, Data}, (*Render)(nil))
c.Map(&Render{res, req, tc, opt, cs, Data})
}
}
|
https://github.com/naoina/genmai/blob/78583835e1e41e3938e1ddfffd7101f8ad27fae0/genmai.go#L1144-L1146
|
func (c *Condition) Or(cond interface{}, args ...interface{}) *Condition {
return c.appendQueryByCondOrExpr("Or", 100, Or, cond, args...)
}
|
https://github.com/apuigsech/seekret/blob/9b1f7ea1b3fd5bd29d93cf62102cb66e54428a49/models/rule.go#L77-L105
|
func (r *Rule) Run(content []byte) []RunResult {
var results []RunResult
b := bufio.NewScanner(bytes.NewReader(content))
nLine := 0
for b.Scan() {
nLine = nLine + 1
line := b.Text()
if r.Match.MatchString(line) {
unmatch := false
for _, Unmatch := range r.Unmatch {
if Unmatch.MatchString(line) {
unmatch = true
}
}
if !unmatch {
results = append(results, RunResult{
Line: line,
Nline: nLine,
})
}
}
}
return results
}
|
https://github.com/llgcode/draw2d/blob/f52c8a71aff06ab8df41843d33ab167b36c971cd/draw2dpdf/gc.go#L89-L93
|
func NewGraphicContext(pdf *gofpdf.Fpdf) *GraphicContext {
gc := &GraphicContext{draw2dbase.NewStackGraphicContext(), pdf, DPI}
gc.SetDPI(DPI)
return gc
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/debugger/types.go#L301-L311
|
func (t *ContinueToLocationTargetCallFrames) UnmarshalEasyJSON(in *jlexer.Lexer) {
switch ContinueToLocationTargetCallFrames(in.String()) {
case ContinueToLocationTargetCallFramesAny:
*t = ContinueToLocationTargetCallFramesAny
case ContinueToLocationTargetCallFramesCurrent:
*t = ContinueToLocationTargetCallFramesCurrent
default:
in.AddError(errors.New("unknown ContinueToLocationTargetCallFrames value"))
}
}
|
https://github.com/lxc/lxd/blob/7a41d14e4c1a6bc25918aca91004d594774dcdd3/lxd/db/containers.go#L749-L765
|
func (c *Cluster) LegacyContainersList(cType ContainerType) ([]string, error) {
q := fmt.Sprintf("SELECT name FROM containers WHERE type=? ORDER BY name")
inargs := []interface{}{cType}
var container string
outfmt := []interface{}{container}
result, err := queryScan(c.db, q, inargs, outfmt)
if err != nil {
return nil, err
}
var ret []string
for _, container := range result {
ret = append(ret, container[0].(string))
}
return ret, nil
}
|
https://github.com/segmentio/nsq-go/blob/ff4eef968f46eb580d9dba4f637c5dfb1e5b2208/producer.go#L74-L88
|
func NewProducer(config ProducerConfig) (p *Producer, err error) {
config.defaults()
p = &Producer{
reqs: make(chan ProducerRequest, config.MaxConcurrency),
done: make(chan struct{}),
address: config.Address,
topic: config.Topic,
dialTimeout: config.DialTimeout,
readTimeout: config.ReadTimeout,
writeTimeout: config.WriteTimeout,
}
return
}
|
https://github.com/go-opencv/go-opencv/blob/a4fe8ec027ccc9eb8b7d0797db7c76e61083f1db/opencv/cxcore.go#L735-L741
|
func AbsDiff(src1, src2, dst *IplImage) {
C.cvAbsDiff(
unsafe.Pointer(src1),
unsafe.Pointer(src2),
unsafe.Pointer(dst),
)
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/emulation/easyjson.go#L826-L830
|
func (v SetEmulatedMediaParams) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation9(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/weaveworks/mesh/blob/512bdb7b3cb7b2c939fcd0ee434d48b6732ecc39/meshconn/peer.go#L178-L182
|
func (p *Peer) OnGossipUnicast(_ mesh.PeerName, buf []byte) error {
pkt := makePkt(buf)
p.recv <- pkt // to ReadFrom
return nil
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/ghproxy/ghcache/ghcache.go#L195-L202
|
func NewFromCache(delegate http.RoundTripper, cache httpcache.Cache, maxConcurrency int) http.RoundTripper {
cacheTransport := httpcache.NewTransport(cache)
cacheTransport.Transport = newThrottlingTransport(maxConcurrency, upstreamTransport{delegate: delegate})
return &requestCoalescer{
keys: make(map[string]*responseWaiter),
delegate: cacheTransport,
}
}
|
https://github.com/stellar/go-stellar-base/blob/79c570612c0b461db178aa8949d9f13cafc2a7c9/xdr/xdr_generated.go#L5030-L5063
|
func NewLedgerKey(aType LedgerEntryType, value interface{}) (result LedgerKey, err error) {
result.Type = aType
switch LedgerEntryType(aType) {
case LedgerEntryTypeAccount:
tv, ok := value.(LedgerKeyAccount)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyAccount")
return
}
result.Account = &tv
case LedgerEntryTypeTrustline:
tv, ok := value.(LedgerKeyTrustLine)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyTrustLine")
return
}
result.TrustLine = &tv
case LedgerEntryTypeOffer:
tv, ok := value.(LedgerKeyOffer)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyOffer")
return
}
result.Offer = &tv
case LedgerEntryTypeData:
tv, ok := value.(LedgerKeyData)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyData")
return
}
result.Data = &tv
}
return
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/debugger/easyjson.go#L2726-L2730
|
func (v PauseParams) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger28(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/dom/dom.go#L1409-L1418
|
func (p *SetNodeNameParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
// execute
var res SetNodeNameReturns
err = cdp.Execute(ctx, CommandSetNodeName, p, &res)
if err != nil {
return 0, err
}
return res.NodeID, nil
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/indexeddb/easyjson.go#L609-L613
|
func (v RequestDataParams) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoIndexeddb5(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
https://github.com/kr/s3/blob/c070c8f9a8f0032d48f0d2a77d4e382788bd8a1d/sign.go#L98-L107
|
func (s *Service) Sign(r *http.Request, k Keys) {
if k.SecurityToken != "" {
r.Header.Set("X-Amz-Security-Token", k.SecurityToken)
}
h := hmac.New(sha1.New, []byte(k.SecretKey))
s.writeSigData(h, r)
sig := make([]byte, base64.StdEncoding.EncodedLen(h.Size()))
base64.StdEncoding.Encode(sig, h.Sum(nil))
r.Header.Set("Authorization", "AWS "+k.AccessKey+":"+string(sig))
}
|
https://github.com/segmentio/nsq-go/blob/ff4eef968f46eb580d9dba4f637c5dfb1e5b2208/response.go#L37-L48
|
func (r Response) Write(w *bufio.Writer) (err error) {
if err = writeFrameHeader(w, FrameTypeResponse, len(r)); err != nil {
err = errors.WithMessage(err, "writing response message")
}
if _, err = w.WriteString(string(r)); err != nil {
err = errors.Wrap(err, "writing response message")
return
}
return
}
|
https://github.com/kubernetes/test-infra/blob/8125fbda10178887be5dff9e901d6a0a519b67bc/prow/github/fakegithub/fakegithub.go#L259-L261
|
func (f *FakeClient) GetCombinedStatus(owner, repo, ref string) (*github.CombinedStatus, error) {
return f.CombinedStatuses[ref], nil
}
|
https://github.com/chromedp/cdproto/blob/d40c70bcdf242660a32f2eadf323662dd75378b5/applicationcache/easyjson.go#L818-L822
|
func (v EventApplicationCacheStatusUpdated) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
easyjsonC5a4559bEncodeGithubComChromedpCdprotoApplicationcache9(&w, v)
return w.Buffer.BuildBytes(), w.Error
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.