_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q181300 | Setup | test | func (s *Storage) Setup() error {
query := fmt.Sprintf(`
CREATE SCHEMA IF NOT EXISTS %s;
CREATE TABLE IF NOT EXISTS %s.%s (
access_token BYTEA PRIMARY KEY,
refresh_token BYTEA,
subject_id TEXT NOT NULL,
subject_client TEXT,
bag bytea NOT NULL,
expire_at TIMESTAMPTZ NOT NULL DEFAULT (NOW() + '%d seconds')
);
CREATE INDEX ON %s.%s (refresh_token);
CREATE INDEX ON %s.%s (subject_id);
CREATE INDEX ON %s.%s (expire_at DESC);
`, s.schema, s.schema, s.table, int64(s.ttl.Seconds()),
s.schema, s.table,
s.schema, s.table,
s.schema, s.table,
)
_, err := s.db.Exec(query)
return err
} | go | {
"resource": ""
} |
q181301 | TearDown | test | func (s *Storage) TearDown() error {
_, err := s.db.Exec(`DROP SCHEMA IF EXISTS ` + s.schema + ` CASCADE`)
return err
} | go | {
"resource": ""
} |
q181302 | initJaeger | test | func initJaeger(service, node, agentAddress string, log *zap.Logger) (opentracing.Tracer, io.Closer, error) {
cfg := &config.Configuration{
Sampler: &config.SamplerConfig{
Type: "const",
Param: 1,
},
Tags: []opentracing.Tag{{
Key: constant.Subsystem + ".listen",
Value: node,
}},
Reporter: &config.ReporterConfig{
LogSpans: true,
LocalAgentHostPort: agentAddress,
},
}
tracer, closer, err := cfg.New(service, config.Logger(zapjaeger.NewLogger(log)))
if err != nil {
return nil, nil, err
}
return tracer, closer, nil
} | go | {
"resource": ""
} |
q181303 | Usage | test | func Usage() {
fmt.Fprintf(errorWriter, "Japanese Morphological Analyzer -- github.com/ikawaha/kagome.ipadic\n")
fmt.Fprintf(errorWriter, "usage: %s <command>\n", path.Base(os.Args[0]))
} | go | {
"resource": ""
} |
q181304 | Build | test | func Build(keywords []string) (DoubleArray, error) {
s := len(keywords)
if s == 0 {
return DoubleArray{}, nil
}
ids := make([]int, s, s)
for i := range ids {
ids[i] = i + 1
}
return BuildWithIDs(keywords, ids)
} | go | {
"resource": ""
} |
q181305 | Read | test | func Read(r io.Reader) (DoubleArray, error) {
var sz int64
if e := binary.Read(r, binary.LittleEndian, &sz); e != nil {
return DoubleArray{}, e
}
//fmt.Println("read data len:", sz)
d := make(DoubleArray, sz, sz)
for i := range d {
if e := binary.Read(r, binary.LittleEndian, &d[i].Base); e != nil {
return d, e
}
if e := binary.Read(r, binary.LittleEndian, &d[i].Check); e != nil {
return d, e
}
}
return d, nil
} | go | {
"resource": ""
} |
q181306 | Get | test | func (c *Cluster) Get(k int32) (*Node, bool) {
if len(c.nodes) == 0 {
return nil, false
}
if len(c.nodes)-1 < int(k) {
return nil, false
}
return c.nodes[k], true
} | go | {
"resource": ""
} |
q181307 | ExternalNodes | test | func (c *Cluster) ExternalNodes() (res []*Node) {
for _, n := range c.nodes {
if n.Addr != c.listen {
res = append(res, n)
}
}
return
} | go | {
"resource": ""
} |
q181308 | GetOther | test | func (c *Cluster) GetOther(accessToken string) (*Node, bool) {
if c == nil {
return nil, false
}
if c.Len() == 1 {
return nil, false
}
if node, ok := c.Get(jump.HashString(accessToken, c.Len())); ok {
if node.Addr != c.listen {
if node.Client != nil {
return node, true
}
}
}
return nil, false
} | go | {
"resource": ""
} |
q181309 | GoString | test | func (c *Cluster) GoString() string {
buf, _ := json.Marshal(map[string]interface{}{
"listen": c.listen,
"nodes": c.nodes,
"buckets": strconv.FormatInt(int64(c.buckets), 10),
})
return string(buf)
} | go | {
"resource": ""
} |
q181310 | Scan | test | func (b *Bag) Scan(src interface{}) (err error) {
switch t := src.(type) {
case []byte:
err = gob.NewDecoder(bytes.NewReader(t)).Decode(b)
default:
return errors.New("unsupported data source type")
}
return
} | go | {
"resource": ""
} |
q181311 | Value | test | func (b Bag) Value() (driver.Value, error) {
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(b)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q181312 | Has | test | func (b *Bag) Has(key string) bool {
_, ok := (*b)[key]
return ok
} | go | {
"resource": ""
} |
q181313 | WriteTo | test | func (idx IndexTable) WriteTo(w io.Writer) (n int64, err error) {
n, err = idx.Da.WriteTo(w)
var b bytes.Buffer
enc := gob.NewEncoder(&b)
if err = enc.Encode(idx.Dup); err != nil {
return
}
x, err := b.WriteTo(w)
if err != nil {
return
}
n += x
return
} | go | {
"resource": ""
} |
q181314 | ReadIndexTable | test | func ReadIndexTable(r io.Reader) (IndexTable, error) {
idx := IndexTable{}
d, err := da.Read(r)
if err != nil {
return idx, fmt.Errorf("read index error, %v", err)
}
idx.Da = d
dec := gob.NewDecoder(r)
if e := dec.Decode(&idx.Dup); e != nil {
return idx, fmt.Errorf("read index dup table error, %v", e)
}
return idx, nil
} | go | {
"resource": ""
} |
q181315 | New | test | func New(admin *admin.Admin) *ActionBar {
bar := &ActionBar{Admin: admin}
ctr := &controller{ActionBar: bar}
admin.GetRouter().Get("/action_bar/switch_mode", ctr.SwitchMode)
admin.GetRouter().Get("/action_bar/inline_edit", ctr.InlineEdit)
return bar
} | go | {
"resource": ""
} |
q181316 | RegisterAction | test | func (bar *ActionBar) RegisterAction(action ActionInterface) {
bar.GlobalActions = append(bar.GlobalActions, action)
bar.actions = bar.GlobalActions
} | go | {
"resource": ""
} |
q181317 | Actions | test | func (bar *ActionBar) Actions(actions ...ActionInterface) *ActionBar {
newBar := &ActionBar{Admin: bar.Admin, actions: bar.GlobalActions}
newBar.actions = append(newBar.actions, actions...)
return newBar
} | go | {
"resource": ""
} |
q181318 | Render | test | func (bar *ActionBar) Render(w http.ResponseWriter, r *http.Request) template.HTML {
var (
actions, inlineActions []ActionInterface
context = bar.Admin.NewContext(w, r)
)
for _, action := range bar.actions {
if action.InlineAction() {
inlineActions = append(inlineActions, action)
} else {
actions = append(actions, action)
}
}
context.Context.CurrentUser = bar.Admin.Auth.GetCurrentUser(context)
result := map[string]interface{}{
"EditMode": bar.EditMode(w, r),
"Auth": bar.Admin.Auth,
"CurrentUser": context.Context.CurrentUser,
"Actions": actions,
"InlineActions": inlineActions,
"RouterPrefix": bar.Admin.GetRouter().Prefix,
}
return context.Render("action_bar/action_bar", result)
} | go | {
"resource": ""
} |
q181319 | FuncMap | test | func (bar *ActionBar) FuncMap(w http.ResponseWriter, r *http.Request) template.FuncMap {
funcMap := template.FuncMap{}
funcMap["render_edit_button"] = func(value interface{}, resources ...*admin.Resource) template.HTML {
return bar.RenderEditButtonWithResource(w, r, value, resources...)
}
return funcMap
} | go | {
"resource": ""
} |
q181320 | EditMode | test | func (bar *ActionBar) EditMode(w http.ResponseWriter, r *http.Request) bool {
return isEditMode(bar.Admin.NewContext(w, r))
} | go | {
"resource": ""
} |
q181321 | SwitchMode | test | func (controller) SwitchMode(context *admin.Context) {
utils.SetCookie(http.Cookie{Name: "qor-action-bar", Value: context.Request.URL.Query().Get("checked")}, context.Context)
referrer := context.Request.Referer()
if referrer == "" {
referrer = "/"
}
http.Redirect(context.Writer, context.Request, referrer, http.StatusFound)
} | go | {
"resource": ""
} |
q181322 | InlineEdit | test | func (controller) InlineEdit(context *admin.Context) {
context.Writer.Write([]byte(context.Render("action_bar/inline_edit")))
} | go | {
"resource": ""
} |
q181323 | Error | test | func (e *Error) Error() string {
return fmt.Sprintf("%s:%d: %s", e.Filename, e.LineNum, e.Msg)
} | go | {
"resource": ""
} |
q181324 | ParseFile | test | func ParseFile(filename string) ([]*Machine, Macros, error) {
// TODO(fhs): Check if file is readable by anyone besides the user if there is password in it.
fd, err := os.Open(filename)
if err != nil {
return nil, nil, err
}
defer fd.Close()
return parse(fd, &filePos{filename, 1})
} | go | {
"resource": ""
} |
q181325 | FindMachine | test | func FindMachine(filename, name string) (*Machine, error) {
mach, _, err := ParseFile(filename)
if err != nil {
return nil, err
}
var def *Machine
for _, m := range mach {
if m.Name == name {
return m, nil
}
if m.Name == "" {
def = m
}
}
if def == nil {
return nil, errors.New("no machine found")
}
return def, nil
} | go | {
"resource": ""
} |
q181326 | New | test | func New(initialisms map[string]bool) (*Kace, error) {
ci := initialisms
if ci == nil {
ci = map[string]bool{}
}
ci = sanitizeCI(ci)
t, err := ktrie.NewKTrie(ci)
if err != nil {
return nil, fmt.Errorf("kace: cannot create trie: %s", err)
}
k := &Kace{
t: t,
}
return k, nil
} | go | {
"resource": ""
} |
q181327 | Camel | test | func (k *Kace) Camel(s string) string {
return camelCase(k.t, s, false)
} | go | {
"resource": ""
} |
q181328 | Pascal | test | func (k *Kace) Pascal(s string) string {
return camelCase(k.t, s, true)
} | go | {
"resource": ""
} |
q181329 | Snake | test | func (k *Kace) Snake(s string) string {
return delimitedCase(s, snakeDelim, false)
} | go | {
"resource": ""
} |
q181330 | SnakeUpper | test | func (k *Kace) SnakeUpper(s string) string {
return delimitedCase(s, snakeDelim, true)
} | go | {
"resource": ""
} |
q181331 | Kebab | test | func (k *Kace) Kebab(s string) string {
return delimitedCase(s, kebabDelim, false)
} | go | {
"resource": ""
} |
q181332 | KebabUpper | test | func (k *Kace) KebabUpper(s string) string {
return delimitedCase(s, kebabDelim, true)
} | go | {
"resource": ""
} |
q181333 | isPathSafe | test | func isPathSafe(s string) error {
u, err := url.Parse(s)
if err != nil {
return err
}
e, err := url.PathUnescape(u.Path)
if err != nil {
return err
}
if strings.Contains(e, "..") {
return fmt.Errorf(errorMessage)
}
if !whitelistPattern.MatchString(e) {
return fmt.Errorf(errorMessage)
}
return nil
} | go | {
"resource": ""
} |
q181334 | Start | test | func (t *WriterTracer) Start(r *http.Request) {
t.StartTime = time.Now().UTC()
t.Request.URL = r.URL.String()
t.Request.Method = r.Method
} | go | {
"resource": ""
} |
q181335 | ParseAuthHeaders | test | func ParseAuthHeaders(r *http.Request) (*AuthCreds, error) {
// according to the doc below oauth 2.0 bearer access token can
// come with query parameter
// http://self-issued.info/docs/draft-ietf-oauth-v2-bearer.html#query-param
// we are going to support this
if r.URL.Query().Get(AccessTokenQueryParam) != "" {
return &AuthCreds{
Type: AuthBearer,
Password: r.URL.Query().Get(AccessTokenQueryParam),
}, nil
}
authHeader := r.Header.Get("Authorization")
if authHeader == "" {
return nil, trace.Wrap(&AccessDeniedError{Message: "unauthorized"})
}
auth := strings.SplitN(authHeader, " ", 2)
if len(auth) != 2 {
return nil, trace.Wrap(
&ParameterError{
Name: "Authorization",
Message: "invalid auth header"})
}
switch auth[0] {
case AuthBasic:
payload, err := base64.StdEncoding.DecodeString(auth[1])
if err != nil {
return nil, trace.Wrap(
&ParameterError{
Name: "Authorization",
Message: err.Error()})
}
pair := strings.SplitN(string(payload), ":", 2)
if len(pair) != 2 {
return nil, trace.Wrap(
&ParameterError{
Name: "Authorization",
Message: "bad header"})
}
return &AuthCreds{Type: AuthBasic, Username: pair[0], Password: pair[1]}, nil
case AuthBearer:
return &AuthCreds{Type: AuthBearer, Password: auth[1]}, nil
}
return nil, trace.Wrap(
&ParameterError{
Name: "Authorization",
Message: "unsupported auth scheme"})
} | go | {
"resource": ""
} |
q181336 | Tracer | test | func Tracer(newTracer NewTracer) ClientParam {
return func(c *Client) error {
c.newTracer = newTracer
return nil
}
} | go | {
"resource": ""
} |
q181337 | HTTPClient | test | func HTTPClient(h *http.Client) ClientParam {
return func(c *Client) error {
c.client = h
return nil
}
} | go | {
"resource": ""
} |
q181338 | BasicAuth | test | func BasicAuth(username, password string) ClientParam {
return func(c *Client) error {
c.auth = &basicAuth{username: username, password: password}
return nil
}
} | go | {
"resource": ""
} |
q181339 | BearerAuth | test | func BearerAuth(token string) ClientParam {
return func(c *Client) error {
c.auth = &bearerAuth{token: token}
return nil
}
} | go | {
"resource": ""
} |
q181340 | CookieJar | test | func CookieJar(jar http.CookieJar) ClientParam {
return func(c *Client) error {
c.jar = jar
return nil
}
} | go | {
"resource": ""
} |
q181341 | SanitizerEnabled | test | func SanitizerEnabled(sanitizerEnabled bool) ClientParam {
return func(c *Client) error {
c.sanitizerEnabled = sanitizerEnabled
return nil
}
} | go | {
"resource": ""
} |
q181342 | OpenFile | test | func (c *Client) OpenFile(ctx context.Context, endpoint string, params url.Values) (ReadSeekCloser, error) {
// If the sanitizer is enabled, make sure the requested path is safe.
if c.sanitizerEnabled {
err := isPathSafe(endpoint)
if err != nil {
return nil, err
}
}
u, err := url.Parse(endpoint)
if err != nil {
return nil, err
}
u.RawQuery = params.Encode()
return newSeeker(c, ctx, u.String())
} | go | {
"resource": ""
} |
q181343 | RoundTrip | test | func (c *Client) RoundTrip(fn RoundTripFn) (*Response, error) {
re, err := fn()
if err != nil {
return nil, err
}
defer re.Body.Close()
buf := &bytes.Buffer{}
_, err = io.Copy(buf, re.Body)
if err != nil {
return nil, err
}
return &Response{
code: re.StatusCode,
headers: re.Header,
body: buf,
cookies: re.Cookies(),
}, nil
} | go | {
"resource": ""
} |
q181344 | SetAuthHeader | test | func (c *Client) SetAuthHeader(h http.Header) {
if c.auth != nil {
h.Set("Authorization", c.auth.String())
}
} | go | {
"resource": ""
} |
q181345 | FileName | test | func (r *FileResponse) FileName() string {
value := r.headers.Get("Content-Disposition")
if len(value) == 0 {
return ""
}
_, params, err := mime.ParseMediaType(value)
if err != nil {
return ""
}
return params["filename"]
} | go | {
"resource": ""
} |
q181346 | newBuffersFromFiles | test | func newBuffersFromFiles(files []File) []fileBuffer {
buffers := make([]fileBuffer, 0, len(files))
for _, file := range files {
buffers = append(buffers, newFileBuffer(file))
}
return buffers
} | go | {
"resource": ""
} |
q181347 | newFileBuffer | test | func newFileBuffer(file File) fileBuffer {
buf := &bytes.Buffer{}
return fileBuffer{
Reader: io.TeeReader(file.Reader, buf),
File: file,
cache: buf,
}
} | go | {
"resource": ""
} |
q181348 | rewind | test | func (r *fileBuffer) rewind() {
r.Reader = io.MultiReader(r.cache, r.File.Reader)
} | go | {
"resource": ""
} |
q181349 | ConvertResponse | test | func ConvertResponse(re *Response, err error) (*Response, error) {
if err != nil {
if uerr, ok := err.(*url.Error); ok && uerr != nil && uerr.Err != nil {
return nil, trace.Wrap(uerr.Err)
}
return nil, trace.Wrap(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | go | {
"resource": ""
} |
q181350 | Set | test | func (o *BoolOption) Set(s string) error {
err := convertString(s, &o.Value)
if err != nil {
return err
}
o.Source = "override"
o.Defined = true
return nil
} | go | {
"resource": ""
} |
q181351 | WriteAnswer | test | func (o *BoolOption) WriteAnswer(name string, value interface{}) error {
if v, ok := value.(bool); ok {
o.Value = v
o.Defined = true
o.Source = "prompt"
return nil
}
return fmt.Errorf("Got %T expected %T type: %v", value, o.Value, value)
} | go | {
"resource": ""
} |
q181352 | String | test | func (o BoolOption) String() string {
if StringifyValue {
return fmt.Sprintf("%v", o.Value)
}
return fmt.Sprintf("{Source:%s Defined:%t Value:%v}", o.Source, o.Defined, o.Value)
} | go | {
"resource": ""
} |
q181353 | TriggerIncidentKey | test | func TriggerIncidentKey(description string, key string) (incidentKey string, err error) {
return trigger(description, key, map[string]interface{}{})
} | go | {
"resource": ""
} |
q181354 | TriggerWithDetails | test | func TriggerWithDetails(description string, details map[string]interface{}) (incidentKey string, err error) {
return trigger(description, "", details)
} | go | {
"resource": ""
} |
q181355 | TriggerIncidentKeyWithDetails | test | func TriggerIncidentKeyWithDetails(description string, key string, details map[string]interface{}) (incidentKey string, err error) {
return trigger(description, key, details)
} | go | {
"resource": ""
} |
q181356 | Merge | test | func Merge(dst, src interface{}) {
m := NewMerger()
m.mergeStructs(reflect.ValueOf(dst), reflect.ValueOf(src))
} | go | {
"resource": ""
} |
q181357 | setSource | test | func (m *Merger) setSource(v reflect.Value) {
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
switch v.Kind() {
case reflect.Map:
for _, key := range v.MapKeys() {
keyval := v.MapIndex(key)
if keyval.Kind() == reflect.Struct && keyval.FieldByName("Source").IsValid() {
// map values are immutable, so we need to copy the value
// update the value, then re-insert the value to the map
newval := reflect.New(keyval.Type())
newval.Elem().Set(keyval)
m.setSource(newval)
v.SetMapIndex(key, newval.Elem())
}
}
case reflect.Struct:
if v.CanAddr() {
if option, ok := v.Addr().Interface().(option); ok {
if option.IsDefined() {
option.SetSource(m.sourceFile)
}
return
}
}
for i := 0; i < v.NumField(); i++ {
structField := v.Type().Field(i)
// PkgPath is empty for upper case (exported) field names.
if structField.PkgPath != "" {
// unexported field, skipping
continue
}
m.setSource(v.Field(i))
}
case reflect.Array:
fallthrough
case reflect.Slice:
for i := 0; i < v.Len(); i++ {
m.setSource(v.Index(i))
}
}
} | go | {
"resource": ""
} |
q181358 | convertString | test | func convertString(src string, dst interface{}) (err error) {
switch v := dst.(type) {
case *bool:
*v, err = strconv.ParseBool(src)
case *string:
*v = src
case *int:
var tmp int64
// this is a cheat, we only know int is at least 32 bits
// but we have to make a compromise here
tmp, err = strconv.ParseInt(src, 10, 32)
*v = int(tmp)
case *int8:
var tmp int64
tmp, err = strconv.ParseInt(src, 10, 8)
*v = int8(tmp)
case *int16:
var tmp int64
tmp, err = strconv.ParseInt(src, 10, 16)
*v = int16(tmp)
case *int32:
var tmp int64
tmp, err = strconv.ParseInt(src, 10, 32)
*v = int32(tmp)
case *int64:
var tmp int64
tmp, err = strconv.ParseInt(src, 10, 64)
*v = int64(tmp)
case *uint:
var tmp uint64
// this is a cheat, we only know uint is at least 32 bits
// but we have to make a compromise here
tmp, err = strconv.ParseUint(src, 10, 32)
*v = uint(tmp)
case *uint8:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 8)
*v = uint8(tmp)
case *uint16:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 16)
*v = uint16(tmp)
case *uint32:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 32)
*v = uint32(tmp)
case *uint64:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 64)
*v = uint64(tmp)
// hmm, collides with uint8
// case *byte:
// tmp := []byte(src)
// if len(tmp) == 1 {
// *v = tmp[0]
// } else {
// err = fmt.Errorf("Cannot convert string %q to byte, length: %d", src, len(tmp))
// }
// hmm, collides with int32
// case *rune:
// tmp := []rune(src)
// if len(tmp) == 1 {
// *v = tmp[0]
// } else {
// err = fmt.Errorf("Cannot convert string %q to rune, lengt: %d", src, len(tmp))
// }
case *float32:
var tmp float64
tmp, err = strconv.ParseFloat(src, 32)
*v = float32(tmp)
case *float64:
var tmp float64
tmp, err = strconv.ParseFloat(src, 64)
*v = float64(tmp)
default:
err = fmt.Errorf("Cannot convert string %q to type %T", src, dst)
}
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q181359 | Do | test | func Do(d DB, f func(t Tx) error) error {
t, err := d.TxBegin()
if err != nil {
return err
}
defer t.TxFinish()
err = f(t)
if err != nil {
return err
}
return t.TxCommit()
} | go | {
"resource": ""
} |
q181360 | NewFile | test | func NewFile(filename string) io.Writer {
if err, _ := os.Open(filename); err != nil {
os.Remove(filename)
}
file, _ := os.Create(filename)
return file
} | go | {
"resource": ""
} |
q181361 | internalRun | test | func (b *Bench) internalRun(showProgress bool) results.ResultSet {
startTime := time.Now()
endTime := startTime.Add(b.duration)
sem := semaphore.NewSemaphore(b.threads, b.rampUp) // create a new semaphore with an initiall capacity or 0
out := make(chan results.Result)
resultsChan := make(chan []results.Result)
go handleResult(showProgress, out, resultsChan)
for run := true; run; run = (time.Now().Before(endTime)) {
sem.Lock() // blocks when channel is full
// execute a request
go doRequest(b.request, b.timeout, sem, out)
}
fmt.Print("\nWaiting for threads to finish ")
for i := sem.Length(); i != 0; i = sem.Length() {
//abandon <- true
time.Sleep(200 * time.Millisecond)
}
fmt.Println(" OK")
fmt.Println("")
close(out)
return <-resultsChan
} | go | {
"resource": ""
} |
q181362 | String | test | func (r Row) String() string {
rStr := fmt.Sprintf("Start Time: %v\n", r.StartTime.UTC())
rStr = fmt.Sprintf("%vElapsed Time: %v\n", rStr, r.ElapsedTime)
rStr = fmt.Sprintf("%vThreads: %v\n", rStr, r.Threads)
rStr = fmt.Sprintf("%vTotal Requests: %v\n", rStr, r.TotalRequests)
rStr = fmt.Sprintf("%vAvg Request Time: %v\n", rStr, r.AvgRequestTime)
rStr = fmt.Sprintf("%vTotal Success: %v\n", rStr, r.TotalSuccess)
rStr = fmt.Sprintf("%vTotal Timeouts: %v\n", rStr, r.TotalTimeouts)
return fmt.Sprintf("%vTotal Failures: %v\n", rStr, r.TotalFailures)
} | go | {
"resource": ""
} |
q181363 | Tabulate | test | func (t *TabularResults) Tabulate(results []ResultSet) []Row {
var rows []Row
startTime := time.Unix(0, 0)
for _, bucket := range results {
if len(bucket) > 0 {
var elapsedTime time.Duration
if startTime == time.Unix(0, 0) {
startTime = bucket[0].Timestamp
}
elapsedTime = bucket[0].Timestamp.Sub(startTime)
row := Row{
StartTime: bucket[0].Timestamp,
ElapsedTime: elapsedTime,
Threads: 0,
TotalRequests: 0,
TotalFailures: 0,
TotalSuccess: 0,
TotalTimeouts: 0,
AvgRequestTime: 0,
}
totalRequestTime := 0 * time.Second
maxThreads := 0
for _, r := range bucket {
row.TotalRequests++
if r.Error != nil {
if _, ok := r.Error.(errors.Timeout); ok {
row.TotalTimeouts++
}
row.TotalFailures++
} else {
row.TotalSuccess++
totalRequestTime += r.RequestTime
}
if r.Threads > maxThreads {
maxThreads = r.Threads
row.Threads = maxThreads
}
}
if totalRequestTime != 0 && row.TotalSuccess != 0 {
avgTime := int64(totalRequestTime) / int64(row.TotalSuccess)
row.AvgRequestTime = time.Duration(avgTime)
}
rows = append(rows, row)
}
}
return rows
} | go | {
"resource": ""
} |
q181364 | AmazonRequest | test | func AmazonRequest() error {
resp, err := http.Get("http://www.amazon.co.uk/")
defer func(response *http.Response) {
if response != nil && response.Body != nil {
response.Body.Close()
}
}(resp)
if err != nil || resp.StatusCode != 200 {
return err
}
return nil
} | go | {
"resource": ""
} |
q181365 | WriteTabularData | test | func WriteTabularData(interval time.Duration, r results.ResultSet, w io.Writer) {
set := r.Reduce(interval)
t := results.TabularResults{}
rows := t.Tabulate(set)
for _, row := range rows {
w.Write([]byte(row.String()))
w.Write([]byte("\n"))
}
} | go | {
"resource": ""
} |
q181366 | Reduce | test | func (r ResultSet) Reduce(interval time.Duration) []ResultSet {
sort.Sort(r)
start := r[0].Timestamp
end := r[len(r)-1].Timestamp
// create the buckets
bucketCount := getBucketCount(start, end, interval)
buckets := make([]ResultSet, bucketCount)
for _, result := range r {
currentBucket := getBucketNumber(result.Timestamp, start, end, interval, bucketCount)
buckets[currentBucket] = append(buckets[currentBucket], result)
}
return buckets
} | go | {
"resource": ""
} |
q181367 | NewSemaphore | test | func NewSemaphore(capacity int, rampUp time.Duration) *Semaphore {
s := Semaphore{
lockDone: make(chan struct{}),
lockLock: make(chan struct{}),
rampUp: rampUp,
}
// if the rampup time is less than 1 then return immediately
if rampUp < 1 {
s.s = make(chan struct{}, capacity)
} else {
s.s = make(chan struct{}, 1)
go s.rampUpThreads(capacity, rampUp)
}
s.resizeUnlock()
return &s
} | go | {
"resource": ""
} |
q181368 | Release | test | func (t *Semaphore) Release() {
t.waitIfResizing()
// we need a read lock to ensure we do not resize whilst resizing
t.readMutex.RLock()
defer t.readMutex.RUnlock()
// make sure we have not called Release without Lock
if len(t.s) == 0 {
return
}
<-t.s
} | go | {
"resource": ""
} |
q181369 | Resize | test | func (t *Semaphore) Resize(capacity int) {
// only allow one resize to be called from one thread
t.resizeMutex.Lock()
if capacity == cap(t.s) {
t.resizeMutex.Unlock()
return
}
// lock the locks
t.resizeLock()
t.readMutex.Lock()
defer t.resizeUnlock()
defer t.resizeMutex.Unlock()
defer t.readMutex.Unlock()
new := make(chan struct{}, capacity) // create the new semaphore with the new capcity
// copy the old values
for n := len(t.s); n != 0; n = len(t.s) {
new <- <-t.s // copy elements to the new channel
}
t.s = new
} | go | {
"resource": ""
} |
q181370 | AddOutput | test | func (b *Bench) AddOutput(interval time.Duration, writer io.Writer, output output.OutputFunc) {
o := outputContainer{
interval: interval,
writer: writer,
function: output,
}
b.outputs = append(b.outputs, o)
} | go | {
"resource": ""
} |
q181371 | RunBenchmarks | test | func (b *Bench) RunBenchmarks(r RequestFunc) {
b.request = r
results := b.internalRun(b.showProgress)
b.processResults(results)
} | go | {
"resource": ""
} |
q181372 | parseBool | test | func parseBool(bytes []byte) (ret bool, err error) {
if len(bytes) != 1 {
err = asn1.SyntaxError{Msg: "invalid boolean"}
return
}
// DER demands that "If the encoding represents the boolean value TRUE,
// its single contents octet shall have all eight bits set to one."
// Thus only 0 and 255 are valid encoded values.
switch bytes[0] {
case 0:
ret = false
case 0xff:
ret = true
default:
err = asn1.SyntaxError{Msg: "invalid boolean"}
}
return
} | go | {
"resource": ""
} |
q181373 | checkInteger | test | func checkInteger(bytes []byte) error {
if len(bytes) == 0 {
return asn1.StructuralError{Msg: "empty integer"}
}
if len(bytes) == 1 {
return nil
}
if (bytes[0] == 0 && bytes[1]&0x80 == 0) || (bytes[0] == 0xff && bytes[1]&0x80 == 0x80) {
return asn1.StructuralError{Msg: "integer not minimally-encoded"}
}
return nil
} | go | {
"resource": ""
} |
q181374 | parseInt64 | test | func parseInt64(bytes []byte) (ret int64, err error) {
err = checkInteger(bytes)
if err != nil {
return
}
if len(bytes) > 8 {
// We'll overflow an int64 in this case.
err = asn1.StructuralError{Msg: "integer too large"}
return
}
for bytesRead := 0; bytesRead < len(bytes); bytesRead++ {
ret <<= 8
ret |= int64(bytes[bytesRead])
}
// Shift up and down in order to sign extend the result.
ret <<= 64 - uint8(len(bytes))*8
ret >>= 64 - uint8(len(bytes))*8
return
} | go | {
"resource": ""
} |
q181375 | parseInt32 | test | func parseInt32(bytes []byte) (int32, error) {
if err := checkInteger(bytes); err != nil {
return 0, err
}
ret64, err := parseInt64(bytes)
if err != nil {
return 0, err
}
if ret64 != int64(int32(ret64)) {
return 0, asn1.StructuralError{Msg: "integer too large"}
}
return int32(ret64), nil
} | go | {
"resource": ""
} |
q181376 | parseBigInt | test | func parseBigInt(bytes []byte) (*big.Int, error) {
if err := checkInteger(bytes); err != nil {
return nil, err
}
ret := new(big.Int)
if len(bytes) > 0 && bytes[0]&0x80 == 0x80 {
// This is a negative number.
notBytes := make([]byte, len(bytes))
for i := range notBytes {
notBytes[i] = ^bytes[i]
}
ret.SetBytes(notBytes)
ret.Add(ret, bigOne)
ret.Neg(ret)
return ret, nil
}
ret.SetBytes(bytes)
return ret, nil
} | go | {
"resource": ""
} |
q181377 | parseBitString | test | func parseBitString(bytes []byte) (ret asn1.BitString, err error) {
if len(bytes) == 0 {
err = asn1.SyntaxError{Msg: "zero length BIT STRING"}
return
}
paddingBits := int(bytes[0])
if paddingBits > 7 ||
len(bytes) == 1 && paddingBits > 0 ||
bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {
err = asn1.SyntaxError{Msg: "invalid padding bits in BIT STRING"}
return
}
ret.BitLength = (len(bytes)-1)*8 - paddingBits
ret.Bytes = bytes[1:]
return
} | go | {
"resource": ""
} |
q181378 | parseObjectIdentifier | test | func parseObjectIdentifier(bytes []byte) (s []int, err error) {
if len(bytes) == 0 {
err = asn1.SyntaxError{Msg: "zero length OBJECT IDENTIFIER"}
return
}
// In the worst case, we get two elements from the first byte (which is
// encoded differently) and then every varint is a single byte long.
s = make([]int, len(bytes)+1)
// The first varint is 40*value1 + value2:
// According to this packing, value1 can take the values 0, 1 and 2 only.
// When value1 = 0 or value1 = 1, then value2 is <= 39. When value1 = 2,
// then there are no restrictions on value2.
v, offset, err := _parseBase128Int(bytes, 0)
if err != nil {
return
}
if v < 80 {
s[0] = v / 40
s[1] = v % 40
} else {
s[0] = 2
s[1] = v - 80
}
i := 2
for ; offset < len(bytes); i++ {
v, offset, err = _parseBase128Int(bytes, offset)
if err != nil {
return
}
s[i] = v
}
s = s[0:i]
return
} | go | {
"resource": ""
} |
q181379 | parseBase128Int | test | func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err error) {
ret, offset, err = _parseBase128Int(bytes, initOffset)
if offset-initOffset >= 4 {
err = asn1.StructuralError{Msg: "base 128 integer too large"}
return
}
return
} | go | {
"resource": ""
} |
q181380 | parseGeneralizedTime | test | func parseGeneralizedTime(bytes []byte) (ret time.Time, err error) {
const formatStr = "20060102150405Z0700"
s := string(bytes)
if ret, err = time.Parse(formatStr, s); err != nil {
return
}
if serialized := ret.Format(formatStr); serialized != s {
err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
}
return
} | go | {
"resource": ""
} |
q181381 | parsePrintableString | test | func parsePrintableString(bytes []byte) (ret string, err error) {
for _, b := range bytes {
if !isPrintable(b) {
err = asn1.SyntaxError{Msg: "PrintableString contains invalid character"}
return
}
}
ret = string(bytes)
return
} | go | {
"resource": ""
} |
q181382 | isPrintable | test | func isPrintable(b byte) bool {
return 'a' <= b && b <= 'z' ||
'A' <= b && b <= 'Z' ||
'0' <= b && b <= '9' ||
'\'' <= b && b <= ')' ||
'+' <= b && b <= '/' ||
b == ' ' ||
b == ':' ||
b == '=' ||
b == '?' ||
// This is technically not allowed in a PrintableString.
// However, x509 certificates with wildcard strings don't
// always use the correct string type so we permit it.
b == '*'
} | go | {
"resource": ""
} |
q181383 | parseSequenceOf | test | func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
expectedTag, compoundType, ok := getUniversalType(elemType)
if !ok {
err = asn1.StructuralError{Msg: "unknown Go type for slice"}
return
}
// First we iterate over the input and count the number of elements,
// checking that the types are correct in each case.
numElements := 0
for offset := 0; offset < len(bytes); {
var t tagAndLength
t, offset, err = parseTagAndLength(bytes, offset)
if err != nil {
return
}
switch t.tag {
case tagIA5String, tagGeneralString, tagT61String, tagUTF8String:
// We pretend that various other string types are
// PRINTABLE STRINGs so that a sequence of them can be
// parsed into a []string.
t.tag = tagPrintableString
case tagGeneralizedTime, tagUTCTime:
// Likewise, both time types are treated the same.
t.tag = tagUTCTime
}
if t.class != classUniversal || t.isCompound != compoundType || t.tag != expectedTag {
err = asn1.StructuralError{Msg: "sequence tag mismatch"}
return
}
if invalidLength(offset, t.length, len(bytes)) {
err = asn1.SyntaxError{Msg: "truncated sequence"}
return
}
offset += t.length
numElements++
}
ret = reflect.MakeSlice(sliceType, numElements, numElements)
params := fieldParameters{}
offset := 0
for i := 0; i < numElements; i++ {
offset, err = parseField(ret.Index(i), bytes, offset, params)
if err != nil {
return
}
}
return
} | go | {
"resource": ""
} |
q181384 | invalidLength | test | func invalidLength(offset, length, sliceLength int) bool {
return offset+length < offset || offset+length > sliceLength
} | go | {
"resource": ""
} |
q181385 | setDefaultValue | test | func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
if !params.optional {
return
}
ok = true
if params.defaultValue == nil {
return
}
if canHaveDefaultValue(v.Kind()) {
v.SetInt(*params.defaultValue)
}
return
} | go | {
"resource": ""
} |
q181386 | UnmarshalWithParams | test | func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err error) {
v := reflect.ValueOf(val).Elem()
offset, err := parseField(v, b, 0, parseFieldParameters(params))
if err != nil {
return nil, err
}
return b[offset:], nil
} | go | {
"resource": ""
} |
q181387 | parseFieldParameters | test | func parseFieldParameters(str string) (ret fieldParameters) {
for _, part := range strings.Split(str, ",") {
switch {
case part == "optional":
ret.optional = true
case part == "explicit":
ret.explicit = true
if ret.tag == nil {
ret.tag = new(int)
}
case part == "generalized":
ret.timeType = tagGeneralizedTime
case part == "utc":
ret.timeType = tagUTCTime
case part == "ia5":
ret.stringType = tagIA5String
case part == "printable":
ret.stringType = tagPrintableString
case part == "utf8":
ret.stringType = tagUTF8String
case strings.HasPrefix(part, "default:"):
i, err := strconv.ParseInt(part[8:], 10, 64)
if err == nil {
ret.defaultValue = new(int64)
*ret.defaultValue = i
}
case strings.HasPrefix(part, "tag:"):
i, err := strconv.Atoi(part[4:])
if err == nil {
ret.tag = new(int)
*ret.tag = i
}
case part == "set":
ret.set = true
case part == "application":
ret.application = true
if ret.tag == nil {
ret.tag = new(int)
}
case part == "omitempty":
ret.omitEmpty = true
}
}
return
} | go | {
"resource": ""
} |
q181388 | getUniversalType | test | func getUniversalType(t reflect.Type) (tagNumber int, isCompound, ok bool) {
switch t {
case objectIdentifierType:
return tagOID, false, true
case bitStringType:
return tagBitString, false, true
case timeType:
return tagUTCTime, false, true
case enumeratedType:
return tagEnum, false, true
case bigIntType:
return tagInteger, false, true
}
switch t.Kind() {
case reflect.Bool:
return tagBoolean, false, true
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return tagInteger, false, true
case reflect.Struct:
return tagSequence, true, true
case reflect.Slice:
if t.Elem().Kind() == reflect.Uint8 {
return tagOctetString, false, true
}
if strings.HasSuffix(t.Name(), "SET") {
return tagSet, true, true
}
return tagSequence, true, true
case reflect.String:
return tagPrintableString, false, true
}
return 0, false, false
} | go | {
"resource": ""
} |
q181389 | DecodeString | test | func DecodeString(raw string) ([]byte, error) {
pad := 8 - (len(raw) % 8)
nb := []byte(raw)
if pad != 8 {
nb = make([]byte, len(raw)+pad)
copy(nb, raw)
for i := 0; i < pad; i++ {
nb[len(raw)+i] = '='
}
}
return lowerBase32.DecodeString(string(nb))
} | go | {
"resource": ""
} |
q181390 | MailNotifier | test | func (m MongoDb) MailNotifier(ctxt string) (models.MailNotifier, error) {
c := m.Connect(models.COLL_NAME_MAIL_NOTIFIER)
defer m.Close(c)
var notifier []models.MailNotifier
if err := c.Find(nil).All(¬ifier); err != nil || len(notifier) == 0 {
logger.Get().Error("%s-Unable to read MailNotifier from DB: %v", ctxt, err)
return models.MailNotifier{}, ErrMissingNotifier
} else {
return notifier[0], nil
}
} | go | {
"resource": ""
} |
q181391 | SaveMailNotifier | test | func (m MongoDb) SaveMailNotifier(ctxt string, notifier models.MailNotifier) error {
c := m.Connect(models.COLL_NAME_MAIL_NOTIFIER)
defer m.Close(c)
_, err := c.Upsert(bson.M{}, bson.M{"$set": notifier})
if err != nil {
logger.Get().Error("%s-Error Updating the mail notifier info for: %s Error: %v", ctxt, notifier.MailId, err)
return errors.New(fmt.Sprintf("Error Updating the mail notifier info for: %s Error: %v", notifier.MailId, err))
}
return nil
} | go | {
"resource": ""
} |
q181392 | RegisterProvider | test | func RegisterProvider(name string, factory ProvidersFactory) {
providersMutex.Lock()
defer providersMutex.Unlock()
if _, found := providers[name]; found {
logger.Get().Critical("Auth provider %s was registered twice", name)
}
providers[name] = factory
} | go | {
"resource": ""
} |
q181393 | InitDb | test | func (m MongoDb) InitDb() error {
if err := m.InitUser(); err != nil {
logger.Get().Error("Error Initilaizing User Table", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q181394 | Until | test | func Until(f func(), period time.Duration, stopCh <-chan struct{}) {
for {
select {
case <-stopCh:
return
default:
}
func() {
defer HandleCrash()
f()
}()
time.Sleep(period)
}
} | go | {
"resource": ""
} |
q181395 | logPanic | test | func logPanic(r interface{}) {
callers := ""
for i := 0; true; i++ {
_, file, line, ok := runtime.Caller(i)
if !ok {
break
}
callers = callers + fmt.Sprintf("%v:%v\n", file, line)
}
logger.Get().Error("Recovered from panic: %#v (%v)\n%v", r, r, callers)
} | go | {
"resource": ""
} |
q181396 | User | test | func (m MongoDb) User(username string) (user models.User, e error) {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
err := c.Find(bson.M{"username": username}).One(&user)
if err != nil {
return user, ErrMissingUser
}
return user, nil
} | go | {
"resource": ""
} |
q181397 | Users | test | func (m MongoDb) Users(filter interface{}) (us []models.User, e error) {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
err := c.Find(filter).All(&us)
if err != nil {
logger.Get().Error("Error getting record from DB. error: %v", err)
return us, mkmgoerror(err.Error())
}
return us, nil
} | go | {
"resource": ""
} |
q181398 | SaveUser | test | func (m MongoDb) SaveUser(user models.User) error {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
_, err := c.Upsert(bson.M{"username": user.Username}, bson.M{"$set": user})
if err != nil {
logger.Get().Error("Error deleting record from DB for user: %s. error: %v", user.Username, err)
return mkmgoerror(err.Error())
}
return nil
} | go | {
"resource": ""
} |
q181399 | DeleteUser | test | func (m MongoDb) DeleteUser(username string) error {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
// raises error if "username" doesn't exist
err := c.Remove(bson.M{"username": username})
if err != nil {
logger.Get().Error("Error deleting record from DB for user: %s. error: %v", username, err)
return mkmgoerror(err.Error())
}
return err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.