id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c18200 | != nil {
return err
}
if err := writeRegion(outfile, blobs, regionTag, len(keys)); err != nil {
return err
}
totalSize := 96 + blobs.Len() + entries.Len()
if _, err := io.Copy(outfile, entries); err != nil {
return err
}
if _, err := io.Copy(outfile, blobs); err != nil {
return err
}
if regionTag == R... | |
c18201 | padding := make([]byte, available-needed-16)
sigh.entries[SIG_RESERVEDSPACE-_SIGHEADER_TAG_BASE] = entry{
dataType: RPM_BIN_TYPE,
count: int32(len(padding)),
contents: padding,
}
}
}
buf := new(bytes.Buffer)
buf.Write(hdr.lead)
if err := sigh.WriteTo(buf, regionTag); err != nil {
return ... | |
c18202 | t.MarshalText()
return string(bs)
} | |
c18203 | = result
}
for i, j := 0, len(chars)-1; i < j; i, j = i+1, j-1 {
chars[i], chars[j] = chars[j], chars[i]
}
return chars, nil
} | |
c18204 | := (&t).UnmarshalText([]byte(token))
return t, err
} | |
c18205 | math.Min(math.MaxUint64, math.Pow(float64(base62Len), float64(length)))))
} | |
c18206 |
handlers: make(map[topicChan]*queue),
}
} | |
c18207 |
for _, addr := range addrs {
if err := q.ConnectToNSQD(addr); err != nil {
return err
}
}
}
return nil
} | |
c18208 |
for _, addr := range addrs {
if err := q.ConnectToNSQLookupd(addr); err != nil {
return err
}
}
}
return nil
} | |
c18209 | {
log.Printf("Handler: topic=%s channel=%s\n", i.topic, i.channel)
}
}
<-make(chan bool)
return nil
} | |
c18210 | context.WithValue(ctx, msgkey, msg)
} | |
c18211 | ok := ctx.Value(msgkey).(*Message)
return value, ok
} | |
c18212 |
} else {
m.Message.Requeue(-1)
}
} | |
c18213 | json.Unmarshal(m.Body, v)
} | |
c18214 | DefaultProducer.Publish(topic, body)
} | |
c18215 |
return DefaultProducer.PublishAsync(topic, body, doneChan, args...)
} | |
c18216 | DefaultProducer.MultiPublish(topic, body)
} | |
c18217 | DefaultProducer.ConnectConfig(addr, config)
} | |
c18218 | p.ConnectConfig(addr, nsq.NewConfig())
} | |
c18219 | = nsq.NewProducer(addr, config)
p.Producer.SetLogger(p.Logger, p.LogLevel)
return
} | |
c18220 | != nil {
return err
}
return p.Publish(topic, body)
} | |
c18221 | GVK set
crd.Kind = "CustomResourceDefinition"
crd.APIVersion = apiext_v1b1.SchemeGroupVersion.String()
return crd, nil
default:
// Must never happen
panic(errors.Errorf("multiple CRDs by group %q and kind %q: %s", resource.Group, resource.Kind, objs))
}
} | |
c18222 | is the first/sole multistore it is added to.
err := informer.AddIndexers(cache.Indexers{
ByNamespaceAndControllerUIDIndex: byNamespaceAndControllerUIDIndex,
})
if err != nil {
return errors.WithStack(err)
}
}
s.informers[gvk] = informer
return nil
} | |
c18223 |
}
search.Delete(keys...)
if search.Len() != 0 {
// not all the provided keys in filter were found
return false
}
sort.Strings(keys)
for _, k := range keys {
io.WriteString(h, k) // nolint: gosec, errcheck
h.Write([]byte{0}) // nolint: gosec, errcheck
// The key is either in Data or BinaryData
data... | |
c18224 | _, k := range keys {
io.WriteString(h, k) // nolint: gosec, errcheck
h.Write([]byte{0}) // nolint: gosec, errcheck
h.Write(secret.Data[k]) // nolint: gosec, errcheck
h.Write([]byte{0}) // nolint: gosec, errcheck
}
return true
} | |
c18225 | {
return &bundles{
client: c.RESTClient(),
ns: namespace,
}
} | |
c18226 | IsCrdConditionPresentAndEqual(crd, conditionType, apiext_v1b1.ConditionTrue)
} | |
c18227 | ok {
return errors.New("informer is already registered")
}
s.informers[gvk] = informer
return nil
} | |
c18228 | len(s.informers))
for gvk, inf := range s.informers {
informers[gvk] = inf
}
return informers
} | |
c18229 | == nil {
return nil, false, errors.Errorf("no informer for %s is registered", gvk)
}
return s.getFromIndexer(informer.GetIndexer(), gvk, namespace, name)
} | |
c18230 | !ok {
return spec, nil
}
ctx := &Context{
Logger: logger,
Store: c.Store,
}
updatedSpec, err := processor.BeforeCreate(ctx, spec)
if err != nil {
return nil, errors.Wrap(err, "failed to pre-process object specification")
}
return util.RuntimeToUnstructured(updatedSpec)
} | |
c18231 | s.calculateNewServiceInstanceCheckSum(ctx, spec)
if err != nil {
return errors.Wrap(err, "failed to generate new checksum")
}
if actual != nil && checkSum != previousEncodedChecksum {
spec.Spec.UpdateRequests = updateCount + 1
}
s.setInstanceAnnotation(spec, checkSum)
return nil
} | |
c18232 | err != nil {
ctx.Logger.Warn("Overriding last applied replicas annotation due to parsing failure", zap.Error(err))
spec.Annotations[LastAppliedReplicasAnnotation] = strconv.Itoa(int(specReplicas))
return
}
if specReplicas == int32(lastAppliedReplicas) {
// spec not changed => use actual running config if it... | |
c18233 | {
return &fakesmithv1.FakeSmithV1{Fake: &c.Fake}
} | |
c18234 | {
return &fakesmithv1.FakeSmithV1{Fake: &c.Fake}
} | |
c18235 |
actualField := actualValue.FieldByName(field)
if !actualField.IsValid() {
return errors.Errorf("no such field %q to cleanup", field)
}
if reflect.DeepEqual(requestedField.Interface(), reflect.Zero(requestedField.Type()).Interface()) {
requestedField.Set(actualField)
}
}
return nil
} | |
c18236 | WorkQueue: c.WorkQueue,
Gvk: secretGVK,
Lookup: c.lookupBundleByObjectByIndex(deploymentByIndex, bySecretNamespaceNameIndexName, byNamespaceNameIndexKey),
})
serviceInstanceInf, ok := resourceInfs[sc_v1b1.SchemeGroupVersion.WithKind("ServiceInstance")]
if ok { // Service Catalog support is enabled
/... | |
c18237 | Interface: c.MainClient.CoreV1().Events(meta_v1.NamespaceNone),
}
recordingWatch := c.Broadcaster.StartRecordingToSink(&sink)
defer recordingWatch.Stop()
c.ReadyForWork()
<-ctx.Done()
} | |
c18238 | gks := make(map[schema.GroupKind]struct{}, len(gvks)) // not clear if duplicates are allowed, so de-dupe
for _, gvk := range gvks {
gks[gvk.GroupKind()] = struct{}{}
}
// find all Bundles that contain this object
for gk := range gks {
bundlesForObject, err := c.BundleStore.GetBundlesByObject(gk,... | |
c18239 | := new(Sleeper)
in.DeepCopyInto(out)
return out
} | |
c18240 | out := new(SleeperList)
in.DeepCopyInto(out)
return out
} | |
c18241 | out := new(SleeperSpec)
in.DeepCopyInto(out)
return out
} | |
c18242 |
out := new(SleeperStatus)
in.DeepCopyInto(out)
return out
} | |
c18243 | nil || !exists {
return nil, err
}
return bundle.(*smith_v1.Bundle), nil
} | |
c18244 | s.getBundles(byCrdGroupKindIndexName, byCrdGroupKindIndexKey(crd.Spec.Group, crd.Spec.Names.Kind))
} | |
c18245 | return s.getBundles(byObjectIndexName, byObjectIndexKey(gk, namespace, name))
} | |
c18246 | c.ns, name), &smithv1.Bundle{})
if obj == nil {
return nil, err
}
return obj.(*smithv1.Bundle), err
} | |
c18247 | label = labels.Everything()
}
list := &smithv1.BundleList{ListMeta: obj.(*smithv1.BundleList).ListMeta}
for _, item := range obj.(*smithv1.BundleList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
} | |
c18248 | error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(bundlesResource, c.ns, opts))
} | |
c18249 |
Invokes(testing.NewDeleteAction(bundlesResource, c.ns, name), &smithv1.Bundle{})
return err
} | |
c18250 | data, subresources...), &smithv1.Bundle{})
if obj == nil {
return nil, err
}
return obj.(*smithv1.Bundle), err
} | |
c18251 | h.controller.Logger,
WorkQueue: h.controller.WorkQueue,
ControllerIndex: &controllerIndexAdapter{bundleStore: h.controller.BundleStore},
ControllerGvk: smith_v1.BundleGVK,
Gvk: gvk,
}
crdInf.AddEventHandler(resourceHandler)
err = h.controller.Store.AddInformer(gvk, crdInf)
if e... | |
c18252 | delete(h.watchers, crd.Name)
gvk := schema.GroupVersionKind{
Group: crd.Spec.Group,
Version: crd.Spec.Versions[0].Name,
Kind: crd.Spec.Names.Kind,
}
h.controller.Store.RemoveInformer(gvk)
return true
} | |
c18253 | := new(Bundle)
in.DeepCopyInto(out)
return out
} | |
c18254 | out := new(BundleList)
in.DeepCopyInto(out)
return out
} | |
c18255 | out := new(BundleSpec)
in.DeepCopyInto(out)
return out
} | |
c18256 |
out := new(BundleStatus)
in.DeepCopyInto(out)
return out
} | |
c18257 | out := new(PluginSpec)
in.DeepCopyInto(out)
return out
} | |
c18258 | out := new(Reference)
in.DeepCopyInto(out)
return out
} | |
c18259 | out := new(Resource)
in.DeepCopyInto(out)
return out
} | |
c18260 |
out := new(ResourceSpec)
in.DeepCopyInto(out)
return out
} | |
c18261 | }
out := new(ResourceStatusData)
in.DeepCopyInto(out)
return out
} | |
c18262 |
allExternalErrors := true
hasRetriableResourceErr := false
var failedResources []string
for resName, resInfo := range st.processedResources {
resErr := resInfo.fetchError()
if resErr != nil {
allExternalErrors = allExternalErrors && resErr.isExternalError
hasRetriableResourceErr = hasRetriableResourceEr... | |
c18263 | {
return true, false, errors.Errorf("plugin %q is not a valid plugin", res.Spec.Plugin.Name)
}
gvk = plugin.Plugin.Describe().GVK
name = res.Spec.Plugin.ObjectName
default:
// neither "object" nor "plugin" field is specified. This shouldn't really happen (schema), so we
// should abort the deletio... | |
c18264 | name2status[pluginName]; ok {
continue // Already reported
}
name2status[pluginName] = struct{}{}
var pluginStatus smith_v1.PluginStatus
pluginContainer, ok := st.pluginContainers[pluginName]
if ok {
describe := pluginContainer.Plugin.Describe()
pluginStatus = smith_v1.PluginStatus{
Name: plu... | |
c18265 | inProgressCond.Status = cond_v1.ConditionTrue
} else {
errorCond.Reason = smith_v1.ResourceReasonTerminalError
}
default:
blockedCond.Status = cond_v1.ConditionUnknown
inProgressCond.Status = cond_v1.ConditionUnknown
readyCond.Status = cond_v1.ConditionUnknown
errorCond.Status = cond_v1.Condit... | |
c18266 | case smith_v1.BundleInProgress:
eventType = core_v1.EventTypeNormal
reason = smith.EventReasonBundleInProgress
case smith_v1.BundleReady:
eventType = core_v1.EventTypeNormal
reason = smith.EventReasonBundleReady
default:
st.logger.Sugar().Errorf("Unexpected bundle condition type %q", condition.Type... | |
c18267 | eventType = core_v1.EventTypeWarning
reason = smith.EventReasonResourceError
case smith_v1.ResourceInProgress:
eventType = core_v1.EventTypeNormal
reason = smith.EventReasonResourceInProgress
case smith_v1.ResourceReady:
eventType = core_v1.EventTypeNormal
reason = smith.EventReasonResource... | |
c18268 | API machinery discards TypeMeta for typed objects. This is annoying.
gvks, _, err := scheme.ObjectKinds(in)
if err != nil {
return err
}
out.GetObjectKind().SetGroupVersionKind(gvks[0])
}
return nil
} | |
c18269 | err := runtime.DefaultUnstructuredConverter.ToUnstructured(obj.DeepCopyObject())
if err != nil {
return nil, errors.WithStack(err)
}
return &unstructured.Unstructured{
Object: u,
}, nil
} | |
c18270 | res.Object
case *plugin.ProcessResultFailure:
return nil, resourceStatusError{
err: res.Error,
isRetriableError: res.IsRetriableError,
isExternalError: res.IsExternalError,
}
default:
return nil, resourceStatusError{
err: errors.Errorf("unexpected plugin result type %q", res.StatusTyp... | |
c18271 | "failed to get the client for %s", gvk)
}
switch actual {
case nil:
return st.createResource(resClient, spec)
default:
return st.updateResource(resClient, spec, actual)
}
} | |
c18272 | We let the next processKey() iteration, triggered by someone else updating the resource, finish the work.
return nil, false, errors.Wrap(err, "object update resulted in conflict (will re-process)")
}
// Unexpected error, will retry
apiStatusErr, ok := err.(api_errors.APIStatus)
if ok {
apiStatus := apiSt... | |
c18273 | error", path)
}
var buf bytes.Buffer
err = j.Execute(&buf, obj)
if err != nil {
return "", errors.Wrap(err, "JsonPath execute error")
}
return buf.String(), nil
} | |
c18274 | return nil, nil
}
if len(values) > 1 {
return nil, errors.Errorf("single result expected, got %d", len(values))
}
if values[0] == nil || len(values[0]) == 0 || values[0][0].IsNil() {
return nil, nil
}
return values[0][0].Interface(), nil
} | |
c18275 | make([]*http.Cookie, 0),
Errors: nil,
BasicAuth: struct{ Username, Password string }{},
Debug: false,
CurlCommand: false,
logger: log.New(os.Stderr, "[goreq]", log.LstdFlags),
retry: &RetryConfig{RetryCount: 0, RetryTimeout: 0, RetryOnHTTPStatus... | |
c18276 | gr.CurlCommand = enable
return gr
} | |
c18277 | *GoReq {
gr.logger = logger
return gr
} | |
c18278 | *GoReq {
gr.Client = client
return gr
} | |
c18279 | gr.Cookies = make([]*http.Cookie, 0)
gr.Errors = nil
gr.retry = &RetryConfig{RetryCount: 0, RetryTimeout: 0, RetryOnHTTPStatus: nil}
gr.bindResponseBody = nil
return gr
} | |
c18280 |
gr.Method = GET
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18281 |
gr.Method = POST
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18282 |
gr.Method = HEAD
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18283 |
gr.Method = PUT
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18284 |
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18285 |
gr.Method = PATCH
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18286 |
gr.URL = targetURL
gr.Errors = nil
return gr
} | |
c18287 |
gr.Errors = append(gr.Errors, err)
} else {
for k, v := range val {
gr.QueryData.Add(k, v.(string))
}
}
}
return gr
} | |
c18288 |
return nil, err
}
conn.SetDeadline(time.Now().Add(timeout))
return conn, nil
}
return gr
} | |
c18289 | vv[i] = Request(r)
}
return policy(Request(r), vv)
}
if gr.Client != nil {
gr.Client.CheckRedirect = gr.CheckRedirect
}
return gr
} | |
c18290 | = paramName
gr.FilePath = filePath
return gr
} | |
c18291 | struct {
Crumb string `json:"crumb"`
CrumbRequestField string `json:"crumbRequestField"`
}{}
err = jenkins.get("/crumbIssuer", nil, &crumb)
if err != nil {
return req, err
}
// update header
req.Header.Set(crumb.CrumbRequestField, crumb.Crumb)
return req, nil
} | |
c18292 | err := jenkins.get("", nil, &payload)
return payload.Jobs, err
} | |
c18293 | = jenkins.get(fmt.Sprintf("/job/%s", name), nil, &job)
return
} | |
c18294 | err = jenkins.getXml(fmt.Sprintf("/job/%s/config.xml", name), nil, &job)
return
} | |
c18295 | err = jenkins.get(fmt.Sprintf("/job/%s/%d", job.Name, number), nil, &build)
return
} | |
c18296 | = jenkins.get(fmt.Sprintf("/job/%s/lastBuild", job.Name), nil, &build)
return
} | |
c18297 |
reader := bytes.NewReader(mavenJobItemXml)
params := url.Values{"name": []string{jobName}}
return jenkins.postXml("/createItem", params, reader, nil)
} | |
c18298 | jenkins.post(fmt.Sprintf("/job/%s/doDelete", job.Name), nil, nil)
} | |
c18299 | jenkins.post(fmt.Sprintf("/view/%s/addJobToView", viewName), params, nil)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.