_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q31400 | values | train | func (config StickerConfig) values() (url.Values, error) {
v, err := config.BaseChat.values()
if err != nil {
return v, err
}
v.Add(config.name(), config.FileID)
return v, nil
} | go | {
"resource": ""
} |
q31401 | values | train | func (config VideoConfig) values() (url.Values, error) {
v, err := config.BaseChat.values()
if err != nil {
return v, err
}
v.Add(config.name(), config.FileID)
if config.Duration != 0 {
v.Add("duration", strconv.Itoa(config.Duration))
}
if config.Caption != "" {
v.Add("caption", config.Caption)
if confi... | go | {
"resource": ""
} |
q31402 | values | train | func (config VideoNoteConfig) values() (url.Values, error) {
v, err := config.BaseChat.values()
if err != nil {
return v, err
}
v.Add(config.name(), config.FileID)
if config.Duration != 0 {
v.Add("duration", strconv.Itoa(config.Duration))
}
// Telegram API seems to have a bug, if no length is provided or i... | go | {
"resource": ""
} |
q31403 | values | train | func (config LocationConfig) values() (url.Values, error) {
v, err := config.BaseChat.values()
if err != nil {
return v, err
}
v.Add("latitude", strconv.FormatFloat(config.Latitude, 'f', 6, 64))
v.Add("longitude", strconv.FormatFloat(config.Longitude, 'f', 6, 64))
return v, nil
} | go | {
"resource": ""
} |
q31404 | values | train | func (config ChatActionConfig) values() (url.Values, error) {
v, err := config.BaseChat.values()
if err != nil {
return v, err
}
v.Add("action", config.Action)
return v, nil
} | go | {
"resource": ""
} |
q31405 | SetLogger | train | func SetLogger(logger BotLogger) error {
if logger == nil {
return errors.New("logger is nil")
}
log = logger
return nil
} | go | {
"resource": ""
} |
q31406 | prepare_diff_messages | train | func prepare_diff_messages() {
// clear buffers
diffbuf = diffbuf[:0]
charbuf = charbuf[:0]
var diff diff_msg
gbeg := 0
for y := 0; y < front_buffer.height; y++ {
same := true
line_offset := y * front_buffer.width
for x := 0; x < front_buffer.width; x++ {
cell_offset := line_offset + x
back := &back_... | go | {
"resource": ""
} |
q31407 | SetCell | train | func SetCell(x, y int, ch rune, fg, bg Attribute) {
if x < 0 || x >= back_buffer.width {
return
}
if y < 0 || y >= back_buffer.height {
return
}
back_buffer.cells[y*back_buffer.width+x] = Cell{ch, fg, bg}
} | go | {
"resource": ""
} |
q31408 | Draw | train | func (eb *EditBox) Draw(x, y, w, h int) {
eb.AdjustVOffset(w)
const coldef = termbox.ColorDefault
fill(x, y, w, h, termbox.Cell{Ch: ' '})
t := eb.text
lx := 0
tabstop := 0
for {
rx := lx - eb.line_voffset
if len(t) == 0 {
break
}
if lx == tabstop {
tabstop += tabstop_length
}
if rx >= w {
... | go | {
"resource": ""
} |
q31409 | AdjustVOffset | train | func (eb *EditBox) AdjustVOffset(width int) {
ht := preferred_horizontal_threshold
max_h_threshold := (width - 1) / 2
if ht > max_h_threshold {
ht = max_h_threshold
}
threshold := width - 1
if eb.line_voffset != 0 {
threshold = width - ht
}
if eb.cursor_voffset-eb.line_voffset >= threshold {
eb.line_voff... | go | {
"resource": ""
} |
q31410 | PollEvent | train | func PollEvent() Event {
// Constant governing macOS specific behavior. See https://github.com/nsf/termbox-go/issues/132
// This is an arbitrary delay which hopefully will be enough time for any lagging
// partial escape sequences to come through.
const esc_wait_delay = 100 * time.Millisecond
var event Event
var... | go | {
"resource": ""
} |
q31411 | Clear | train | func Clear(fg, bg Attribute) error {
foreground, background = fg, bg
err := update_size_maybe()
back_buffer.clear()
return err
} | go | {
"resource": ""
} |
q31412 | Sync | train | func Sync() error {
front_buffer.clear()
err := send_clear()
if err != nil {
return err
}
return Flush()
} | go | {
"resource": ""
} |
q31413 | incRequestsTotal | train | func (m Metrics) incRequestsTotal(method string) {
if ptr, ok := m.RequestsTotal[method]; ok {
atomic.AddUint64(ptr, 1)
}
} | go | {
"resource": ""
} |
q31414 | incErrorsTotal | train | func (m Metrics) incErrorsTotal(err HTTPError) {
ptr := m.ErrorsTotal.retrievePointerFor(err)
atomic.AddUint64(ptr, 1)
} | go | {
"resource": ""
} |
q31415 | incBytesReceived | train | func (m Metrics) incBytesReceived(delta uint64) {
atomic.AddUint64(m.BytesReceived, delta)
} | go | {
"resource": ""
} |
q31416 | Load | train | func (e *ErrorsTotalMap) Load() map[HTTPError]*uint64 {
m := make(map[HTTPError]*uint64, len(e.counter))
e.lock.RLock()
for err, ptr := range e.counter {
httpErr := NewHTTPError(errors.New(err.Message), err.StatusCode)
m[httpErr] = ptr
}
e.lock.RUnlock()
return m
} | go | {
"resource": ""
} |
q31417 | Prefix | train | func (l *LockerOptions) Prefix() string {
prefix := l.prefix
if !strings.HasPrefix(prefix, "/") {
prefix = "/" + prefix
}
if prefix == "" {
return DefaultPrefix
} else {
return prefix
}
} | go | {
"resource": ""
} |
q31418 | New | train | func New(storeSize int64, dataStore tusd.DataStore, terminater tusd.TerminaterDataStore) *LimitedStore {
return &LimitedStore{
StoreSize: storeSize,
DataStore: dataStore,
terminater: terminater,
uploads: make(map[string]int64),
mutex: new(sync.Mutex),
}
} | go | {
"resource": ""
} |
q31419 | ensureSpace | train | func (store *LimitedStore) ensureSpace(size int64) error {
if (store.usedSize + size) <= store.StoreSize {
// Enough space is available to store the new upload
return nil
}
sortedUploads := make(pairlist, len(store.uploads))
i := 0
for u, h := range store.uploads {
sortedUploads[i] = pair{u, h}
i++
}
so... | go | {
"resource": ""
} |
q31420 | newLock | train | func (store FileStore) newLock(id string) (lockfile.Lockfile, error) {
path, err := filepath.Abs(filepath.Join(store.Path, id+".lock"))
if err != nil {
return lockfile.Lockfile(""), err
}
// We use Lockfile directly instead of lockfile.New to bypass the unnecessary
// check whether the provided path is absolute... | go | {
"resource": ""
} |
q31421 | binPath | train | func (store FileStore) binPath(id string) string {
return filepath.Join(store.Path, id+".bin")
} | go | {
"resource": ""
} |
q31422 | infoPath | train | func (store FileStore) infoPath(id string) string {
return filepath.Join(store.Path, id+".info")
} | go | {
"resource": ""
} |
q31423 | writeInfo | train | func (store FileStore) writeInfo(id string, info tusd.FileInfo) error {
data, err := json.Marshal(info)
if err != nil {
return err
}
return ioutil.WriteFile(store.infoPath(id), data, defaultFilePerm)
} | go | {
"resource": ""
} |
q31424 | New | train | func New(client *consul.Client) *ConsulLocker {
return &ConsulLocker{
Client: client,
locks: make(map[string]*consul.Lock),
mutex: new(sync.RWMutex),
}
} | go | {
"resource": ""
} |
q31425 | Middleware | train | func (handler *UnroutedHandler) Middleware(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Allow overriding the HTTP method. The reason for this is
// that some libraries/environments to not support PATCH and
// DELETE requests, e.g. Flash in a browser and... | go | {
"resource": ""
} |
q31426 | HeadFile | train | func (handler *UnroutedHandler) HeadFile(w http.ResponseWriter, r *http.Request) {
id, err := extractIDFromPath(r.URL.Path)
if err != nil {
handler.sendError(w, r, err)
return
}
if handler.composer.UsesLocker {
locker := handler.composer.Locker
if err := locker.LockUpload(id); err != nil {
handler.send... | go | {
"resource": ""
} |
q31427 | writeChunk | train | func (handler *UnroutedHandler) writeChunk(id string, info FileInfo, w http.ResponseWriter, r *http.Request) error {
// Get Content-Length if possible
length := r.ContentLength
offset := info.Offset
// Test if this upload fits into the file's size
if !info.SizeIsDeferred && offset+length > info.Size {
return Er... | go | {
"resource": ""
} |
q31428 | GetFile | train | func (handler *UnroutedHandler) GetFile(w http.ResponseWriter, r *http.Request) {
if !handler.composer.UsesGetReader {
handler.sendError(w, r, ErrNotImplemented)
return
}
id, err := extractIDFromPath(r.URL.Path)
if err != nil {
handler.sendError(w, r, err)
return
}
if handler.composer.UsesLocker {
loc... | go | {
"resource": ""
} |
q31429 | DelFile | train | func (handler *UnroutedHandler) DelFile(w http.ResponseWriter, r *http.Request) {
// Abort the request handling if the required interface is not implemented
if !handler.composer.UsesTerminater {
handler.sendError(w, r, ErrNotImplemented)
return
}
id, err := extractIDFromPath(r.URL.Path)
if err != nil {
hand... | go | {
"resource": ""
} |
q31430 | sendError | train | func (handler *UnroutedHandler) sendError(w http.ResponseWriter, r *http.Request, err error) {
// Interpret os.ErrNotExist as 404 Not Found
if os.IsNotExist(err) {
err = ErrNotFound
}
// Errors for read timeouts contain too much information which is not
// necessary for us and makes grouping for the metrics har... | go | {
"resource": ""
} |
q31431 | sendResp | train | func (handler *UnroutedHandler) sendResp(w http.ResponseWriter, r *http.Request, status int) {
w.WriteHeader(status)
handler.log("ResponseOutgoing", "status", strconv.Itoa(status), "method", r.Method, "path", r.URL.Path)
} | go | {
"resource": ""
} |
q31432 | absFileURL | train | func (handler *UnroutedHandler) absFileURL(r *http.Request, id string) string {
if handler.isBasePathAbs {
return handler.basePath + id
}
// Read origin and protocol from request
host, proto := getHostAndProtocol(r, handler.config.RespectForwardedHeaders)
url := proto + "://" + host + handler.basePath + id
r... | go | {
"resource": ""
} |
q31433 | sendProgressMessages | train | func (handler *UnroutedHandler) sendProgressMessages(info FileInfo, reader io.Reader) (io.Reader, chan<- struct{}) {
progress := &progressWriter{
Offset: info.Offset,
}
stop := make(chan struct{}, 1)
reader = io.TeeReader(reader, progress)
go func() {
for {
select {
case <-stop:
info.Offset = atomic... | go | {
"resource": ""
} |
q31434 | sizeOfUploads | train | func (handler *UnroutedHandler) sizeOfUploads(ids []string) (size int64, err error) {
for _, id := range ids {
info, err := handler.composer.Core.GetInfo(id)
if err != nil {
return size, err
}
if info.SizeIsDeferred || info.Offset != info.Size {
err = ErrUploadNotFinished
return size, err
}
size... | go | {
"resource": ""
} |
q31435 | validateNewUploadLengthHeaders | train | func (handler *UnroutedHandler) validateNewUploadLengthHeaders(uploadLengthHeader string, uploadDeferLengthHeader string) (uploadLength int64, uploadLengthDeferred bool, err error) {
haveBothLengthHeaders := uploadLengthHeader != "" && uploadDeferLengthHeader != ""
haveInvalidDeferHeader := uploadDeferLengthHeader !=... | go | {
"resource": ""
} |
q31436 | extractIDFromPath | train | func extractIDFromPath(url string) (string, error) {
result := reExtractFileID.FindStringSubmatch(url)
if len(result) != 2 {
return "", ErrNotFound
}
return result[1], nil
} | go | {
"resource": ""
} |
q31437 | NewGCSService | train | func NewGCSService(filename string) (*GCSService, error) {
ctx := context.Background()
client, err := storage.NewClient(ctx, option.WithServiceAccountFile(filename))
if err != nil {
return nil, err
}
service := &GCSService{
Client: client,
}
return service, nil
} | go | {
"resource": ""
} |
q31438 | GetObjectSize | train | func (service *GCSService) GetObjectSize(ctx context.Context, params GCSObjectParams) (int64, error) {
attrs, err := service.GetObjectAttrs(ctx, params)
if err != nil {
return 0, err
}
return attrs.Size, nil
} | go | {
"resource": ""
} |
q31439 | DeleteObjectsWithFilter | train | func (service *GCSService) DeleteObjectsWithFilter(ctx context.Context, params GCSFilterParams) error {
names, err := service.FilterObjects(ctx, params)
if err != nil {
return err
}
var objectParams GCSObjectParams
for _, name := range names {
objectParams = GCSObjectParams{
Bucket: params.Bucket,
ID: ... | go | {
"resource": ""
} |
q31440 | compose | train | func (service *GCSService) compose(ctx context.Context, bucket string, srcs []string, dst string) error {
dstParams := GCSObjectParams{
Bucket: bucket,
ID: dst,
}
objSrcs := make([]*storage.ObjectHandle, len(srcs))
var crc uint32
for i := 0; i < len(srcs); i++ {
objSrcs[i] = service.Client.Bucket(bucket)... | go | {
"resource": ""
} |
q31441 | ComposeObjects | train | func (service *GCSService) ComposeObjects(ctx context.Context, params GCSComposeParams) error {
err := service.recursiveCompose(ctx, params.Sources, params, 0)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q31442 | ReadObject | train | func (service *GCSService) ReadObject(ctx context.Context, params GCSObjectParams) (GCSReader, error) {
r, err := service.Client.Bucket(params.Bucket).Object(params.ID).NewReader(ctx)
if err != nil {
return nil, err
}
return r, nil
} | go | {
"resource": ""
} |
q31443 | SetObjectMetadata | train | func (service *GCSService) SetObjectMetadata(ctx context.Context, params GCSObjectParams, metadata map[string]string) error {
attrs := storage.ObjectAttrsToUpdate{
Metadata: metadata,
}
_, err := service.Client.Bucket(params.Bucket).Object(params.ID).Update(ctx, attrs)
return err
} | go | {
"resource": ""
} |
q31444 | DeleteObject | train | func (service *GCSService) DeleteObject(ctx context.Context, params GCSObjectParams) error {
return service.Client.Bucket(params.Bucket).Object(params.ID).Delete(ctx)
} | go | {
"resource": ""
} |
q31445 | WriteObject | train | func (service *GCSService) WriteObject(ctx context.Context, params GCSObjectParams, r io.Reader) (int64, error) {
obj := service.Client.Bucket(params.Bucket).Object(params.ID)
w := obj.NewWriter(ctx)
n, err := io.Copy(w, r)
if err != nil {
return 0, err
}
err = w.Close()
if err != nil {
if gErr, ok := err... | go | {
"resource": ""
} |
q31446 | ComposeFrom | train | func (service *GCSService) ComposeFrom(ctx context.Context, objSrcs []*storage.ObjectHandle, dstParams GCSObjectParams, contentType string) (uint32, error) {
dstObj := service.Client.Bucket(dstParams.Bucket).Object(dstParams.ID)
c := dstObj.ComposerFrom(objSrcs...)
c.ContentType = contentType
_, err := c.Run(ctx)
... | go | {
"resource": ""
} |
q31447 | UnlockUpload | train | func (locker *MemoryLocker) UnlockUpload(id string) error {
locker.mutex.Lock()
// Deleting a non-existing key does not end in unexpected errors or panic
// since this operation results in a no-op
delete(locker.locks, id)
locker.mutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q31448 | New | train | func New(bucket string, service GCSAPI) GCSStore {
return GCSStore{
Bucket: bucket,
Service: service,
}
} | go | {
"resource": ""
} |
q31449 | NewWithPrefix | train | func NewWithPrefix(client *etcd3.Client, prefix string) (*Etcd3Locker, error) {
lockerOptions := DefaultLockerOptions()
lockerOptions.SetPrefix(prefix)
return NewWithLockerOptions(client, lockerOptions)
} | go | {
"resource": ""
} |
q31450 | newStoreComposerFromDataStore | train | func newStoreComposerFromDataStore(store DataStore) *StoreComposer {
composer := NewStoreComposer()
composer.UseCore(store)
if mod, ok := store.(TerminaterDataStore); ok {
composer.UseTerminater(mod)
}
if mod, ok := store.(FinisherDataStore); ok {
composer.UseFinisher(mod)
}
if mod, ok := store.(LockerDataS... | go | {
"resource": ""
} |
q31451 | Capabilities | train | func (store *StoreComposer) Capabilities() string {
str := "Core: "
if store.Core != nil {
str += "✓"
} else {
str += "✗"
}
str += ` Terminater: `
if store.UsesTerminater {
str += "✓"
} else {
str += "✗"
}
str += ` Finisher: `
if store.UsesFinisher {
str += "✓"
} else {
str += "✗"
}
str += ` ... | go | {
"resource": ""
} |
q31452 | New | train | func New(bucket string, service S3API) S3Store {
return S3Store{
Bucket: bucket,
Service: service,
MaxPartSize: 5 * 1024 * 1024 * 1024,
MinPartSize: 5 * 1024 * 1024,
MaxMultipartParts: 10000,
MaxObjectSize: 5 * 1024 * 1024 * 1024 * 1024,
}
} | go | {
"resource": ""
} |
q31453 | isAwsError | train | func isAwsError(err error, code string) bool {
if err, ok := err.(awserr.Error); ok && err.Code() == code {
return true
}
return false
} | go | {
"resource": ""
} |
q31454 | Acquire | train | func (lock *etcd3Lock) Acquire() error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// this is a blocking call; if we receive DeadlineExceeded
// the lock is most likely already taken
if err := lock.Mutex.Lock(ctx); err != nil {
if err == context.DeadlineExceeded {
... | go | {
"resource": ""
} |
q31455 | DecodeHookExec | train | func DecodeHookExec(
raw DecodeHookFunc,
from reflect.Type, to reflect.Type,
data interface{}) (interface{}, error) {
switch f := typedDecodeHook(raw).(type) {
case DecodeHookFuncType:
return f(from, to, data)
case DecodeHookFuncKind:
return f(from.Kind(), to.Kind(), data)
default:
return nil, errors.New("... | go | {
"resource": ""
} |
q31456 | ComposeDecodeHookFunc | train | func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
var err error
for _, f1 := range fs {
data, err = DecodeHookExec(f1, f, t, data)
if err != nil {
return nil, err
}
// Modify the from kind t... | go | {
"resource": ""
} |
q31457 | StringToTimeDurationHookFunc | train | func StringToTimeDurationHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t != reflect.TypeOf(time.Duration(5)) {
return data, nil
}
// Convert it by parsing
return time.Parse... | go | {
"resource": ""
} |
q31458 | StringToIPHookFunc | train | func StringToIPHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t != reflect.TypeOf(net.IP{}) {
return data, nil
}
// Convert it by parsing
ip := net.ParseIP(data.(string))
... | go | {
"resource": ""
} |
q31459 | StringToIPNetHookFunc | train | func StringToIPNetHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t != reflect.TypeOf(net.IPNet{}) {
return data, nil
}
// Convert it by parsing
_, net, err := net.ParseCIDR(... | go | {
"resource": ""
} |
q31460 | StringToTimeHookFunc | train | func StringToTimeHookFunc(layout string) DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t != reflect.TypeOf(time.Time{}) {
return data, nil
}
// Convert it by parsing
return time.Parse... | go | {
"resource": ""
} |
q31461 | WeaklyTypedHook | train | func WeaklyTypedHook(
f reflect.Kind,
t reflect.Kind,
data interface{}) (interface{}, error) {
dataVal := reflect.ValueOf(data)
switch t {
case reflect.String:
switch f {
case reflect.Bool:
if dataVal.Bool() {
return "1", nil
}
return "0", nil
case reflect.Float32:
return strconv.FormatFloat... | go | {
"resource": ""
} |
q31462 | Decode | train | func Decode(input interface{}, output interface{}) error {
config := &DecoderConfig{
Metadata: nil,
Result: output,
}
decoder, err := NewDecoder(config)
if err != nil {
return err
}
return decoder.Decode(input)
} | go | {
"resource": ""
} |
q31463 | NewDecoder | train | func NewDecoder(config *DecoderConfig) (*Decoder, error) {
val := reflect.ValueOf(config.Result)
if val.Kind() != reflect.Ptr {
return nil, errors.New("result must be a pointer")
}
val = val.Elem()
if !val.CanAddr() {
return nil, errors.New("result must be addressable (a pointer)")
}
if config.Metadata != ... | go | {
"resource": ""
} |
q31464 | WrappedErrors | train | func (e *Error) WrappedErrors() []error {
if e == nil {
return nil
}
result := make([]error, len(e.Errors))
for i, e := range e.Errors {
result[i] = errors.New(e)
}
return result
} | go | {
"resource": ""
} |
q31465 | rateLimit | train | func (cs *Server) rateLimit(keyID, claimedIP string) (isSpammer bool) {
cs.whiteListMu.Lock()
if _, ok := cs.whiteList[keyID+"-"+claimedIP]; ok {
cs.whiteListMu.Unlock()
return false
}
cs.whiteListMu.Unlock()
// If they haven't successfully challenged us before, they look suspicious.
cs.keyIDSeenMu.Lock()
la... | go | {
"resource": ""
} |
q31466 | NewClient | train | func NewClient(keyRing, keyId, challengeIP string) (*Client, error) {
signer, err := secretKeyEntity(keyRing, keyId)
if err != nil {
return nil, fmt.Errorf("could not get signer %v from keyRing %v: %v", keyId, keyRing, err)
}
cl := &Client{
keyRing: keyRing,
keyId: keyId,
signer: signer,
ch... | go | {
"resource": ""
} |
q31467 | Handler | train | func (cl *Client) Handler() (prefix string, h http.Handler) {
return clientHandlerPrefix, cl.handler
} | go | {
"resource": ""
} |
q31468 | listenSelfCheck | train | func (cl *Client) listenSelfCheck(serverAddr string) error {
tr := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
ServerName: cl.challengeIP + SNISuffix,
},
}
httpClient := &http.Client{
Transport: tr,
}
errc := make(chan error, 1)
respc := make(chan *http.Response, 1... | go | {
"resource": ""
} |
q31469 | New | train | func New(maxBytes int64, cache, origin blobserver.Storage) *Storage {
sto := &Storage{
origin: origin,
cache: cache,
lru: lru.NewUnlocked(0),
maxCacheBytes: maxBytes,
}
return sto
} | go | {
"resource": ""
} |
q31470 | removeOldest | train | func (sto *Storage) removeOldest() bool {
ctx := context.TODO()
k, v := sto.lru.RemoveOldest()
if v == nil {
return false
}
sb := v.(blob.SizedRef)
// TODO: run these without sto.mu held in background
// goroutine? at least pass a context?
err := sto.cache.RemoveBlobs(ctx, []blob.Ref{sb.Ref})
if err != nil {... | go | {
"resource": ""
} |
q31471 | New | train | func New(authToken, parentDir string, limit int,
updadeSearchSession func(string), triggerRender func()) *js.Object {
parentDirbr, ok := blob.Parse(parentDir)
if !ok {
dom.GetWindow().Alert(fmt.Sprintf("invalid parentDir blobRef: %q", parentDir))
return nil
}
return js.MakeWrapper(&Query{
ParentDir: ... | go | {
"resource": ""
} |
q31472 | Get | train | func (q *Query) Get() {
if q.isComplete {
return
}
if q.pending {
return
}
q.pending = true
go func() {
if err := q.get(); err != nil {
dom.GetWindow().Alert(fmt.Sprintf("%v", err))
return
}
q.TriggerRender()
}()
} | go | {
"resource": ""
} |
q31473 | newKVDB | train | func newKVDB(cfg jsonconfig.Obj) (sorted.KeyValue, error) {
var (
user = cfg.RequiredString("user")
database = cfg.RequiredString("database")
host = cfg.OptionalString("host", "")
password = cfg.OptionalString("password", "")
)
if err := cfg.Validate(); err != nil {
return nil, err
}
if !validDat... | go | {
"resource": ""
} |
q31474 | Wipe | train | func (kv *keyValue) Wipe() error {
if _, err := kv.db.Exec("DROP TABLE IF EXISTS " + kv.database + ".rows"); err != nil {
return err
}
if _, err := kv.db.Exec("DROP TABLE IF EXISTS " + kv.database + ".meta"); err != nil {
return err
}
return kv.finalize()
} | go | {
"resource": ""
} |
q31475 | finalize | train | func (kv *keyValue) finalize() error {
if err := createTables(kv.db, kv.database); err != nil {
return err
}
if err := kv.ping(); err != nil {
return fmt.Errorf("MySQL db unreachable: %v", err)
}
version, err := kv.SchemaVersion()
if err != nil {
return fmt.Errorf("error getting current database schema ve... | go | {
"resource": ""
} |
q31476 | CreateDB | train | func CreateDB(db *sql.DB, dbname string) error {
if dbname == "" {
return errors.New("can not create database: database name is missing")
}
if _, err := db.Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s", dbname)); err != nil {
return fmt.Errorf("error creating database %v: %v", dbname, err)
}
return nil
} | go | {
"resource": ""
} |
q31477 | Close | train | func (kv *keyValue) Close() error {
dbsmu.Lock()
defer dbsmu.Unlock()
delete(dbs, kv.dsn)
return kv.DB.Close()
} | go | {
"resource": ""
} |
q31478 | emailOnTimeout | train | func emailOnTimeout(fnName string, d time.Duration, fn func() error) error {
c := make(chan error, 1)
go func() {
c <- fn()
}()
select {
case <-time.After(d):
log.Printf("timeout for %s, sending e-mail about it", fnName)
m := mailGun.NewMessage(
"noreply@perkeep.org",
"timeout for docker on pk-web",
... | go | {
"resource": ""
} |
q31479 | u32 | train | func u32(n int64) uint32 {
if n < 0 || n > math.MaxUint32 {
panic("bad size " + fmt.Sprint(n))
}
return uint32(n)
} | go | {
"resource": ""
} |
q31480 | fetch | train | func (ds *Storage) fetch(ctx context.Context, br blob.Ref, offset, length int64) (rc io.ReadCloser, size uint32, err error) {
// TODO: use ctx, if the os package ever supports that.
fileName := ds.blobPath(br)
stat, err := ds.fs.Stat(fileName)
if os.IsNotExist(err) {
return nil, 0, os.ErrNotExist
}
size = u32(s... | go | {
"resource": ""
} |
q31481 | AddFlags | train | func AddFlags() {
defaultPath := "/x/y/z/we're/in-a-test"
if !buildinfo.TestingLinked() {
defaultPath = osutil.UserClientConfigPath()
}
flag.StringVar(&flagServer, "server", "", "Perkeep server prefix. If blank, the default from the \"server\" field of "+defaultPath+" is used. Acceptable forms: https://you.exampl... | go | {
"resource": ""
} |
q31482 | parseConfig | train | func (c *Client) parseConfig() {
if android.OnAndroid() {
panic("parseConfig should never have been called on Android")
}
if configDisabled {
panic("parseConfig should never have been called with CAMLI_DISABLE_CLIENT_CONFIG_FILE set")
}
configPath := osutil.UserClientConfigPath()
if _, err := wkfs.Stat(config... | go | {
"resource": ""
} |
q31483 | convertToMultiServers | train | func convertToMultiServers(conf jsonconfig.Obj) (jsonconfig.Obj, error) {
server := conf.OptionalString("server", "")
if server == "" {
return nil, errors.New("could not convert config to multi-servers style: no \"server\" key found")
}
newConf := jsonconfig.Obj{
"servers": map[string]interface{}{
"server": ... | go | {
"resource": ""
} |
q31484 | printConfigChangeHelp | train | func printConfigChangeHelp(conf jsonconfig.Obj) {
// rename maps from old key names to the new ones.
// If there is no new one, the value is the empty string.
rename := map[string]string{
"keyId": "identity",
"publicKeyBlobref": "",
"selfPubKeyDir": "",
"secretRing": "identitySecretRing",... | go | {
"resource": ""
} |
q31485 | getServer | train | func getServer() (string, error) {
if s := os.Getenv("CAMLI_SERVER"); s != "" {
return cleanServer(s)
}
if flagServer != "" {
if !isURLOrHostPort(flagServer) {
configOnce.Do(parseConfig)
serverConf, ok := config.Servers[flagServer]
if ok {
return serverConf.Server, nil
}
log.Printf("%q looks l... | go | {
"resource": ""
} |
q31486 | SetupAuth | train | func (c *Client) SetupAuth() error {
if c.noExtConfig {
if c.authMode != nil {
if _, ok := c.authMode.(*auth.None); !ok {
return nil
}
}
return errors.New("client: noExtConfig set; auth should not be configured from config or env vars")
}
// env var takes precedence, but only if we're in dev mode or ... | go | {
"resource": ""
} |
q31487 | serverAuth | train | func serverAuth(server string) string {
configOnce.Do(parseConfig)
alias := config.Alias(server)
if alias == "" {
return ""
}
return config.Servers[alias].Auth
} | go | {
"resource": ""
} |
q31488 | SetupAuthFromString | train | func (c *Client) SetupAuthFromString(a string) error {
// TODO(mpl): review the one using that (pkg/blobserver/remote/remote.go)
var err error
c.authMode, err = auth.FromConfig(a)
return err
} | go | {
"resource": ""
} |
q31489 | serverTrustedCerts | train | func (c *Client) serverTrustedCerts(server string) []string {
configOnce.Do(c.parseConfig)
if config == nil {
return nil
}
alias := config.Alias(server)
if alias == "" {
return nil
}
return config.Servers[alias].TrustedCerts
} | go | {
"resource": ""
} |
q31490 | newIgnoreChecker | train | func newIgnoreChecker(ignoredFiles []string) func(path string) (shouldIgnore bool) {
var fns []func(string) bool
// copy of ignoredFiles for us to mutate
ignFiles := append([]string(nil), ignoredFiles...)
for k, v := range ignFiles {
if strings.HasPrefix(v, filepath.FromSlash("~/")) {
ignFiles[k] = filepath.J... | go | {
"resource": ""
} |
q31491 | hasDirPrefix | train | func hasDirPrefix(dirPrefix, fullpath string) bool {
if !strings.HasPrefix(fullpath, dirPrefix) {
return false
}
if len(fullpath) == len(dirPrefix) {
return true
}
if fullpath[len(dirPrefix)] == filepath.Separator {
return true
}
return false
} | go | {
"resource": ""
} |
q31492 | hasComponent | train | func hasComponent(component, fullpath string) bool {
// trim Windows volume name
fullpath = strings.TrimPrefix(fullpath, filepath.VolumeName(fullpath))
for {
i := strings.Index(fullpath, component)
if i == -1 {
return false
}
if i != 0 && fullpath[i-1] == filepath.Separator {
componentEnd := i + len(co... | go | {
"resource": ""
} |
q31493 | genAll | train | func genAll() ([]string, error) {
zipSource()
for _, platform := range []string{"linux", "darwin", "windows"} {
genBinaries(platform)
packBinaries(platform)
}
getVersions()
return []string{
"perkeep-darwin.tar.gz",
"perkeep-linux.tar.gz",
"perkeep-src.zip",
"perkeep-windows.zip",
}, nil
} | go | {
"resource": ""
} |
q31494 | getVersions | train | func getVersions() {
pkBin := filepath.Join(workDir, runtime.GOOS, "bin", "perkeepd")
cmd := exec.Command(pkBin, "-version")
var buf bytes.Buffer
cmd.Stderr = &buf
if err := cmd.Run(); err != nil {
log.Fatalf("Error getting version from perkeepd: %v, %v", err, buf.String())
}
sc := bufio.NewScanner(&buf)
for ... | go | {
"resource": ""
} |
q31495 | zipSource | train | func zipSource() string {
cwd := filepath.Join(workDir, "src")
check(os.MkdirAll(cwd, 0755))
image := goDockerImage
args := []string{
"run",
"--rm",
"--volume=" + cwd + ":/OUT",
"--volume=" + path.Join(releaseDir, "zip-source.go") + ":" + zipSourceProgram + ":ro",
}
if isWIP() {
args = append(args, "--v... | go | {
"resource": ""
} |
q31496 | committers | train | func committers() (map[string]string, error) {
cmd := exec.Command("git", "shortlog", "-n", "-e", "-s", *flagStatsFrom+".."+revOrHEAD())
out, err := cmd.CombinedOutput()
if err != nil {
return nil, fmt.Errorf("%v; %v", err, string(out))
}
rxp := regexp.MustCompile(`^\s+(\d+)\s+(.*)<(.*)>.*$`)
sc := bufio.NewSca... | go | {
"resource": ""
} |
q31497 | ProjectTokenSource | train | func ProjectTokenSource(proj string, scopes ...string) (oauth2.TokenSource, error) {
// TODO(bradfitz): try different strategies too, like
// three-legged flow if the service account doesn't exist, and
// then cache the token file on disk somewhere. Or maybe that should be an
// option, for environments without std... | go | {
"resource": ""
} |
q31498 | SHA256Prefix | train | func SHA256Prefix(data []byte) string {
h := sha256.New()
h.Write(data)
return fmt.Sprintf("%x", h.Sum(nil))[:20]
} | go | {
"resource": ""
} |
q31499 | SHA1Prefix | train | func SHA1Prefix(data []byte) string {
h := sha1.New()
h.Write(data)
return fmt.Sprintf("%x", h.Sum(nil))[:20]
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.