id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c167900 | {
return Compress(flate.DefaultCompression)(next)
} | |
c167901 | {
return ThrottleBacklog(limit, 0, defaultBacklogTimeout)
} | |
c167902 | }
// Filling tokens.
for i := 0; i < limit+backlogLimit; i++ {
if i < limit {
t.tokens <- token{}
}
t.backlogTokens <- token{}
}
fn := func(h http.Handler) http.Handler {
t.h = h
return &t
}
return fn
} | |
c167903 | http.Error(w, errContextCanceled, http.StatusServiceUnavailable)
return
case tok := <-t.tokens:
defer func() {
t.tokens <- tok
}()
t.h.ServeHTTP(w, r)
}
return
default:
http.Error(w, errCapacityExceeded, http.StatusServiceUnavailable)
return
}
} | |
c167904 | w.(io.ReaderFrom)
if fl && hj && rf {
return &httpFancyWriter{bw}
}
}
if fl {
return &flushWriter{bw}
}
return &bw
} | |
c167905 | by :id
r.Put("/", rs.Update) // PUT /todos/{id} - update a single todo by :id
r.Delete("/", rs.Delete) // DELETE /todos/{id} - delete a single todo by :id
r.Get("/sync", rs.Sync)
})
return r
} | |
c167906 | err != nil {
return nil, err
}
if awsConfig.AssumeRole != "" {
log.Infof("Assuming role: %s", awsConfig.AssumeRole)
session.Config.WithCredentials(stscreds.NewCredentials(session, awsConfig.AssumeRole))
}
provider := &AWSProvider{
client: route53.New(session),
domainFilter: awsCon... | |
c167907 | {
changes := make([]*route53.Change, 0, len(endpoints))
for _, endpoint := range endpoints {
changes = append(changes, p.newChange(action, endpoint, recordsCache, zones))
}
return changes
} | |
c167908 |
publicZone = z
}
} else {
// Include all private zones
matchingZones = append(matchingZones, z)
}
}
}
if publicZone != nil {
matchingZones = append(matchingZones, publicZone)
}
return matchingZones
} | |
c167909 | return canonicalHostedZone(ep.Targets[0]) != ""
}
return false
} | |
c167910 | if addr.DNSName == ep.Targets[0] {
if hostedZone := canonicalHostedZone(addr.Targets[0]); hostedZone != "" {
return hostedZone
}
}
}
}
return ""
} | |
c167911 | if strings.HasSuffix(hostname, suffix) {
return zone
}
}
return ""
} | |
c167912 | provider: provider,
ownerID: ownerID,
mapper: mapper,
cacheInterval: cacheInterval,
}, nil
} | |
c167913 | will have empty owner
endpoints = append(endpoints, record)
continue
}
if err != nil {
return nil, err
}
endpointDNSName := im.mapper.toEndpointName(record.DNSName)
labelMap[endpointDNSName] = labels
}
for _, ep := range endpoints {
ep.Labels = endpoint.NewLabels()
if labels, ok := labelMap[e... | |
c167914 | := range domainFilters {
filters[i] = strings.TrimSuffix(strings.TrimSpace(domain), ".")
}
return DomainFilter{filters}
} | |
c167915 | {
return true
} else if strings.HasPrefix(filter, ".") && strings.HasSuffix(strippedDomain, filter) {
return true
} else if strings.Count(strippedDomain, ".") == strings.Count(filter, ".") {
if strippedDomain == filter {
return true
}
} else if strings.HasSuffix(strippedDomain, "."+filter) {
r... | |
c167916 | return df.filters[0] != ""
}
return len(df.filters) > 0
} | |
c167917 | changes.UpdateNew {
log.Infof("UPDATE (new): %v", v)
}
for _, v := range changes.Delete {
log.Infof("DELETE: %v", v)
}
}
}
} | |
c167918 | log.Warnf("Unable to initialize zones for inmemory provider")
}
}
}
} | |
c167919 | NewDomainFilter([]string{""}),
client: newInMemoryClient(),
}
for _, opt := range opts {
opt(im)
}
return im
} | |
c167920 | return im.client.CreateZone(newZone)
} | |
c167921 | {
return im.filter.Zones(im.client.Zones())
} | |
c167922 |
for _, updateOldEndpoint := range changes.UpdateOld {
if rec := c.findByType(updateOldEndpoint.Type, curZone[updateOldEndpoint.Name]); rec == nil || rec.Target != updateOldEndpoint.Target {
return ErrRecordNotFound
}
}
for _, deleteEndpoint := range changes.Delete {
if rec := c.findByType(deleteEndpoint.Ty... | |
c167923 | tags = []string{}
}
return ZoneTagFilter{zoneTags: tags}
} | |
c167924 |
case 1:
if _, hasTag := tagsMap[filterParts[0]]; !hasTag {
return false
}
case 2:
if value, hasTag := tagsMap[filterParts[0]]; !hasTag || value != filterParts[1] {
return false
}
}
}
return true
} | |
c167925 |
// Add default resource event handlers to properly initialize informer.
ingressInformer.Informer().AddEventHandler(
cache.ResourceEventHandlerFuncs{
AddFunc: func(obj interface{}) {
},
},
)
// TODO informer is not explicitly stopped since controller is not passing in its channel.
informerFactory.Start... | |
c167926 | }
if sc.combineFQDNAnnotation {
ingEndpoints = append(ingEndpoints, iEndpoints...)
} else {
ingEndpoints = iEndpoints
}
}
if len(ingEndpoints) == 0 {
log.Debugf("No endpoints could be generated from ingress %s/%s", ing.Namespace, ing.Name)
continue
}
log.Debugf("Endpoints generated fr... | |
c167927 | // convert the ingress' annotations to an equivalent label selector
annotations := labels.Set(ingress.Annotations)
// include ingress if its annotations match the selector
if selector.Matches(annotations) {
filteredList = append(filteredList, ingress)
}
}
return filteredList, nil
} | |
c167928 | rule.Host == "" {
continue
}
endpoints = append(endpoints, endpointsForHostname(rule.Host, targets, ttl, providerSpecific)...)
}
for _, tls := range ing.Spec.TLS {
for _, host := range tls.Hosts {
if host == "" {
continue
}
endpoints = append(endpoints, endpointsForHostname(host, targets, ttl,... | |
c167929 |
}
if key == "heritage" {
foundExternalDNSHeritage = true
continue
}
if strings.HasPrefix(key, heritage) {
endpointLabels[strings.TrimPrefix(key, heritage+"/")] = val
}
}
if !foundExternalDNSHeritage {
return nil, ErrInvalidHeritage
}
return endpointLabels, nil
} | |
c167930 |
tokens = append(tokens, fmt.Sprintf("%s/%s=%s", heritage, key, l[key]))
}
if withQuotes {
return fmt.Sprintf("\"%s\"", strings.Join(tokens, ","))
}
return strings.Join(tokens, ",")
} | |
c167931 |
p.kubeOnce.Do(func() {
p.kubeClient, err = NewKubeClient(p.KubeConfig, p.KubeMaster, p.RequestTimeout)
})
return p.kubeClient, err
} | |
c167932 | p.istioClient, err = NewIstioClient(p.KubeConfig)
})
return p.istioClient, err
} | |
c167933 | {
return nil, err
}
sources = append(sources, source)
}
return sources, nil
} | |
c167934 |
kubernetesClient, err := p.KubeClient()
if err != nil {
return nil, err
}
istioClient, err := p.IstioClient()
if err != nil {
return nil, err
}
return NewIstioGatewaySource(kubernetesClient, istioClient, cfg.IstioIngressGatewayServices, cfg.Namespace, cfg.AnnotationFilter, cfg.FQDNTemplate, cfg.Com... | |
c167935 | := strings.Split(path, "/")
return parts[len(parts)-1]
},
})
}
config.Timeout = requestTimeout
client, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
log.Infof("Created Kubernetes client %s", config.Host)
return client, nil
} | |
c167936 | %q in GroupVersion %q", kind, apiVersion)
}
scheme := runtime.NewScheme()
addKnownTypes(scheme, groupVersion)
config.ContentConfig.GroupVersion = &groupVersion
config.APIPath = "/apis"
config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: serializer.NewCodecFactory(scheme)}
crdClient, err... | |
c167937 | namespace: namespace,
crdClient: crdClient,
codec: runtime.NewParameterCodec(scheme),
}, nil
} | |
c167938 | {
case zoneTypePublic:
return !aws.BoolValue(zone.Config.PrivateZone)
case zoneTypePrivate:
return aws.BoolValue(zone.Config.PrivateZone)
}
// We return false on any other path, e.g. unknown zone type filter value.
return false
} | |
c167939 |
transportConfig := ibclient.NewTransportConfig(
strconv.FormatBool(infobloxConfig.SSLVerify),
httpRequestTimeout,
httpPoolConnections,
)
requestBuilder := &ibclient.WapiRequestBuilder{}
requestor := &ibclient.WapiHttpRequestor{}
client, err := ibclient.NewConnector(hostConfig, transportConfig, requestBuil... | |
c167940 | != nil {
return err
}
created, deleted := p.mapChanges(zones, changes)
p.deleteRecords(deleted)
p.createRecords(created)
return nil
} | |
c167941 |
// Transform the slice into a map so it will
// be way much easier and fast to filter later
serviceTypes := make(map[string]struct{})
for _, serviceType := range serviceTypeFilter {
serviceTypes[serviceType] = struct{}{}
}
return &serviceSource{
client: kubeClient,
namespace: ... | |
c167942 |
// apply template if none of the above is found
if (sc.combineFQDNAnnotation || len(svcEndpoints) == 0) && sc.fqdnTemplate != nil {
sEndpoints, err := sc.endpointsFromTemplate(svc, nodeTargets)
if err != nil {
return nil, err
}
if sc.combineFQDNAnnotation {
svcEndpoints = append(svcEndpoints, ... | |
c167943 |
providerSpecific := getProviderSpecificAnnotations(svc.Annotations)
hostnameList := getHostnamesFromAnnotations(svc.Annotations)
for _, hostname := range hostnameList {
endpoints = append(endpoints, sc.generateEndpoints(svc, hostname, nodeTargets, providerSpecific)...)
}
}
return endpoints
} | |
c167944 | the service's annotations to an equivalent label selector
annotations := labels.Set(service.Annotations)
// include service if its annotations match the selector
if selector.Matches(annotations) {
filteredList = append(filteredList, service)
}
}
return filteredList, nil
} | |
c167945 | if _, ok := sc.serviceTypeFilter[string(service.Spec.Type)]; ok {
filteredList = append(filteredList, service)
}
}
return filteredList
} | |
c167946 | = t.getUpdates()
for _, pol := range p.Policies {
changes = pol.Apply(changes)
}
plan := &Plan{
Current: p.Current,
Desired: p.Desired,
Changes: changes,
}
return plan
} | |
c167947 | NewExoscaleProviderWithClient(endpoint, apiKey, apiSecret, client, dryRun, opts...)
} | |
c167948 | changes.UpdateNew {
log.Infof("UPDATE (new): %v", v)
}
for _, v := range changes.Delete {
log.Infof("DELETE: %v", v)
}
}
}
} | |
c167949 |
}
linodeClient := linodego.NewClient(oauth2Client)
linodeClient.SetUserAgent(fmt.Sprintf("ExternalDNS/%s linodego/%s", appVersion, linodego.Version))
provider := &LinodeProvider{
Client: &linodeClient,
domainFilter: domainFilter,
DryRun: dryRun,
}
return provider, nil
} | |
c167950 |
t = append(t, target...)
return t
} | |
c167951 | i, e := range t {
if e != o[i] {
return false
}
}
return true
} | |
c167952 | := range t {
if e != o[i] {
return e < o[i]
}
}
return false
} | |
c167953 | NewEndpointWithTTL(dnsName, recordType, TTL(0), targets...)
} | |
c167954 | strings.TrimSuffix(dnsName, "."),
Targets: cleanTargets,
RecordType: recordType,
Labels: NewLabels(),
RecordTTL: ttl,
}
} | |
c167955 | key {
return providerSpecific, true
}
}
return ProviderSpecificProperty{}, false
} | |
c167956 |
if strings.HasSuffix(zoneID, id) {
return true
}
}
return false
} | |
c167957 | "" {
return errors.New("no Dyn username specified")
}
if cfg.DynCustomerName == "" {
return errors.New("no Dyn customer name specified")
}
if cfg.DynMinTTLSeconds < 0 {
return errors.New("TTL specified for Dyn is negative")
}
}
if cfg.IgnoreHostnameAnnotation && cfg.FQDNTemplate == "" {
return... | |
c167958 | return n.service.Records.Create(r)
} | |
c167959 | {
return n.service.Records.Delete(zone, domain, t)
} | |
c167960 | return n.service.Records.Update(r)
} | |
c167961 | *http.Response, error) {
return n.service.Zones.Get(zone)
} | |
c167962 | *http.Response, error) {
return n.service.Zones.List()
} | |
c167963 | endpoints = append(endpoints, endpoint.NewEndpointWithTTL(
record.Domain,
record.Type,
endpoint.TTL(record.TTL),
record.ShortAns...,
),
)
}
}
}
return endpoints, nil
} | |
c167964 | ns1DefaultTTL
if change.Endpoint.RecordTTL.IsConfigured() {
ttl = int(change.Endpoint.RecordTTL)
}
record.TTL = ttl
return record
} | |
c167965 | switch change.Action {
case ns1Create:
_, err := p.client.CreateRecord(record)
if err != nil {
return err
}
case ns1Delete:
_, err := p.client.DeleteRecord(zoneName, record.Domain, record.Type)
if err != nil {
return err
}
case ns1Update:
_, err := p.client.UpdateRecord(... | |
c167966 |
for _, endpoint := range endpoints {
changes = append(changes, &ns1Change{
Action: action,
Endpoint: endpoint,
},
)
}
return changes
} | |
c167967 | changes[z.Zone] = []*ns1Change{}
}
for _, c := range changeSets {
zone, _ := zoneNameIDMapper.FindZone(c.Endpoint.DNSName)
if zone == "" {
log.Debugf("Skipping record %s because no hosted zone matching record DNS Name was detected ", c.Endpoint.DNSName)
continue
}
changes[zone] = append(changes[zone],... | |
c167968 | = append(levels, level.String())
}
return levels
} | |
c167969 | UpdateOld: changes.UpdateOld,
UpdateNew: changes.UpdateNew,
}
} | |
c167970 | &plan.Plan{
Policies: []plan.Policy{c.Policy},
Current: records,
Desired: endpoints,
}
plan = plan.Calculate()
err = c.Registry.ApplyChanges(plan.Changes)
if err != nil {
registryErrors.Inc()
return err
}
return nil
} | |
c167971 | }
select {
case <-ticker.C:
case <-stopChan:
log.Info("Terminating main controller loop")
return
}
}
} | |
c167972 | zoneService{config},
domainFilter: domainFilter,
zoneIDFilter: zoneIDFilter,
proxiedByDefault: proxiedByDefault,
DryRun: dryRun,
PaginationOptions: cloudflare.PaginationOptions{
PerPage: zonesPerPage,
Page: 1,
},
}
return provider, nil
} | |
c167973 | 0, len(endpoints))
for _, endpoint := range endpoints {
changes = append(changes, newCloudFlareChange(action, endpoint, proxiedByDefault))
}
return changes
} | |
c167974 | err := client.Identity.Whoami()
if err != nil {
return "", err
}
return strconv.Itoa(whoamiResponse.Data.Account.ID), nil
} | |
c167975 | := &dnsimpleProvider{
client: dnsimpleZoneService{service: client.Zones},
identity: identityService{service: client.Identity},
domainFilter: domainFilter,
zoneIDFilter: zoneIDFilter,
dryRun: dryRun,
}
whoamiResponse, err := provider.identity.service.Whoami()
if err != nil {
return nil, e... | |
c167976 | continue
}
if !p.zoneIDFilter.Match(strconv.Itoa(zone.ID)) {
continue
}
zones[strconv.Itoa(zone.ID)] = zone
}
page++
if page > zonesResponse.Pagination.TotalPages {
break
}
}
return zones, nil
} | |
c167977 | = append(endpoints, endpoint.NewEndpointWithTTL(record.Name+"."+record.ZoneID, record.Type, endpoint.TTL(record.TTL), record.Content))
}
page++
if page > records.Pagination.TotalPages {
break
}
}
}
return endpoints, nil
} | |
c167978 | Name: e.DNSName,
Type: e.RecordType,
Content: e.Targets[0],
TTL: ttl,
},
}
return change
} | |
c167979 | endpoints {
changes = append(changes, newDnsimpleChange(action, e))
}
return changes
} | |
c167980 | if err != nil {
return err
}
_, err = p.client.DeleteRecord(p.accountID, zone.Name, recordID)
if err != nil {
return err
}
case dnsimpleUpdate:
recordID, err := p.GetRecordID(zone.Name, change.ResourceRecordSet.Name)
if err != nil {
return err
}
_, err = p.client.Updat... | |
c167981 | == recordName {
return record.ID, nil
}
}
page++
if page > records.Pagination.TotalPages {
break
}
}
return 0, fmt.Errorf("No record id found")
} | |
c167982 | nil || len(z.Name) > len(zone.Name) {
newZ := z
zone = &newZ
}
}
}
return zone
} | |
c167983 | p.submitChanges(newDnsimpleChanges(dnsimpleCreate, endpoints))
} | |
c167984 | p.submitChanges(newDnsimpleChanges(dnsimpleDelete, endpoints))
} | |
c167985 | p.submitChanges(newDnsimpleChanges(dnsimpleUpdate, endpoints))
} | |
c167986 | newDnsimpleChanges(dnsimpleCreate, changes.Create)...)
combinedChanges = append(combinedChanges, newDnsimpleChanges(dnsimpleUpdate, changes.UpdateNew)...)
combinedChanges = append(combinedChanges, newDnsimpleChanges(dnsimpleDelete, changes.Delete)...)
return p.submitChanges(combinedChanges)
} | |
c167987 | project,
dryRun: dryRun,
domainFilter: domainFilter,
zoneIDFilter: zoneIDFilter,
resourceRecordSetsClient: resourceRecordSetsService{dnsClient.ResourceRecordSets},
managedZonesClient: managedZonesService{dnsClient.ManagedZones},
changesClient: ... | |
c167988 | r.Type, endpoint.TTL(r.Ttl), r.Rrdatas...))
}
return nil
}
for _, z := range zones {
if err := p.resourceRecordSetsClient.List(p.project, z.Name).Pages(context.TODO(), f); err != nil {
return nil, err
}
}
return endpoints, nil
} | |
c167989 |
if p.domainFilter.Match(endpoint.DNSName) {
records = append(records, newRecord(endpoint))
}
}
return records
} | |
c167990 | del.Rrdatas, del.Ttl)
}
for _, add := range c.Additions {
log.Infof("Add records: %s %s %s %d", add.Name, add.Type, add.Rrdatas, add.Ttl)
}
}
if p.dryRun {
return nil
}
for z, c := range changes {
if _, err := p.changesClient.Create(p.project, z, c).Do(); err != nil {
return err
}
}
return n... | |
c167991 | for _, d := range change.Deletions {
if zoneName, _ := zoneNameIDMapper.FindZone(ensureTrailingDot(d.Name)); zoneName != "" {
changes[zoneName].Deletions = append(changes[zoneName].Deletions, d)
} else {
log.Warnf("No matching zone for record deletion: %s %s %s %d", d.Name, d.Type, d.Rrdatas, d.Ttl)
}
}
... | |
c167992 | copy(targets, []string(ep.Targets))
if ep.RecordType == endpoint.RecordTypeCNAME {
targets[0] = ensureTrailingDot(targets[0])
}
// no annotation results in a Ttl of 0, default to 300 for backwards-compatability
var ttl int64 = googleRecordTTL
if ep.RecordTTL.IsConfigured() {
ttl = int64(ep.RecordTTL)
}
re... | |
c167993 | client.BaseURL, err = url.Parse(os.Getenv("RC0_BASE_URL"))
}
if err != nil {
return nil, fmt.Errorf("failed to initialize rcodezero provider: %v", err)
}
provider := &RcodeZeroProvider{
Client: client,
DomainFilter: domainFilter,
DryRun: dryRun,
TXTEncrypt: txtEnc,
}
if txtEnc {
prov... | |
c167994 | := range zones {
if p.DomainFilter.Match(zone.Domain) {
result = append(result, zone)
}
}
return result, nil
} | |
c167995 | && strings.EqualFold(r.Type, "TXT") {
p.Client.RRSet.DecryptTXT(p.Key, r)
}
if len(r.Records) > 1 {
for _, _r := range r.Records {
if !_r.Disabled {
endpoints = append(endpoints, endpoint.NewEndpointWithTTL(r.Name, r.Type, endpoint.TTL(r.TTL), _r.Content))
}
}
} else {
... | |
c167996 | new RR resulted in an error: %v", sr.Message)
}
case rc0.ChangeTypeUPDATE:
sr, err := p.Client.RRSet.Edit(zoneName, []*rc0.RRSetChange{change})
if err != nil {
return err
}
if sr.HasError() {
return fmt.Errorf("updating existing RR resulted in an error: %v", sr.Message)
}
ca... | |
c167997 | := range endpoints {
changes = append(changes, p.NewRcodezeroChange(action, _endpoint))
}
return changes
} | |
c167998 | Name: endpoint.DNSName,
Records: []*rc0.Record{{
Disabled: false,
Content: endpoint.Targets[0],
}},
}
if p.TXTEncrypt && (p.Key != nil) && strings.EqualFold(endpoint.RecordType, "TXT") {
p.Client.RRSet.EncryptTXT(p.Key, change)
}
return change
} | |
c167999 | Alibaba Cloud DNS client: %v", err)
}
// Private DNS service
var pvtzClient AlibabaCloudPrivateZoneAPI
if cfg.RoleName == "" {
pvtzClient, err = pvtz.NewClientWithAccessKey(
"cn-hangzhou", // The Private Zone location is fixed
cfg.AccessKeyID,
cfg.AccessKeySecret,
)
} else {
pvtzClient, err = pvtz... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.