github.com/simonswine/terraform@v0.9.0-beta2/builtin/providers/dns/provider.go (about)

     1  package dns
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"github.com/hashicorp/terraform/terraform"
     9  	"github.com/miekg/dns"
    10  )
    11  
    12  // Provider returns a schema.Provider for DNS dynamic updates.
    13  func Provider() terraform.ResourceProvider {
    14  	return &schema.Provider{
    15  		Schema: map[string]*schema.Schema{
    16  			"update": &schema.Schema{
    17  				Type:     schema.TypeList,
    18  				MaxItems: 1,
    19  				Optional: true,
    20  				Elem: &schema.Resource{
    21  					Schema: map[string]*schema.Schema{
    22  						"server": &schema.Schema{
    23  							Type:        schema.TypeString,
    24  							Required:    true,
    25  							DefaultFunc: schema.EnvDefaultFunc("DNS_UPDATE_SERVER", nil),
    26  						},
    27  						"port": &schema.Schema{
    28  							Type:     schema.TypeInt,
    29  							Optional: true,
    30  							Default:  53,
    31  						},
    32  						"key_name": &schema.Schema{
    33  							Type:        schema.TypeString,
    34  							Optional:    true,
    35  							DefaultFunc: schema.EnvDefaultFunc("DNS_UPDATE_KEYNAME", nil),
    36  						},
    37  						"key_algorithm": &schema.Schema{
    38  							Type:        schema.TypeString,
    39  							Optional:    true,
    40  							DefaultFunc: schema.EnvDefaultFunc("DNS_UPDATE_KEYALGORITHM", nil),
    41  						},
    42  						"key_secret": &schema.Schema{
    43  							Type:        schema.TypeString,
    44  							Optional:    true,
    45  							DefaultFunc: schema.EnvDefaultFunc("DNS_UPDATE_KEYSECRET", nil),
    46  						},
    47  					},
    48  				},
    49  			},
    50  		},
    51  
    52  		ResourcesMap: map[string]*schema.Resource{
    53  			"dns_a_record_set":    resourceDnsARecordSet(),
    54  			"dns_aaaa_record_set": resourceDnsAAAARecordSet(),
    55  			"dns_cname_record":    resourceDnsCnameRecord(),
    56  			"dns_ptr_record":      resourceDnsPtrRecord(),
    57  		},
    58  
    59  		ConfigureFunc: configureProvider,
    60  	}
    61  }
    62  
    63  func configureProvider(d *schema.ResourceData) (interface{}, error) {
    64  
    65  	var server, keyname, keyalgo, keysecret string
    66  	var port int
    67  
    68  	// if the update block is missing, schema.EnvDefaultFunc is not called
    69  	if v, ok := d.GetOk("update"); ok {
    70  		update := v.([]interface{})[0].(map[string]interface{})
    71  		if val, ok := update["port"]; ok {
    72  			port = int(val.(int))
    73  		}
    74  		if val, ok := update["server"]; ok {
    75  			server = val.(string)
    76  		}
    77  		if val, ok := update["key_name"]; ok {
    78  			keyname = val.(string)
    79  		}
    80  		if val, ok := update["key_algorithm"]; ok {
    81  			keyalgo = val.(string)
    82  		}
    83  		if val, ok := update["key_secret"]; ok {
    84  			keysecret = val.(string)
    85  		}
    86  	} else {
    87  		if len(os.Getenv("DNS_UPDATE_SERVER")) > 0 {
    88  			server = os.Getenv("DNS_UPDATE_SERVER")
    89  		} else {
    90  			return nil, nil
    91  		}
    92  		port = 53
    93  		if len(os.Getenv("DNS_UPDATE_KEYNAME")) > 0 {
    94  			keyname = os.Getenv("DNS_UPDATE_KEYNAME")
    95  		}
    96  		if len(os.Getenv("DNS_UPDATE_KEYALGORITHM")) > 0 {
    97  			keyalgo = os.Getenv("DNS_UPDATE_KEYALGORITHM")
    98  		}
    99  		if len(os.Getenv("DNS_UPDATE_KEYSECRET")) > 0 {
   100  			keysecret = os.Getenv("DNS_UPDATE_KEYSECRET")
   101  		}
   102  	}
   103  
   104  	config := Config{
   105  		server:    server,
   106  		port:      port,
   107  		keyname:   keyname,
   108  		keyalgo:   keyalgo,
   109  		keysecret: keysecret,
   110  	}
   111  
   112  	return config.Client()
   113  }
   114  
   115  func getAVal(record interface{}) (string, error) {
   116  
   117  	recstr := record.(*dns.A).String()
   118  	var name, ttl, class, typ, addr string
   119  
   120  	_, err := fmt.Sscanf(recstr, "%s\t%s\t%s\t%s\t%s", &name, &ttl, &class, &typ, &addr)
   121  	if err != nil {
   122  		return "", fmt.Errorf("Error parsing record: %s", err)
   123  	}
   124  
   125  	return addr, nil
   126  }
   127  
   128  func getAAAAVal(record interface{}) (string, error) {
   129  
   130  	recstr := record.(*dns.AAAA).String()
   131  	var name, ttl, class, typ, addr string
   132  
   133  	_, err := fmt.Sscanf(recstr, "%s\t%s\t%s\t%s\t%s", &name, &ttl, &class, &typ, &addr)
   134  	if err != nil {
   135  		return "", fmt.Errorf("Error parsing record: %s", err)
   136  	}
   137  
   138  	return addr, nil
   139  }
   140  
   141  func getCnameVal(record interface{}) (string, error) {
   142  
   143  	recstr := record.(*dns.CNAME).String()
   144  	var name, ttl, class, typ, cname string
   145  
   146  	_, err := fmt.Sscanf(recstr, "%s\t%s\t%s\t%s\t%s", &name, &ttl, &class, &typ, &cname)
   147  	if err != nil {
   148  		return "", fmt.Errorf("Error parsing record: %s", err)
   149  	}
   150  
   151  	return cname, nil
   152  }
   153  
   154  func getPtrVal(record interface{}) (string, error) {
   155  
   156  	recstr := record.(*dns.PTR).String()
   157  	var name, ttl, class, typ, ptr string
   158  
   159  	_, err := fmt.Sscanf(recstr, "%s\t%s\t%s\t%s\t%s", &name, &ttl, &class, &typ, &ptr)
   160  	if err != nil {
   161  		return "", fmt.Errorf("Error parsing record: %s", err)
   162  	}
   163  
   164  	return ptr, nil
   165  }