github.com/peterbale/terraform@v0.9.0-beta2.0.20170315142748-5723acd55547/builtin/providers/consul/data_source_consul_catalog_nodes.go (about)

     1  package consul
     2  
     3  import (
     4  	"fmt"
     5  
     6  	consulapi "github.com/hashicorp/consul/api"
     7  	"github.com/hashicorp/errwrap"
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  )
    10  
    11  const (
    12  	catalogNodesElem       = "nodes"
    13  	catalogNodesDatacenter = "datacenter"
    14  	catalogNodesQueryOpts  = "query_options"
    15  
    16  	catalogNodesNodeID              = "id"
    17  	catalogNodesNodeAddress         = "address"
    18  	catalogNodesNodeMeta            = "meta"
    19  	catalogNodesNodeName            = "name"
    20  	catalogNodesNodeTaggedAddresses = "tagged_addresses"
    21  
    22  	catalogNodesNodeIDs   = "node_ids"
    23  	catalogNodesNodeNames = "node_names"
    24  
    25  	catalogNodesAPITaggedLAN    = "lan"
    26  	catalogNodesAPITaggedWAN    = "wan"
    27  	catalogNodesSchemaTaggedLAN = "lan"
    28  	catalogNodesSchemaTaggedWAN = "wan"
    29  )
    30  
    31  func dataSourceConsulCatalogNodes() *schema.Resource {
    32  	return &schema.Resource{
    33  		Read: dataSourceConsulCatalogNodesRead,
    34  		Schema: map[string]*schema.Schema{
    35  			// Filters
    36  			catalogNodesQueryOpts: schemaQueryOpts,
    37  
    38  			// Out parameters
    39  			catalogNodesDatacenter: &schema.Schema{
    40  				Computed: true,
    41  				Type:     schema.TypeString,
    42  			},
    43  			catalogNodesNodeIDs: &schema.Schema{
    44  				Computed: true,
    45  				Type:     schema.TypeList,
    46  				Elem:     &schema.Schema{Type: schema.TypeString},
    47  			},
    48  			catalogNodesNodeNames: &schema.Schema{
    49  				Computed: true,
    50  				Type:     schema.TypeList,
    51  				Elem:     &schema.Schema{Type: schema.TypeString},
    52  			},
    53  			catalogNodesElem: &schema.Schema{
    54  				Computed: true,
    55  				Type:     schema.TypeList,
    56  				Elem: &schema.Resource{
    57  					Schema: map[string]*schema.Schema{
    58  						catalogNodesNodeID: &schema.Schema{
    59  							Type:         schema.TypeString,
    60  							Computed:     true,
    61  							ValidateFunc: makeValidationFunc(catalogNodesNodeID, []interface{}{validateRegexp(`^[\S]+$`)}),
    62  						},
    63  						catalogNodesNodeName: &schema.Schema{
    64  							Type:         schema.TypeString,
    65  							Computed:     true,
    66  							ValidateFunc: makeValidationFunc(catalogNodesNodeName, []interface{}{validateRegexp(`^[\S]+$`)}),
    67  						},
    68  						catalogNodesNodeAddress: &schema.Schema{
    69  							Type:     schema.TypeString,
    70  							Computed: true,
    71  						},
    72  						catalogNodesNodeMeta: &schema.Schema{
    73  							Type:     schema.TypeMap,
    74  							Computed: true,
    75  						},
    76  						catalogNodesNodeTaggedAddresses: &schema.Schema{
    77  							Type:     schema.TypeMap,
    78  							Computed: true,
    79  							Elem: &schema.Resource{
    80  								Schema: map[string]*schema.Schema{
    81  									catalogNodesSchemaTaggedLAN: &schema.Schema{
    82  										Type:     schema.TypeString,
    83  										Computed: true,
    84  									},
    85  									catalogNodesSchemaTaggedWAN: &schema.Schema{
    86  										Type:     schema.TypeString,
    87  										Computed: true,
    88  									},
    89  								},
    90  							},
    91  						},
    92  					},
    93  				},
    94  			},
    95  		},
    96  	}
    97  }
    98  
    99  func dataSourceConsulCatalogNodesRead(d *schema.ResourceData, meta interface{}) error {
   100  	client := meta.(*consulapi.Client)
   101  
   102  	// Parse out data source filters to populate Consul's query options
   103  	queryOpts, err := getQueryOpts(d, client)
   104  	if err != nil {
   105  		return errwrap.Wrapf("unable to get query options for fetching catalog nodes: {{err}}", err)
   106  	}
   107  
   108  	nodes, meta, err := client.Catalog().Nodes(queryOpts)
   109  	if err != nil {
   110  		return err
   111  	}
   112  
   113  	l := make([]interface{}, 0, len(nodes))
   114  
   115  	nodeNames := make([]interface{}, 0, len(nodes))
   116  	nodeIDs := make([]interface{}, 0, len(nodes))
   117  
   118  	for _, node := range nodes {
   119  		const defaultNodeAttrs = 4
   120  		m := make(map[string]interface{}, defaultNodeAttrs)
   121  		id := node.ID
   122  		if id == "" {
   123  			id = node.Node
   124  		}
   125  
   126  		nodeIDs = append(nodeIDs, id)
   127  		nodeNames = append(nodeNames, node.Node)
   128  
   129  		m[catalogNodesNodeAddress] = node.Address
   130  		m[catalogNodesNodeID] = id
   131  		m[catalogNodesNodeName] = node.Node
   132  		m[catalogNodesNodeMeta] = node.Meta
   133  		m[catalogNodesNodeTaggedAddresses] = node.TaggedAddresses
   134  
   135  		l = append(l, m)
   136  	}
   137  
   138  	const idKeyFmt = "catalog-nodes-%s"
   139  	d.SetId(fmt.Sprintf(idKeyFmt, queryOpts.Datacenter))
   140  
   141  	d.Set(catalogNodesDatacenter, queryOpts.Datacenter)
   142  	if err := d.Set(catalogNodesNodeIDs, nodeIDs); err != nil {
   143  		return errwrap.Wrapf("Unable to store node IDs: {{err}}", err)
   144  	}
   145  
   146  	if err := d.Set(catalogNodesNodeNames, nodeNames); err != nil {
   147  		return errwrap.Wrapf("Unable to store node names: {{err}}", err)
   148  	}
   149  
   150  	if err := d.Set(catalogNodesElem, l); err != nil {
   151  		return errwrap.Wrapf("Unable to store nodes: {{err}}", err)
   152  	}
   153  
   154  	return nil
   155  }