_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q18200 | WriteTo | train | func (hdr *rpmHeader) WriteTo(outfile io.Writer, regionTag int) error {
if regionTag != 0 && regionTag >= RPMTAG_HEADERREGIONS {
return errors.New("invalid region tag")
}
// sort tags
var keys []int
for k := range hdr.entries {
if k < RPMTAG_HEADERREGIONS {
// discard existing regions
continue
}
keys... | go | {
"resource": ""
} |
q18201 | DumpSignatureHeader | train | func (hdr *RpmHeader) DumpSignatureHeader(sameSize bool) ([]byte, error) {
if len(hdr.lead) != 96 {
return nil, errors.New("invalid or missing RPM lead")
}
sigh := hdr.sigHeader
regionTag := RPMTAG_HEADERSIGNATURES
delete(sigh.entries, SIG_RESERVEDSPACE-_SIGHEADER_TAG_BASE)
if sameSize {
needed, err := sigh.s... | go | {
"resource": ""
} |
q18202 | Encode | train | func (t Token) Encode() string {
bs, _ := t.MarshalText()
return string(bs)
} | go | {
"resource": ""
} |
q18203 | MarshalText | train | func (t Token) MarshalText() ([]byte, error) {
number := uint64(t)
var chars []byte
if number == 0 {
return chars, nil
}
for number > 0 {
result := number / base62Len
remainder := number % base62Len
chars = append(chars, Base62[remainder])
number = result
}
for i, j := 0, len(chars)-1; i < j; i, j =... | go | {
"resource": ""
} |
q18204 | Decode | train | func Decode(token string) (Token, error) {
var t Token
err := (&t).UnmarshalText([]byte(token))
return t, err
} | go | {
"resource": ""
} |
q18205 | maxHashInt | train | func maxHashInt(length int) uint64 {
return uint64(math.Max(0, math.Min(math.MaxUint64, math.Pow(float64(base62Len), float64(length)))))
} | go | {
"resource": ""
} |
q18206 | New | train | func New() *Consumer {
return &Consumer{
Logger: nsqlog.Logger,
LogLevel: nsqlog.LogLevel,
handlers: make(map[topicChan]*queue),
}
} | go | {
"resource": ""
} |
q18207 | Connect | train | func (c *Consumer) Connect(addrs ...string) error {
for _, q := range c.handlers {
for _, addr := range addrs {
if err := q.ConnectToNSQD(addr); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q18208 | ConnectLookupd | train | func (c *Consumer) ConnectLookupd(addrs ...string) error {
for _, q := range c.handlers {
for _, addr := range addrs {
if err := q.ConnectToNSQLookupd(addr); err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q18209 | Start | train | func (c *Consumer) Start(debug bool) error {
if debug {
for i := range c.handlers {
log.Printf("Handler: topic=%s channel=%s\n", i.topic, i.channel)
}
}
<-make(chan bool)
return nil
} | go | {
"resource": ""
} |
q18210 | WithMessage | train | func WithMessage(ctx context.Context, msg *Message) context.Context {
return context.WithValue(ctx, msgkey, msg)
} | go | {
"resource": ""
} |
q18211 | MessageFromContext | train | func MessageFromContext(ctx context.Context) (*Message, bool) {
value, ok := ctx.Value(msgkey).(*Message)
return value, ok
} | go | {
"resource": ""
} |
q18212 | Finish | train | func (m *Message) Finish(success bool) {
if success {
m.Message.Finish()
} else {
m.Message.Requeue(-1)
}
} | go | {
"resource": ""
} |
q18213 | ReadJSON | train | func (m *Message) ReadJSON(v interface{}) error {
return json.Unmarshal(m.Body, v)
} | go | {
"resource": ""
} |
q18214 | Publish | train | func Publish(topic string, body []byte) error {
return DefaultProducer.Publish(topic, body)
} | go | {
"resource": ""
} |
q18215 | PublishAsync | train | func PublishAsync(topic string, body []byte, doneChan chan *nsq.ProducerTransaction, args ...interface{}) error {
return DefaultProducer.PublishAsync(topic, body, doneChan, args...)
} | go | {
"resource": ""
} |
q18216 | MultiPublish | train | func MultiPublish(topic string, body [][]byte) error {
return DefaultProducer.MultiPublish(topic, body)
} | go | {
"resource": ""
} |
q18217 | ConnectConfig | train | func ConnectConfig(addr string, config *nsq.Config) error {
return DefaultProducer.ConnectConfig(addr, config)
} | go | {
"resource": ""
} |
q18218 | Connect | train | func (p *Producer) Connect(addr string) (err error) {
return p.ConnectConfig(addr, nsq.NewConfig())
} | go | {
"resource": ""
} |
q18219 | ConnectConfig | train | func (p *Producer) ConnectConfig(addr string, config *nsq.Config) (err error) {
p.Producer, err = nsq.NewProducer(addr, config)
p.Producer.SetLogger(p.Logger, p.LogLevel)
return
} | go | {
"resource": ""
} |
q18220 | PublishJSON | train | func (p *Producer) PublishJSON(topic string, v interface{}) error {
body, err := json.Marshal(v)
if err != nil {
return err
}
return p.Publish(topic, body)
} | go | {
"resource": ""
} |
q18221 | Get | train | func (s *Crd) Get(resource schema.GroupKind) (*apiext_v1b1.CustomResourceDefinition, error) {
objs, err := s.byIndex(byGroupKindIndexName, byGroupKindIndexKey(resource.Group, resource.Kind))
if err != nil {
return nil, err
}
switch len(objs) {
case 0:
return nil, nil
case 1:
crd := objs[0].(*apiext_v1b1.Cus... | go | {
"resource": ""
} |
q18222 | AddInformer | train | func (s *Multi) AddInformer(gvk schema.GroupVersionKind, informer cache.SharedIndexInformer) error {
s.mx.Lock()
defer s.mx.Unlock()
if _, ok := s.informers[gvk]; ok {
return errors.New("informer is already registered")
}
f := informer.GetIndexer().GetIndexers()[ByNamespaceAndControllerUIDIndex]
if f == nil {
... | go | {
"resource": ""
} |
q18223 | HashConfigMap | train | func HashConfigMap(configMap *core_v1.ConfigMap, h hash.Hash, filter sets.String) bool {
keys := make([]string, 0, len(configMap.Data))
search := sets.NewString(filter.UnsortedList()...)
for k := range configMap.Data {
if filter.Len() == 0 || filter.Has(k) {
keys = append(keys, k)
}
}
for k := range configM... | go | {
"resource": ""
} |
q18224 | HashSecret | train | func HashSecret(secret *core_v1.Secret, h hash.Hash, filter sets.String) bool {
keys := make([]string, 0, len(secret.Data))
search := sets.NewString(filter.UnsortedList()...)
for k := range secret.Data {
if filter.Len() == 0 || filter.Has(k) {
keys = append(keys, k)
}
}
search.Delete(keys...)
if search.Len... | go | {
"resource": ""
} |
q18225 | newBundles | train | func newBundles(c *SmithV1Client, namespace string) *bundles {
return &bundles{
client: c.RESTClient(),
ns: namespace,
}
} | go | {
"resource": ""
} |
q18226 | IsCrdConditionTrue | train | func IsCrdConditionTrue(crd *apiext_v1b1.CustomResourceDefinition, conditionType apiext_v1b1.CustomResourceDefinitionConditionType) bool {
return IsCrdConditionPresentAndEqual(crd, conditionType, apiext_v1b1.ConditionTrue)
} | go | {
"resource": ""
} |
q18227 | AddInformer | train | func (s *MultiBasic) AddInformer(gvk schema.GroupVersionKind, informer cache.SharedIndexInformer) error {
s.mx.Lock()
defer s.mx.Unlock()
if _, ok := s.informers[gvk]; ok {
return errors.New("informer is already registered")
}
s.informers[gvk] = informer
return nil
} | go | {
"resource": ""
} |
q18228 | GetInformers | train | func (s *MultiBasic) GetInformers() map[schema.GroupVersionKind]cache.SharedIndexInformer {
s.mx.RLock()
defer s.mx.RUnlock()
informers := make(map[schema.GroupVersionKind]cache.SharedIndexInformer, len(s.informers))
for gvk, inf := range s.informers {
informers[gvk] = inf
}
return informers
} | go | {
"resource": ""
} |
q18229 | Get | train | func (s *MultiBasic) Get(gvk schema.GroupVersionKind, namespace, name string) (obj runtime.Object, exists bool, e error) {
var informer cache.SharedIndexInformer
func() {
s.mx.RLock()
defer s.mx.RUnlock()
informer = s.informers[gvk]
}()
if informer == nil {
return nil, false, errors.Errorf("no informer for ... | go | {
"resource": ""
} |
q18230 | BeforeCreate | train | func (c *Checker) BeforeCreate(logger *zap.Logger, spec *unstructured.Unstructured) (*unstructured.Unstructured /*updatedSpec*/, error) {
processor, ok := c.KnownTypes[spec.GroupVersionKind().GroupKind()]
if !ok {
return spec, nil
}
ctx := &Context{
Logger: logger,
Store: c.Store,
}
updatedSpec, err := pro... | go | {
"resource": ""
} |
q18231 | setSecretParametersChecksumAnnotation | train | func (s serviceInstance) setSecretParametersChecksumAnnotation(ctx *specchecker.Context, spec, actual *sc_v1b1.ServiceInstance) error {
if spec.Annotations[SecretParametersChecksumAnnotation] == Disabled {
return nil
}
var previousEncodedChecksum string
var updateCount int64
if actual != nil {
previousEncoded... | go | {
"resource": ""
} |
q18232 | setLastAppliedReplicasAnnotation | train | func (deployment) setLastAppliedReplicasAnnotation(ctx *specchecker.Context, spec, actual *apps_v1.Deployment) {
if spec.Annotations[LastAppliedReplicasAnnotation] == Disabled {
return
}
if spec.Spec.Replicas == nil {
var one int32 = 1
spec.Spec.Replicas = &one
}
specReplicas := *spec.Spec.Replicas
if act... | go | {
"resource": ""
} |
q18233 | SmithV1 | train | func (c *Clientset) SmithV1() smithv1.SmithV1Interface {
return &fakesmithv1.FakeSmithV1{Fake: &c.Fake}
} | go | {
"resource": ""
} |
q18234 | Smith | train | func (c *Clientset) Smith() smithv1.SmithV1Interface {
return &fakesmithv1.FakeSmithV1{Fake: &c.Fake}
} | go | {
"resource": ""
} |
q18235 | setEmptyFieldsFromActual | train | func setEmptyFieldsFromActual(requested, actual interface{}, fields ...string) error {
requestedValue := reflect.ValueOf(requested).Elem()
actualValue := reflect.ValueOf(actual).Elem()
if requestedValue.Type() != actualValue.Type() {
return errors.Errorf("attempted to set fields from different types: %q from %q",... | go | {
"resource": ""
} |
q18236 | Prepare | train | func (c *Controller) Prepare(crdInf cache.SharedIndexInformer, resourceInfs map[schema.GroupVersionKind]cache.SharedIndexInformer) error {
c.crdContext, c.crdContextCancel = context.WithCancel(context.Background())
crdInf.AddEventHandler(&crdEventHandler{
controller: c,
watchers: make(map[string]watchState),
}... | go | {
"resource": ""
} |
q18237 | Run | train | func (c *Controller) Run(ctx context.Context) {
defer c.wg.Wait()
defer c.crdContextCancel() // should be executed after stopping is set to true
defer func() {
c.wgLock.Lock()
defer c.wgLock.Unlock()
c.stopping = true
}()
c.Logger.Info("Starting Bundle controller")
defer c.Logger.Info("Shutting down Bundle... | go | {
"resource": ""
} |
q18238 | lookupBundleByObjectByIndex | train | func (c *Controller) lookupBundleByObjectByIndex(byIndex byIndexFunc, indexName string, indexKey indexKeyFunc) func(runtime.Object) ([]runtime.Object, error) {
return func(obj runtime.Object) ([]runtime.Object /*bundles*/, error) {
// obj is an object that is referred by some other object that might be in a Bundle
... | go | {
"resource": ""
} |
q18239 | DeepCopy | train | func (in *Sleeper) DeepCopy() *Sleeper {
if in == nil {
return nil
}
out := new(Sleeper)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18240 | DeepCopy | train | func (in *SleeperList) DeepCopy() *SleeperList {
if in == nil {
return nil
}
out := new(SleeperList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18241 | DeepCopy | train | func (in *SleeperSpec) DeepCopy() *SleeperSpec {
if in == nil {
return nil
}
out := new(SleeperSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18242 | DeepCopy | train | func (in *SleeperStatus) DeepCopy() *SleeperStatus {
if in == nil {
return nil
}
out := new(SleeperStatus)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18243 | Get | train | func (s *BundleStore) Get(namespace, bundleName string) (*smith_v1.Bundle, error) {
bundle, exists, err := s.store.Get(smith_v1.BundleGVK, namespace, bundleName)
if err != nil || !exists {
return nil, err
}
return bundle.(*smith_v1.Bundle), nil
} | go | {
"resource": ""
} |
q18244 | GetBundlesByCrd | train | func (s *BundleStore) GetBundlesByCrd(crd *apiext_v1b1.CustomResourceDefinition) ([]*smith_v1.Bundle, error) {
return s.getBundles(byCrdGroupKindIndexName, byCrdGroupKindIndexKey(crd.Spec.Group, crd.Spec.Names.Kind))
} | go | {
"resource": ""
} |
q18245 | GetBundlesByObject | train | func (s *BundleStore) GetBundlesByObject(gk schema.GroupKind, namespace, name string) ([]*smith_v1.Bundle, error) {
return s.getBundles(byObjectIndexName, byObjectIndexKey(gk, namespace, name))
} | go | {
"resource": ""
} |
q18246 | Get | train | func (c *FakeBundles) Get(name string, options v1.GetOptions) (result *smithv1.Bundle, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(bundlesResource, c.ns, name), &smithv1.Bundle{})
if obj == nil {
return nil, err
}
return obj.(*smithv1.Bundle), err
} | go | {
"resource": ""
} |
q18247 | List | train | func (c *FakeBundles) List(opts v1.ListOptions) (result *smithv1.BundleList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(bundlesResource, bundlesKind, c.ns, opts), &smithv1.BundleList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {... | go | {
"resource": ""
} |
q18248 | Watch | train | func (c *FakeBundles) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(bundlesResource, c.ns, opts))
} | go | {
"resource": ""
} |
q18249 | Delete | train | func (c *FakeBundles) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(bundlesResource, c.ns, name), &smithv1.Bundle{})
return err
} | go | {
"resource": ""
} |
q18250 | Patch | train | func (c *FakeBundles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *smithv1.Bundle, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(bundlesResource, c.ns, name, pt, data, subresources...), &smithv1.Bundle{})
if obj == nil {
return nil, err
}
ret... | go | {
"resource": ""
} |
q18251 | ensureWatch | train | func (h *crdEventHandler) ensureWatch(logger *zap.Logger, crd *apiext_v1b1.CustomResourceDefinition) bool {
if crd.Name == smith_v1.BundleResourceName {
return false
}
if _, ok := h.watchers[crd.Name]; ok {
return true
}
if !resources.IsCrdConditionTrue(crd, apiext_v1b1.Established) {
logger.Info("Not adding... | go | {
"resource": ""
} |
q18252 | ensureNoWatch | train | func (h *crdEventHandler) ensureNoWatch(logger *zap.Logger, crd *apiext_v1b1.CustomResourceDefinition) bool {
crdWatch, ok := h.watchers[crd.Name]
if !ok {
// Nothing to do. This can happen if there was an error adding a watch
return false
}
logger.Info("Removing watch for CRD")
crdWatch.cancel()
delete(h.wat... | go | {
"resource": ""
} |
q18253 | DeepCopy | train | func (in *Bundle) DeepCopy() *Bundle {
if in == nil {
return nil
}
out := new(Bundle)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18254 | DeepCopy | train | func (in *BundleList) DeepCopy() *BundleList {
if in == nil {
return nil
}
out := new(BundleList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18255 | DeepCopy | train | func (in *BundleSpec) DeepCopy() *BundleSpec {
if in == nil {
return nil
}
out := new(BundleSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18256 | DeepCopy | train | func (in *BundleStatus) DeepCopy() *BundleStatus {
if in == nil {
return nil
}
out := new(BundleStatus)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18257 | DeepCopy | train | func (in *PluginSpec) DeepCopy() *PluginSpec {
if in == nil {
return nil
}
out := new(PluginSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18258 | DeepCopy | train | func (in *Reference) DeepCopy() *Reference {
if in == nil {
return nil
}
out := new(Reference)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18259 | DeepCopy | train | func (in *Resource) DeepCopy() *Resource {
if in == nil {
return nil
}
out := new(Resource)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18260 | DeepCopy | train | func (in *ResourceSpec) DeepCopy() *ResourceSpec {
if in == nil {
return nil
}
out := new(ResourceSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18261 | DeepCopy | train | func (in *ResourceStatusData) DeepCopy() *ResourceStatusData {
if in == nil {
return nil
}
out := new(ResourceStatusData)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q18262 | ProcessBundle | train | func (c *Controller) ProcessBundle(logger *zap.Logger, bundle *smith_v1.Bundle) (bool /*external*/, bool /*retriable*/, error) {
st := bundleSyncTask{
logger: logger,
bundleClient: c.BundleClient,
smartClient: c.SmartClient,
checker: ... | go | {
"resource": ""
} |
q18263 | findObjectsToDelete | train | func (st *bundleSyncTask) findObjectsToDelete() (bool /*external*/, bool /*retriable*/, error) {
objs, err := st.store.ObjectsControlledBy(st.bundle.Namespace, st.bundle.UID)
if err != nil {
return false, false, err
}
st.objectsToDelete = make(map[objectRef]runtime.Object, len(objs))
for _, obj := range objs {
... | go | {
"resource": ""
} |
q18264 | pluginStatuses | train | func (st *bundleSyncTask) pluginStatuses() []smith_v1.PluginStatus {
// Plugin statuses
name2status := make(map[smith_v1.PluginName]struct{})
// most likely will be of the same size as before
pluginStatuses := make([]smith_v1.PluginStatus, 0, len(st.bundle.Status.PluginStatuses))
for _, res := range st.bundle.Spec... | go | {
"resource": ""
} |
q18265 | resourceConditions | train | func (st *bundleSyncTask) resourceConditions(res smith_v1.Resource) (
cond_v1.Condition, /* blockedCond */
cond_v1.Condition, /* inProgressCond */
cond_v1.Condition, /* readyCond */
cond_v1.Condition, /* errorCond */
) {
blockedCond := cond_v1.Condition{Type: smith_v1.ResourceBlocked, Status: cond_v1.ConditionFals... | go | {
"resource": ""
} |
q18266 | checkBundleConditionNeedsUpdate | train | func (st *bundleSyncTask) checkBundleConditionNeedsUpdate(condition *cond_v1.Condition) bool {
now := meta_v1.Now()
condition.LastTransitionTime = now
needsUpdate := cond_v1.PrepareCondition(st.bundle.Status.Conditions, condition)
if needsUpdate && condition.Status == cond_v1.ConditionTrue {
st.bundleTransition... | go | {
"resource": ""
} |
q18267 | checkResourceConditionNeedsUpdate | train | func (st *bundleSyncTask) checkResourceConditionNeedsUpdate(resName smith_v1.ResourceName, condition *cond_v1.Condition) bool {
now := meta_v1.Now()
condition.LastTransitionTime = now
needsUpdate := true
// Try to find this resource status
_, status := st.bundle.Status.GetResourceStatus(resName)
if status != n... | go | {
"resource": ""
} |
q18268 | ConvertType | train | func ConvertType(scheme *runtime.Scheme, in, out runtime.Object) error {
in = in.DeepCopyObject()
if err := scheme.Convert(in, out, nil); err != nil {
return err
}
gvkOut := out.GetObjectKind().GroupVersionKind()
if gvkOut.Kind == "" || gvkOut.Version == "" { // Group can be empty
// API machinery discards Typ... | go | {
"resource": ""
} |
q18269 | RuntimeToUnstructured | train | func RuntimeToUnstructured(obj runtime.Object) (*unstructured.Unstructured, error) {
gvk := obj.GetObjectKind().GroupVersionKind()
if gvk.Kind == "" || gvk.Version == "" { // Group can be empty
return nil, errors.Errorf("cannot convert %T to Unstructured: object Kind and/or object Version is empty", obj)
}
u, err... | go | {
"resource": ""
} |
q18270 | evalPluginSpec | train | func (st *resourceSyncTask) evalPluginSpec(res *smith_v1.Resource, actual runtime.Object) (*unstructured.Unstructured, resourceStatus) {
pluginContainer, ok := st.pluginContainers[res.Spec.Plugin.Name]
if !ok {
return nil, resourceStatusError{
err: errors.Errorf("no such plugin %q", res.Spec.Plugin.N... | go | {
"resource": ""
} |
q18271 | createOrUpdate | train | func (st *resourceSyncTask) createOrUpdate(spec *unstructured.Unstructured, actual runtime.Object) (actualRet *unstructured.Unstructured, retriableRet bool, e error) {
// Prepare client
gvk := spec.GroupVersionKind()
resClient, err := st.smartClient.ForGVK(gvk, st.bundle.Namespace)
if err != nil {
return nil, fal... | go | {
"resource": ""
} |
q18272 | updateResource | train | func (st *resourceSyncTask) updateResource(resClient dynamic.ResourceInterface, spec *unstructured.Unstructured, actual runtime.Object) (actualRet *unstructured.Unstructured, retriableError bool, e error) {
st.logger.Debug("Object found, checking spec", ctrlLogz.ObjectGk(spec.GroupVersionKind().GroupKind()), ctrlLogz.... | go | {
"resource": ""
} |
q18273 | GetJSONPathString | train | func GetJSONPathString(obj interface{}, path string) (string, error) {
j := jsonpath.New("GetJSONPathString")
// If the key is missing, return an empty string without errors
j.AllowMissingKeys(true)
err := j.Parse(path)
if err != nil {
return "", errors.Wrapf(err, "JsonPath parse %s error", path)
}
var buf byt... | go | {
"resource": ""
} |
q18274 | GetJSONPathValue | train | func GetJSONPathValue(obj interface{}, path string, allowMissingKeys bool) (interface{}, error) {
j := jsonpath.New("GetJSONPathValue")
// If the key is missing, return an empty string without errors
j.AllowMissingKeys(allowMissingKeys)
err := j.Parse(path)
if err != nil {
return "", errors.Wrapf(err, "JsonPath ... | go | {
"resource": ""
} |
q18275 | New | train | func New() *GoReq {
gr := &GoReq{
Data: make(map[string]interface{}),
Header: make(map[string]string),
FormData: url.Values{},
QueryData: url.Values{},
Client: nil,
Transport: &http.Transport{},
Cookies: make([]*http.Cookie, 0),
Errors: ... | go | {
"resource": ""
} |
q18276 | SetCurlCommand | train | func (gr *GoReq) SetCurlCommand(enable bool) *GoReq {
gr.CurlCommand = enable
return gr
} | go | {
"resource": ""
} |
q18277 | SetLogger | train | func (gr *GoReq) SetLogger(logger *log.Logger) *GoReq {
gr.logger = logger
return gr
} | go | {
"resource": ""
} |
q18278 | SetClient | train | func (gr *GoReq) SetClient(client *http.Client) *GoReq {
gr.Client = client
return gr
} | go | {
"resource": ""
} |
q18279 | Reset | train | func (gr *GoReq) Reset() *GoReq {
gr.URL = ""
gr.Method = ""
gr.Header = make(map[string]string)
gr.Data = make(map[string]interface{})
gr.FormData = url.Values{}
gr.QueryData = url.Values{}
gr.RawStringData = ""
gr.RawBytesData = make([]byte, 0)
gr.FilePath = ""
gr.FileParam = ""
gr.Cookies = make([]*http.C... | go | {
"resource": ""
} |
q18280 | Get | train | func (gr *GoReq) Get(targetURL string) *GoReq {
//gr.Reset()
gr.Method = GET
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18281 | Post | train | func (gr *GoReq) Post(targetURL string) *GoReq {
//gr.Reset()
gr.Method = POST
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18282 | Head | train | func (gr *GoReq) Head(targetURL string) *GoReq {
//gr.Reset()
gr.Method = HEAD
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18283 | Put | train | func (gr *GoReq) Put(targetURL string) *GoReq {
//gr.Reset()
gr.Method = PUT
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18284 | Delete | train | func (gr *GoReq) Delete(targetURL string) *GoReq {
//gr.Reset()
gr.Method = DELETE
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18285 | Patch | train | func (gr *GoReq) Patch(targetURL string) *GoReq {
//gr.Reset()
gr.Method = PATCH
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18286 | Options | train | func (gr *GoReq) Options(targetURL string) *GoReq {
//gr.Reset()
gr.Method = OPTIONS
gr.URL = targetURL
gr.Errors = nil
return gr
} | go | {
"resource": ""
} |
q18287 | queryStruct | train | func (gr *GoReq) queryStruct(content interface{}) *GoReq {
if marshalContent, err := json.Marshal(content); err != nil {
gr.Errors = append(gr.Errors, err)
} else {
var val map[string]interface{}
if err := json.Unmarshal(marshalContent, &val); err != nil {
gr.Errors = append(gr.Errors, err)
} else {
for... | go | {
"resource": ""
} |
q18288 | Timeout | train | func (gr *GoReq) Timeout(timeout time.Duration) *GoReq {
gr.Transport.Dial = func(network, addr string) (net.Conn, error) {
conn, err := net.DialTimeout(network, addr, timeout)
if err != nil {
gr.Errors = append(gr.Errors, err)
return nil, err
}
conn.SetDeadline(time.Now().Add(timeout))
return conn, ni... | go | {
"resource": ""
} |
q18289 | RedirectPolicy | train | func (gr *GoReq) RedirectPolicy(policy func(req Request, via []Request) error) *GoReq {
gr.CheckRedirect = func(r *http.Request, v []*http.Request) error {
vv := make([]Request, len(v))
for i, r := range v {
vv[i] = Request(r)
}
return policy(Request(r), vv)
}
if gr.Client != nil {
gr.Client.CheckRedire... | go | {
"resource": ""
} |
q18290 | SendFile | train | func (gr *GoReq) SendFile(paramName, filePath string) *GoReq {
gr.FileParam = paramName
gr.FilePath = filePath
return gr
} | go | {
"resource": ""
} |
q18291 | checkCrumb | train | func (jenkins *Jenkins) checkCrumb(req *http.Request) (*http.Request, error) {
// api - store jenkins api useCrumbs response
api := struct {
UseCrumbs bool `json:"useCrumbs"`
}{}
err := jenkins.get("/api/json", url.Values{"tree": []string{"useCrumbs"}}, &api)
if err != nil {
return req, err
}
if !api.UseC... | go | {
"resource": ""
} |
q18292 | GetJobs | train | func (jenkins *Jenkins) GetJobs() ([]Job, error) {
var payload = struct {
Jobs []Job `json:"jobs"`
}{}
err := jenkins.get("", nil, &payload)
return payload.Jobs, err
} | go | {
"resource": ""
} |
q18293 | GetJob | train | func (jenkins *Jenkins) GetJob(name string) (job Job, err error) {
err = jenkins.get(fmt.Sprintf("/job/%s", name), nil, &job)
return
} | go | {
"resource": ""
} |
q18294 | GetJobConfig | train | func (jenkins *Jenkins) GetJobConfig(name string) (job MavenJobItem, err error) {
err = jenkins.getXml(fmt.Sprintf("/job/%s/config.xml", name), nil, &job)
return
} | go | {
"resource": ""
} |
q18295 | GetBuild | train | func (jenkins *Jenkins) GetBuild(job Job, number int) (build Build, err error) {
err = jenkins.get(fmt.Sprintf("/job/%s/%d", job.Name, number), nil, &build)
return
} | go | {
"resource": ""
} |
q18296 | GetLastBuild | train | func (jenkins *Jenkins) GetLastBuild(job Job) (build Build, err error) {
err = jenkins.get(fmt.Sprintf("/job/%s/lastBuild", job.Name), nil, &build)
return
} | go | {
"resource": ""
} |
q18297 | CreateJob | train | func (jenkins *Jenkins) CreateJob(mavenJobItem MavenJobItem, jobName string) error {
mavenJobItemXml, _ := xml.Marshal(mavenJobItem)
reader := bytes.NewReader(mavenJobItemXml)
params := url.Values{"name": []string{jobName}}
return jenkins.postXml("/createItem", params, reader, nil)
} | go | {
"resource": ""
} |
q18298 | DeleteJob | train | func (jenkins *Jenkins) DeleteJob(job Job) error {
return jenkins.post(fmt.Sprintf("/job/%s/doDelete", job.Name), nil, nil)
} | go | {
"resource": ""
} |
q18299 | AddJobToView | train | func (jenkins *Jenkins) AddJobToView(viewName string, job Job) error {
params := url.Values{"name": []string{job.Name}}
return jenkins.post(fmt.Sprintf("/view/%s/addJobToView", viewName), params, nil)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.