id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c17300 | queries
if queries != nil && len(queries) > 0 {
for _, eventQuery := range queries {
if eventQuery.Filter != FilterTimestamp && eventQuery.Filter != FilterActee {
return nil, errors.New("Unsupported query filter type " + eventQuery.Filter)
}
if !stringInSlice(eventQuery.Operator, ValidOperators) {
... | |
c17301 |
body, err := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
if err != nil {
return ServiceKey{}, err
}
err = json.Unmarshal(body, &serviceKeyResource)
if err != nil {
return ServiceKey{}, err
}
return serviceKeyResource.Entity, nil
} | |
c17302 | it a SecGroup
err = json.Unmarshal(bodyRaw, &jStruct)
if err != nil {
return nil, errors.Wrap(err, "Could not unmarshal response body as json")
}
//pull a few extra fields from other places
ret := jStruct.Entity
ret.Guid = jStruct.Meta.Guid
ret.CreatedAt = jStruct.Meta.CreatedAt
ret.UpdatedAt = jStruct.Meta.... | |
c17303 | var response SecGroupCreateResponse
bodyRaw, _ := ioutil.ReadAll(resp.Body)
err = json.Unmarshal(bodyRaw, &response)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshaling response")
}
return nil, fmt.Errorf(`Request failed CF API returned with status code %d
-------------------------------
E... | |
c17304 | nextURL = u.(string)
}
default:
return nil, fmt.Errorf("Unexpected type [%s] for next url", reflect.TypeOf(resp.Pagination.Next).String())
}
if nextURL == "" {
return allProcesses, nil
}
u, err := url.Parse(nextURL)
if err != nil {
return nil, err
}
urlPath = u.Path
query, err = url... | |
c17305 |
return c.listApps("/v2/apps?"+query.Encode(), totalPages)
} | |
c17306 | != "" {
//Getting Spaces Resource
space, err := app.Space()
if err != nil {
errors.Wrap(err, "Unable to get the Space for the apps "+app.Name)
} else {
app.SpaceData.Entity = space
}
//Getting orgResource
org, err := app.SpaceData.Entity.Org()
if err != nil {
errors.Wrap(err, "Unable to get ... | |
c17307 | return
}
if len(apps) == 0 {
err = fmt.Errorf("No app found with name: `%s` in space with GUID `%s` and org with GUID `%s`", appName, spaceGuid, orgGuid)
return
}
app = apps[0]
return
} | |
c17308 | requestURL, requestFile)
req, err := r.toHTTP()
if err != nil {
return errors.Wrapf(err, "Error uploading app %s bits", appGUID)
}
req.ContentLength = fileStats.Size()
contentType := fmt.Sprintf("multipart/form-data; boundary=%s", writer.Boundary())
req.Header.Set("Content-Type", contentType)
resp, err := c... | |
c17309 |
}
client := &http.Client{Transport: tr}
resp, err = client.Get(blobStoreLocation)
if err != nil {
return nil, errors.Wrapf(err, "Error downloading app %s bits from blobstore", guid)
}
} else {
return nil, errors.Wrapf(err, "Error downloading app %s bits, expected redirect to blobstore", guid)
}
retur... | |
c17310 | != nil {
return App{}, errors.Wrapf(err, "Error reading app %s http response body", req.Name)
}
err = json.Unmarshal(resBody, &appResp)
if err != nil {
return App{}, errors.Wrapf(err, "Error deserializing app %s response", req.Name)
}
return c.mergeAppResource(appResp), nil
} | |
c17311 | requesting info")
}
defer resp.Body.Close()
var i Info
err = json.NewDecoder(resp.Body).Decode(&i)
if err != nil {
return nil, errors.Wrap(err, "Error unmarshalling info")
}
return &i, nil
} | |
c17312 | }
}
return CloudFoundryError{
cfErrorsV3.Errors[0].Code,
cfErrorsV3.Errors[0].Title,
cfErrorsV3.Errors[0].Detail,
}
} | |
c17313 | _, e := range serviceUsageEventsResponse.Resources {
e.Entity.GUID = e.Meta.Guid
e.Entity.CreatedAt = e.Meta.CreatedAt
e.Entity.c = c
serviceUsageEvents = append(serviceUsageEvents, e.Entity)
}
requestURL = serviceUsageEventsResponse.NextURL
if requestURL == "" {
break
}
}
return serviceUsageE... | |
c17314 | e := range eventResp.Resources {
e.Entity.GUID = e.Meta.Guid
e.Entity.CreatedAt = e.Meta.CreatedAt
e.Entity.c = c
events = append(events, e.Entity)
}
requestURL = eventResp.NextURL
if requestURL == "" {
break
}
}
return events, nil
} | |
c17315 | if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
return 0, errors.Wrap(err, "error unmarshaling events")
}
return apiResp.TotalResults, nil
} | |
c17316 | {
return task, errors.Wrap(err, "Error reading task after creation")
}
err = json.Unmarshal(body, &task)
if err != nil {
return task, errors.Wrap(err, "Error unmarshaling task")
}
return task, err
} | |
c17317 | != nil {
return task, errors.Wrap(err, "Error reading task")
}
err = json.Unmarshal(body, &task)
if err != nil {
return task, errors.Wrap(err, "Error unmarshaling task")
}
return task, err
} | |
c17318 | if resp.StatusCode != 202 {
return errors.Wrapf(err, "Failed terminating task, response status code %d", resp.StatusCode)
}
return nil
} | |
c17319 | Password: "admin",
Token: "",
SkipSslValidation: false,
HttpClient: http.DefaultClient,
UserAgent: "Go-CF-client/1.1",
}
} | |
c17320 | to have no "bearer" prefix
token := &oauth2.Token{
AccessToken: config.Token,
TokenType: "Bearer"}
config.TokenSource = authConfig.TokenSource(ctx, token)
config.HttpClient = oauth2.NewClient(ctx, config.TokenSource)
return config
} | |
c17321 | c.Config.ApiAddress + path,
params: make(map[string][]string),
}
return r
} | |
c17322 | *Request {
r := c.NewRequest(method, path)
// Set request body
r.body = body
return r
} | |
c17323 | return http.ErrUseLastResponse
}
defer func() {
c.Config.HttpClient.CheckRedirect = prevCheckRedirect
}()
return c.DoRequest(r)
} | |
c17324 |
plans, err := c.ListServicePlansByQuery(q)
if err != nil {
return ServicePlanVisibility{}, errors.Wrap(err, fmt.Sprintf("Couldn't find a service plan with unique_id: %s", uniqueId))
}
return c.CreateServicePlanVisibility(plans[0].Guid, organizationGuid)
} | |
c17325 | err != nil {
return User{}, err
}
err = json.Unmarshal(body, &userRes)
if err != nil {
return User{}, err
}
return c.mergeUserResource(userRes), nil
} | |
c17326 | e := range appUsageEventsResponse.Resources {
e.Entity.GUID = e.Meta.Guid
e.Entity.CreatedAt = e.Meta.CreatedAt
e.Entity.c = c
appUsageEvents = append(appUsageEvents, e.Entity)
}
requestURL = appUsageEventsResponse.NextURL
if requestURL == "" {
break
}
}
return appUsageEvents, nil
} | |
c17327 |
return Route{}, err
}
return c.mergeRouteResource(routesResource), nil
} | |
c17328 | if resp.StatusCode != http.StatusCreated {
return fmt.Errorf("Error binding route %s to app %s, response code: %d", routeGUID, appGUID, resp.StatusCode)
}
return nil
} | |
c17329 | h%2 != 0 && h != d.Height {
return fmt.Errorf("invalid interlaced input height %v", d.Height)
}
}
return nil
} | |
c17330 | 2
case Ratio420, Ratio422:
return (d.Width + 1) >> 1
case Ratio440, Ratio444:
return d.Width
}
panic(fmt.Errorf("invalid ratio %v", d.Ratio))
} | |
c17331 | Ratio420, Ratio440:
h := (d.Height + 1) >> 1
if d.Interlaced && h&1 != 0 {
h++
}
return h
}
panic(fmt.Errorf("invalid ratio %v", d.Ratio))
} | |
c17332 | Ratio411
case image.YCbCrSubsampleRatio420:
return Ratio420
case image.YCbCrSubsampleRatio422:
return Ratio422
case image.YCbCrSubsampleRatio440:
return Ratio440
case image.YCbCrSubsampleRatio444:
return Ratio444
}
return Ratio444
} | |
c17333 | nil, err
}
err = checkConversion(dst, src)
if err != nil {
return nil, err
}
return &ConverterConfig{
Input: *src,
Output: *dst,
}, nil
} | |
c17334 | psnrs = append(psnrs, psnrPlane(src[i].Data, dst[i].Data, src[i].Width*src[i].Pack, src[i].Height, src[i].Pitch, dst[i].Pitch))
}
return psnrs, nil
} | |
c17335 | 0)}
ctx.scaler = getHorizontalScaler(ctx.kernels[0].size, !cfg.DisableAsm)
if cfg.Vertical {
ctx.scaler = getVerticalScaler(ctx.kernels[0].size, !cfg.DisableAsm)
if cfg.Interlaced {
ctx.kernels = append(ctx.kernels, makeKernel(&ctx.cfg, filter, 1))
}
}
return &ctx
} | |
c17336 | {
pix := int(s[xoff+0])*int(c[0]) +
int(s[xoff+1])*int(c[1])
d[x] = u8((pix + 1<<(Bits-1)) >> Bits)
c = c[2:]
}
di += dp
si += sp
}
} | |
c17337 |
err = dumpPlane(prefix, &p, i)
if err != nil {
return err
}
}
return nil
} | |
c17338 | := l.LoadString(src, options)
return l, err
} | |
c17339 | := l.LoadFile(path, options)
return l, err
} | |
c17340 | {
return l.parse(r, options)
} | |
c17341 | r := strings.NewReader(src)
return l.parse(r, options)
} | |
c17342 |
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return l.parse(f, options)
} | |
c17343 | error {
l.rules[r.Value] = r
return nil
} | |
c17344 |
}
i := strings.IndexRune(part, '.')
if i < 0 {
return options.DefaultRule
}
part = part[i+1:]
}
return nil
} | |
c17345 | err := NewRule(content)
if err != nil {
panic(err)
}
return rule
} | |
c17346 | l.List.Find(domain, nil)
return rule.Decompose(domain)[1]
} | |
c17347 |
// "dirs only" option
if opts.DirsOnly {
continue
}
var rePrefix string
if opts.IgnoreCase {
rePrefix = "(?i)"
}
// Pattern matching
if opts.Pattern != "" {
re, err := regexp.Compile(rePrefix + opts.Pattern)
if err == nil && !re.MatchString(name) {
continue
}
}
//... | |
c17348 |
case i > KB:
eFmt = "K"
n = float64(i) / float64(KB)
default:
sFmt = "%.0f"
n = float64(i)
}
if eFmt != "" && n >= 10 {
sFmt = "%.0f"
}
result = fmt.Sprintf(sFmt+eFmt, n)
result = strings.Trim(result, " ")
return
} | |
c17349 | strings.ToLower(str) {
return true
}
}
return false
} | |
c17350 | if v[0] != `` {
return field.Name(), v[0], nil
} else {
return field.Name(), field.Name(), nil
}
}
}
}
if fallbackIdentityFieldName == `` {
fallbackIdentityFieldName = DefaultStructIdentityFieldName
}
if _, ok := s.FieldOk(fallbackIdentityFieldName); ok {
return fallbackIdentityField... | |
c17351 | protocol := stringutil.SplitPair(self.URI.Scheme, `+`)
return backend, strings.Trim(protocol, `/`)
} | |
c17352 |
} else if len(defaults) > 0 {
return defaults[0]
} else {
return ``
}
} | |
c17353 | } else if len(defaults) > 0 {
return defaults[0]
} else {
return ``
}
} | |
c17354 | `/`)
dataset = strings.TrimSuffix(dataset, `/`)
return dataset
} | |
c17355 | self.URI.User = url.UserPassword(username, password)
} | |
c17356 | password := machine.Get(`password`)
if login != `` || password != `` {
self.URI.User = url.UserPassword(login, password)
}
}
} else {
return fmt.Errorf("netrc error: %v", err)
}
}
}
return nil
} | |
c17357 | DefaultIdentityField,
IdentityFieldType: DefaultIdentityFieldType,
IdentityFieldValidator: ValidateNotEmpty,
}
} | |
c17358 | !typeutil.IsZero(value) {
if expireAt := typeutil.V(value).Time(); !expireAt.IsZero() {
return expireAt.Sub(time.Now())
}
}
}
return 0
} | |
c17359 | return true
} else {
return false
}
} | |
c17360 | if self.IndexName != `` {
return self.IndexName
}
return self.Name
} | |
c17361 | return self.IndexName
}
return self.Name
} | |
c17362 | nil {
self.IdentityFieldFormatter = formatter
}
if validator != nil {
self.IdentityFieldValidator = validator
}
return self
} | |
c17363 | = append(self.Fields, fields...)
return self
} | |
c17364 | are either client-only fields or we know better
// than the database on this one
self.Fields[i].Required = defField.Required
self.Fields[i].Type = defField.Type
self.Fields[i].KeyType = defField.KeyType
self.Fields[i].Subtype = defField.Subtype
self.Fields[i].DefaultValue = defField.DefaultValu... | |
c17365 |
for _, field := range self.Fields {
if field.Name == name {
return field, true
}
}
}
return Field{}, false
} | |
c17366 | Index: self.IdentityFieldIndex,
Identity: true,
Key: true,
Required: true,
}, true
} else {
for _, field := range self.Fields {
if field.Index == index {
return field, true
}
}
}
return Field{}, false
} | |
c17367 | ok := self.GetField(name); ok {
return (field.Key && !field.Identity)
}
return false
} | |
c17368 | Identity: true,
Key: true,
Required: true,
},
}
// append additional key fields
for _, field := range self.Fields {
if field.Key {
keys = append(keys, field)
}
}
return keys
} | |
c17369 | !field.Identity {
return field, true
}
}
return Field{}, false
} | |
c17370 | v, err := field.ConvertValue(value); err == nil {
return v
}
}
return value
} | |
c17371 | record.ID != nil {
if id, err := self.formatAndValidateId(record.ID, RetrieveOperation, record); err == nil {
rv[self.GetIdentityFieldName()] = id
} else {
return nil, err
}
}
if len(self.Fields) > 0 {
for _, field := range self.Fields {
if v := record.Get(field.Name); v != nil {
if l... | |
c17372 | if err := self.PreSaveValidator(record); err != nil {
return err
}
}
}
return nil
} | |
c17373 | `` {
merr = log.AppendError(merr, fmt.Errorf("collection[%s] field[%s]: invalid type %q", self.Name, field.Name, field.Type))
}
}
return merr
} | |
c17374 | id); err == nil {
return record.Populate(into, self.collection)
} else {
return err
}
} | |
c17375 | self.db.Exists(self.collection.Name, id)
} | |
c17376 | err == nil {
return self.db.Update(self.collection.Name, dal.NewRecordSet(record))
} else {
return err
}
} | |
c17377 |
return self.Create(from)
} else {
return self.Update(from)
}
} | |
c17378 | self.db.Delete(self.collection.Name, ids...)
} | |
c17379 |
if search := self.db.WithSearch(self.collection, f); search != nil {
return search.DeleteQuery(self.collection, f)
} else {
return fmt.Errorf("backend %T does not support searching", self.db)
}
} else {
return err
}
} | |
c17380 | search.Query(self.collection, f); err == nil {
return self.populateOutputParameter(f, recordset, into)
} else {
return err
}
} else {
return fmt.Errorf("backend %T does not support searching", self.db)
}
} else {
return err
}
} | |
c17381 | if err := record.Populate(into, self.collection); err == nil {
resultFn(into, nil)
} else {
return err
}
}
} else {
resultFn(nil, err)
}
return nil
})
return err
} else {
return fmt.Errorf("backend %T does not support searching", self.db)
}
} else {
re... | |
c17382 |
}
if typeutil.IsZero(value) {
value = stringutil.UUID().String()
}
return value, nil
} | |
c17383 | }
if typeutil.IsZero(value) {
if v, err := encoder(stringutil.UUID().Bytes()); err == nil {
if typeutil.IsZero(v) {
return value, fmt.Errorf("UUID encoder produced a zero-length result")
}
value = v
} else {
return value, err
}
}
return value, nil
}
} | |
c17384 | {
if typeutil.IsZero(value) {
return onlyIf(value, op)
}
}
return value, nil
}
} | |
c17385 | := make([]interface{}, len(fields))
for i, field := range fields {
values[i] = record.Get(field)
}
return fmt.Sprintf(format, values...), nil
} else {
return nil, fmt.Errorf("DeriveFromFields formatter requires a *dal.Record argument, got %T", input)
}
}
} | |
c17386 | return time.Now(), nil
} else {
return value, nil
}
} | |
c17387 | o == PersistOperation {
return time.Now(), nil
} else {
return v, nil
}
})(value, op)
} | |
c17388 | error) {
if op == PersistOperation {
if duration != 0 {
return time.Now().Add(duration), nil
}
}
return value, nil
}
} | |
c17389 |
if !rx.MatchString(typeutil.String(value)) {
return fmt.Errorf("Value does not match pattern %q", rx.String())
}
}
return nil
}
} | |
c17390 | {
for _, validator := range validators {
if err := validator(value); err != nil {
return err
}
}
return nil
}
} | |
c17391 | range choices {
if ok, err := stringutil.RelaxedEqual(choice, value); err == nil && ok {
return nil
}
}
return fmt.Errorf("value must be one of: %+v", choices)
}
} | |
c17392 | fmt.Errorf("expected non-empty value, got: %v", value)
}
return nil
} | |
c17393 | == nil {
if v <= 0 {
return fmt.Errorf("expected value > 0, got: %v", v)
}
} else {
return err
}
return nil
} | |
c17394 |
return fmt.Errorf("Invalid URL")
}
} else {
return err
}
return nil
} | |
c17395 | ` `)
// querylog.Debugf("[%v] %v %v", self, cmd, debug)
return redis.DoWithTimeout(conn, self.cmdTimeout, cmd, args...)
} else {
return nil, fmt.Errorf("Failed to borrow Redis connection")
}
} | |
c17396 | if err := tx.Commit(); err == nil {
return nil
} else {
return err
}
} else {
defer tx.Rollback()
return err
}
} else {
defer tx.Rollback()
return err
}
} else {
return err
}
} | |
c17397 | type with data from this record
if err := record.Populate(elem.Interface(), schema); err == nil {
// if the slice elements are pointers, we can append the pointer we just created as-is
// otherwise, we need to indirect the value and append a copy
if indirectResult {
vInto.Set(reflect.Append(vInto,... | |
c17398 | get the name of the identity field from the given struct
if _, key, err := getIdentityFieldNameFromStruct(into, fallbackIdFieldName); err == nil && key != `` {
idFieldName = key
} else if err != nil {
return err
} else {
return fmt.Errorf("Could not determine identity field name")
}
if data, err :=... | |
c17399 | context.WithValue(parent, contextKey{}, logger)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.