_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q13800 | ErrorWithLevel | train | func (c *Client) ErrorWithLevel(level string, err error) {
c.ErrorWithExtras(level, err, noExtras)
} | go | {
"resource": ""
} |
q13801 | Errorf | train | func (c *Client) Errorf(level string, format string, args ...interface{}) {
c.ErrorWithStackSkipWithExtras(level, fmt.Errorf(format, args...), 1, noExtras)
} | go | {
"resource": ""
} |
q13802 | ErrorWithExtras | train | func (c *Client) ErrorWithExtras(level string, err error, extras map[string]interface{}) {
c.ErrorWithStackSkipWithExtras(level, err, 1, extras)
} | go | {
"resource": ""
} |
q13803 | ErrorWithExtrasAndContext | train | func (c *Client) ErrorWithExtrasAndContext(ctx context.Context, level string, err error, extras map[string]interface{}) {
c.ErrorWithStackSkipWithExtrasAndContext(ctx, level, err, 1, extras)
} | go | {
"resource": ""
} |
q13804 | RequestError | train | func (c *Client) RequestError(level string, r *http.Request, err error) {
c.RequestErrorWithExtras(level, r, err, noExtras)
} | go | {
"resource": ""
} |
q13805 | RequestErrorWithExtras | train | func (c *Client) RequestErrorWithExtras(level string, r *http.Request, err error, extras map[string]interface{}) {
c.RequestErrorWithStackSkipWithExtras(level, r, err, 1, extras)
} | go | {
"resource": ""
} |
q13806 | RequestErrorWithExtrasAndContext | train | func (c *Client) RequestErrorWithExtrasAndContext(ctx context.Context, level string, r *http.Request, err error, extras map[string]interface{}) {
c.RequestErrorWithStackSkipWithExtrasAndContext(ctx, level, r, err, 1, extras)
} | go | {
"resource": ""
} |
q13807 | ErrorWithStackSkip | train | func (c *Client) ErrorWithStackSkip(level string, err error, skip int) {
c.ErrorWithStackSkipWithExtras(level, err, skip, noExtras)
} | go | {
"resource": ""
} |
q13808 | ErrorWithStackSkipWithExtras | train | func (c *Client) ErrorWithStackSkipWithExtras(level string, err error, skip int, extras map[string]interface{}) {
c.ErrorWithStackSkipWithExtrasAndContext(context.TODO(), level, err, skip, extras)
} | go | {
"resource": ""
} |
q13809 | ErrorWithStackSkipWithExtrasAndContext | train | func (c *Client) ErrorWithStackSkipWithExtrasAndContext(ctx context.Context, level string, err error, skip int, extras map[string]interface{}) {
if !c.configuration.enabled {
return
}
body := c.buildBody(ctx, level, err.Error(), extras)
addErrorToBody(c.configuration, body, err, skip)
c.push(body)
} | go | {
"resource": ""
} |
q13810 | RequestErrorWithStackSkip | train | func (c *Client) RequestErrorWithStackSkip(level string, r *http.Request, err error, skip int) {
c.RequestErrorWithStackSkipWithExtras(level, r, err, skip, noExtras)
} | go | {
"resource": ""
} |
q13811 | RequestErrorWithStackSkipWithExtras | train | func (c *Client) RequestErrorWithStackSkipWithExtras(level string, r *http.Request, err error, skip int, extras map[string]interface{}) {
c.RequestErrorWithStackSkipWithExtrasAndContext(context.TODO(), level, r, err, skip, extras)
} | go | {
"resource": ""
} |
q13812 | RequestErrorWithStackSkipWithExtrasAndContext | train | func (c *Client) RequestErrorWithStackSkipWithExtrasAndContext(ctx context.Context, level string, r *http.Request, err error, skip int, extras map[string]interface{}) {
if !c.configuration.enabled {
return
}
body := c.buildBody(ctx, level, err.Error(), extras)
data := addErrorToBody(c.configuration, body, err, skip)
data["request"] = c.requestDetails(r)
c.push(body)
} | go | {
"resource": ""
} |
q13813 | MessageWithExtras | train | func (c *Client) MessageWithExtras(level string, msg string, extras map[string]interface{}) {
c.MessageWithExtrasAndContext(context.TODO(), level, msg, extras)
} | go | {
"resource": ""
} |
q13814 | MessageWithExtrasAndContext | train | func (c *Client) MessageWithExtrasAndContext(ctx context.Context, level string, msg string, extras map[string]interface{}) {
if !c.configuration.enabled {
return
}
body := c.buildBody(ctx, level, msg, extras)
data := body["data"].(map[string]interface{})
data["body"] = messageBody(msg)
c.push(body)
} | go | {
"resource": ""
} |
q13815 | RequestMessage | train | func (c *Client) RequestMessage(level string, r *http.Request, msg string) {
c.RequestMessageWithExtras(level, r, msg, noExtras)
} | go | {
"resource": ""
} |
q13816 | RequestMessageWithExtras | train | func (c *Client) RequestMessageWithExtras(level string, r *http.Request, msg string, extras map[string]interface{}) {
c.RequestMessageWithExtrasAndContext(context.TODO(), level, r, msg, extras)
} | go | {
"resource": ""
} |
q13817 | RequestMessageWithExtrasAndContext | train | func (c *Client) RequestMessageWithExtrasAndContext(ctx context.Context, level string, r *http.Request, msg string, extras map[string]interface{}) {
if !c.configuration.enabled {
return
}
body := c.buildBody(ctx, level, msg, extras)
data := body["data"].(map[string]interface{})
data["body"] = messageBody(msg)
data["request"] = c.requestDetails(r)
c.push(body)
} | go | {
"resource": ""
} |
q13818 | NewPersonContext | train | func NewPersonContext(ctx context.Context, p *Person) context.Context {
return context.WithValue(ctx, personKey, p)
} | go | {
"resource": ""
} |
q13819 | PersonFromContext | train | func PersonFromContext(ctx context.Context) (*Person, bool) {
p, ok := ctx.Value(personKey).(*Person)
return p, ok
} | go | {
"resource": ""
} |
q13820 | clientPost | train | func clientPost(token, endpoint string, body map[string]interface{}, logger ClientLogger) (error, bool) {
if len(token) == 0 {
rollbarError(logger, "empty token")
return nil, false
}
jsonBody, err := json.Marshal(body)
if err != nil {
rollbarError(logger, "failed to encode payload: %s", err.Error())
return err, false
}
resp, err := http.Post(endpoint, "application/json", bytes.NewReader(jsonBody))
if err != nil {
rollbarError(logger, "POST failed: %s", err.Error())
return err, isTemporary(err)
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
rollbarError(logger, "received response: %s", resp.Status)
// http.StatusTooManyRequests is only defined in Go 1.6+ so we use 429 directly
isRateLimit := resp.StatusCode == 429
return ErrHTTPError(resp.StatusCode), isRateLimit
}
return nil, false
} | go | {
"resource": ""
} |
q13821 | NewAsyncTransport | train | func NewAsyncTransport(token string, endpoint string, buffer int) *AsyncTransport {
transport := &AsyncTransport{
Token: token,
Endpoint: endpoint,
Buffer: buffer,
RetryAttempts: DefaultRetryAttempts,
PrintPayloadOnError: true,
bodyChannel: make(chan payload, buffer),
}
go func() {
for p := range transport.bodyChannel {
err, canRetry := transport.post(p)
if err != nil {
if canRetry && p.retriesLeft > 0 {
p.retriesLeft -= 1
select {
case transport.bodyChannel <- p:
default:
// This can happen if the bodyChannel had an item added to it from another
// thread while we are processing such that the channel is now full. If we try
// to send the payload back to the channel without this select statement we
// could deadlock. Instead we consider this a retry failure.
if transport.PrintPayloadOnError {
writePayloadToStderr(transport.Logger, p.body)
}
transport.waitGroup.Done()
}
} else {
if transport.PrintPayloadOnError {
writePayloadToStderr(transport.Logger, p.body)
}
transport.waitGroup.Done()
}
} else {
transport.waitGroup.Done()
}
}
}()
return transport
} | go | {
"resource": ""
} |
q13822 | Send | train | func (t *AsyncTransport) Send(body map[string]interface{}) error {
if len(t.bodyChannel) < t.Buffer {
t.waitGroup.Add(1)
p := payload{
body: body,
retriesLeft: t.RetryAttempts,
}
t.bodyChannel <- p
} else {
err := ErrBufferFull{}
rollbarError(t.Logger, err.Error())
if t.PrintPayloadOnError {
writePayloadToStderr(t.Logger, body)
}
return err
}
return nil
} | go | {
"resource": ""
} |
q13823 | Close | train | func (t *AsyncTransport) Close() error {
close(t.bodyChannel)
t.Wait()
return nil
} | go | {
"resource": ""
} |
q13824 | Install | train | func (i *VCSInstaller) Install() error {
repo, err := vcs.NewRepo(i.Source, i.Path())
if err != nil {
return err
}
if err := i.sync(repo); err != nil {
return err
}
ref, err := i.solveVersion(repo)
if err != nil {
return err
}
if ref != "" {
if err := i.setVersion(repo, ref); err != nil {
return err
}
}
if !isRig(repo.LocalPath()) {
return rig.ErrDoesNotExist
}
return nil
} | go | {
"resource": ""
} |
q13825 | setVersion | train | func (i *VCSInstaller) setVersion(repo vcs.Repo, ref string) error {
return repo.UpdateVersion(ref)
} | go | {
"resource": ""
} |
q13826 | sync | train | func (i *VCSInstaller) sync(repo vcs.Repo) error {
if _, err := os.Stat(repo.LocalPath()); os.IsNotExist(err) {
return repo.Get()
}
return repo.Update()
} | go | {
"resource": ""
} |
q13827 | String | train | func String() string {
ver := "dev"
if strings.Compare(Version, "") != 0 {
ver = fmt.Sprintf("%s", Version)
}
if strings.Compare(BuildMetadata, "") != 0 {
ver = fmt.Sprintf("%s+%s", ver, BuildMetadata)
}
return ver
} | go | {
"resource": ""
} |
q13828 | Install | train | func Install(i Installer) error {
basePath := filepath.Dir(i.Path())
if _, pathErr := os.Stat(basePath); os.IsNotExist(pathErr) {
if err := os.MkdirAll(basePath, 0755); err != nil {
return err
}
}
if _, pathErr := os.Stat(i.Path()); !os.IsNotExist(pathErr) {
return i.Update()
}
return i.Install()
} | go | {
"resource": ""
} |
q13829 | Update | train | func Update(i Installer) error {
if _, pathErr := os.Stat(i.Path()); os.IsNotExist(pathErr) {
return rig.ErrDoesNotExist
}
return i.Update()
} | go | {
"resource": ""
} |
q13830 | New | train | func New(source, name, version string, home home.Home) (Installer, error) {
if isLocalReference(source) {
return NewLocalInstaller(source, name, home)
}
return NewVCSInstaller(source, name, version, home)
} | go | {
"resource": ""
} |
q13831 | isRig | train | func isRig(dirname string) bool {
_, err := os.Stat(filepath.Join(dirname, "Food"))
return err == nil
} | go | {
"resource": ""
} |
q13832 | Ohaif | train | func Ohaif(format string, a ...interface{}) (int, error) {
return fmt.Printf(fmt.Sprintf("==> %s", format), a...)
} | go | {
"resource": ""
} |
q13833 | Warningf | train | func Warningf(format string, a ...interface{}) (int, error) {
return fmt.Printf(emoji.Sprintf("!!! %s", format), a...)
} | go | {
"resource": ""
} |
q13834 | NewFromReader | train | func NewFromReader(r io.Reader) (*InstallReceipt, error) {
var receipt InstallReceipt
err := json.NewDecoder(r).Decode(&receipt)
return &receipt, err
} | go | {
"resource": ""
} |
q13835 | Save | train | func (i *InstallReceipt) Save(w io.Writer) error {
data, err := json.MarshalIndent(i, "", " ")
if err != nil {
return err
}
_, err = w.Write(data)
w.Write([]byte("\n"))
return err
} | go | {
"resource": ""
} |
q13836 | ensureFood | train | func ensureFood() error {
ohai.Ohailn("Installing default fish food...")
addArgs := []string{
"https://github.com/fishworks/fish-food",
}
rigCmd, _, err := rootCmd.Find([]string{"rig", "add"})
if err != nil {
return err
}
return rigCmd.RunE(rigCmd, addArgs)
} | go | {
"resource": ""
} |
q13837 | NewLocalInstaller | train | func NewLocalInstaller(source string, name string, home home.Home) (*LocalInstaller, error) {
i := &LocalInstaller{
Source: source,
Home: home,
Name: name,
}
if i.Name == "" {
i.Name = filepath.Base(i.Source)
}
return i, nil
} | go | {
"resource": ""
} |
q13838 | Install | train | func (i *LocalInstaller) Install() error {
if !isRig(i.Source) {
return rig.ErrDoesNotExist
}
src, err := filepath.Abs(i.Source)
if err != nil {
return err
}
return i.link(src)
} | go | {
"resource": ""
} |
q13839 | link | train | func (i *LocalInstaller) link(from string) error {
origin, err := filepath.Abs(from)
if err != nil {
return err
}
dest, err := filepath.Abs(i.Path())
if err != nil {
return err
}
return os.Symlink(origin, dest)
} | go | {
"resource": ""
} |
q13840 | Uninstall | train | func (f *Food) Uninstall() error {
pkg := f.GetPackage(runtime.GOOS, runtime.GOARCH)
if pkg == nil {
return nil
}
if f.Linked() {
if err := f.Unlink(pkg); err != nil {
return err
}
}
barrelDir := filepath.Join(home.Home(home.HomePath).Barrel(), f.Name, f.Version)
os.Remove(filepath.Join(home.Home(home.HomePath).Barrel(), f.Name, receipt.ReceiptFilename))
return os.RemoveAll(barrelDir)
} | go | {
"resource": ""
} |
q13841 | Link | train | func (f *Food) Link(pkg *Package) error {
barrelDir := filepath.Join(home.Home(home.HomePath).Barrel(), f.Name, f.Version)
for _, r := range pkg.Resources {
// TODO: run this in parallel
destPath := filepath.Join(home.HomePrefix, r.InstallPath)
if err := os.MkdirAll(filepath.Dir(destPath), 0755); err != nil && !os.IsExist(err) {
return err
}
if r.Executable {
if err := os.Chmod(filepath.Join(barrelDir, r.Path), 0755); err != nil {
return err
}
}
if err := os.Symlink(filepath.Join(barrelDir, r.Path), destPath); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q13842 | Unlink | train | func (f *Food) Unlink(pkg *Package) error {
for _, r := range pkg.Resources {
// TODO: check if the linked path we are about to remove is really owned by us
if err := os.RemoveAll(filepath.Join(home.HomePrefix, r.InstallPath)); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q13843 | Lint | train | func (f *Food) Lint() (errs []error) {
var wg sync.WaitGroup
for _, pkg := range f.Packages {
wg.Add(1)
go func(pkg *Package) {
defer wg.Done()
u, err := url.Parse(pkg.URL)
if err != nil {
errs = append(errs, fmt.Errorf("could not parse package URL '%s' as a URL: %v", pkg.URL, err))
}
cachedFilePath := filepath.Join(home.UserHome(home.UserHomePath).Cache(), fmt.Sprintf("%s-%s-%s-%s%s", f.Name, f.Version, pkg.OS, pkg.Arch, filepath.Ext(u.Path)))
if err := f.DownloadTo(pkg, cachedFilePath); err != nil {
errs = append(errs, err)
}
if err := checksumVerifyPath(cachedFilePath, pkg.SHA256); err != nil {
errs = append(errs, fmt.Errorf("shasum verify check failed: %v", err))
}
}(pkg)
}
wg.Wait()
return
} | go | {
"resource": ""
} |
q13844 | DownloadTo | train | func (f *Food) DownloadTo(pkg *Package, filePath string) error {
var success = true
if err := downloadCachedFileToPath(filePath, pkg.URL); err != nil {
success = false
log.Errorln(err)
// try using the mirrors
for i := range pkg.Mirrors {
if err := downloadCachedFileToPath(filePath, pkg.Mirrors[i]); err == nil {
success = true
break
} else {
log.Errorln(err)
}
}
}
if !success {
return fmt.Errorf("failed to download package for OS/arch %s/%s with URL %s to filepath %s", pkg.OS, pkg.Arch, pkg.URL, filePath)
}
return nil
} | go | {
"resource": ""
} |
q13845 | downloadCachedFileToPath | train | func downloadCachedFileToPath(filePath string, url string) error {
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
return err
}
if _, err = os.Stat(filePath); err == nil {
return nil
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
out, err := os.Create(filePath)
if err != nil {
return err
}
defer out.Close()
_, err = io.Copy(out, resp.Body)
return err
} | go | {
"resource": ""
} |
q13846 | Bool | train | func (j *JsonQuery) Bool(s ...string) (bool, error) {
val, err := rquery(j.blob, s...)
if err != nil {
return false, err
}
return boolFromInterface(val)
} | go | {
"resource": ""
} |
q13847 | Float | train | func (j *JsonQuery) Float(s ...string) (float64, error) {
val, err := rquery(j.blob, s...)
if err != nil {
return 0.0, err
}
return floatFromInterface(val)
} | go | {
"resource": ""
} |
q13848 | Int | train | func (j *JsonQuery) Int(s ...string) (int, error) {
val, err := rquery(j.blob, s...)
if err != nil {
return 0, err
}
return intFromInterface(val)
} | go | {
"resource": ""
} |
q13849 | String | train | func (j *JsonQuery) String(s ...string) (string, error) {
val, err := rquery(j.blob, s...)
if err != nil {
return "", err
}
return stringFromInterface(val)
} | go | {
"resource": ""
} |
q13850 | Object | train | func (j *JsonQuery) Object(s ...string) (map[string]interface{}, error) {
val, err := rquery(j.blob, s...)
if err != nil {
return map[string]interface{}{}, err
}
return objectFromInterface(val)
} | go | {
"resource": ""
} |
q13851 | ArrayOfStrings | train | func (j *JsonQuery) ArrayOfStrings(s ...string) ([]string, error) {
array, err := j.Array(s...)
if err != nil {
return []string{}, err
}
toReturn := make([]string, len(array))
for index, val := range array {
toReturn[index], err = stringFromInterface(val)
if err != nil {
return toReturn, err
}
}
return toReturn, nil
} | go | {
"resource": ""
} |
q13852 | ArrayOfInts | train | func (j *JsonQuery) ArrayOfInts(s ...string) ([]int, error) {
array, err := j.Array(s...)
if err != nil {
return []int{}, err
}
toReturn := make([]int, len(array))
for index, val := range array {
toReturn[index], err = intFromInterface(val)
if err != nil {
return toReturn, err
}
}
return toReturn, nil
} | go | {
"resource": ""
} |
q13853 | ArrayOfFloats | train | func (j *JsonQuery) ArrayOfFloats(s ...string) ([]float64, error) {
array, err := j.Array(s...)
if err != nil {
return []float64{}, err
}
toReturn := make([]float64, len(array))
for index, val := range array {
toReturn[index], err = floatFromInterface(val)
if err != nil {
return toReturn, err
}
}
return toReturn, nil
} | go | {
"resource": ""
} |
q13854 | ArrayOfBools | train | func (j *JsonQuery) ArrayOfBools(s ...string) ([]bool, error) {
array, err := j.Array(s...)
if err != nil {
return []bool{}, err
}
toReturn := make([]bool, len(array))
for index, val := range array {
toReturn[index], err = boolFromInterface(val)
if err != nil {
return toReturn, err
}
}
return toReturn, nil
} | go | {
"resource": ""
} |
q13855 | rquery | train | func rquery(blob interface{}, s ...string) (interface{}, error) {
var (
val interface{}
err error
)
val = blob
for _, q := range s {
val, err = query(val, q)
if err != nil {
return nil, err
}
}
switch val.(type) {
case nil:
return nil, fmt.Errorf("Nil value found at %s\n", s[len(s)-1])
}
return val, nil
} | go | {
"resource": ""
} |
q13856 | NewError | train | func NewError(err error) *Error {
e := &Error{}
if err != nil {
e.Store(err)
}
return e
} | go | {
"resource": ""
} |
q13857 | Load | train | func (e *Error) Load() error {
v := e.v.Load()
if v == nil {
return nil
}
eh := v.(errorHolder)
return eh.err
} | go | {
"resource": ""
} |
q13858 | NewString | train | func NewString(str string) *String {
s := &String{}
if str != "" {
s.Store(str)
}
return s
} | go | {
"resource": ""
} |
q13859 | Load | train | func (s *String) Load() string {
v := s.v.Load()
if v == nil {
return ""
}
return v.(string)
} | go | {
"resource": ""
} |
q13860 | Add | train | func (i *Int32) Add(n int32) int32 {
return atomic.AddInt32(&i.v, n)
} | go | {
"resource": ""
} |
q13861 | Sub | train | func (i *Int32) Sub(n int32) int32 {
return atomic.AddInt32(&i.v, -n)
} | go | {
"resource": ""
} |
q13862 | Swap | train | func (i *Int32) Swap(n int32) int32 {
return atomic.SwapInt32(&i.v, n)
} | go | {
"resource": ""
} |
q13863 | Add | train | func (i *Int64) Add(n int64) int64 {
return atomic.AddInt64(&i.v, n)
} | go | {
"resource": ""
} |
q13864 | Sub | train | func (i *Int64) Sub(n int64) int64 {
return atomic.AddInt64(&i.v, -n)
} | go | {
"resource": ""
} |
q13865 | Swap | train | func (i *Int64) Swap(n int64) int64 {
return atomic.SwapInt64(&i.v, n)
} | go | {
"resource": ""
} |
q13866 | Add | train | func (i *Uint32) Add(n uint32) uint32 {
return atomic.AddUint32(&i.v, n)
} | go | {
"resource": ""
} |
q13867 | Sub | train | func (i *Uint32) Sub(n uint32) uint32 {
return atomic.AddUint32(&i.v, ^(n - 1))
} | go | {
"resource": ""
} |
q13868 | Swap | train | func (i *Uint32) Swap(n uint32) uint32 {
return atomic.SwapUint32(&i.v, n)
} | go | {
"resource": ""
} |
q13869 | Add | train | func (i *Uint64) Add(n uint64) uint64 {
return atomic.AddUint64(&i.v, n)
} | go | {
"resource": ""
} |
q13870 | Sub | train | func (i *Uint64) Sub(n uint64) uint64 {
return atomic.AddUint64(&i.v, ^(n - 1))
} | go | {
"resource": ""
} |
q13871 | Swap | train | func (i *Uint64) Swap(n uint64) uint64 {
return atomic.SwapUint64(&i.v, n)
} | go | {
"resource": ""
} |
q13872 | Swap | train | func (b *Bool) Swap(new bool) bool {
return truthy(atomic.SwapUint32(&b.v, boolToInt(new)))
} | go | {
"resource": ""
} |
q13873 | Add | train | func (f *Float64) Add(s float64) float64 {
for {
old := f.Load()
new := old + s
if f.CAS(old, new) {
return new
}
}
} | go | {
"resource": ""
} |
q13874 | NewDuration | train | func NewDuration(d time.Duration) *Duration {
return &Duration{v: *NewInt64(int64(d))}
} | go | {
"resource": ""
} |
q13875 | Add | train | func (d *Duration) Add(n time.Duration) time.Duration {
return time.Duration(d.v.Add(int64(n)))
} | go | {
"resource": ""
} |
q13876 | Sub | train | func (d *Duration) Sub(n time.Duration) time.Duration {
return time.Duration(d.v.Sub(int64(n)))
} | go | {
"resource": ""
} |
q13877 | Swap | train | func (d *Duration) Swap(n time.Duration) time.Duration {
return time.Duration(d.v.Swap(int64(n)))
} | go | {
"resource": ""
} |
q13878 | NewPool | train | func NewPool() (pool *Pool) {
return &Pool{
Clients: make(map[string]*PoolClient, poolSize),
SelectionHandler: SelectWithRate,
}
} | go | {
"resource": ""
} |
q13879 | Add | train | func (pool *Pool) Add(net, addr string, rate int) (err error) {
pool.mutex.Lock()
defer pool.mutex.Unlock()
var item *PoolClient
var ok bool
if item, ok = pool.Clients[addr]; ok {
item.Rate = rate
} else {
var client *Client
client, err = New(net, addr)
if err == nil {
item = &PoolClient{Client: client, Rate: rate}
pool.Clients[addr] = item
}
}
return
} | go | {
"resource": ""
} |
q13880 | Remove | train | func (pool *Pool) Remove(addr string) {
pool.mutex.Lock()
defer pool.mutex.Unlock()
delete(pool.Clients, addr)
} | go | {
"resource": ""
} |
q13881 | Status | train | func (pool *Pool) Status(addr, handle string) (status *Status, err error) {
if client, ok := pool.Clients[addr]; ok {
client.Lock()
defer client.Unlock()
status, err = client.Status(handle)
} else {
err = ErrNotFound
}
return
} | go | {
"resource": ""
} |
q13882 | Echo | train | func (pool *Pool) Echo(addr string, data []byte) (echo []byte, err error) {
var client *PoolClient
if addr == "" {
client = pool.selectServer()
} else {
var ok bool
if client, ok = pool.Clients[addr]; !ok {
err = ErrNotFound
return
}
}
client.Lock()
defer client.Unlock()
echo, err = client.Echo(data)
return
} | go | {
"resource": ""
} |
q13883 | Encode | train | func (req *request) Encode() (data []byte) {
l := len(req.Data) // length of data
tl := l + minPacketLength // add 12 bytes head
data = getBuffer(tl)
copy(data[:4], reqStr)
binary.BigEndian.PutUint32(data[4:8], req.DataType)
binary.BigEndian.PutUint32(data[8:12], uint32(l))
copy(data[minPacketLength:], req.Data)
return
} | go | {
"resource": ""
} |
q13884 | New | train | func New(network, addr string) (client *Client, err error) {
client = &Client{
net: network,
addr: addr,
respHandler: newResponseHandlerMap(),
innerHandler: newResponseHandlerMap(),
in: make(chan *Response, queueSize),
ResponseTimeout: DefaultTimeout,
}
client.conn, err = net.Dial(client.net, client.addr)
if err != nil {
return
}
client.rw = bufio.NewReadWriter(bufio.NewReader(client.conn),
bufio.NewWriter(client.conn))
go client.readLoop()
go client.processLoop()
return
} | go | {
"resource": ""
} |
q13885 | Status | train | func (client *Client) Status(handle string) (status *Status, err error) {
if client.conn == nil {
return nil, ErrLostConn
}
var mutex sync.Mutex
mutex.Lock()
client.innerHandler.put("s"+handle, func(resp *Response) {
defer mutex.Unlock()
var err error
status, err = resp._status()
if err != nil {
client.err(err)
}
})
req := getRequest()
req.DataType = dtGetStatus
req.Data = []byte(handle)
client.write(req)
mutex.Lock()
return
} | go | {
"resource": ""
} |
q13886 | newAgent | train | func newAgent(net, addr string, worker *Worker) (a *agent, err error) {
a = &agent{
net: net,
addr: addr,
worker: worker,
in: make(chan []byte, queueSize),
}
return
} | go | {
"resource": ""
} |
q13887 | read | train | func (a *agent) read() (data []byte, err error) {
n := 0
tmp := getBuffer(bufferSize)
var buf bytes.Buffer
// read the header so we can get the length of the data
if n, err = a.rw.Read(tmp); err != nil {
return
}
dl := int(binary.BigEndian.Uint32(tmp[8:12]))
// write what we read so far
buf.Write(tmp[:n])
// read until we receive all the data
for buf.Len() < dl+minPacketLength {
if n, err = a.rw.Read(tmp); err != nil {
return buf.Bytes(), err
}
buf.Write(tmp[:n])
}
return buf.Bytes(), err
} | go | {
"resource": ""
} |
q13888 | write | train | func (a *agent) write(outpack *outPack) (err error) {
var n int
buf := outpack.Encode()
for i := 0; i < len(buf); i += n {
n, err = a.rw.Write(buf[i:])
if err != nil {
return err
}
}
return a.rw.Flush()
} | go | {
"resource": ""
} |
q13889 | Write | train | func (a *agent) Write(outpack *outPack) (err error) {
a.Lock()
defer a.Unlock()
return a.write(outpack)
} | go | {
"resource": ""
} |
q13890 | Encode | train | func (outpack *outPack) Encode() (data []byte) {
var l int
if outpack.dataType == dtWorkFail {
l = len(outpack.handle)
} else {
l = len(outpack.data)
if outpack.handle != "" {
l += len(outpack.handle) + 1
}
}
data = getBuffer(l + minPacketLength)
binary.BigEndian.PutUint32(data[:4], req)
binary.BigEndian.PutUint32(data[4:8], outpack.dataType)
binary.BigEndian.PutUint32(data[8:minPacketLength], uint32(l))
i := minPacketLength
if outpack.handle != "" {
hi := len(outpack.handle) + i
copy(data[i:hi], []byte(outpack.handle))
if outpack.dataType != dtWorkFail {
data[hi] = '\x00'
}
i = hi + 1
}
if outpack.dataType != dtWorkFail {
copy(data[i:], outpack.data)
}
return
} | go | {
"resource": ""
} |
q13891 | getError | train | func getError(data []byte) (err error) {
rel := bytes.SplitN(data, []byte{'\x00'}, 2)
if len(rel) != 2 {
err = fmt.Errorf("Not a error data: %v", data)
return
}
err = fmt.Errorf("%s: %s", rel[0], rel[1])
return
} | go | {
"resource": ""
} |
q13892 | err | train | func (worker *Worker) err(e error) {
if worker.ErrorHandler != nil {
worker.ErrorHandler(e)
}
} | go | {
"resource": ""
} |
q13893 | broadcast | train | func (worker *Worker) broadcast(outpack *outPack) {
for _, v := range worker.agents {
v.write(outpack)
}
} | go | {
"resource": ""
} |
q13894 | RemoveFunc | train | func (worker *Worker) RemoveFunc(funcname string) (err error) {
worker.Lock()
defer worker.Unlock()
if _, ok := worker.funcs[funcname]; !ok {
return fmt.Errorf("The function does not exist: %s", funcname)
}
delete(worker.funcs, funcname)
if worker.running {
worker.removeFunc(funcname)
}
return
} | go | {
"resource": ""
} |
q13895 | handleInPack | train | func (worker *Worker) handleInPack(inpack *inPack) {
switch inpack.dataType {
case dtNoJob:
inpack.a.PreSleep()
case dtNoop:
inpack.a.Grab()
case dtJobAssign, dtJobAssignUniq:
go func() {
if err := worker.exec(inpack); err != nil {
worker.err(err)
}
}()
if worker.limit != nil {
worker.limit <- true
}
inpack.a.Grab()
case dtError:
worker.err(inpack.Err())
fallthrough
case dtEchoRes:
fallthrough
default:
worker.customeHandler(inpack)
}
} | go | {
"resource": ""
} |
q13896 | Ready | train | func (worker *Worker) Ready() (err error) {
if len(worker.agents) == 0 {
return ErrNoneAgents
}
if len(worker.funcs) == 0 {
return ErrNoneFuncs
}
for _, a := range worker.agents {
if err = a.Connect(); err != nil {
return
}
}
for funcname, f := range worker.funcs {
worker.addFunc(funcname, f.timeout)
}
worker.ready = true
return
} | go | {
"resource": ""
} |
q13897 | Work | train | func (worker *Worker) Work() {
if !worker.ready {
// didn't run Ready beforehand, so we'll have to do it:
err := worker.Ready()
if err != nil {
panic(err)
}
}
worker.running = true
for _, a := range worker.agents {
a.Grab()
}
var inpack *inPack
for inpack = range worker.in {
worker.handleInPack(inpack)
}
} | go | {
"resource": ""
} |
q13898 | customeHandler | train | func (worker *Worker) customeHandler(inpack *inPack) {
if worker.JobHandler != nil {
if err := worker.JobHandler(inpack); err != nil {
worker.err(err)
}
}
} | go | {
"resource": ""
} |
q13899 | Close | train | func (worker *Worker) Close() {
worker.Lock()
defer worker.Unlock()
if worker.running == true {
for _, a := range worker.agents {
a.Close()
}
worker.running = false
close(worker.in)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.