_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168000 | recordsForDNS | validation | func (p *AlibabaCloudProvider) recordsForDNS() (endpoints []*endpoint.Endpoint, _ error) {
records, err := p.records()
if err != nil {
return nil, err
}
for _, recordList := range p.groupRecords(records) {
name := p.getDNSName(recordList[0].RR, recordList[0].DomainName)
recordType := recordList[0].Type
ttl... | go | {
"resource": ""
} |
q168001 | privateZoneRecords | validation | func (p *AlibabaCloudProvider) privateZoneRecords() (endpoints []*endpoint.Endpoint, _ error) {
zones, err := p.getPrivateZones()
if err != nil {
return nil, err
}
for _, zone := range zones {
recordMap := p.groupPrivateZoneRecords(zone)
for _, recordList := range recordMap {
name := p.getDNSName(recordL... | go | {
"resource": ""
} |
q168002 | SaveService | validation | func (c etcdClient) SaveService(service *Service) error {
ctx, cancel := context.WithTimeout(c.ctx, etcdTimeout)
defer cancel()
value, err := json.Marshal(&service)
if err != nil {
return err
}
_, err = c.client.Put(ctx, service.Key, string(value))
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q168003 | DeleteService | validation | func (c etcdClient) DeleteService(key string) error {
ctx, cancel := context.WithTimeout(c.ctx, etcdTimeout)
defer cancel()
_, err := c.client.Delete(ctx, key, etcdcv3.WithPrefix())
return err
} | go | {
"resource": ""
} |
q168004 | newTLSConfig | validation | func newTLSConfig(certPath, keyPath, caPath, serverName string, insecure bool) (*tls.Config, error) {
if certPath != "" && keyPath == "" || certPath == "" && keyPath != "" {
return nil, errors.New("either both cert and key or none must be provided")
}
var certificates []tls.Certificate
if certPath != "" {
cert,... | go | {
"resource": ""
} |
q168005 | getETCDConfig | validation | func getETCDConfig() (*etcdcv3.Config, error) {
etcdURLsStr := os.Getenv("ETCD_URLS")
if etcdURLsStr == "" {
etcdURLsStr = "http://localhost:2379"
}
etcdURLs := strings.Split(etcdURLsStr, ",")
firstURL := strings.ToLower(etcdURLs[0])
if strings.HasPrefix(firstURL, "http://") {
return &etcdcv3.Config{Endpoints... | go | {
"resource": ""
} |
q168006 | newETCDClient | validation | func newETCDClient() (coreDNSClient, error) {
cfg, err := getETCDConfig()
if err != nil {
return nil, err
}
c, err := etcdcv3.New(*cfg)
if err != nil {
return nil, err
}
return etcdClient{c, context.Background()}, nil
} | go | {
"resource": ""
} |
q168007 | NewCoreDNSProvider | validation | func NewCoreDNSProvider(domainFilter DomainFilter, dryRun bool) (Provider, error) {
client, err := newETCDClient()
if err != nil {
return nil, err
}
return coreDNSProvider{
client: client,
dryRun: dryRun,
domainFilter: domainFilter,
}, nil
} | go | {
"resource": ""
} |
q168008 | Records | validation | func (p coreDNSProvider) Records() ([]*endpoint.Endpoint, error) {
var result []*endpoint.Endpoint
services, err := p.client.GetServices(coreDNSPrefix)
if err != nil {
return nil, err
}
for _, service := range services {
domains := strings.Split(strings.TrimPrefix(service.Key, coreDNSPrefix), "/")
reverse(do... | go | {
"resource": ""
} |
q168009 | NewRfc2136Provider | validation | func NewRfc2136Provider(host string, port int, zoneName string, insecure bool, keyName string, secret string, secretAlg string, axfr bool, domainFilter DomainFilter, dryRun bool, actions rfc2136Actions) (Provider, error) {
secretAlgChecked, ok := tsigAlgs[secretAlg]
if !ok && !insecure {
return nil, errors.Errorf("... | go | {
"resource": ""
} |
q168010 | stringifyHTTPResponseBody | validation | func stringifyHTTPResponseBody(r *http.Response) (body string) {
if r == nil {
return ""
}
buf := new(bytes.Buffer)
buf.ReadFrom(r.Body)
body = buf.String()
return body
} | go | {
"resource": ""
} |
q168011 | NewPDNSProvider | validation | func NewPDNSProvider(config PDNSConfig) (*PDNSProvider, error) {
// Do some input validation
if config.APIKey == "" {
return nil, errors.New("Missing API Key for PDNS. Specify using --pdns-api-key=")
}
// We do not support dry running, exit safely instead of surprising the user
// TODO: Add Dry Run support
i... | go | {
"resource": ""
} |
q168012 | mutateRecords | validation | func (p *PDNSProvider) mutateRecords(endpoints []*endpoint.Endpoint, changetype pdnsChangeType) error {
zonelist, err := p.ConvertEndpointsToZones(endpoints, changetype)
if err != nil {
return err
}
for _, zone := range zonelist {
jso, err := json.Marshal(zone)
if err != nil {
log.Errorf("JSON Marshal for ... | go | {
"resource": ""
} |
q168013 | NewAWSSDProvider | validation | func NewAWSSDProvider(domainFilter DomainFilter, namespaceType string, assumeRole string, dryRun bool) (*AWSSDProvider, error) {
config := aws.NewConfig()
config = config.WithHTTPClient(
instrumented_http.NewClient(config.HTTPClient, &instrumented_http.Callbacks{
PathProcessor: func(path string) string {
pa... | go | {
"resource": ""
} |
q168014 | newSdNamespaceFilter | validation | func newSdNamespaceFilter(namespaceTypeConfig string) *sd.NamespaceFilter {
switch namespaceTypeConfig {
case sdNamespaceTypePublic:
return &sd.NamespaceFilter{
Name: aws.String(sd.NamespaceFilterNameType),
Values: []*string{aws.String(sd.NamespaceTypeDnsPublic)},
}
case sdNamespaceTypePrivate:
return ... | go | {
"resource": ""
} |
q168015 | Records | validation | func (p *AWSSDProvider) Records() (endpoints []*endpoint.Endpoint, err error) {
namespaces, err := p.ListNamespaces()
if err != nil {
return nil, err
}
for _, ns := range namespaces {
services, err := p.ListServicesByNamespaceID(ns.Id)
if err != nil {
return nil, err
}
for _, srv := range services {
... | go | {
"resource": ""
} |
q168016 | ApplyChanges | validation | func (p *AWSSDProvider) ApplyChanges(changes *plan.Changes) error {
// return early if there is nothing to change
if len(changes.Create) == 0 && len(changes.Delete) == 0 && len(changes.UpdateNew) == 0 {
log.Info("All records are already up to date")
return nil
}
// convert updates to delete and create operatio... | go | {
"resource": ""
} |
q168017 | ListNamespaces | validation | func (p *AWSSDProvider) ListNamespaces() ([]*sd.NamespaceSummary, error) {
namespaces := make([]*sd.NamespaceSummary, 0)
f := func(resp *sd.ListNamespacesOutput, lastPage bool) bool {
for _, ns := range resp.Namespaces {
if !p.namespaceFilter.Match(aws.StringValue(ns.Name)) {
continue
}
namespaces = a... | go | {
"resource": ""
} |
q168018 | GetServiceDetail | validation | func (p *AWSSDProvider) GetServiceDetail(serviceID *string) (*sd.Service, error) {
output, err := p.client.GetService(&sd.GetServiceInput{
Id: serviceID,
})
if err != nil {
return nil, err
}
return output.Service, nil
} | go | {
"resource": ""
} |
q168019 | ListInstancesByServiceID | validation | func (p *AWSSDProvider) ListInstancesByServiceID(serviceID *string) ([]*sd.InstanceSummary, error) {
instances := make([]*sd.InstanceSummary, 0)
f := func(resp *sd.ListInstancesOutput, lastPage bool) bool {
instances = append(instances, resp.Instances...)
return true
}
err := p.client.ListInstancesPages(&sd.... | go | {
"resource": ""
} |
q168020 | CreateService | validation | func (p *AWSSDProvider) CreateService(namespaceID *string, srvName *string, ep *endpoint.Endpoint) (*sd.Service, error) {
log.Infof("Creating a new service \"%s\" in \"%s\" namespace", *srvName, *namespaceID)
srvType := p.serviceTypeFromEndpoint(ep)
routingPolicy := p.routingPolicyFromEndpoint(ep)
ttl := int64(sd... | go | {
"resource": ""
} |
q168021 | UpdateService | validation | func (p *AWSSDProvider) UpdateService(service *sd.Service, ep *endpoint.Endpoint) error {
log.Infof("Updating service \"%s\"", *service.Name)
srvType := p.serviceTypeFromEndpoint(ep)
ttl := int64(sdDefaultRecordTTL)
if ep.RecordTTL.IsConfigured() {
ttl = int64(ep.RecordTTL)
}
if !p.dryRun {
_, err := p.cli... | go | {
"resource": ""
} |
q168022 | RegisterInstance | validation | func (p *AWSSDProvider) RegisterInstance(service *sd.Service, ep *endpoint.Endpoint) error {
for _, target := range ep.Targets {
log.Infof("Registering a new instance \"%s\" for service \"%s\" (%s)", target, *service.Name, *service.Id)
attr := make(map[string]*string)
if ep.RecordType == endpoint.RecordTypeCNA... | go | {
"resource": ""
} |
q168023 | DeregisterInstance | validation | func (p *AWSSDProvider) DeregisterInstance(service *sd.Service, ep *endpoint.Endpoint) error {
for _, target := range ep.Targets {
log.Infof("De-registering an instance \"%s\" for service \"%s\" (%s)", target, *service.Name, *service.Id)
if !p.dryRun {
_, err := p.client.DeregisterInstance(&sd.DeregisterInstan... | go | {
"resource": ""
} |
q168024 | targetToInstanceID | validation | func (p *AWSSDProvider) targetToInstanceID(target string) string {
if len(target) > 64 {
hash := sha256.Sum256([]byte(strings.ToLower(target)))
return hex.EncodeToString(hash[:])
}
return strings.ToLower(target)
} | go | {
"resource": ""
} |
q168025 | matchingNamespaces | validation | func matchingNamespaces(hostname string, namespaces []*sd.NamespaceSummary) []*sd.NamespaceSummary {
matchingNamespaces := make([]*sd.NamespaceSummary, 0)
for _, ns := range namespaces {
if *ns.Name == hostname {
matchingNamespaces = append(matchingNamespaces, ns)
}
}
return matchingNamespaces
} | go | {
"resource": ""
} |
q168026 | routingPolicyFromEndpoint | validation | func (p *AWSSDProvider) routingPolicyFromEndpoint(ep *endpoint.Endpoint) string {
if ep.RecordType == endpoint.RecordTypeA {
return sd.RoutingPolicyMultivalue
}
return sd.RoutingPolicyWeighted
} | go | {
"resource": ""
} |
q168027 | isAWSLoadBalancer | validation | func (p *AWSSDProvider) isAWSLoadBalancer(hostname string) bool {
return strings.HasSuffix(hostname, sdElbHostnameSuffix)
} | go | {
"resource": ""
} |
q168028 | ResolveUpdate | validation | func (s PerResource) ResolveUpdate(current *endpoint.Endpoint, candidates []*endpoint.Endpoint) *endpoint.Endpoint {
currentResource := current.Labels[endpoint.ResourceLabelKey] // resource which has already acquired the DNS
// TODO: sort candidates only needed because we can still have two endpoints from same resour... | go | {
"resource": ""
} |
q168029 | less | validation | func (s PerResource) less(x, y *endpoint.Endpoint) bool {
return x.Targets.IsLess(y.Targets)
} | go | {
"resource": ""
} |
q168030 | NewDigitalOceanProvider | validation | func NewDigitalOceanProvider(domainFilter DomainFilter, dryRun bool) (*DigitalOceanProvider, error) {
token, ok := os.LookupEnv("DO_TOKEN")
if !ok {
return nil, fmt.Errorf("No token found")
}
oauthClient := oauth2.NewClient(oauth2.NoContext, oauth2.StaticTokenSource(&oauth2.Token{
AccessToken: token,
}))
clie... | go | {
"resource": ""
} |
q168031 | newDigitalOceanChanges | validation | func newDigitalOceanChanges(action string, endpoints []*endpoint.Endpoint) []*DigitalOceanChange {
changes := make([]*DigitalOceanChange, 0, len(endpoints))
for _, endpoint := range endpoints {
changes = append(changes, newDigitalOceanChange(action, endpoint))
}
return changes
} | go | {
"resource": ""
} |
q168032 | getRecordID | validation | func (p *DigitalOceanProvider) getRecordID(records []godo.DomainRecord, record godo.DomainRecord) int {
for _, zoneRecord := range records {
if zoneRecord.Name == record.Name && zoneRecord.Type == record.Type {
return zoneRecord.ID
}
}
return 0
} | go | {
"resource": ""
} |
q168033 | digitalOceanChangesByZone | validation | func digitalOceanChangesByZone(zones []godo.Domain, changeSet []*DigitalOceanChange) map[string][]*DigitalOceanChange {
changes := make(map[string][]*DigitalOceanChange)
zoneNameIDMapper := zoneIDName{}
for _, z := range zones {
zoneNameIDMapper.Add(z.Name, z.Name)
changes[z.Name] = []*DigitalOceanChange{}
}
... | go | {
"resource": ""
} |
q168034 | legacyEndpointsFromService | validation | func legacyEndpointsFromService(svc *v1.Service, compatibility string) []*endpoint.Endpoint {
switch compatibility {
case "mate":
return legacyEndpointsFromMateService(svc)
case "molecule":
return legacyEndpointsFromMoleculeService(svc)
}
return []*endpoint.Endpoint{}
} | go | {
"resource": ""
} |
q168035 | legacyEndpointsFromMateService | validation | func legacyEndpointsFromMateService(svc *v1.Service) []*endpoint.Endpoint {
var endpoints []*endpoint.Endpoint
// Get the desired hostname of the service from the annotation.
hostname, exists := svc.Annotations[mateAnnotationKey]
if !exists {
return nil
}
// Create a corresponding endpoint for each configured... | go | {
"resource": ""
} |
q168036 | legacyEndpointsFromMoleculeService | validation | func legacyEndpointsFromMoleculeService(svc *v1.Service) []*endpoint.Endpoint {
var endpoints []*endpoint.Endpoint
// Check that the Service opted-in to being processed.
if svc.Labels["dns"] != "route53" {
return nil
}
// Get the desired hostname of the service from the annotation.
hostnameAnnotation, exists ... | go | {
"resource": ""
} |
q168037 | getTargetsFromTargetAnnotation | validation | func getTargetsFromTargetAnnotation(annotations map[string]string) endpoint.Targets {
var targets endpoint.Targets
// Get the desired hostname of the ingress from the annotation.
targetAnnotation, exists := annotations[targetAnnotationKey]
if exists && targetAnnotation != "" {
// splits the hostname annotation a... | go | {
"resource": ""
} |
q168038 | suitableType | validation | func suitableType(target string) string {
if net.ParseIP(target) != nil {
return endpoint.RecordTypeA
}
return endpoint.RecordTypeCNAME
} | go | {
"resource": ""
} |
q168039 | endpointsForHostname | validation | func endpointsForHostname(hostname string, targets endpoint.Targets, ttl endpoint.TTL, providerSpecific endpoint.ProviderSpecific) []*endpoint.Endpoint {
var endpoints []*endpoint.Endpoint
var aTargets endpoint.Targets
var cnameTargets endpoint.Targets
for _, t := range targets {
switch suitableType(t) {
case... | go | {
"resource": ""
} |
q168040 | NewDynProvider | validation | func NewDynProvider(config DynConfig) (Provider, error) {
return &dynProviderState{
DynConfig: config,
ZoneSnapshot: &ZoneSnapshot{
endpoints: map[string][]*endpoint.Endpoint{},
serials: map[string]int{},
},
}, nil
} | go | {
"resource": ""
} |
q168041 | endpointToRecord | validation | func endpointToRecord(ep *endpoint.Endpoint) *dynect.DataBlock {
result := dynect.DataBlock{}
if ep.RecordType == endpoint.RecordTypeA {
result.Address = ep.Targets[0]
} else if ep.RecordType == endpoint.RecordTypeCNAME {
result.CName = ep.Targets[0]
} else if ep.RecordType == endpoint.RecordTypeTXT {
result... | go | {
"resource": ""
} |
q168042 | fetchAllRecordsInZone | validation | func (d *dynProviderState) fetchAllRecordsInZone(zone string) (*dynectsoap.GetAllRecordsResponseType, error) {
var err error
client := dynectsoap.NewClient("https://api2.dynect.net/SOAP/")
service := dynectsoap.NewDynect(client)
sessionRequest := dynectsoap.SessionLoginRequestType{
Customer_name: d.CustomerName... | go | {
"resource": ""
} |
q168043 | zones | validation | func (d *dynProviderState) zones(client *dynect.Client) []string {
return d.ZoneIDFilter.zoneIDs
} | go | {
"resource": ""
} |
q168044 | replaceRecord | validation | func (d *dynProviderState) replaceRecord(client *dynect.Client, ep *endpoint.Endpoint) error {
link, record := d.buildRecordRequest(ep)
if link == "" {
return nil
}
response := dynect.RecordResponse{}
err := apiRetryLoop(func() error {
return client.Do("PUT", link, record, &response)
})
log.Debugf("Replaci... | go | {
"resource": ""
} |
q168045 | commit | validation | func (d *dynProviderState) commit(client *dynect.Client) error {
errs := []error{}
for _, zone := range d.zones(client) {
// extra call if in debug mode to fetch pending changes
if log.GetLevel() >= log.DebugLevel {
response := ZoneChangesResponse{}
err := client.Do("GET", fmt.Sprintf("ZoneChanges/%s/", zo... | go | {
"resource": ""
} |
q168046 | Endpoints | validation | func (ms *multiSource) Endpoints() ([]*endpoint.Endpoint, error) {
result := []*endpoint.Endpoint{}
for _, s := range ms.children {
endpoints, err := s.Endpoints()
if err != nil {
return nil, err
}
result = append(result, endpoints...)
}
return result, nil
} | go | {
"resource": ""
} |
q168047 | newDesignateClient | validation | func newDesignateClient() (designateClientInterface, error) {
serviceClient, err := createDesignateServiceClient()
if err != nil {
return nil, err
}
return &designateClient{serviceClient}, nil
} | go | {
"resource": ""
} |
q168048 | remapEnv | validation | func remapEnv(mapping map[string]string) {
for k, v := range mapping {
currentVal := os.Getenv(k)
newVal := os.Getenv(v)
if currentVal == "" && newVal != "" {
os.Setenv(k, newVal)
}
}
} | go | {
"resource": ""
} |
q168049 | createDesignateServiceClient | validation | func createDesignateServiceClient() (*gophercloud.ServiceClient, error) {
opts, err := getAuthSettings()
if err != nil {
return nil, err
}
log.Infof("Using OpenStack Keystone at %s", opts.IdentityEndpoint)
authProvider, err := openstack.NewClient(opts.IdentityEndpoint)
if err != nil {
return nil, err
}
tls... | go | {
"resource": ""
} |
q168050 | ForEachZone | validation | func (c designateClient) ForEachZone(handler func(zone *zones.Zone) error) error {
pager := zones.List(c.serviceClient, zones.ListOpts{})
return pager.EachPage(
func(page pagination.Page) (bool, error) {
list, err := zones.ExtractZones(page)
if err != nil {
return false, err
}
for _, zone := range l... | go | {
"resource": ""
} |
q168051 | ForEachRecordSet | validation | func (c designateClient) ForEachRecordSet(zoneID string, handler func(recordSet *recordsets.RecordSet) error) error {
pager := recordsets.ListByZone(c.serviceClient, zoneID, recordsets.ListOpts{})
return pager.EachPage(
func(page pagination.Page) (bool, error) {
list, err := recordsets.ExtractRecordSets(page)
... | go | {
"resource": ""
} |
q168052 | CreateRecordSet | validation | func (c designateClient) CreateRecordSet(zoneID string, opts recordsets.CreateOpts) (string, error) {
r, err := recordsets.Create(c.serviceClient, zoneID, opts).Extract()
if err != nil {
return "", err
}
return r.ID, nil
} | go | {
"resource": ""
} |
q168053 | UpdateRecordSet | validation | func (c designateClient) UpdateRecordSet(zoneID, recordSetID string, opts recordsets.UpdateOpts) error {
_, err := recordsets.Update(c.serviceClient, zoneID, recordSetID, opts).Extract()
return err
} | go | {
"resource": ""
} |
q168054 | DeleteRecordSet | validation | func (c designateClient) DeleteRecordSet(zoneID, recordSetID string) error {
return recordsets.Delete(c.serviceClient, zoneID, recordSetID).ExtractErr()
} | go | {
"resource": ""
} |
q168055 | NewDesignateProvider | validation | func NewDesignateProvider(domainFilter DomainFilter, dryRun bool) (Provider, error) {
client, err := newDesignateClient()
if err != nil {
return nil, err
}
return &designateProvider{
client: client,
domainFilter: domainFilter,
dryRun: dryRun,
}, nil
} | go | {
"resource": ""
} |
q168056 | canonicalizeDomainNames | validation | func canonicalizeDomainNames(domains []string) []string {
var cDomains []string
for _, d := range domains {
if !strings.HasSuffix(d, ".") {
d += "."
cDomains = append(cDomains, strings.ToLower(d))
}
}
return cDomains
} | go | {
"resource": ""
} |
q168057 | canonicalizeDomainName | validation | func canonicalizeDomainName(d string) string {
if !strings.HasSuffix(d, ".") {
d += "."
}
return strings.ToLower(d)
} | go | {
"resource": ""
} |
q168058 | getZones | validation | func (p designateProvider) getZones() (map[string]string, error) {
result := map[string]string{}
err := p.client.ForEachZone(
func(zone *zones.Zone) error {
if zone.Type != "" && strings.ToUpper(zone.Type) != "PRIMARY" || zone.Status != "ACTIVE" {
return nil
}
zoneName := canonicalizeDomainName(zone.... | go | {
"resource": ""
} |
q168059 | getHostZoneID | validation | func (p designateProvider) getHostZoneID(hostname string, managedZones map[string]string) (string, error) {
longestZoneLength := 0
resultID := ""
for zoneID, zoneName := range managedZones {
if !strings.HasSuffix(hostname, zoneName) {
continue
}
ln := len(zoneName)
if ln > longestZoneLength {
resultID... | go | {
"resource": ""
} |
q168060 | addEndpoint | validation | func addEndpoint(ep *endpoint.Endpoint, recordSets map[string]*recordSet, delete bool) {
key := fmt.Sprintf("%s/%s", ep.DNSName, ep.RecordType)
rs := recordSets[key]
if rs == nil {
rs = &recordSet{
dnsName: canonicalizeDomainName(ep.DNSName),
recordType: ep.RecordType,
names: make(map[string]bool)... | go | {
"resource": ""
} |
q168061 | NewIstioGatewaySource | validation | func NewIstioGatewaySource(
kubeClient kubernetes.Interface,
istioClient istiomodel.ConfigStore,
istioIngressGatewayServices []string,
namespace string,
annotationFilter string,
fqdnTemplate string,
combineFqdnAnnotation bool,
ignoreHostnameAnnotation bool,
) (Source, error) {
var (
tmpl *template.Template
... | go | {
"resource": ""
} |
q168062 | filterByAnnotations | validation | func (sc *gatewaySource) filterByAnnotations(configs []istiomodel.Config) ([]istiomodel.Config, 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": ""
} |
q168063 | endpointsFromGatewayConfig | validation | func (sc *gatewaySource) endpointsFromGatewayConfig(config istiomodel.Config) ([]*endpoint.Endpoint, error) {
var endpoints []*endpoint.Endpoint
ttl, err := getTTLFromAnnotations(config.Annotations)
if err != nil {
log.Warn(err)
}
targets := getTargetsFromTargetAnnotation(config.Annotations)
if len(targets) ... | go | {
"resource": ""
} |
q168064 | DeepCopy | validation | func (in *DNSEndpoint) DeepCopy() *DNSEndpoint {
if in == nil {
return nil
}
out := new(DNSEndpoint)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q168065 | DeepCopy | validation | func (in *DNSEndpointList) DeepCopy() *DNSEndpointList {
if in == nil {
return nil
}
out := new(DNSEndpointList)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q168066 | DeepCopy | validation | func (in *DNSEndpointSpec) DeepCopy() *DNSEndpointSpec {
if in == nil {
return nil
}
out := new(DNSEndpointSpec)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q168067 | DeepCopy | validation | func (in *DNSEndpointStatus) DeepCopy() *DNSEndpointStatus {
if in == nil {
return nil
}
out := new(DNSEndpointStatus)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q168068 | DeepCopy | validation | func (in *Endpoint) DeepCopy() *Endpoint {
if in == nil {
return nil
}
out := new(Endpoint)
in.DeepCopyInto(out)
return out
} | go | {
"resource": ""
} |
q168069 | DeepCopy | validation | func (in Labels) DeepCopy() Labels {
if in == nil {
return nil
}
out := new(Labels)
in.DeepCopyInto(out)
return *out
} | go | {
"resource": ""
} |
q168070 | DeepCopy | validation | func (in ProviderSpecific) DeepCopy() ProviderSpecific {
if in == nil {
return nil
}
out := new(ProviderSpecific)
in.DeepCopyInto(out)
return *out
} | go | {
"resource": ""
} |
q168071 | DeepCopy | validation | func (in Targets) DeepCopy() Targets {
if in == nil {
return nil
}
out := new(Targets)
in.DeepCopyInto(out)
return *out
} | go | {
"resource": ""
} |
q168072 | ensureTrailingDot | validation | func ensureTrailingDot(hostname string) string {
if net.ParseIP(hostname) != nil {
return hostname
}
return strings.TrimSuffix(hostname, ".") + "."
} | go | {
"resource": ""
} |
q168073 | NewNoopRegistry | validation | func NewNoopRegistry(provider provider.Provider) (*NoopRegistry, error) {
return &NoopRegistry{
provider: provider,
}, nil
} | go | {
"resource": ""
} |
q168074 | ApplyChanges | validation | func (im *NoopRegistry) ApplyChanges(changes *plan.Changes) error {
return im.provider.ApplyChanges(changes)
} | go | {
"resource": ""
} |
q168075 | Endpoints | validation | func (ms *dedupSource) Endpoints() ([]*endpoint.Endpoint, error) {
result := []*endpoint.Endpoint{}
collected := map[string]bool{}
endpoints, err := ms.source.Endpoints()
if err != nil {
return nil, err
}
for _, ep := range endpoints {
identifier := ep.DNSName + " / " + ep.Targets.String()
if _, ok := co... | go | {
"resource": ""
} |
q168076 | NewFakeSource | validation | func NewFakeSource(fqdnTemplate string) (Source, error) {
if fqdnTemplate == "" {
fqdnTemplate = defaultFQDNTemplate
}
return &fakeSource{
dnsName: fqdnTemplate,
}, nil
} | go | {
"resource": ""
} |
q168077 | CreateTLSConfig | validation | func CreateTLSConfig(prefix string) (*tls.Config, error) {
caFile := os.Getenv(fmt.Sprintf("%s_CA_FILE", prefix))
certFile := os.Getenv(fmt.Sprintf("%s_CERT_FILE", prefix))
keyFile := os.Getenv(fmt.Sprintf("%s_KEY_FILE", prefix))
serverName := os.Getenv(fmt.Sprintf("%s_TLS_SERVER_NAME", prefix))
isInsecureStr := s... | go | {
"resource": ""
} |
q168078 | NewAWSSDRegistry | validation | func NewAWSSDRegistry(provider provider.Provider, ownerID string) (*AWSSDRegistry, error) {
if ownerID == "" {
return nil, errors.New("owner id cannot be empty")
}
return &AWSSDRegistry{
provider: provider,
ownerID: ownerID,
}, nil
} | go | {
"resource": ""
} |
q168079 | ApplyChanges | validation | func (sdr *AWSSDRegistry) ApplyChanges(changes *plan.Changes) error {
filteredChanges := &plan.Changes{
Create: changes.Create,
UpdateNew: filterOwnedRecords(sdr.ownerID, changes.UpdateNew),
UpdateOld: filterOwnedRecords(sdr.ownerID, changes.UpdateOld),
Delete: filterOwnedRecords(sdr.ownerID, changes.Del... | go | {
"resource": ""
} |
q168080 | LoadOCIConfig | validation | func LoadOCIConfig(path string) (*OCIConfig, error) {
contents, err := ioutil.ReadFile(path)
if err != nil {
return nil, errors.Wrapf(err, "reading OCI config file %q", path)
}
cfg := OCIConfig{}
if err := yaml.Unmarshal(contents, &cfg); err != nil {
return nil, errors.Wrapf(err, "parsing OCI config file %q",... | go | {
"resource": ""
} |
q168081 | NewOCIProvider | validation | func NewOCIProvider(cfg OCIConfig, domainFilter DomainFilter, zoneIDFilter ZoneIDFilter, dryRun bool) (*OCIProvider, error) {
var client ociDNSClient
client, err := dns.NewDnsClientWithConfigurationProvider(common.NewRawConfigurationProvider(
cfg.Auth.TenancyID,
cfg.Auth.UserID,
cfg.Auth.Region,
cfg.Auth.Fing... | go | {
"resource": ""
} |
q168082 | ApplyChanges | validation | func (p *OCIProvider) ApplyChanges(changes *plan.Changes) error {
log.Debugf("Processing chages: %+v", changes)
ops := []dns.RecordOperation{}
ops = append(ops, p.newFilteredRecordOperations(changes.Create, dns.RecordOperationOperationAdd)...)
ops = append(ops, p.newFilteredRecordOperations(changes.UpdateNew, dns... | go | {
"resource": ""
} |
q168083 | newRecordOperation | validation | func newRecordOperation(ep *endpoint.Endpoint, opType dns.RecordOperationOperationEnum) dns.RecordOperation {
targets := make([]string, len(ep.Targets))
copy(targets, []string(ep.Targets))
if ep.RecordType == endpoint.RecordTypeCNAME {
targets[0] = ensureTrailingDot(targets[0])
}
rdata := strings.Join(targets, "... | go | {
"resource": ""
} |
q168084 | operationsByZone | validation | func operationsByZone(zones map[string]*dns.ZoneSummary, ops []dns.RecordOperation) map[string][]dns.RecordOperation {
changes := make(map[string][]dns.RecordOperation)
zoneNameIDMapper := zoneIDName{}
for _, z := range zones {
zoneNameIDMapper.Add(*z.Id, *z.Name)
changes[*z.Id] = []dns.RecordOperation{}
}
f... | go | {
"resource": ""
} |
q168085 | NewAzureProvider | validation | func NewAzureProvider(configFile string, domainFilter DomainFilter, zoneIDFilter ZoneIDFilter, resourceGroup string, dryRun bool) (*AzureProvider, error) {
contents, err := ioutil.ReadFile(configFile)
if err != nil {
return nil, fmt.Errorf("failed to read Azure config file '%s': %v", configFile, err)
}
cfg := con... | go | {
"resource": ""
} |
q168086 | getAccessToken | validation | func getAccessToken(cfg config, environment azure.Environment) (*adal.ServicePrincipalToken, error) {
// Try to retrive token with MSI.
if cfg.UseManagedIdentityExtension {
log.Info("Using managed identity extension to retrieve access token for Azure API.")
msiEndpoint, err := adal.GetMSIVMEndpoint()
if err != ... | go | {
"resource": ""
} |
q168087 | Create | validation | func (c *defaultDiskCreator) Create(size int, publicSSHKeyPath, diskPath string) error {
log.Debugf("Creating %d MB hard disk image...", size)
tarBuf, err := mcnutils.MakeDiskImage(publicSSHKeyPath)
if err != nil {
return err
}
log.Debug("Calling inner createDiskImage")
return createDiskImage(diskPath, size,... | go | {
"resource": ""
} |
q168088 | createDiskImage | validation | func createDiskImage(dest string, size int, r io.Reader) error {
// Convert a raw image from stdin to the dest VMDK image.
sizeBytes := int64(size) << 20 // usually won't fit in 32-bit int (max 2GB)
// FIXME: why isn't this just using the vbm*() functions?
cmd := exec.Command(vboxManageCmd, "convertfromraw", "stdin... | go | {
"resource": ""
} |
q168089 | Save | validation | func (n *hostOnlyNetwork) Save(vbox VBoxManager) error {
if err := n.SaveIPv4(vbox); err != nil {
return err
}
if n.DHCP {
vbox.vbm("hostonlyif", "ipconfig", n.Name, "--dhcp") // not implemented as of VirtualBox 4.3
}
return nil
} | go | {
"resource": ""
} |
q168090 | SaveIPv4 | validation | func (n *hostOnlyNetwork) SaveIPv4(vbox VBoxManager) error {
if n.IPv4.IP != nil && n.IPv4.Mask != nil {
if runtime.GOOS == "windows" {
log.Warn("Windows might ask for the permission to configure a network adapter. Sometimes, such confirmation window is minimized in the taskbar.")
}
if err := vbox.vbm("hosto... | go | {
"resource": ""
} |
q168091 | createHostonlyAdapter | validation | func createHostonlyAdapter(vbox VBoxManager) (*hostOnlyNetwork, error) {
if runtime.GOOS == "windows" {
log.Warn("Windows might ask for the permission to create a network adapter. Sometimes, such confirmation window is minimized in the taskbar.")
}
out, err := vbox.vbmOut("hostonlyif", "create")
if err != nil {
... | go | {
"resource": ""
} |
q168092 | listHostOnlyAdapters | validation | func listHostOnlyAdapters(vbox VBoxManager) (map[string]*hostOnlyNetwork, error) {
out, err := vbox.vbmOut("list", "hostonlyifs")
if err != nil {
return nil, err
}
byName := map[string]*hostOnlyNetwork{}
byIP := map[string]*hostOnlyNetwork{}
n := &hostOnlyNetwork{}
err = parseKeyValues(out, reColonLine, func... | go | {
"resource": ""
} |
q168093 | removeOrphanDHCPServers | validation | func removeOrphanDHCPServers(vbox VBoxManager) error {
dhcps, err := listDHCPServers(vbox)
if err != nil {
return err
}
if len(dhcps) == 0 {
return nil
}
log.Debug("Removing orphan DHCP servers...")
nets, err := listHostOnlyAdapters(vbox)
if err != nil {
return err
}
for name := range dhcps {
if s... | go | {
"resource": ""
} |
q168094 | addHostOnlyDHCPServer | validation | func addHostOnlyDHCPServer(ifname string, d dhcpServer, vbox VBoxManager) error {
name := dhcpPrefix + ifname
dhcps, err := listDHCPServers(vbox)
if err != nil {
return err
}
// On some platforms (OSX), creating a host-only adapter adds a default dhcpserver,
// while on others (Windows?) it does not.
command... | go | {
"resource": ""
} |
q168095 | listDHCPServers | validation | func listDHCPServers(vbox VBoxManager) (map[string]*dhcpServer, error) {
out, err := vbox.vbmOut("list", "dhcpservers")
if err != nil {
return nil, err
}
m := map[string]*dhcpServer{}
dhcp := &dhcpServer{}
err = parseKeyValues(out, reColonLine, func(key, val string) error {
switch key {
case "NetworkName"... | go | {
"resource": ""
} |
q168096 | checkIPNetCollision | validation | func checkIPNetCollision(hostonly *net.IPNet, hostIfaces map[string]*net.IPNet) (bool, error) {
for _, ifaceNet := range hostIfaces {
if hostonly.IP.Equal(ifaceNet.IP.Mask(ifaceNet.Mask)) {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q168097 | NewDriverNotSupported | validation | func NewDriverNotSupported(driverName, hostName, storePath string) Driver {
return &DriverNotSupported{
BaseDriver: &BaseDriver{
MachineName: hostName,
StorePath: storePath,
},
Name: driverName,
}
} | go | {
"resource": ""
} |
q168098 | DriverName | validation | func (c *RPCClientDriver) DriverName() string {
driverName, err := c.rpcStringCall(DriverNameMethod)
if err != nil {
log.Warnf("Error attempting call to get driver name: %s", err)
}
return driverName
} | go | {
"resource": ""
} |
q168099 | MustBeRunning | validation | func MustBeRunning(d Driver) error {
s, err := d.GetState()
if err != nil {
return err
}
if s != state.Running {
return ErrHostIsNotRunning
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.