id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168000 | {
target := record.Value
if recordType == "TXT" {
target = p.unescapeTXTRecordValue(target)
}
targets = append(targets, target)
}
ep := endpoint.NewEndpointWithTTL(name, recordType, endpoint.TTL(ttl), targets...)
endpoints = append(endpoints, ep)
}
return endpoints, nil
} | |
c168001 | []string
for _, record := range recordList {
target := record.Value
if recordType == "TXT" {
target = p.unescapeTXTRecordValue(target)
}
targets = append(targets, target)
}
ep := endpoint.NewEndpointWithTTL(name, recordType, endpoint.TTL(ttl), targets...)
endpoints = append(endpoints, ... | |
c168002 |
_, err = c.client.Put(ctx, service.Key, string(value))
if err != nil {
return err
}
return nil
} | |
c168003 | c.client.Delete(ctx, key, etcdcv3.WithPrefix())
return err
} | |
c168004 | certificates = append(certificates, cert)
}
roots, err := loadRoots(caPath)
if err != nil {
return nil, err
}
return &tls.Config{
Certificates: certificates,
RootCAs: roots,
InsecureSkipVerify: insecure,
ServerName: serverName,
}, nil
} | |
c168005 | certFile := os.Getenv("ETCD_CERT_FILE")
keyFile := os.Getenv("ETCD_KEY_FILE")
serverName := os.Getenv("ETCD_TLS_SERVER_NAME")
isInsecureStr := strings.ToLower(os.Getenv("ETCD_TLS_INSECURE"))
isInsecure := isInsecureStr == "true" || isInsecureStr == "yes" || isInsecureStr == "1"
tlsConfig, err := newTLSConfig... | |
c168006 | return nil, err
}
return etcdClient{c, context.Background()}, nil
} | |
c168007 | client: client,
dryRun: dryRun,
domainFilter: domainFilter,
}, nil
} | |
c168008 | guessRecordType(service.Host),
endpoint.TTL(service.TTL),
service.Host,
)
ep.Labels["originalText"] = service.Text
ep.Labels[randomPrefixLabel] = prefix
result = append(result, ep)
}
if service.Text != "" {
ep := endpoint.NewEndpoint(
dnsName,
endpoint.RecordTypeTXT,
service.Text... | |
c168009 | r := &rfc2136Provider{
nameserver: net.JoinHostPort(host, strconv.Itoa(port)),
zoneName: dns.Fqdn(zoneName),
insecure: insecure,
domainFilter: domainFilter,
dryRun: dryRun,
axfr: axfr,
}
if actions != nil {
r.actions = actions
} else {
r.actions = r
}
if !insecure {
r.ts... | |
c168010 |
buf := new(bytes.Buffer)
buf.ReadFrom(r.Body)
body = buf.String()
return body
} | |
c168011 | err := config.TLSConfig.setHTTPClient(pdnsClientConfig); err != nil {
return nil, err
}
provider := &PDNSProvider{
client: &PDNSAPIClient{
dryRun: config.DryRun,
authCtx: context.WithValue(context.TODO(), pgo.ContextAPIKey, pgo.APIKey{Key: config.APIKey}),
client: pgo.NewAPIClient(pdns... | |
c168012 | }
resp, err := p.client.PatchZone(zone.Id, zone)
if err != nil {
log.Debugf("PDNS API response: %s", stringifyHTTPResponseBody(resp))
return err
}
}
return nil
} | |
c168013 | if assumeRole != "" {
log.Infof("Assuming role: %s", assumeRole)
sess.Config.WithCredentials(stscreds.NewCredentials(sess, assumeRole))
}
sess.Handlers.Build.PushBack(request.MakeAddToUserAgentHandler("ExternalDNS", externaldns.Version))
provider := &AWSSDProvider{
client: sd.New(sess),
names... | |
c168014 | case sdNamespaceTypePrivate:
return &sd.NamespaceFilter{
Name: aws.String(sd.NamespaceFilterNameType),
Values: []*string{aws.String(sd.NamespaceTypeDnsPrivate)},
}
default:
return nil
}
} | |
c168015 | if err != nil {
return nil, err
}
if len(instances) > 0 {
ep := p.instancesToEndpoint(ns, srv, instances)
endpoints = append(endpoints, ep)
}
}
}
return endpoints, nil
} | |
c168016 |
// When just list of targets is updated `[1.2.3.4] -> [1.2.3.4, 1.2.3.5]` it is translated to:
// ```
// deletes = [1.2.3.4]
// creates = [1.2.3.4, 1.2.3.5]
// ```
// then when deletes are executed after creates it will miss the `1.2.3.4` instance.
err = p.submitDeletes(namespaces, changes.Delete)
if err != ni... | |
c168017 | := p.client.ListNamespacesPages(&sd.ListNamespacesInput{
Filters: []*sd.NamespaceFilter{p.namespaceTypeFilter},
}, f)
if err != nil {
return nil, err
}
return namespaces, nil
} | |
c168018 |
if err != nil {
return nil, err
}
return output.Service, nil
} | |
c168019 |
err := p.client.ListInstancesPages(&sd.ListInstancesInput{
ServiceId: serviceID,
}, f)
if err != nil {
return nil, err
}
return instances, nil
} | |
c168020 | namespaceID,
RoutingPolicy: aws.String(routingPolicy),
DnsRecords: []*sd.DnsRecord{{
Type: aws.String(srvType),
TTL: aws.Int64(ttl),
}},
},
})
if err != nil {
return nil, err
}
return out.Service, nil
}
// return mock service summary in case of dry run
return &sd.Service{Id: ... | |
c168021 |
Service: &sd.ServiceChange{
Description: aws.String(ep.Labels[endpoint.AWSSDDescriptionLabel]),
DnsConfig: &sd.DnsConfigChange{
DnsRecords: []*sd.DnsRecord{{
Type: aws.String(srvType),
TTL: aws.Int64(ttl),
}},
}}})
if err != nil {
return err
}
}
return nil
} | |
c168022 |
} else {
return fmt.Errorf("invalid endpoint type (%v)", ep)
}
if !p.dryRun {
_, err := p.client.RegisterInstance(&sd.RegisterInstanceInput{
ServiceId: service.Id,
Attributes: attr,
InstanceId: aws.String(p.targetToInstanceID(target)),
})
if err != nil {
return err
}
}
}
ret... | |
c168023 | InstanceId: aws.String(p.targetToInstanceID(target)),
ServiceId: service.Id,
})
if err != nil {
return err
}
}
}
return nil
} | |
c168024 |
hash := sha256.Sum256([]byte(strings.ToLower(target)))
return hex.EncodeToString(hash[:])
}
return strings.ToLower(target)
} | |
c168025 | 0)
for _, ns := range namespaces {
if *ns.Name == hostname {
matchingNamespaces = append(matchingNamespaces, ns)
}
}
return matchingNamespaces
} | |
c168026 | sd.RoutingPolicyMultivalue
}
return sd.RoutingPolicyWeighted
} | |
c168027 | return strings.HasSuffix(hostname, sdElbHostnameSuffix)
} | |
c168028 | still have two endpoints from same resource here. We sort for consistency
// TODO: remove once single endpoint can have multiple targets
sort.SliceStable(candidates, func(i, j int) bool {
return s.less(candidates[i], candidates[j])
})
for _, ep := range candidates {
if ep.Labels[endpoint.ResourceLabelKey] == c... | |
c168029 | x.Targets.IsLess(y.Targets)
} | |
c168030 |
client := godo.NewClient(oauthClient)
provider := &DigitalOceanProvider{
Client: client.Domains,
domainFilter: domainFilter,
DryRun: dryRun,
}
return provider, nil
} | |
c168031 | endpoints {
changes = append(changes, newDigitalOceanChange(action, endpoint))
}
return changes
} | |
c168032 | if zoneRecord.Name == record.Name && zoneRecord.Type == record.Type {
return zoneRecord.ID
}
}
return 0
} | |
c168033 | changes[z.Name] = []*DigitalOceanChange{}
}
for _, c := range changeSet {
zone, _ := zoneNameIDMapper.FindZone(c.ResourceRecordSet.Name)
if zone == "" {
log.Debugf("Skipping record %s because no hosted zone matching record DNS Name was detected ", c.ResourceRecordSet.Name)
continue
}
changes[zone] = ... | |
c168034 | case "molecule":
return legacyEndpointsFromMoleculeService(svc)
}
return []*endpoint.Endpoint{}
} | |
c168035 | if lb.IP != "" {
endpoints = append(endpoints, endpoint.NewEndpoint(hostname, endpoint.RecordTypeA, lb.IP))
}
if lb.Hostname != "" {
endpoints = append(endpoints, endpoint.NewEndpoint(hostname, endpoint.RecordTypeCNAME, lb.Hostname))
}
}
return endpoints
} | |
c168036 | entrypoint.
for _, lb := range svc.Status.LoadBalancer.Ingress {
if lb.IP != "" {
endpoints = append(endpoints, endpoint.NewEndpoint(hostname, endpoint.RecordTypeA, lb.IP))
}
if lb.Hostname != "" {
endpoints = append(endpoints, endpoint.NewEndpoint(hostname, endpoint.RecordTypeCNAME, lb.Hostname))
... | |
c168037 | periods
targetsList := strings.Split(strings.Replace(targetAnnotation, " ", "", -1), ",")
for _, targetHostname := range targetsList {
targetHostname = strings.TrimSuffix(targetHostname, ".")
targets = append(targets, targetHostname)
}
}
return targets
} | |
c168038 | return endpoint.RecordTypeA
}
return endpoint.RecordTypeCNAME
} | |
c168039 |
ProviderSpecific: providerSpecific,
}
endpoints = append(endpoints, epA)
}
if len(cnameTargets) > 0 {
epCNAME := &endpoint.Endpoint{
DNSName: strings.TrimSuffix(hostname, "."),
Targets: cnameTargets,
RecordTTL: ttl,
RecordType: endpoint.RecordTypeCNAME,
Labels:... | |
c168040 | map[string][]*endpoint.Endpoint{},
serials: map[string]int{},
},
}, nil
} | |
c168041 | {
result.CName = ep.Targets[0]
} else if ep.RecordType == endpoint.RecordTypeTXT {
result.TxtData = ep.Targets[0]
}
return &result
} | |
c168042 | error {
return service.Do(&req, &records)
})
if err != nil {
return nil, err
}
log.Debugf("Got all Records, status is %s", records.Status)
if strings.ToLower(records.Status) == "incomplete" {
jobRequest := dynectsoap.GetJobRequestType{
Token: token,
Job_id: records.Job_id,
Fault_... | |
c168043 | return d.ZoneIDFilter.zoneIDs
} | |
c168044 | link, record, &response)
})
log.Debugf("Replacing record %s: %+v,", link, errorOrValue(err, &response))
return err
} | |
c168045 | waste the good work so far
err = apiRetryLoop(func() error {
return client.Do("PUT", fmt.Sprintf("Zone/%s/", zone), &zonePublish, &response)
})
log.Infof("Committing changes for zone %s: %+v", zone, errorOrValue(err, &response))
}
switch len(errs) {
case 0:
return nil
case 1:
return errs[0]
default:... | |
c168046 | return nil, err
}
result = append(result, endpoints...)
}
return result, nil
} | |
c168047 | return nil, err
}
return &designateClient{serviceClient}, nil
} | |
c168048 | if currentVal == "" && newVal != "" {
os.Setenv(k, newVal)
}
}
} | |
c168049 | }
authProvider.HTTPClient.Transport = transport
if err = openstack.Authenticate(authProvider, opts); err != nil {
return nil, err
}
eo := gophercloud.EndpointOpts{
Region: os.Getenv("OS_REGION_NAME"),
}
client, err := openstack.NewDNSV2(authProvider, eo)
if err != nil {
return nil, err
}
log.Infof("F... | |
c168050 | error) {
list, err := zones.ExtractZones(page)
if err != nil {
return false, err
}
for _, zone := range list {
err := handler(&zone)
if err != nil {
return false, err
}
}
return true, nil
},
)
} | |
c168051 | func(page pagination.Page) (bool, error) {
list, err := recordsets.ExtractRecordSets(page)
if err != nil {
return false, err
}
for _, recordSet := range list {
err := handler(&recordSet)
if err != nil {
return false, err
}
}
return true, nil
},
)
} | |
c168052 | error) {
r, err := recordsets.Create(c.serviceClient, zoneID, opts).Extract()
if err != nil {
return "", err
}
return r.ID, nil
} | |
c168053 | err := recordsets.Update(c.serviceClient, zoneID, recordSetID, opts).Extract()
return err
} | |
c168054 | recordsets.Delete(c.serviceClient, zoneID, recordSetID).ExtractErr()
} | |
c168055 | client: client,
domainFilter: domainFilter,
dryRun: dryRun,
}, nil
} | |
c168056 | cDomains = append(cDomains, strings.ToLower(d))
}
}
return cDomains
} | |
c168057 | d += "."
}
return strings.ToLower(d)
} | |
c168058 |
zoneName := canonicalizeDomainName(zone.Name)
if !p.domainFilter.Match(zoneName) {
return nil
}
result[zone.ID] = zoneName
return nil
},
)
return result, err
} | |
c168059 |
ln := len(zoneName)
if ln > longestZoneLength {
resultID = zoneID
longestZoneLength = ln
}
}
return resultID, nil
} | |
c168060 | ok := rs.names[rec]; !ok && rec != "" {
rs.names[rec] = true
}
}
targets := ep.Targets
if ep.RecordType == endpoint.RecordTypeCNAME {
targets = canonicalizeDomainNames(targets)
}
for _, t := range targets {
rs.names[t] = !delete
}
recordSets[key] = rs
} | |
c168061 | kubeClient,
istioClient: istioClient,
istioIngressGatewayServices: istioIngressGatewayServices,
namespace: namespace,
annotationFilter: annotationFilter,
fqdnTemplate: tmpl,
combineFQDNAnnotation: combineFqdnAnnotation,
ignoreHostname... | |
c168062 | {
// convert the annotations to an equivalent label selector
annotations := labels.Set(config.Annotations)
// include if the annotations match the selector
if selector.Matches(annotations) {
filteredList = append(filteredList, config)
}
}
return filteredList, nil
} | |
c168063 |
}
endpoints = append(endpoints, endpointsForHostname(host, targets, ttl, providerSpecific)...)
}
}
// Skip endpoints if we do not want entries from annotations
if !sc.ignoreHostnameAnnotation {
hostnameList := getHostnamesFromAnnotations(config.Annotations)
for _, hostname := range hostnameList {
en... | |
c168064 | out := new(DNSEndpoint)
in.DeepCopyInto(out)
return out
} | |
c168065 |
out := new(DNSEndpointList)
in.DeepCopyInto(out)
return out
} | |
c168066 |
out := new(DNSEndpointSpec)
in.DeepCopyInto(out)
return out
} | |
c168067 | }
out := new(DNSEndpointStatus)
in.DeepCopyInto(out)
return out
} | |
c168068 | out := new(Endpoint)
in.DeepCopyInto(out)
return out
} | |
c168069 | := new(Labels)
in.DeepCopyInto(out)
return *out
} | |
c168070 |
out := new(ProviderSpecific)
in.DeepCopyInto(out)
return *out
} | |
c168071 | := new(Targets)
in.DeepCopyInto(out)
return *out
} | |
c168072 |
return strings.TrimSuffix(hostname, ".") + "."
} | |
c168073 | &NoopRegistry{
provider: provider,
}, nil
} | |
c168074 | return im.provider.ApplyChanges(changes)
} | |
c168075 | log.Debugf("Removing duplicate endpoint %s", ep)
continue
}
collected[identifier] = true
result = append(result, ep)
}
return result, nil
} | |
c168076 | }
return &fakeSource{
dnsName: fqdnTemplate,
}, nil
} | |
c168077 |
isInsecureStr := strings.ToLower(os.Getenv(fmt.Sprintf("%s_TLS_INSECURE", prefix)))
isInsecure := isInsecureStr == "true" || isInsecureStr == "yes" || isInsecureStr == "1"
tlsConfig, err := NewTLSConfig(certFile, keyFile, caFile, serverName, isInsecure, defaultMinVersion)
if err != nil {
return nil, err
}
retu... | |
c168078 | "" {
return nil, errors.New("owner id cannot be empty")
}
return &AWSSDRegistry{
provider: provider,
ownerID: ownerID,
}, nil
} | |
c168079 |
Delete: filterOwnedRecords(sdr.ownerID, changes.Delete),
}
sdr.updateLabels(filteredChanges.Create)
sdr.updateLabels(filteredChanges.UpdateNew)
sdr.updateLabels(filteredChanges.UpdateOld)
sdr.updateLabels(filteredChanges.Delete)
return sdr.provider.ApplyChanges(filteredChanges)
} | |
c168080 | &cfg); err != nil {
return nil, errors.Wrapf(err, "parsing OCI config file %q", path)
}
return &cfg, nil
} | |
c168081 | if err != nil {
return nil, errors.Wrap(err, "initialising OCI DNS API client")
}
return &OCIProvider{
client: client,
cfg: cfg,
domainFilter: domainFilter,
zoneIDFilter: zoneIDFilter,
dryRun: dryRun,
}, nil
} | |
c168082 |
log.Infof("Change zone: %q", zoneID)
for _, op := range ops {
log.Info(op)
}
}
if p.dryRun {
return nil
}
for zoneID, ops := range opsByZone {
if _, err := p.client.PatchZoneRecords(ctx, dns.PatchZoneRecordsRequest{
CompartmentId: &p.cfg.CompartmentID,
ZoneNameOrId: &zoneI... | |
c168083 | ociRecordTTL
if ep.RecordTTL.IsConfigured() {
ttl = int(ep.RecordTTL)
}
return dns.RecordOperation{
Domain: &ep.DNSName,
Rdata: &rdata,
Ttl: &ttl,
Rtype: &ep.RecordType,
Operation: opType,
}
} | |
c168084 |
log.Warnf("No matching zone for record operation %s", op)
}
}
// Remove zones that don't have any changes.
for zone, ops := range changes {
if len(ops) == 0 {
delete(changes, zone)
}
}
return changes
} | |
c168085 | zonesClient := dns.NewZonesClientWithBaseURI(environment.ResourceManagerEndpoint, cfg.SubscriptionID)
zonesClient.Authorizer = autorest.NewBearerAuthorizer(token)
recordsClient := dns.NewRecordSetsClientWithBaseURI(environment.ResourceManagerEndpoint, cfg.SubscriptionID)
recordsClient.Authorizer = autorest.NewBeare... | |
c168086 | 0 && len(cfg.ClientSecret) > 0 {
log.Info("Using client_id+client_secret to retrieve access token for Azure API.")
oauthConfig, err := adal.NewOAuthConfig(environment.ActiveDirectoryEndpoint, cfg.TenantID)
if err != nil {
return nil, fmt.Errorf("failed to retrieve OAuth config: %v", err)
}
token, err := ... | |
c168087 |
tarBuf, err := mcnutils.MakeDiskImage(publicSSHKeyPath)
if err != nil {
return err
}
log.Debug("Calling inner createDiskImage")
return createDiskImage(diskPath, size, tarBuf)
} | |
c168088 | number of bytes written to stdin must match sizeBytes, or
// VBoxManage.exe on Windows will fail. Fill remaining with zeros.
if left := sizeBytes - n; left > 0 {
if err := zeroFill(stdin, left); err != nil {
return err
}
}
log.Debug("Closing STDIN")
// cmd won't exit until the stdin is closed.
if err :=... | |
c168089 |
return err
}
if n.DHCP {
vbox.vbm("hostonlyif", "ipconfig", n.Name, "--dhcp") // not implemented as of VirtualBox 4.3
}
return nil
} | |
c168090 |
if err := vbox.vbm("hostonlyif", "ipconfig", n.Name, "--ip", n.IPv4.IP.String(), "--netmask", net.IP(n.IPv4.Mask).String()); err != nil {
return err
}
}
return nil
} | |
c168091 | in the taskbar.")
}
out, err := vbox.vbmOut("hostonlyif", "create")
if err != nil {
return nil, err
}
res := reHostOnlyAdapterCreated.FindStringSubmatch(string(out))
if res == nil {
return nil, errors.New("Failed to create host-only adapter")
}
return &hostOnlyNetwork{Name: res[1]}, nil
} | |
c168092 | byName[n.NetworkName]; present {
return fmt.Errorf("VirtualBox is configured with multiple host-only adapters with the same name %q. Please remove one", n.NetworkName)
}
byName[n.NetworkName] = n
if len(n.IPv4.IP) != 0 {
if _, present := byIP[n.IPv4.IP.String()]; present {
return fmt.Errorf("Vir... | |
c168093 |
if err := vbox.vbm("dhcpserver", "remove", "--netname", name); err != nil {
log.Warnf("Unable to remove orphan dhcp server %q: %s", name, err)
}
}
}
}
return nil
} | |
c168094 | "--netname", name,
"--ip", d.IPv4.IP.String(),
"--netmask", net.IP(d.IPv4.Mask).String(),
"--lowerip", d.LowerIP.String(),
"--upperip", d.UpperIP.String(),
}
if d.Enabled {
args = append(args, "--enable")
} else {
args = append(args, "--disable")
}
if runtime.GOOS == "windows" {
log.Warn("Windows m... | |
c168095 |
dhcp.UpperIP = net.ParseIP(val)
case "lowerIPAddress":
dhcp.LowerIP = net.ParseIP(val)
case "NetworkMask":
dhcp.IPv4.Mask = parseIPv4Mask(val)
case "Enabled":
dhcp.Enabled = (val == "Yes")
}
return nil
})
if err != nil {
return nil, err
}
return m, nil
} | |
c168096 | if hostonly.IP.Equal(ifaceNet.IP.Mask(ifaceNet.Mask)) {
return true, nil
}
}
return false, nil
} | |
c168097 |
BaseDriver: &BaseDriver{
MachineName: hostName,
StorePath: storePath,
},
Name: driverName,
}
} | |
c168098 | attempting call to get driver name: %s", err)
}
return driverName
} | |
c168099 |
if s != state.Running {
return ErrHostIsNotRunning
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.