github.com/nbering/terraform@v0.8.5-0.20170113232247-453f670684b5/builtin/providers/ignition/provider.go (about)

     1  package ignition
     2  
     3  import (
     4  	"bytes"
     5  	"crypto/sha256"
     6  	"encoding/hex"
     7  	"encoding/json"
     8  	"fmt"
     9  	"io"
    10  	"net/url"
    11  	"sync"
    12  
    13  	"github.com/coreos/go-systemd/unit"
    14  	"github.com/coreos/ignition/config/types"
    15  	"github.com/hashicorp/terraform/helper/schema"
    16  	"github.com/hashicorp/terraform/terraform"
    17  )
    18  
    19  func Provider() terraform.ResourceProvider {
    20  	return &schema.Provider{
    21  		ResourcesMap: map[string]*schema.Resource{
    22  			"ignition_config":        resourceConfig(),
    23  			"ignition_disk":          resourceDisk(),
    24  			"ignition_raid":          resourceRaid(),
    25  			"ignition_filesystem":    resourceFilesystem(),
    26  			"ignition_file":          resourceFile(),
    27  			"ignition_systemd_unit":  resourceSystemdUnit(),
    28  			"ignition_networkd_unit": resourceNetworkdUnit(),
    29  			"ignition_user":          resourceUser(),
    30  			"ignition_group":         resourceGroup(),
    31  		},
    32  		ConfigureFunc: func(*schema.ResourceData) (interface{}, error) {
    33  			return &cache{
    34  				disks:         make(map[string]*types.Disk, 0),
    35  				arrays:        make(map[string]*types.Raid, 0),
    36  				filesystems:   make(map[string]*types.Filesystem, 0),
    37  				files:         make(map[string]*types.File, 0),
    38  				systemdUnits:  make(map[string]*types.SystemdUnit, 0),
    39  				networkdUnits: make(map[string]*types.NetworkdUnit, 0),
    40  				users:         make(map[string]*types.User, 0),
    41  				groups:        make(map[string]*types.Group, 0),
    42  			}, nil
    43  		},
    44  	}
    45  }
    46  
    47  type cache struct {
    48  	disks         map[string]*types.Disk
    49  	arrays        map[string]*types.Raid
    50  	filesystems   map[string]*types.Filesystem
    51  	files         map[string]*types.File
    52  	systemdUnits  map[string]*types.SystemdUnit
    53  	networkdUnits map[string]*types.NetworkdUnit
    54  	users         map[string]*types.User
    55  	groups        map[string]*types.Group
    56  
    57  	sync.Mutex
    58  }
    59  
    60  func (c *cache) addDisk(g *types.Disk) string {
    61  	c.Lock()
    62  	defer c.Unlock()
    63  
    64  	id := id(g)
    65  	c.disks[id] = g
    66  
    67  	return id
    68  }
    69  
    70  func (c *cache) addRaid(r *types.Raid) string {
    71  	c.Lock()
    72  	defer c.Unlock()
    73  
    74  	id := id(r)
    75  	c.arrays[id] = r
    76  
    77  	return id
    78  }
    79  
    80  func (c *cache) addFilesystem(f *types.Filesystem) string {
    81  	c.Lock()
    82  	defer c.Unlock()
    83  
    84  	id := id(f)
    85  	c.filesystems[id] = f
    86  
    87  	return id
    88  }
    89  
    90  func (c *cache) addFile(f *types.File) string {
    91  	c.Lock()
    92  	defer c.Unlock()
    93  
    94  	id := id(f)
    95  	c.files[id] = f
    96  
    97  	return id
    98  }
    99  
   100  func (c *cache) addSystemdUnit(u *types.SystemdUnit) string {
   101  	c.Lock()
   102  	defer c.Unlock()
   103  
   104  	id := id(u)
   105  	c.systemdUnits[id] = u
   106  
   107  	return id
   108  }
   109  
   110  func (c *cache) addNetworkdUnit(u *types.NetworkdUnit) string {
   111  	c.Lock()
   112  	defer c.Unlock()
   113  
   114  	id := id(u)
   115  	c.networkdUnits[id] = u
   116  
   117  	return id
   118  }
   119  
   120  func (c *cache) addUser(u *types.User) string {
   121  	c.Lock()
   122  	defer c.Unlock()
   123  
   124  	id := id(u)
   125  	c.users[id] = u
   126  
   127  	return id
   128  }
   129  
   130  func (c *cache) addGroup(g *types.Group) string {
   131  	c.Lock()
   132  	defer c.Unlock()
   133  
   134  	id := id(g)
   135  	c.groups[id] = g
   136  
   137  	return id
   138  }
   139  
   140  func id(input interface{}) string {
   141  	b, _ := json.Marshal(input)
   142  	return hash(string(b))
   143  }
   144  
   145  func hash(s string) string {
   146  	sha := sha256.Sum256([]byte(s))
   147  	return hex.EncodeToString(sha[:])
   148  }
   149  
   150  func castSliceInterface(i []interface{}) []string {
   151  	var o []string
   152  	for _, value := range i {
   153  		o = append(o, value.(string))
   154  	}
   155  
   156  	return o
   157  }
   158  
   159  func getUInt(d *schema.ResourceData, key string) *uint {
   160  	var uid *uint
   161  	if value, ok := d.GetOk(key); ok {
   162  		u := uint(value.(int))
   163  		uid = &u
   164  	}
   165  
   166  	return uid
   167  }
   168  
   169  func validateUnit(content string) error {
   170  	r := bytes.NewBuffer([]byte(content))
   171  
   172  	u, err := unit.Deserialize(r)
   173  	if len(u) == 0 {
   174  		return fmt.Errorf("invalid or empty unit content")
   175  	}
   176  
   177  	if err == nil {
   178  		return nil
   179  	}
   180  
   181  	if err == io.EOF {
   182  		return fmt.Errorf("unexpected EOF reading unit content")
   183  	}
   184  
   185  	return err
   186  }
   187  
   188  func buildURL(raw string) (types.Url, error) {
   189  	u, err := url.Parse(raw)
   190  	if err != nil {
   191  		return types.Url{}, err
   192  	}
   193  
   194  	return types.Url(*u), nil
   195  }
   196  
   197  func buildHash(raw string) (types.Hash, error) {
   198  	h := types.Hash{}
   199  	err := h.UnmarshalJSON([]byte(fmt.Sprintf("%q", raw)))
   200  
   201  	return h, err
   202  }