_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q33400 | newLambda | train | func newLambda(s LambdaSettings) *goadLambda {
setLambdaExecTimeout(&s)
setDefaultConcurrencyCount(&s)
l := &goadLambda{}
l.Settings = s
l.Metrics = NewRequestMetric(s.LambdaRegion, s.RunnerID)
remainingRequestCount := s.MaxRequestCount - s.CompletedRequestCount
if remainingRequestCount < 0 {
remainingReques... | go | {
"resource": ""
} |
q33401 | Regions | train | func (r *LambdaResults) Regions() []string {
regions := make([]string, 0)
for _, lambda := range r.Lambdas {
if lambda.Region != "" {
regions = append(regions, lambda.Region)
}
}
regions = util.RemoveDuplicates(regions)
sort.Strings(regions)
return regions
} | go | {
"resource": ""
} |
q33402 | RegionsData | train | func (r *LambdaResults) RegionsData() map[string]AggData {
regionsMap := make(map[string]AggData)
for _, region := range r.Regions() {
regionsMap[region] = sumAggData(r.ResultsForRegion(region))
}
return regionsMap
} | go | {
"resource": ""
} |
q33403 | ResultsForRegion | train | func (r *LambdaResults) ResultsForRegion(region string) []AggData {
lambdasOfRegion := make([]AggData, 0)
for _, lambda := range r.Lambdas {
if lambda.Region == region {
lambdasOfRegion = append(lambdasOfRegion, lambda)
}
}
return lambdasOfRegion
} | go | {
"resource": ""
} |
q33404 | Run | train | func Run() {
app.HelpFlag.Short('h')
app.Version(version.String())
app.VersionFlag.Short('V')
config := aggregateConfiguration()
err := config.Check()
goad.HandleErr(err)
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM) // but interrupts from kbd are blocked by termbo... | go | {
"resource": ""
} |
q33405 | clearLogo | train | func clearLogo() {
w, h := termbox.Size()
clearStr := strings.Repeat(" ", w)
for i := 0; i < h-1; i++ {
renderString(0, i, clearStr, coldef, coldef)
}
} | go | {
"resource": ""
} |
q33406 | renderRegion | train | func renderRegion(data result.AggData, y int) int {
x := 0
renderString(x, y, "Region: ", termbox.ColorWhite, termbox.ColorBlue)
x += 8
regionStr := fmt.Sprintf("%s", data.Region)
renderString(x, y, regionStr, termbox.ColorWhite|termbox.AttrBold, termbox.ColorBlue)
x = 0
y++
headingStr := " TotReqs TotBytes... | go | {
"resource": ""
} |
q33407 | Start | train | func Start(t *types.TestConfig) (<-chan *result.LambdaResults, func()) {
var infra infrastructure.Infrastructure
if t.RunDocker {
infra = dockerinfra.New(t)
} else {
infra = awsinfra.New(t)
}
teardown, err := infra.Setup()
HandleErr(err)
t.Lambdas = numberOfLambdas(t.Concurrency, len(t.Regions))
infrastruc... | go | {
"resource": ""
} |
q33408 | New | train | func New(awsConfig *aws.Config, queueURL string) *Adapter {
return &Adapter{getClient(awsConfig), queueURL}
} | go | {
"resource": ""
} |
q33409 | Receive | train | func (adaptor Adapter) Receive() []*api.RunnerResult {
params := &sqs.ReceiveMessageInput{
QueueUrl: aws.String(adaptor.QueueURL),
MaxNumberOfMessages: aws.Int64(10),
VisibilityTimeout: aws.Int64(1),
WaitTimeSeconds: aws.Int64(1),
}
resp, err := adaptor.Client.ReceiveMessage(params)
if err... | go | {
"resource": ""
} |
q33410 | SendResult | train | func (adaptor Adapter) SendResult(result api.RunnerResult) error {
str, jsonerr := jsonFromResult(result)
if jsonerr != nil {
fmt.Println(jsonerr)
panic(jsonerr)
}
params := &sqs.SendMessageInput{
MessageBody: aws.String(str),
MessageGroupId: aws.String("goad-lambda"),
MessageDeduplicat... | go | {
"resource": ""
} |
q33411 | SendResult | train | func (adaptor DummyAdapter) SendResult(result api.RunnerResult) {
str, jsonerr := jsonFromResult(result)
if jsonerr != nil {
fmt.Println(jsonerr)
return
}
fmt.Println("\n" + str)
} | go | {
"resource": ""
} |
q33412 | Serve | train | func Serve() {
http.HandleFunc("/goad", serveResults)
http.HandleFunc("/_health", health)
err := http.ListenAndServe(*addr, nil)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
} | go | {
"resource": ""
} |
q33413 | New | train | func New(config *types.TestConfig) infrastructure.Infrastructure {
awsConfig := aws.NewConfig().WithRegion(config.Regions[0])
infra := &AwsInfrastructure{config: config, awsConfig: awsConfig}
return infra
} | go | {
"resource": ""
} |
q33414 | Validate | train | func (v Validator) Validate(src io.Reader) error {
buf, err := ioutil.ReadAll(src)
if err != nil {
return errors.Wrap(err, "unable to read the document file")
}
if f, ok := mapValidate[v]; ok {
if f == nil {
return fmt.Errorf("internal error: mapValidate[%q] is nil", v)
}
err = f(bytes.NewReader(buf))
... | go | {
"resource": ""
} |
q33415 | ChainID | train | func ChainID(dgsts []digest.Digest) digest.Digest {
chainIDs := make([]digest.Digest, len(dgsts))
copy(chainIDs, dgsts)
ChainIDs(chainIDs)
if len(chainIDs) == 0 {
return ""
}
return chainIDs[len(chainIDs)-1]
} | go | {
"resource": ""
} |
q33416 | FromReader | train | func FromReader(rd io.Reader) (digest.Digest, error) {
return digest.Canonical.FromReader(rd)
} | go | {
"resource": ""
} |
q33417 | newFSLoaderFactory | train | func newFSLoaderFactory(namespaces []string, fs http.FileSystem) *fsLoaderFactory {
return &fsLoaderFactory{
namespaces: namespaces,
fs: fs,
}
} | go | {
"resource": ""
} |
q33418 | refContents | train | func (factory *fsLoaderFactory) refContents(ref gojsonreference.JsonReference) ([]byte, error) {
refStr := ref.String()
path := ""
for _, ns := range factory.namespaces {
if strings.HasPrefix(refStr, ns) {
path = "/" + strings.TrimPrefix(refStr, ns)
break
}
}
if path == "" {
return nil, fmt.Errorf("Sch... | go | {
"resource": ""
} |
q33419 | decodeJSONUsingNumber | train | func decodeJSONUsingNumber(r io.Reader) (interface{}, error) {
// Copied from gojsonschema.
var document interface{}
decoder := json.NewDecoder(r)
decoder.UseNumber()
err := decoder.Decode(&document)
if err != nil {
return nil, err
}
return document, nil
} | go | {
"resource": ""
} |
q33420 | JsonReference | train | func (l *fsLoader) JsonReference() (gojsonreference.JsonReference, error) { // nolint: golint
return gojsonreference.NewJsonReference(l.JsonSource().(string))
} | go | {
"resource": ""
} |
q33421 | NewEnqueuer | train | func NewEnqueuer(namespace string, pool *redis.Pool) *Enqueuer {
if pool == nil {
panic("NewEnqueuer needs a non-nil *redis.Pool")
}
return &Enqueuer{
Namespace: namespace,
Pool: pool,
queuePrefix: redisKeyJobsPrefix(namespace),
knownJobs: make(map[string... | go | {
"resource": ""
} |
q33422 | EnqueueIn | train | func (e *Enqueuer) EnqueueIn(jobName string, secondsFromNow int64, args map[string]interface{}) (*ScheduledJob, error) {
job := &Job{
Name: jobName,
ID: makeIdentifier(),
EnqueuedAt: nowEpochSeconds(),
Args: args,
}
rawJSON, err := job.serialize()
if err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q33423 | EnqueueUniqueIn | train | func (e *Enqueuer) EnqueueUniqueIn(jobName string, secondsFromNow int64, args map[string]interface{}) (*ScheduledJob, error) {
return e.EnqueueUniqueInByKey(jobName, secondsFromNow, args, nil)
} | go | {
"resource": ""
} |
q33424 | EnqueueUniqueInByKey | train | func (e *Enqueuer) EnqueueUniqueInByKey(jobName string, secondsFromNow int64, args map[string]interface{}, keyMap map[string]interface{}) (*ScheduledJob, error) {
enqueue, job, err := e.uniqueJobHelper(jobName, args, keyMap)
if err != nil {
return nil, err
}
scheduledJob := &ScheduledJob{
RunAt: nowEpochSecond... | go | {
"resource": ""
} |
q33425 | NewClient | train | func NewClient(namespace string, pool *redis.Pool) *Client {
return &Client{
namespace: namespace,
pool: pool,
}
} | go | {
"resource": ""
} |
q33426 | WorkerObservations | train | func (c *Client) WorkerObservations() ([]*WorkerObservation, error) {
conn := c.pool.Get()
defer conn.Close()
hbs, err := c.WorkerPoolHeartbeats()
if err != nil {
logError("worker_observations.worker_pool_heartbeats", err)
return nil, err
}
var workerIDs []string
for _, hb := range hbs {
workerIDs = appe... | go | {
"resource": ""
} |
q33427 | Queues | train | func (c *Client) Queues() ([]*Queue, error) {
conn := c.pool.Get()
defer conn.Close()
key := redisKeyKnownJobs(c.namespace)
jobNames, err := redis.Strings(conn.Do("SMEMBERS", key))
if err != nil {
return nil, err
}
sort.Strings(jobNames)
for _, jobName := range jobNames {
conn.Send("LLEN", redisKeyJobs(c.... | go | {
"resource": ""
} |
q33428 | DeleteDeadJob | train | func (c *Client) DeleteDeadJob(diedAt int64, jobID string) error {
ok, _, err := c.deleteZsetJob(redisKeyDead(c.namespace), diedAt, jobID)
if err != nil {
return err
}
if !ok {
return ErrNotDeleted
}
return nil
} | go | {
"resource": ""
} |
q33429 | RetryDeadJob | train | func (c *Client) RetryDeadJob(diedAt int64, jobID string) error {
// Get queues for job names
queues, err := c.Queues()
if err != nil {
logError("client.retry_all_dead_jobs.queues", err)
return err
}
// Extract job names
var jobNames []string
for _, q := range queues {
jobNames = append(jobNames, q.JobNam... | go | {
"resource": ""
} |
q33430 | RetryAllDeadJobs | train | func (c *Client) RetryAllDeadJobs() error {
// Get queues for job names
queues, err := c.Queues()
if err != nil {
logError("client.retry_all_dead_jobs.queues", err)
return err
}
// Extract job names
var jobNames []string
for _, q := range queues {
jobNames = append(jobNames, q.JobName)
}
script := redi... | go | {
"resource": ""
} |
q33431 | DeleteAllDeadJobs | train | func (c *Client) DeleteAllDeadJobs() error {
conn := c.pool.Get()
defer conn.Close()
_, err := conn.Do("DEL", redisKeyDead(c.namespace))
if err != nil {
logError("client.delete_all_dead_jobs", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q33432 | DeleteScheduledJob | train | func (c *Client) DeleteScheduledJob(scheduledFor int64, jobID string) error {
ok, jobBytes, err := c.deleteZsetJob(redisKeyScheduled(c.namespace), scheduledFor, jobID)
if err != nil {
return err
}
// If we get a job back, parse it and see if it's a unique job. If it is, we need to delete the unique key.
if len(... | go | {
"resource": ""
} |
q33433 | DeleteRetryJob | train | func (c *Client) DeleteRetryJob(retryAt int64, jobID string) error {
ok, _, err := c.deleteZsetJob(redisKeyRetry(c.namespace), retryAt, jobID)
if err != nil {
return err
}
if !ok {
return ErrNotDeleted
}
return nil
} | go | {
"resource": ""
} |
q33434 | setArg | train | func (j *Job) setArg(key string, val interface{}) {
if j.Args == nil {
j.Args = make(map[string]interface{})
}
j.Args[key] = val
} | go | {
"resource": ""
} |
q33435 | Checkin | train | func (j *Job) Checkin(msg string) {
if j.observer != nil {
j.observer.observeCheckin(j.Name, j.ID, msg)
}
} | go | {
"resource": ""
} |
q33436 | defaultBackoffCalculator | train | func defaultBackoffCalculator(job *Job) int64 {
fails := job.Fails
return (fails * fails * fails * fails) + 15 + (rand.Int63n(30) * (fails + 1))
} | go | {
"resource": ""
} |
q33437 | NewServer | train | func NewServer(namespace string, pool *redis.Pool, hostPort string) *Server {
router := web.New(context{})
server := &Server{
namespace: namespace,
pool: pool,
client: work.NewClient(namespace, pool),
hostPort: hostPort,
server: manners.NewWithServer(&http.Server{Addr: hostPort, Handler: router}... | go | {
"resource": ""
} |
q33438 | Start | train | func (w *Server) Start() {
w.wg.Add(1)
go func(w *Server) {
w.server.ListenAndServe()
w.wg.Done()
}(w)
} | go | {
"resource": ""
} |
q33439 | runJob | train | func runJob(job *Job, ctxType reflect.Type, middleware []*middlewareHandler, jt *jobType) (returnCtx reflect.Value, returnError error) {
returnCtx = reflect.New(ctxType)
currentMiddleware := 0
maxMiddleware := len(middleware)
var next NextMiddlewareFunc
next = func() error {
if currentMiddleware < maxMiddleware... | go | {
"resource": ""
} |
q33440 | NewWorkerPool | train | func NewWorkerPool(ctx interface{}, concurrency uint, namespace string, pool *redis.Pool) *WorkerPool {
return NewWorkerPoolWithOptions(ctx, concurrency, namespace, pool, WorkerPoolOptions{})
} | go | {
"resource": ""
} |
q33441 | NewWorkerPoolWithOptions | train | func NewWorkerPoolWithOptions(ctx interface{}, concurrency uint, namespace string, pool *redis.Pool, workerPoolOpts WorkerPoolOptions) *WorkerPool {
if pool == nil {
panic("NewWorkerPool needs a non-nil *redis.Pool")
}
ctxType := reflect.TypeOf(ctx)
validateContextType(ctxType)
wp := &WorkerPool{
workerPoolID... | go | {
"resource": ""
} |
q33442 | JobWithOptions | train | func (wp *WorkerPool) JobWithOptions(name string, jobOpts JobOptions, fn interface{}) *WorkerPool {
jobOpts = applyDefaultsAndValidate(jobOpts)
vfn := reflect.ValueOf(fn)
validateHandlerType(wp.contextType, vfn)
jt := &jobType{
Name: name,
DynamicHandler: vfn,
JobOptions: jobOpts,
}
if gh, ok... | go | {
"resource": ""
} |
q33443 | Start | train | func (wp *WorkerPool) Start() {
if wp.started {
return
}
wp.started = true
// TODO: we should cleanup stale keys on startup from previously registered jobs
wp.writeConcurrencyControlsToRedis()
go wp.writeKnownJobsToRedis()
for _, w := range wp.workers {
go w.start()
}
wp.heartbeater = newWorkerPoolHeart... | go | {
"resource": ""
} |
q33444 | Stop | train | func (wp *WorkerPool) Stop() {
if !wp.started {
return
}
wp.started = false
wg := sync.WaitGroup{}
for _, w := range wp.workers {
wg.Add(1)
go func(w *worker) {
w.stop()
wg.Done()
}(w)
}
wg.Wait()
wp.heartbeater.stop()
wp.retrier.stop()
wp.scheduler.stop()
wp.deadPoolReaper.stop()
wp.periodic... | go | {
"resource": ""
} |
q33445 | Drain | train | func (wp *WorkerPool) Drain() {
wg := sync.WaitGroup{}
for _, w := range wp.workers {
wg.Add(1)
go func(w *worker) {
w.drain()
wg.Done()
}(w)
}
wg.Wait()
} | go | {
"resource": ""
} |
q33446 | NewAPI | train | func NewAPI(opts ...apiOption) (*API, error) {
api := &API{}
for _, opt := range opts {
err := opt(api)
if err != nil {
return nil, errors.Wrap(err, "applying option")
}
}
return api, nil
} | go | {
"resource": ""
} |
q33447 | Query | train | func (api *API) Query(ctx context.Context, req *QueryRequest) (QueryResponse, error) {
span, ctx := tracing.StartSpanFromContext(ctx, "API.Query")
defer span.Finish()
if err := api.validate(apiQuery); err != nil {
return QueryResponse{}, errors.Wrap(err, "validating api method")
}
q, err := pql.NewParser(strin... | go | {
"resource": ""
} |
q33448 | CreateIndex | train | func (api *API) CreateIndex(ctx context.Context, indexName string, options IndexOptions) (*Index, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.CreateIndex")
defer span.Finish()
if err := api.validate(apiCreateIndex); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
// Create i... | go | {
"resource": ""
} |
q33449 | Index | train | func (api *API) Index(ctx context.Context, indexName string) (*Index, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.Index")
defer span.Finish()
if err := api.validate(apiIndex); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
index := api.holder.Index(indexName)
if index == n... | go | {
"resource": ""
} |
q33450 | DeleteIndex | train | func (api *API) DeleteIndex(ctx context.Context, indexName string) error {
span, _ := tracing.StartSpanFromContext(ctx, "API.DeleteIndex")
defer span.Finish()
if err := api.validate(apiDeleteIndex); err != nil {
return errors.Wrap(err, "validating api method")
}
// Delete index from the holder.
err := api.hol... | go | {
"resource": ""
} |
q33451 | CreateField | train | func (api *API) CreateField(ctx context.Context, indexName string, fieldName string, opts ...FieldOption) (*Field, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.CreateField")
defer span.Finish()
if err := api.validate(apiCreateField); err != nil {
return nil, errors.Wrap(err, "validating api method")... | go | {
"resource": ""
} |
q33452 | Field | train | func (api *API) Field(ctx context.Context, indexName, fieldName string) (*Field, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.Field")
defer span.Finish()
if err := api.validate(apiField); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
field := api.holder.Field(indexName, fie... | go | {
"resource": ""
} |
q33453 | DeleteField | train | func (api *API) DeleteField(ctx context.Context, indexName string, fieldName string) error {
span, _ := tracing.StartSpanFromContext(ctx, "API.DeleteField")
defer span.Finish()
if err := api.validate(apiDeleteField); err != nil {
return errors.Wrap(err, "validating api method")
}
// Find index.
index := api.h... | go | {
"resource": ""
} |
q33454 | DeleteAvailableShard | train | func (api *API) DeleteAvailableShard(_ context.Context, indexName, fieldName string, shardID uint64) error {
if err := api.validate(apiDeleteAvailableShard); err != nil {
return errors.Wrap(err, "validating api method")
}
// Find field.
field := api.holder.Field(indexName, fieldName)
if field == nil {
return ... | go | {
"resource": ""
} |
q33455 | ShardNodes | train | func (api *API) ShardNodes(ctx context.Context, indexName string, shard uint64) ([]*Node, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.ShardNodes")
defer span.Finish()
if err := api.validate(apiShardNodes); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
return api.cluster.sh... | go | {
"resource": ""
} |
q33456 | FragmentBlockData | train | func (api *API) FragmentBlockData(ctx context.Context, body io.Reader) ([]byte, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.FragmentBlockData")
defer span.Finish()
if err := api.validate(apiFragmentBlockData); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
reqBytes, err := ... | go | {
"resource": ""
} |
q33457 | FragmentBlocks | train | func (api *API) FragmentBlocks(ctx context.Context, indexName, fieldName, viewName string, shard uint64) ([]FragmentBlock, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.FragmentBlocks")
defer span.Finish()
if err := api.validate(apiFragmentBlocks); err != nil {
return nil, errors.Wrap(err, "validatin... | go | {
"resource": ""
} |
q33458 | FragmentData | train | func (api *API) FragmentData(ctx context.Context, indexName, fieldName, viewName string, shard uint64) (io.WriterTo, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.FragmentData")
defer span.Finish()
if err := api.validate(apiFragmentData); err != nil {
return nil, errors.Wrap(err, "validating api meth... | go | {
"resource": ""
} |
q33459 | Hosts | train | func (api *API) Hosts(ctx context.Context) []*Node {
span, _ := tracing.StartSpanFromContext(ctx, "API.Hosts")
defer span.Finish()
return api.cluster.Nodes()
} | go | {
"resource": ""
} |
q33460 | RecalculateCaches | train | func (api *API) RecalculateCaches(ctx context.Context) error {
span, _ := tracing.StartSpanFromContext(ctx, "API.RecalculateCaches")
defer span.Finish()
if err := api.validate(apiRecalculateCaches); err != nil {
return errors.Wrap(err, "validating api method")
}
err := api.server.SendSync(&RecalculateCaches{})... | go | {
"resource": ""
} |
q33461 | ClusterMessage | train | func (api *API) ClusterMessage(ctx context.Context, reqBody io.Reader) error {
span, _ := tracing.StartSpanFromContext(ctx, "API.ClusterMessage")
defer span.Finish()
if err := api.validate(apiClusterMessage); err != nil {
return errors.Wrap(err, "validating api method")
}
// Read entire body.
body, err := iou... | go | {
"resource": ""
} |
q33462 | Schema | train | func (api *API) Schema(ctx context.Context) []*IndexInfo {
span, _ := tracing.StartSpanFromContext(ctx, "API.Schema")
defer span.Finish()
return api.holder.limitedSchema()
} | go | {
"resource": ""
} |
q33463 | Views | train | func (api *API) Views(ctx context.Context, indexName string, fieldName string) ([]*view, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.Views")
defer span.Finish()
if err := api.validate(apiViews); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
// Retrieve views.
f := api.hol... | go | {
"resource": ""
} |
q33464 | DeleteView | train | func (api *API) DeleteView(ctx context.Context, indexName string, fieldName string, viewName string) error {
span, _ := tracing.StartSpanFromContext(ctx, "API.DeleteView")
defer span.Finish()
if err := api.validate(apiDeleteView); err != nil {
return errors.Wrap(err, "validating api method")
}
// Retrieve fiel... | go | {
"resource": ""
} |
q33465 | IndexAttrDiff | train | func (api *API) IndexAttrDiff(ctx context.Context, indexName string, blocks []AttrBlock) (map[uint64]map[string]interface{}, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.IndexAttrDiff")
defer span.Finish()
if err := api.validate(apiIndexAttrDiff); err != nil {
return nil, errors.Wrap(err, "validatin... | go | {
"resource": ""
} |
q33466 | FieldAttrDiff | train | func (api *API) FieldAttrDiff(ctx context.Context, indexName string, fieldName string, blocks []AttrBlock) (map[uint64]map[string]interface{}, error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.FieldAttrDiff")
defer span.Finish()
if err := api.validate(apiFieldAttrDiff); err != nil {
return nil, errors.Wr... | go | {
"resource": ""
} |
q33467 | OptImportOptionsClear | train | func OptImportOptionsClear(c bool) ImportOption {
return func(o *ImportOptions) error {
o.Clear = c
return nil
}
} | go | {
"resource": ""
} |
q33468 | OptImportOptionsIgnoreKeyCheck | train | func OptImportOptionsIgnoreKeyCheck(b bool) ImportOption {
return func(o *ImportOptions) error {
o.IgnoreKeyCheck = b
return nil
}
} | go | {
"resource": ""
} |
q33469 | AvailableShardsByIndex | train | func (api *API) AvailableShardsByIndex(ctx context.Context) map[string]*roaring.Bitmap {
span, _ := tracing.StartSpanFromContext(ctx, "API.AvailableShardsByIndex")
defer span.Finish()
return api.holder.availableShardsByIndex()
} | go | {
"resource": ""
} |
q33470 | StatsWithTags | train | func (api *API) StatsWithTags(tags []string) stats.StatsClient {
if api.holder == nil || api.cluster == nil {
return nil
}
return api.holder.Stats.WithTags(tags...)
} | go | {
"resource": ""
} |
q33471 | SetCoordinator | train | func (api *API) SetCoordinator(ctx context.Context, id string) (oldNode, newNode *Node, err error) {
span, _ := tracing.StartSpanFromContext(ctx, "API.SetCoordinator")
defer span.Finish()
if err := api.validate(apiSetCoordinator); err != nil {
return nil, nil, errors.Wrap(err, "validating api method")
}
oldNod... | go | {
"resource": ""
} |
q33472 | RemoveNode | train | func (api *API) RemoveNode(id string) (*Node, error) {
if err := api.validate(apiRemoveNode); err != nil {
return nil, errors.Wrap(err, "validating api method")
}
removeNode := api.cluster.nodeByID(id)
if removeNode == nil {
if !api.cluster.topologyContainsNode(id) {
return nil, errors.Wrap(ErrNodeIDNotExis... | go | {
"resource": ""
} |
q33473 | ResizeAbort | train | func (api *API) ResizeAbort() error {
if err := api.validate(apiResizeAbort); err != nil {
return errors.Wrap(err, "validating api method")
}
err := api.cluster.completeCurrentJob(resizeJobStateAborted)
return errors.Wrap(err, "complete current job")
} | go | {
"resource": ""
} |
q33474 | GetTranslateData | train | func (api *API) GetTranslateData(ctx context.Context, offset int64) (io.ReadCloser, error) {
span, ctx := tracing.StartSpanFromContext(ctx, "API.GetTranslateData")
defer span.Finish()
rc, err := api.holder.translateFile.Reader(ctx, offset)
if err != nil {
return nil, errors.Wrap(err, "read from translate store")... | go | {
"resource": ""
} |
q33475 | Info | train | func (api *API) Info() serverInfo {
si := api.server.systemInfo
// we don't report errors on failures to get this information
physicalCores, logicalCores, _ := si.CPUCores()
mhz, _ := si.CPUMHz()
mem, _ := si.MemTotal()
return serverInfo{
ShardWidth: ShardWidth,
CPUPhysicalCores: physicalCores,
CPULog... | go | {
"resource": ""
} |
q33476 | TranslateKeys | train | func (api *API) TranslateKeys(body io.Reader) ([]byte, error) {
reqBytes, err := ioutil.ReadAll(body)
if err != nil {
return nil, NewBadRequestError(errors.Wrap(err, "read body error"))
}
var req TranslateKeysRequest
if err := api.Serializer.Unmarshal(reqBytes, &req); err != nil {
return nil, NewBadRequestErro... | go | {
"resource": ""
} |
q33477 | StartSpanFromContext | train | func (t *Tracer) StartSpanFromContext(ctx context.Context, operationName string) (tracing.Span, context.Context) {
var opts []opentracing.StartSpanOption
if parent := opentracing.SpanFromContext(ctx); parent != nil {
opts = append(opts, opentracing.ChildOf(parent.Context()))
}
span := t.tracer.StartSpan(operation... | go | {
"resource": ""
} |
q33478 | InjectHTTPHeaders | train | func (t *Tracer) InjectHTTPHeaders(r *http.Request) {
if span := opentracing.SpanFromContext(r.Context()); span != nil {
if err := t.tracer.Inject(
span.Context(),
opentracing.HTTPHeaders,
opentracing.HTTPHeadersCarrier(r.Header),
); err != nil {
log.Printf("opentracing inject error: %s", err)
}
}
} | go | {
"resource": ""
} |
q33479 | ExtractHTTPHeaders | train | func (t *Tracer) ExtractHTTPHeaders(r *http.Request) (tracing.Span, context.Context) {
// Deserialize tracing context into request.
wireContext, _ := t.tracer.Extract(
opentracing.HTTPHeaders,
opentracing.HTTPHeadersCarrier(r.Header),
)
span := t.tracer.StartSpan("HTTP", ext.RPCServerOption(wireContext))
ctx ... | go | {
"resource": ""
} |
q33480 | Printf | train | func (cl *CaptureLogger) Printf(format string, v ...interface{}) {
cl.Prints = append(cl.Prints, fmt.Sprintf(format, v...))
} | go | {
"resource": ""
} |
q33481 | Debugf | train | func (cl *CaptureLogger) Debugf(format string, v ...interface{}) {
cl.Debugs = append(cl.Debugs, fmt.Sprintf(format, v...))
} | go | {
"resource": ""
} |
q33482 | newView | train | func newView(path, index, field, name string, fieldOptions FieldOptions) *view {
return &view{
path: path,
index: index,
field: field,
name: name,
fieldType: fieldOptions.Type,
cacheType: fieldOptions.CacheType,
cacheSize: fieldOptions.CacheSize,
fragments: make(map[uint64]*fragment),
broadcaste... | go | {
"resource": ""
} |
q33483 | open | train | func (v *view) open() error {
// Never keep a cache for field views.
if strings.HasPrefix(v.name, viewBSIGroupPrefix) {
v.cacheType = CacheTypeNone
}
if err := func() error {
// Ensure the view's path exists.
v.logger.Debugf("ensure view path exists: %s", v.path)
if err := os.MkdirAll(v.path, 0777); err !... | go | {
"resource": ""
} |
q33484 | openFragments | train | func (v *view) openFragments() error {
file, err := os.Open(filepath.Join(v.path, "fragments"))
if os.IsNotExist(err) {
return nil
} else if err != nil {
return errors.Wrap(err, "opening fragments directory")
}
defer file.Close()
fis, err := file.Readdir(0)
if err != nil {
return errors.Wrap(err, "reading... | go | {
"resource": ""
} |
q33485 | close | train | func (v *view) close() error {
v.mu.Lock()
defer v.mu.Unlock()
// Close all fragments.
for _, frag := range v.fragments {
if err := frag.Close(); err != nil {
return errors.Wrap(err, "closing fragment")
}
}
v.fragments = make(map[uint64]*fragment)
return nil
} | go | {
"resource": ""
} |
q33486 | availableShards | train | func (v *view) availableShards() *roaring.Bitmap {
v.mu.RLock()
defer v.mu.RUnlock()
b := roaring.NewBitmap()
for shard := range v.fragments {
_, _ = b.Add(shard) // ignore error, no writer attached
}
return b
} | go | {
"resource": ""
} |
q33487 | fragmentPath | train | func (v *view) fragmentPath(shard uint64) string {
return filepath.Join(v.path, "fragments", strconv.FormatUint(shard, 10))
} | go | {
"resource": ""
} |
q33488 | Fragment | train | func (v *view) Fragment(shard uint64) *fragment {
v.mu.RLock()
defer v.mu.RUnlock()
return v.fragments[shard]
} | go | {
"resource": ""
} |
q33489 | allFragments | train | func (v *view) allFragments() []*fragment {
v.mu.Lock()
defer v.mu.Unlock()
other := make([]*fragment, 0, len(v.fragments))
for _, fragment := range v.fragments {
other = append(other, fragment)
}
return other
} | go | {
"resource": ""
} |
q33490 | CreateFragmentIfNotExists | train | func (v *view) CreateFragmentIfNotExists(shard uint64) (*fragment, error) {
v.mu.Lock()
defer v.mu.Unlock()
// Find fragment in cache first.
if frag := v.fragments[shard]; frag != nil {
return frag, nil
}
// Initialize and open fragment.
frag := v.newFragment(v.fragmentPath(shard), shard)
if err := frag.Open... | go | {
"resource": ""
} |
q33491 | deleteFragment | train | func (v *view) deleteFragment(shard uint64) error {
fragment := v.Fragment(shard)
if fragment == nil {
return ErrFragmentNotFound
}
v.logger.Printf("delete fragment: (%s/%s/%s) %d", v.index, v.field, v.name, shard)
// Close data files before deletion.
if err := fragment.Close(); err != nil {
return errors.W... | go | {
"resource": ""
} |
q33492 | row | train | func (v *view) row(rowID uint64) *Row {
row := NewRow()
for _, frag := range v.allFragments() {
fr := frag.row(rowID)
if fr == nil {
continue
}
row.Merge(fr)
}
return row
} | go | {
"resource": ""
} |
q33493 | setBit | train | func (v *view) setBit(rowID, columnID uint64) (changed bool, err error) {
shard := columnID / ShardWidth
frag, err := v.CreateFragmentIfNotExists(shard)
if err != nil {
return changed, err
}
return frag.setBit(rowID, columnID)
} | go | {
"resource": ""
} |
q33494 | clearBit | train | func (v *view) clearBit(rowID, columnID uint64) (changed bool, err error) {
shard := columnID / ShardWidth
frag := v.Fragment(shard)
if frag == nil {
return false, nil
}
return frag.clearBit(rowID, columnID)
} | go | {
"resource": ""
} |
q33495 | sum | train | func (v *view) sum(filter *Row, bitDepth uint) (sum, count uint64, err error) {
for _, f := range v.allFragments() {
fsum, fcount, err := f.sum(filter, bitDepth)
if err != nil {
return sum, count, err
}
sum += fsum
count += fcount
}
return sum, count, nil
} | go | {
"resource": ""
} |
q33496 | min | train | func (v *view) min(filter *Row, bitDepth uint) (min, count uint64, err error) {
var minHasValue bool
for _, f := range v.allFragments() {
fmin, fcount, err := f.min(filter, bitDepth)
if err != nil {
return min, count, err
}
// Don't consider a min based on zero columns.
if fcount == 0 {
continue
}
... | go | {
"resource": ""
} |
q33497 | max | train | func (v *view) max(filter *Row, bitDepth uint) (max, count uint64, err error) {
for _, f := range v.allFragments() {
fmax, fcount, err := f.max(filter, bitDepth)
if err != nil {
return max, count, err
}
if fcount > 0 && fmax > max {
max = fmax
count += fcount
}
}
return max, count, nil
} | go | {
"resource": ""
} |
q33498 | rangeOp | train | func (v *view) rangeOp(op pql.Token, bitDepth uint, predicate uint64) (*Row, error) {
r := NewRow()
for _, frag := range v.allFragments() {
other, err := frag.rangeOp(op, bitDepth, predicate)
if err != nil {
return nil, err
}
r = r.Union(other)
}
return r, nil
} | go | {
"resource": ""
} |
q33499 | NewConfigCommand | train | func NewConfigCommand(stdin io.Reader, stdout, stderr io.Writer) *ConfigCommand {
return &ConfigCommand{
CmdIO: pilosa.NewCmdIO(stdin, stdout, stderr),
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.