_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q167900 | DefaultCompress | validation | func DefaultCompress(next http.Handler) http.Handler {
return Compress(flate.DefaultCompression)(next)
} | go | {
"resource": ""
} |
q167901 | Throttle | validation | func Throttle(limit int) func(http.Handler) http.Handler {
return ThrottleBacklog(limit, 0, defaultBacklogTimeout)
} | go | {
"resource": ""
} |
q167902 | ThrottleBacklog | validation | func ThrottleBacklog(limit int, backlogLimit int, backlogTimeout time.Duration) func(http.Handler) http.Handler {
if limit < 1 {
panic("chi/middleware: Throttle expects limit > 0")
}
if backlogLimit < 0 {
panic("chi/middleware: Throttle expects backlogLimit to be positive")
}
t := throttler{
tokens: ... | go | {
"resource": ""
} |
q167903 | ServeHTTP | validation | func (t *throttler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
select {
case <-ctx.Done():
http.Error(w, errContextCanceled, http.StatusServiceUnavailable)
return
case btok := <-t.backlogTokens:
timer := time.NewTimer(t.backlogTimeout)
defer func() {
t.backlogTokens <- btok
... | go | {
"resource": ""
} |
q167904 | NewWrapResponseWriter | validation | func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter {
_, fl := w.(http.Flusher)
bw := basicWriter{ResponseWriter: w}
if protoMajor == 2 {
_, ps := w.(http.Pusher)
if fl && ps {
return &http2FancyWriter{bw}
}
} else {
_, hj := w.(http.Hijacker)
_, rf := w.(io.ReaderFro... | go | {
"resource": ""
} |
q167905 | Routes | validation | func (rs todosResource) Routes() chi.Router {
r := chi.NewRouter()
// r.Use() // some middleware..
r.Get("/", rs.List) // GET /todos - read a list of todos
r.Post("/", rs.Create) // POST /todos - create a new todo and persist it
r.Put("/", rs.Delete)
r.Route("/{id}", func(r chi.Router) {
// r.Use(rs.TodoCt... | go | {
"resource": ""
} |
q167906 | NewAWSProvider | validation | func NewAWSProvider(awsConfig AWSConfig) (*AWSProvider, error) {
config := aws.NewConfig().WithMaxRetries(awsConfig.APIRetries)
config.WithHTTPClient(
instrumented_http.NewClient(config.HTTPClient, &instrumented_http.Callbacks{
PathProcessor: func(path string) string {
parts := strings.Split(path, "/")
... | go | {
"resource": ""
} |
q167907 | newChanges | validation | func (p *AWSProvider) newChanges(action string, endpoints []*endpoint.Endpoint, recordsCache []*endpoint.Endpoint, zones map[string]*route53.HostedZone) []*route53.Change {
changes := make([]*route53.Change, 0, len(endpoints))
for _, endpoint := range endpoints {
changes = append(changes, p.newChange(action, endpo... | go | {
"resource": ""
} |
q167908 | suitableZones | validation | func suitableZones(hostname string, zones map[string]*route53.HostedZone) []*route53.HostedZone {
var matchingZones []*route53.HostedZone
var publicZone *route53.HostedZone
for _, z := range zones {
if aws.StringValue(z.Name) == hostname || strings.HasSuffix(hostname, "."+aws.StringValue(z.Name)) {
if z.Config... | go | {
"resource": ""
} |
q167909 | isAWSLoadBalancer | validation | func isAWSLoadBalancer(ep *endpoint.Endpoint) bool {
if ep.RecordType == endpoint.RecordTypeCNAME {
return canonicalHostedZone(ep.Targets[0]) != ""
}
return false
} | go | {
"resource": ""
} |
q167910 | isAWSAlias | validation | func isAWSAlias(ep *endpoint.Endpoint, addrs []*endpoint.Endpoint) string {
if prop, exists := ep.GetProviderSpecificProperty("alias"); ep.RecordType == endpoint.RecordTypeCNAME && exists && prop.Value == "true" {
for _, addr := range addrs {
if addr.DNSName == ep.Targets[0] {
if hostedZone := canonicalHosted... | go | {
"resource": ""
} |
q167911 | canonicalHostedZone | validation | func canonicalHostedZone(hostname string) string {
for suffix, zone := range canonicalHostedZones {
if strings.HasSuffix(hostname, suffix) {
return zone
}
}
return ""
} | go | {
"resource": ""
} |
q167912 | NewTXTRegistry | validation | func NewTXTRegistry(provider provider.Provider, txtPrefix, ownerID string, cacheInterval time.Duration) (*TXTRegistry, error) {
if ownerID == "" {
return nil, errors.New("owner id cannot be empty")
}
mapper := newPrefixNameMapper(txtPrefix)
return &TXTRegistry{
provider: provider,
ownerID: ownerI... | go | {
"resource": ""
} |
q167913 | Records | validation | func (im *TXTRegistry) Records() ([]*endpoint.Endpoint, error) {
// If we have the zones cached AND we have refreshed the cache since the
// last given interval, then just use the cached results.
if im.recordsCache != nil && time.Since(im.recordsCacheRefreshTime) < im.cacheInterval {
log.Debug("Using cached record... | go | {
"resource": ""
} |
q167914 | NewDomainFilter | validation | func NewDomainFilter(domainFilters []string) DomainFilter {
filters := make([]string, len(domainFilters))
// user can define filter domains either with trailing dot or without, we remove all trailing periods from
// the internal representation
for i, domain := range domainFilters {
filters[i] = strings.TrimSuffi... | go | {
"resource": ""
} |
q167915 | Match | validation | func (df DomainFilter) Match(domain string) bool {
// return always true, if not filter is specified
if len(df.filters) == 0 {
return true
}
for _, filter := range df.filters {
strippedDomain := strings.TrimSuffix(domain, ".")
if filter == "" {
return true
} else if strings.HasPrefix(filter, ".") && st... | go | {
"resource": ""
} |
q167916 | IsConfigured | validation | func (df DomainFilter) IsConfigured() bool {
if len(df.filters) == 1 {
return df.filters[0] != ""
}
return len(df.filters) > 0
} | go | {
"resource": ""
} |
q167917 | InMemoryWithLogging | validation | func InMemoryWithLogging() InMemoryOption {
return func(p *InMemoryProvider) {
p.OnApplyChanges = func(changes *plan.Changes) {
for _, v := range changes.Create {
log.Infof("CREATE: %v", v)
}
for _, v := range changes.UpdateOld {
log.Infof("UPDATE (old): %v", v)
}
for _, v := range changes.Upd... | go | {
"resource": ""
} |
q167918 | InMemoryInitZones | validation | func InMemoryInitZones(zones []string) InMemoryOption {
return func(p *InMemoryProvider) {
for _, z := range zones {
if err := p.CreateZone(z); err != nil {
log.Warnf("Unable to initialize zones for inmemory provider")
}
}
}
} | go | {
"resource": ""
} |
q167919 | NewInMemoryProvider | validation | func NewInMemoryProvider(opts ...InMemoryOption) *InMemoryProvider {
im := &InMemoryProvider{
filter: &filter{},
OnApplyChanges: func(changes *plan.Changes) {},
OnRecords: func() {},
domain: NewDomainFilter([]string{""}),
client: newInMemoryClient(),
}
for _, opt := range opts... | go | {
"resource": ""
} |
q167920 | CreateZone | validation | func (im *InMemoryProvider) CreateZone(newZone string) error {
return im.client.CreateZone(newZone)
} | go | {
"resource": ""
} |
q167921 | Zones | validation | func (im *InMemoryProvider) Zones() map[string]string {
return im.filter.Zones(im.client.Zones())
} | go | {
"resource": ""
} |
q167922 | validateChangeBatch | validation | func (c *inMemoryClient) validateChangeBatch(zone string, changes *inMemoryChange) error {
curZone, ok := c.zones[zone]
if !ok {
return ErrZoneNotFound
}
mesh := map[string]map[string]bool{}
for _, newEndpoint := range changes.Create {
if c.findByType(newEndpoint.Type, curZone[newEndpoint.Name]) != nil {
re... | go | {
"resource": ""
} |
q167923 | NewZoneTagFilter | validation | func NewZoneTagFilter(tags []string) ZoneTagFilter {
if len(tags) == 1 && len(tags[0]) == 0 {
tags = []string{}
}
return ZoneTagFilter{zoneTags: tags}
} | go | {
"resource": ""
} |
q167924 | Match | validation | func (f ZoneTagFilter) Match(tagsMap map[string]string) bool {
for _, tagFilter := range f.zoneTags {
filterParts := strings.SplitN(tagFilter, "=", 2)
switch len(filterParts) {
case 1:
if _, hasTag := tagsMap[filterParts[0]]; !hasTag {
return false
}
case 2:
if value, hasTag := tagsMap[filterParts... | go | {
"resource": ""
} |
q167925 | NewIngressSource | validation | func NewIngressSource(kubeClient kubernetes.Interface, namespace, annotationFilter string, fqdnTemplate string, combineFqdnAnnotation bool, ignoreHostnameAnnotation bool) (Source, error) {
var (
tmpl *template.Template
err error
)
if fqdnTemplate != "" {
tmpl, err = template.New("endpoint").Funcs(template.Fun... | go | {
"resource": ""
} |
q167926 | Endpoints | validation | func (sc *ingressSource) Endpoints() ([]*endpoint.Endpoint, error) {
ingresses, err := sc.ingressInformer.Lister().Ingresses(sc.namespace).List(labels.Everything())
if err != nil {
return nil, err
}
ingresses, err = sc.filterByAnnotations(ingresses)
if err != nil {
return nil, err
}
endpoints := []*endpoint... | go | {
"resource": ""
} |
q167927 | filterByAnnotations | validation | func (sc *ingressSource) filterByAnnotations(ingresses []*v1beta1.Ingress) ([]*v1beta1.Ingress, error) {
labelSelector, err := metav1.ParseToLabelSelector(sc.annotationFilter)
if err != nil {
return nil, err
}
selector, err := metav1.LabelSelectorAsSelector(labelSelector)
if err != nil {
return nil, err
}
/... | go | {
"resource": ""
} |
q167928 | endpointsFromIngress | validation | func endpointsFromIngress(ing *v1beta1.Ingress, ignoreHostnameAnnotation bool) []*endpoint.Endpoint {
var endpoints []*endpoint.Endpoint
ttl, err := getTTLFromAnnotations(ing.Annotations)
if err != nil {
log.Warn(err)
}
targets := getTargetsFromTargetAnnotation(ing.Annotations)
if len(targets) == 0 {
targe... | go | {
"resource": ""
} |
q167929 | NewLabelsFromString | validation | func NewLabelsFromString(labelText string) (Labels, error) {
endpointLabels := map[string]string{}
labelText = strings.Trim(labelText, "\"") // drop quotes
tokens := strings.Split(labelText, ",")
foundExternalDNSHeritage := false
for _, token := range tokens {
if len(strings.Split(token, "=")) != 2 {
continue... | go | {
"resource": ""
} |
q167930 | Serialize | validation | func (l Labels) Serialize(withQuotes bool) string {
var tokens []string
tokens = append(tokens, fmt.Sprintf("heritage=%s", heritage))
var keys []string
for key := range l {
keys = append(keys, key)
}
sort.Strings(keys) // sort for consistency
for _, key := range keys {
tokens = append(tokens, fmt.Sprintf("%... | go | {
"resource": ""
} |
q167931 | KubeClient | validation | func (p *SingletonClientGenerator) KubeClient() (kubernetes.Interface, error) {
var err error
p.kubeOnce.Do(func() {
p.kubeClient, err = NewKubeClient(p.KubeConfig, p.KubeMaster, p.RequestTimeout)
})
return p.kubeClient, err
} | go | {
"resource": ""
} |
q167932 | IstioClient | validation | func (p *SingletonClientGenerator) IstioClient() (istiomodel.ConfigStore, error) {
var err error
p.istioOnce.Do(func() {
p.istioClient, err = NewIstioClient(p.KubeConfig)
})
return p.istioClient, err
} | go | {
"resource": ""
} |
q167933 | ByNames | validation | func ByNames(p ClientGenerator, names []string, cfg *Config) ([]Source, error) {
sources := []Source{}
for _, name := range names {
source, err := BuildWithConfig(name, p, cfg)
if err != nil {
return nil, err
}
sources = append(sources, source)
}
return sources, nil
} | go | {
"resource": ""
} |
q167934 | BuildWithConfig | validation | func BuildWithConfig(source string, p ClientGenerator, cfg *Config) (Source, error) {
switch source {
case "service":
client, err := p.KubeClient()
if err != nil {
return nil, err
}
return NewServiceSource(client, cfg.Namespace, cfg.AnnotationFilter, cfg.FQDNTemplate, cfg.CombineFQDNAndAnnotation, cfg.Comp... | go | {
"resource": ""
} |
q167935 | NewKubeClient | validation | func NewKubeClient(kubeConfig, kubeMaster string, requestTimeout time.Duration) (*kubernetes.Clientset, error) {
if kubeConfig == "" {
if _, err := os.Stat(clientcmd.RecommendedHomeFile); err == nil {
kubeConfig = clientcmd.RecommendedHomeFile
}
}
config, err := clientcmd.BuildConfigFromFlags(kubeMaster, kub... | go | {
"resource": ""
} |
q167936 | NewCRDClientForAPIVersionKind | validation | func NewCRDClientForAPIVersionKind(client kubernetes.Interface, kubeConfig, kubeMaster, apiVersion, kind string) (*rest.RESTClient, *runtime.Scheme, error) {
if kubeConfig == "" {
if _, err := os.Stat(clientcmd.RecommendedHomeFile); err == nil {
kubeConfig = clientcmd.RecommendedHomeFile
}
}
config, err := c... | go | {
"resource": ""
} |
q167937 | NewCRDSource | validation | func NewCRDSource(crdClient rest.Interface, namespace, kind string, scheme *runtime.Scheme) (Source, error) {
return &crdSource{
crdResource: strings.ToLower(kind) + "s",
namespace: namespace,
crdClient: crdClient,
codec: runtime.NewParameterCodec(scheme),
}, nil
} | go | {
"resource": ""
} |
q167938 | Match | validation | func (f ZoneTypeFilter) Match(zone *route53.HostedZone) bool {
// An empty zone filter includes all hosted zones.
if f.zoneType == "" {
return true
}
// If the zone has no config we assume it's a public zone since the config's field
// `PrivateZone` is false by default in go.
if zone.Config == nil {
return f... | go | {
"resource": ""
} |
q167939 | NewInfobloxProvider | validation | func NewInfobloxProvider(infobloxConfig InfobloxConfig) (*InfobloxProvider, error) {
hostConfig := ibclient.HostConfig{
Host: infobloxConfig.Host,
Port: strconv.Itoa(infobloxConfig.Port),
Username: infobloxConfig.Username,
Password: infobloxConfig.Password,
Version: infobloxConfig.Version,
}
http... | go | {
"resource": ""
} |
q167940 | ApplyChanges | validation | func (p *InfobloxProvider) ApplyChanges(changes *plan.Changes) error {
zones, err := p.zones()
if err != nil {
return err
}
created, deleted := p.mapChanges(zones, changes)
p.deleteRecords(deleted)
p.createRecords(created)
return nil
} | go | {
"resource": ""
} |
q167941 | NewServiceSource | validation | func NewServiceSource(kubeClient kubernetes.Interface, namespace, annotationFilter string, fqdnTemplate string, combineFqdnAnnotation bool, compatibility string, publishInternal bool, publishHostIP bool, serviceTypeFilter []string, ignoreHostnameAnnotation bool) (Source, error) {
var (
tmpl *template.Template
err ... | go | {
"resource": ""
} |
q167942 | Endpoints | validation | func (sc *serviceSource) Endpoints() ([]*endpoint.Endpoint, error) {
services, err := sc.serviceInformer.Lister().Services(sc.namespace).List(labels.Everything())
if err != nil {
return nil, err
}
services, err = sc.filterByAnnotations(services)
if err != nil {
return nil, err
}
// filter on service types i... | go | {
"resource": ""
} |
q167943 | endpoints | validation | func (sc *serviceSource) endpoints(svc *v1.Service, nodeTargets endpoint.Targets) []*endpoint.Endpoint {
var endpoints []*endpoint.Endpoint
// Skip endpoints if we do not want entries from annotations
if !sc.ignoreHostnameAnnotation {
providerSpecific := getProviderSpecificAnnotations(svc.Annotations)
hostnameLi... | go | {
"resource": ""
} |
q167944 | filterByAnnotations | validation | func (sc *serviceSource) filterByAnnotations(services []*v1.Service) ([]*v1.Service, error) {
labelSelector, err := metav1.ParseToLabelSelector(sc.annotationFilter)
if err != nil {
return nil, err
}
selector, err := metav1.LabelSelectorAsSelector(labelSelector)
if err != nil {
return nil, err
}
// empty fil... | go | {
"resource": ""
} |
q167945 | filterByServiceType | validation | func (sc *serviceSource) filterByServiceType(services []*v1.Service) []*v1.Service {
filteredList := []*v1.Service{}
for _, service := range services {
// Check if the service is of the given type or not
if _, ok := sc.serviceTypeFilter[string(service.Spec.Type)]; ok {
filteredList = append(filteredList, servi... | go | {
"resource": ""
} |
q167946 | Calculate | validation | func (p *Plan) Calculate() *Plan {
t := newPlanTable()
for _, current := range filterRecordsForPlan(p.Current) {
t.addCurrent(current)
}
for _, desired := range filterRecordsForPlan(p.Desired) {
t.addCandidate(desired)
}
changes := &Changes{}
changes.Create = t.getCreates()
changes.Delete = t.getDeletes()... | go | {
"resource": ""
} |
q167947 | NewExoscaleProvider | validation | func NewExoscaleProvider(endpoint, apiKey, apiSecret string, dryRun bool, opts ...ExoscaleOption) *ExoscaleProvider {
client := egoscale.NewClient(endpoint, apiKey, apiSecret)
return NewExoscaleProviderWithClient(endpoint, apiKey, apiSecret, client, dryRun, opts...)
} | go | {
"resource": ""
} |
q167948 | ExoscaleWithLogging | validation | func ExoscaleWithLogging() ExoscaleOption {
return func(p *ExoscaleProvider) {
p.OnApplyChanges = func(changes *plan.Changes) {
for _, v := range changes.Create {
log.Infof("CREATE: %v", v)
}
for _, v := range changes.UpdateOld {
log.Infof("UPDATE (old): %v", v)
}
for _, v := range changes.Upd... | go | {
"resource": ""
} |
q167949 | NewLinodeProvider | validation | func NewLinodeProvider(domainFilter DomainFilter, dryRun bool, appVersion string) (*LinodeProvider, error) {
token, ok := os.LookupEnv("LINODE_TOKEN")
if !ok {
return nil, fmt.Errorf("no token found")
}
tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
oauth2Client := &http.Client{
T... | go | {
"resource": ""
} |
q167950 | NewTargets | validation | func NewTargets(target ...string) Targets {
t := make(Targets, 0, len(target))
t = append(t, target...)
return t
} | go | {
"resource": ""
} |
q167951 | Same | validation | func (t Targets) Same(o Targets) bool {
if len(t) != len(o) {
return false
}
sort.Stable(t)
sort.Stable(o)
for i, e := range t {
if e != o[i] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q167952 | IsLess | validation | func (t Targets) IsLess(o Targets) bool {
if len(t) < len(o) {
return true
}
if len(t) > len(o) {
return false
}
sort.Sort(t)
sort.Sort(o)
for i, e := range t {
if e != o[i] {
return e < o[i]
}
}
return false
} | go | {
"resource": ""
} |
q167953 | NewEndpoint | validation | func NewEndpoint(dnsName, recordType string, targets ...string) *Endpoint {
return NewEndpointWithTTL(dnsName, recordType, TTL(0), targets...)
} | go | {
"resource": ""
} |
q167954 | NewEndpointWithTTL | validation | func NewEndpointWithTTL(dnsName, recordType string, ttl TTL, targets ...string) *Endpoint {
cleanTargets := make([]string, len(targets))
for idx, target := range targets {
cleanTargets[idx] = strings.TrimSuffix(target, ".")
}
return &Endpoint{
DNSName: strings.TrimSuffix(dnsName, "."),
Targets: cleanTa... | go | {
"resource": ""
} |
q167955 | GetProviderSpecificProperty | validation | func (e *Endpoint) GetProviderSpecificProperty(key string) (ProviderSpecificProperty, bool) {
for _, providerSpecific := range e.ProviderSpecific {
if providerSpecific.Name == key {
return providerSpecific, true
}
}
return ProviderSpecificProperty{}, false
} | go | {
"resource": ""
} |
q167956 | Match | validation | func (f ZoneIDFilter) Match(zoneID string) bool {
// An empty filter includes all zones.
if len(f.zoneIDs) == 0 {
return true
}
for _, id := range f.zoneIDs {
if strings.HasSuffix(zoneID, id) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q167957 | ValidateConfig | validation | func ValidateConfig(cfg *externaldns.Config) error {
// TODO: Should probably return field.ErrorList
if cfg.LogFormat != "text" && cfg.LogFormat != "json" {
return fmt.Errorf("unsupported log format: %s", cfg.LogFormat)
}
if len(cfg.Sources) == 0 {
return errors.New("no sources specified")
}
if cfg.Provider =... | go | {
"resource": ""
} |
q167958 | CreateRecord | validation | func (n NS1DomainService) CreateRecord(r *dns.Record) (*http.Response, error) {
return n.service.Records.Create(r)
} | go | {
"resource": ""
} |
q167959 | DeleteRecord | validation | func (n NS1DomainService) DeleteRecord(zone string, domain string, t string) (*http.Response, error) {
return n.service.Records.Delete(zone, domain, t)
} | go | {
"resource": ""
} |
q167960 | UpdateRecord | validation | func (n NS1DomainService) UpdateRecord(r *dns.Record) (*http.Response, error) {
return n.service.Records.Update(r)
} | go | {
"resource": ""
} |
q167961 | GetZone | validation | func (n NS1DomainService) GetZone(zone string) (*dns.Zone, *http.Response, error) {
return n.service.Zones.Get(zone)
} | go | {
"resource": ""
} |
q167962 | ListZones | validation | func (n NS1DomainService) ListZones() ([]*dns.Zone, *http.Response, error) {
return n.service.Zones.List()
} | go | {
"resource": ""
} |
q167963 | Records | validation | func (p *NS1Provider) Records() ([]*endpoint.Endpoint, error) {
zones, err := p.zonesFiltered()
if err != nil {
return nil, err
}
var endpoints []*endpoint.Endpoint
for _, zone := range zones {
// TODO handle Header Codes
zoneData, _, err := p.client.GetZone(zone.String())
if err != nil {
return nil,... | go | {
"resource": ""
} |
q167964 | ns1BuildRecord | validation | func ns1BuildRecord(zoneName string, change *ns1Change) *dns.Record {
record := dns.NewRecord(zoneName, change.Endpoint.DNSName, change.Endpoint.RecordType)
for _, v := range change.Endpoint.Targets {
record.AddAnswer(dns.NewAnswer(strings.Split(v, " ")))
}
// set detault ttl
var ttl = ns1DefaultTTL
if change.E... | go | {
"resource": ""
} |
q167965 | ns1SubmitChanges | validation | func (p *NS1Provider) ns1SubmitChanges(changes []*ns1Change) error {
// return early if there is nothing to change
if len(changes) == 0 {
return nil
}
zones, err := p.zonesFiltered()
if err != nil {
return err
}
// separate into per-zone change sets to be passed to the API.
changesByZone := ns1ChangesByZo... | go | {
"resource": ""
} |
q167966 | newNS1Changes | validation | func newNS1Changes(action string, endpoints []*endpoint.Endpoint) []*ns1Change {
changes := make([]*ns1Change, 0, len(endpoints))
for _, endpoint := range endpoints {
changes = append(changes, &ns1Change{
Action: action,
Endpoint: endpoint,
},
)
}
return changes
} | go | {
"resource": ""
} |
q167967 | ns1ChangesByZone | validation | func ns1ChangesByZone(zones []*dns.Zone, changeSets []*ns1Change) map[string][]*ns1Change {
changes := make(map[string][]*ns1Change)
zoneNameIDMapper := zoneIDName{}
for _, z := range zones {
zoneNameIDMapper.Add(z.Zone, z.Zone)
changes[z.Zone] = []*ns1Change{}
}
for _, c := range changeSets {
zone, _ := zo... | go | {
"resource": ""
} |
q167968 | allLogLevelsAsStrings | validation | func allLogLevelsAsStrings() []string {
var levels []string
for _, level := range logrus.AllLevels {
levels = append(levels, level.String())
}
return levels
} | go | {
"resource": ""
} |
q167969 | Apply | validation | func (p *UpsertOnlyPolicy) Apply(changes *Changes) *Changes {
return &Changes{
Create: changes.Create,
UpdateOld: changes.UpdateOld,
UpdateNew: changes.UpdateNew,
}
} | go | {
"resource": ""
} |
q167970 | RunOnce | validation | func (c *Controller) RunOnce() error {
records, err := c.Registry.Records()
if err != nil {
registryErrors.Inc()
return err
}
registryEndpointsTotal.Set(float64(len(records)))
endpoints, err := c.Source.Endpoints()
if err != nil {
sourceErrors.Inc()
return err
}
sourceEndpointsTotal.Set(float64(len(end... | go | {
"resource": ""
} |
q167971 | Run | validation | func (c *Controller) Run(stopChan <-chan struct{}) {
ticker := time.NewTicker(c.Interval)
defer ticker.Stop()
for {
err := c.RunOnce()
if err != nil {
log.Error(err)
}
select {
case <-ticker.C:
case <-stopChan:
log.Info("Terminating main controller loop")
return
}
}
} | go | {
"resource": ""
} |
q167972 | NewCloudFlareProvider | validation | func NewCloudFlareProvider(domainFilter DomainFilter, zoneIDFilter ZoneIDFilter, zonesPerPage int, proxiedByDefault bool, dryRun bool) (*CloudFlareProvider, error) {
// initialize via API email and API key and returns new API object
config, err := cloudflare.New(os.Getenv("CF_API_KEY"), os.Getenv("CF_API_EMAIL"))
if... | go | {
"resource": ""
} |
q167973 | newCloudFlareChanges | validation | func newCloudFlareChanges(action string, endpoints []*endpoint.Endpoint, proxiedByDefault bool) []*cloudFlareChange {
changes := make([]*cloudFlareChange, 0, len(endpoints))
for _, endpoint := range endpoints {
changes = append(changes, newCloudFlareChange(action, endpoint, proxiedByDefault))
}
return changes
} | go | {
"resource": ""
} |
q167974 | GetAccountID | validation | func (p *dnsimpleProvider) GetAccountID(credentials dnsimple.Credentials, client dnsimple.Client) (accountID string, err error) {
// get DNSimple client accountID
whoamiResponse, err := client.Identity.Whoami()
if err != nil {
return "", err
}
return strconv.Itoa(whoamiResponse.Data.Account.ID), nil
} | go | {
"resource": ""
} |
q167975 | NewDnsimpleProvider | validation | func NewDnsimpleProvider(domainFilter DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool) (Provider, error) {
oauthToken := os.Getenv("DNSIMPLE_OAUTH")
if len(oauthToken) == 0 {
return nil, fmt.Errorf("No dnsimple oauth token provided")
}
client := dnsimple.NewClient(dnsimple.NewOauthTokenCredentials(oauthToken... | go | {
"resource": ""
} |
q167976 | Zones | validation | func (p *dnsimpleProvider) Zones() (map[string]dnsimple.Zone, error) {
zones := make(map[string]dnsimple.Zone)
page := 1
listOptions := &dnsimple.ZoneListOptions{}
for {
listOptions.Page = page
zonesResponse, err := p.client.ListZones(p.accountID, listOptions)
if err != nil {
return nil, err
}
for _, z... | go | {
"resource": ""
} |
q167977 | Records | validation | func (p *dnsimpleProvider) Records() (endpoints []*endpoint.Endpoint, _ error) {
zones, err := p.Zones()
if err != nil {
return nil, err
}
for _, zone := range zones {
page := 1
listOptions := &dnsimple.ZoneRecordListOptions{}
for {
listOptions.Page = page
records, err := p.client.ListRecords(p.accoun... | go | {
"resource": ""
} |
q167978 | newDnsimpleChange | validation | func newDnsimpleChange(action string, e *endpoint.Endpoint) *dnsimpleChange {
ttl := dnsimpleRecordTTL
if e.RecordTTL.IsConfigured() {
ttl = int(e.RecordTTL)
}
change := &dnsimpleChange{
Action: action,
ResourceRecordSet: dnsimple.ZoneRecord{
Name: e.DNSName,
Type: e.RecordType,
Content: e.Tar... | go | {
"resource": ""
} |
q167979 | newDnsimpleChanges | validation | func newDnsimpleChanges(action string, endpoints []*endpoint.Endpoint) []*dnsimpleChange {
changes := make([]*dnsimpleChange, 0, len(endpoints))
for _, e := range endpoints {
changes = append(changes, newDnsimpleChange(action, e))
}
return changes
} | go | {
"resource": ""
} |
q167980 | submitChanges | validation | func (p *dnsimpleProvider) submitChanges(changes []*dnsimpleChange) error {
if len(changes) == 0 {
log.Infof("All records are already up to date")
return nil
}
zones, err := p.Zones()
if err != nil {
return err
}
for _, change := range changes {
zone := dnsimpleSuitableZone(change.ResourceRecordSet.Name, ... | go | {
"resource": ""
} |
q167981 | GetRecordID | validation | func (p *dnsimpleProvider) GetRecordID(zone string, recordName string) (recordID int, err error) {
page := 1
listOptions := &dnsimple.ZoneRecordListOptions{Name: recordName}
for {
listOptions.Page = page
records, err := p.client.ListRecords(p.accountID, zone, listOptions)
if err != nil {
return 0, err
}
... | go | {
"resource": ""
} |
q167982 | dnsimpleSuitableZone | validation | func dnsimpleSuitableZone(hostname string, zones map[string]dnsimple.Zone) *dnsimple.Zone {
var zone *dnsimple.Zone
for _, z := range zones {
if strings.HasSuffix(hostname, z.Name) {
if zone == nil || len(z.Name) > len(zone.Name) {
newZ := z
zone = &newZ
}
}
}
return zone
} | go | {
"resource": ""
} |
q167983 | CreateRecords | validation | func (p *dnsimpleProvider) CreateRecords(endpoints []*endpoint.Endpoint) error {
return p.submitChanges(newDnsimpleChanges(dnsimpleCreate, endpoints))
} | go | {
"resource": ""
} |
q167984 | DeleteRecords | validation | func (p *dnsimpleProvider) DeleteRecords(endpoints []*endpoint.Endpoint) error {
return p.submitChanges(newDnsimpleChanges(dnsimpleDelete, endpoints))
} | go | {
"resource": ""
} |
q167985 | UpdateRecords | validation | func (p *dnsimpleProvider) UpdateRecords(endpoints []*endpoint.Endpoint) error {
return p.submitChanges(newDnsimpleChanges(dnsimpleUpdate, endpoints))
} | go | {
"resource": ""
} |
q167986 | ApplyChanges | validation | func (p *dnsimpleProvider) ApplyChanges(changes *plan.Changes) error {
combinedChanges := make([]*dnsimpleChange, 0, len(changes.Create)+len(changes.UpdateNew)+len(changes.Delete))
combinedChanges = append(combinedChanges, newDnsimpleChanges(dnsimpleCreate, changes.Create)...)
combinedChanges = append(combinedChang... | go | {
"resource": ""
} |
q167987 | NewGoogleProvider | validation | func NewGoogleProvider(project string, domainFilter DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool) (*GoogleProvider, error) {
gcloud, err := google.DefaultClient(context.TODO(), dns.NdevClouddnsReadwriteScope)
if err != nil {
return nil, err
}
gcloud = instrumented_http.NewClient(gcloud, &instrumented_htt... | go | {
"resource": ""
} |
q167988 | Records | validation | func (p *GoogleProvider) Records() (endpoints []*endpoint.Endpoint, _ error) {
zones, err := p.Zones()
if err != nil {
return nil, err
}
f := func(resp *dns.ResourceRecordSetsListResponse) error {
for _, r := range resp.Rrsets {
if !supportedRecordType(r.Type) {
continue
}
endpoints = append(endpo... | go | {
"resource": ""
} |
q167989 | newFilteredRecords | validation | func (p *GoogleProvider) newFilteredRecords(endpoints []*endpoint.Endpoint) []*dns.ResourceRecordSet {
records := []*dns.ResourceRecordSet{}
for _, endpoint := range endpoints {
if p.domainFilter.Match(endpoint.DNSName) {
records = append(records, newRecord(endpoint))
}
}
return records
} | go | {
"resource": ""
} |
q167990 | submitChange | validation | func (p *GoogleProvider) submitChange(change *dns.Change) error {
if len(change.Additions) == 0 && len(change.Deletions) == 0 {
log.Info("All records are already up to date")
return nil
}
zones, err := p.Zones()
if err != nil {
return err
}
// separate into per-zone change sets to be passed to the API.
c... | go | {
"resource": ""
} |
q167991 | separateChange | validation | func separateChange(zones map[string]*dns.ManagedZone, change *dns.Change) map[string]*dns.Change {
changes := make(map[string]*dns.Change)
zoneNameIDMapper := zoneIDName{}
for _, z := range zones {
zoneNameIDMapper[z.Name] = z.DnsName
changes[z.Name] = &dns.Change{
Additions: []*dns.ResourceRecordSet{},
D... | go | {
"resource": ""
} |
q167992 | newRecord | validation | func newRecord(ep *endpoint.Endpoint) *dns.ResourceRecordSet {
// TODO(linki): works around appending a trailing dot to TXT records. I think
// we should go back to storing DNS names with a trailing dot internally. This
// way we can use it has is here and trim it off if it exists when necessary.
targets := make([]... | go | {
"resource": ""
} |
q167993 | NewRcodeZeroProvider | validation | func NewRcodeZeroProvider(domainFilter DomainFilter, dryRun bool, txtEnc bool) (*RcodeZeroProvider, error) {
client, err := rc0.NewClient(os.Getenv("RC0_API_KEY"))
if err != nil {
return nil, err
}
value := os.Getenv("RC0_BASE_URL")
if len(value) != 0 {
client.BaseURL, err = url.Parse(os.Getenv("RC0_BASE_UR... | go | {
"resource": ""
} |
q167994 | Zones | validation | func (p *RcodeZeroProvider) Zones() ([]*rc0.Zone, error) {
var result []*rc0.Zone
zones, err := p.fetchZones()
if err != nil {
return nil, err
}
for _, zone := range zones {
if p.DomainFilter.Match(zone.Domain) {
result = append(result, zone)
}
}
return result, nil
} | go | {
"resource": ""
} |
q167995 | Records | validation | func (p *RcodeZeroProvider) Records() ([]*endpoint.Endpoint, error) {
zones, err := p.Zones()
if err != nil {
return nil, err
}
var endpoints []*endpoint.Endpoint
for _, zone := range zones {
rrset, err := p.fetchRecords(zone.Domain)
if err != nil {
return nil, err
}
for _, r := range rrset {
... | go | {
"resource": ""
} |
q167996 | submitChanges | validation | func (p *RcodeZeroProvider) submitChanges(changes []*rc0.RRSetChange) error {
if len(changes) == 0 {
return nil
}
zones, err := p.Zones()
if err != nil {
return err
}
// separate into per-zone change sets to be passed to the API.
changesByZone := rcodezeroChangesByZone(zones, changes)
for zoneName, chan... | go | {
"resource": ""
} |
q167997 | NewRcodezeroChanges | validation | func (p *RcodeZeroProvider) NewRcodezeroChanges(action string, endpoints []*endpoint.Endpoint) []*rc0.RRSetChange {
changes := make([]*rc0.RRSetChange, 0, len(endpoints))
for _, _endpoint := range endpoints {
changes = append(changes, p.NewRcodezeroChange(action, _endpoint))
}
return changes
} | go | {
"resource": ""
} |
q167998 | NewRcodezeroChange | validation | func (p *RcodeZeroProvider) NewRcodezeroChange(action string, endpoint *endpoint.Endpoint) *rc0.RRSetChange {
change := &rc0.RRSetChange{
Type: endpoint.RecordType,
ChangeType: action,
Name: endpoint.DNSName,
Records: []*rc0.Record{{
Disabled: false,
Content: endpoint.Targets[0],
}},
}
... | go | {
"resource": ""
} |
q167999 | NewAlibabaCloudProvider | validation | func NewAlibabaCloudProvider(configFile string, domainFilter DomainFilter, zoneIDFileter ZoneIDFilter, zoneType string, dryRun bool) (*AlibabaCloudProvider, error) {
cfg := alibabaCloudConfig{}
if configFile != "" {
contents, err := ioutil.ReadFile(configFile)
if err != nil {
return nil, fmt.Errorf("Failed to ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.