_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q182700 | Auth | test | func (s *FakeVCDClient) Auth(username, password string) (err error) {
return s.ErrAuthFake
} | go | {
"resource": ""
} |
q182701 | QueryTemplate | test | func (s *FakeVCDClient) QueryTemplate(templateName string) (vappTemplate *vcloudclient.VAppTemplateRecord, err error) {
return s.FakeVAppTemplateRecord, s.ErrDeployFake
} | go | {
"resource": ""
} |
q182702 | NewEncoder | test | func NewEncoder(w io.Writer) Encoder {
return versionOneEncoder{w, make([]byte, 9), bytes.NewBuffer(make([]byte, 0, 4096))}
} | go | {
"resource": ""
} |
q182703 | Getter | test | func Getter(g NonceGetter) Option {
return Option{func(o *options) {
o.getter = g
}}
} | go | {
"resource": ""
} |
q182704 | Setter | test | func Setter(s NonceSetter) Option {
return Option{func(o *options) {
o.setter = s
}}
} | go | {
"resource": ""
} |
q182705 | Age | test | func Age(age time.Duration) Option {
return Option{func(o *options) {
o.age = age
}}
} | go | {
"resource": ""
} |
q182706 | Nonce | test | func Nonce(h http.Handler, opts ...Option) http.Handler {
headerStorage := nonceHeaderStorage{}
o := options{
logger: handler.OutLogger(),
generator: timeRandomGenerator,
getter: headerStorage,
setter: headerStorage,
age: 45 * time.Second,
}
o.apply(opts)
store := nonceStore{}
opChan := ... | go | {
"resource": ""
} |
q182707 | NonceValueFromRequest | test | func NonceValueFromRequest(r *http.Request) NonceStatus {
if c := r.Context().Value(nonceValueKey); c != nil {
if v, ok := c.(NonceStatus); ok {
return v
}
}
return NonceStatus{NonceNotRequested}
} | go | {
"resource": ""
} |
q182708 | StoreNonce | test | func StoreNonce(w http.ResponseWriter, r *http.Request) (err error) {
if c := r.Context().Value(nonceSetterKey); c != nil {
if setter, ok := c.(func(http.ResponseWriter, *http.Request) error); ok {
err = setter(w, r)
}
}
return err
} | go | {
"resource": ""
} |
q182709 | PutFloat32Array | test | func (b *TupleBuilder) PutFloat32Array(field string, value []float32) (wrote int, err error) {
// field type should be
if err = b.typeCheck(field, Float32ArrayField); err != nil {
return 0, err
}
size := len(value)
if size < math.MaxUint8 {
if b.available() < size*4+2 {
return 0, xbinary.ErrOutOfRange
... | go | {
"resource": ""
} |
q182710 | PutFloat64Array | test | func (b *TupleBuilder) PutFloat64Array(field string, value []float64) (wrote int, err error) {
// field type should be
if err = b.typeCheck(field, Float64ArrayField); err != nil {
return 0, err
}
size := len(value)
if size < math.MaxUint8 {
if b.available() < size*8+2 {
return 0, xbinary.ErrOutOfRange
... | go | {
"resource": ""
} |
q182711 | Do | test | func (s *ClientDoer) Do(req *http.Request) (resp *http.Response, err error) {
s.SpyRequest = *req
return s.Response, s.Error
} | go | {
"resource": ""
} |
q182712 | NewLease | test | func NewLease(taskCollection integrations.Collection, availableSkus map[string]skurepo.SkuBuilder) *Lease {
return &Lease{
taskCollection: taskCollection,
taskManager: taskmanager.NewTaskManager(taskCollection),
availableSkus: availableSkus,
Task: taskmanager.RedactedTask{},
}
} | go | {
"resource": ""
} |
q182713 | Delete | test | func (s *Lease) Delete(logger *log.Logger, req *http.Request) (statusCode int, response interface{}) {
var (
err error
)
statusCode = http.StatusNotFound
s.taskCollection.Wake()
if err = s.InitFromHTTPRequest(req); err == nil {
logger.Println("restocking inventory...")
s.ReStock()
statusCode = http.Status... | go | {
"resource": ""
} |
q182714 | Post | test | func (s *Lease) Post(logger *log.Logger, req *http.Request) (statusCode int, response interface{}) {
var (
err error
)
statusCode = http.StatusNotFound
s.taskCollection.Wake()
logger.Println("collection dialed successfully")
if err = s.InitFromHTTPRequest(req); err == nil {
logger.Println("obtaining lease...... | go | {
"resource": ""
} |
q182715 | ReStock | test | func (s *Lease) ReStock() (skuTask *taskmanager.Task) {
if skuConstructor, ok := s.availableSkus[s.Sku]; ok {
leaseMap := structs.Map(s)
sku := skuConstructor.New(s.taskManager, leaseMap)
skuTask = sku.ReStock()
s.Task = skuTask.GetRedactedVersion()
} else {
s.Task.Status = TaskStatusUnavailable
}
retur... | go | {
"resource": ""
} |
q182716 | Procurement | test | func (s *Lease) Procurement() (skuTask *taskmanager.Task) {
if skuConstructor, ok := s.availableSkus[s.Sku]; ok {
leaseMap := structs.Map(s)
sku := skuConstructor.New(s.taskManager, leaseMap)
GLogger.Println("here is my sku: ", sku)
skuTask = sku.Procurement()
tt := skuTask.Read(func(t *taskmanager.Task) in... | go | {
"resource": ""
} |
q182717 | InitFromHTTPRequest | test | func (s *Lease) InitFromHTTPRequest(req *http.Request) (err error) {
if req.Body != nil {
if body, err := ioutil.ReadAll(req.Body); err == nil {
if err = json.Unmarshal(body, s); err != nil {
GLogger.Println(err)
}
}
} else {
err = ErrEmptyBody
}
if s.ProcurementMeta == nil {
s.ProcurementMeta... | go | {
"resource": ""
} |
q182718 | Is | test | func (t *Tuple) Is(tupleType TupleType) bool {
return t.Header.Hash == tupleType.Hash && t.Header.NamespaceHash == tupleType.NamespaceHash
} | go | {
"resource": ""
} |
q182719 | Offset | test | func (t *Tuple) Offset(field string) (int, error) {
index, exists := t.Header.Type.Offset(field)
if !exists {
return 0, ErrFieldDoesNotExist
}
// Tuple type and tuple header do not agree on fields
if index < 0 || index >= int(t.Header.FieldCount) {
return 0, ErrInvalidFieldIndex
}
return int(t.Header.Offset... | go | {
"resource": ""
} |
q182720 | WriteTo | test | func (t Tuple) WriteTo(w io.Writer) (n int, err error) {
// write header
wrote, err := t.Header.WriteTo(w)
if err != nil {
return int(wrote), nil
}
n, err = w.Write(t.data)
if err != nil {
return int(n), err
}
return int(wrote) + n, nil
} | go | {
"resource": ""
} |
q182721 | PutTuple | test | func (b *TupleBuilder) PutTuple(field string, value Tuple) (wrote int, err error) {
// field type should be
if err = b.typeCheck(field, TupleField); err != nil {
return 0, err
}
size := value.Size() + value.Header.Size()
if size < math.MaxUint8 {
// check length
if b.available() < size+2 {
return 0, xb... | go | {
"resource": ""
} |
q182722 | WriteString | test | func (ctx *Cotex) WriteString(content string) {
ctx.ResponseWriter.Write([]byte(content))
} | go | {
"resource": ""
} |
q182723 | NotFound | test | func (ctx *Cotex) NotFound(message string) {
ctx.ResponseWriter.WriteHeader(404)
ctx.ResponseWriter.Write([]byte(message))
} | go | {
"resource": ""
} |
q182724 | Run | test | func (s *Agent) Run(process func(*Agent) error) {
s.task.Update(func(t *Task) interface{} {
t.taskManager = s.taskManager
t.Status = AgentTaskStatusRunning
return t
})
s.statusEmitter <- AgentTaskStatusRunning
go s.startTaskPoller()
go s.listenForPoll()
go func(agent Agent) {
s := &agent
s.processExitH... | go | {
"resource": ""
} |
q182725 | NewWaitGroup | test | func NewWaitGroup(throttle int) *WaitGroup {
return &WaitGroup{
outstanding: 0,
throttle: throttle,
completed: make(chan bool, throttle),
}
} | go | {
"resource": ""
} |
q182726 | Add | test | func (w *WaitGroup) Add() {
w.outstanding++
if w.outstanding > w.throttle {
select {
case <-w.completed:
w.outstanding--
return
}
}
} | go | {
"resource": ""
} |
q182727 | Wait | test | func (w *WaitGroup) Wait() {
if w.outstanding == 0 {
return
}
for w.outstanding > 0 {
select {
case <-w.completed:
w.outstanding--
}
}
} | go | {
"resource": ""
} |
q182728 | Gzip | test | func Gzip(h http.Handler, opts ...Option) http.Handler {
o := options{logger: handler.OutLogger()}
o.apply(opts)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
h.ServeHTTP(w, r)
return
}
wrapper := handler.NewRespon... | go | {
"resource": ""
} |
q182729 | New | test | func New(uri string, user string, password string) InnkeeperClient {
return &IkClient{
URI: uri,
User: user,
Password: password,
}
} | go | {
"resource": ""
} |
q182730 | Error | test | func (r *Render) Error(status int, message ...string) {
r.WriteHeader(status)
if len(message) > 0 {
r.Write([]byte(message[0]))
}
} | go | {
"resource": ""
} |
q182731 | Renderer | test | 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)
} ... | go | {
"resource": ""
} |
q182732 | NewClient | test | func NewClient(apiKey string, url string, client clientDoer) *PDClient {
return &PDClient{
APIKey: apiKey,
client: client,
URL: url,
}
} | go | {
"resource": ""
} |
q182733 | GetTask | test | func (s *PDClient) GetTask(taskID string) (task TaskResponse, res *http.Response, err error) {
req, _ := s.createRequest("GET", fmt.Sprintf("%s/v1/task/%s", s.URL, taskID), bytes.NewBufferString(``))
if res, err = s.client.Do(req); err == nil && res.StatusCode == http.StatusOK {
resBodyBytes, _ := ioutil.ReadAll(r... | go | {
"resource": ""
} |
q182734 | WriteImageToHTTP | test | func WriteImageToHTTP(w http.ResponseWriter, img image.Image) error {
buffer := new(bytes.Buffer)
if err := png.Encode(buffer, img); err != nil {
return err
}
w.Header().Set("Content-Type", "image/png")
w.Header().Set("Content-Length", strconv.Itoa(len(buffer.Bytes())))
if _, err := w.Write(buffer.Bytes()); er... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.