func (t *CloudInitTarget) WriteFile(destPath string, contents fi.Resource, fileMode os.FileMode, dirMode os.FileMode) error {
var p *fi.Source
if hs, ok := contents.(fi.HasSource); ok {
p = hs.GetSource()
}
if p != nil {
t.AddMkdirpCommand(path.Dir(destPath), dirMode)
t.fetch(p, destPath)
} else {
// TODO: No way to specify parent dir permissions?
f := &CloudConfigFile{
Encoding: "b64",
Owner: "root:root",
Permissions: fi.FileModeToString(fileMode),
Path: destPath,
}
d, err := fi.ResourceAsBytes(contents)
if err != nil {
return err
}
// Not a strict limit, just a sanity check
if len(d) > 256*1024 {
return fmt.Errorf("resource is very large (failed sanity-check): %v", contents)
}
f.Content = base64.StdEncoding.EncodeToString(d)
t.Config.WriteFiles = append(t.Config.WriteFiles, f)
}
return nil
}
func (t *TerraformTarget) AddFile(resourceType string, resourceName string, key string, r fi.Resource) (*Literal, error) {
id := resourceType + "_" + resourceName + "_" + key
d, err := fi.ResourceAsBytes(r)
if err != nil {
return nil, fmt.Errorf("error rending resource %s %v", id, err)
}
p := path.Join("data", id)
t.files[p] = d
l := LiteralExpression(fmt.Sprintf("${file(%q)}", p))
return l, nil
}
func (l *Loader) renderResource(resourceName string, args []string) (string, error) {
resourceKey := strings.TrimSuffix(resourceName, ".template")
resourceKey = strings.TrimPrefix(resourceKey, "resources/")
configResource := l.Resources[resourceKey]
if configResource == nil {
return "", fmt.Errorf("cannot find resource %q", resourceName)
}
if tr, ok := configResource.(fi.TemplateResource); ok {
configResource = tr.Curry(args)
} else if len(args) != 0 {
return "", fmt.Errorf("args passed when building node config, but config was not a template %q", resourceName)
}
data, err := fi.ResourceAsBytes(configResource)
if err != nil {
return "", fmt.Errorf("error reading resource %q: %v", resourceName, err)
}
return string(data), nil
}
func (_ *Instance) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *Instance) error {
if a == nil {
if e.ImageID == nil {
return fi.RequiredField("ImageID")
}
image, err := t.Cloud.ResolveImage(*e.ImageID)
if err != nil {
return err
}
glog.V(2).Infof("Creating Instance with Name:%q", *e.Name)
request := &ec2.RunInstancesInput{
ImageId: image.ImageId,
InstanceType: e.InstanceType,
MinCount: aws.Int64(1),
MaxCount: aws.Int64(1),
}
if e.SSHKey != nil {
request.KeyName = e.SSHKey.Name
}
securityGroupIDs := []*string{}
for _, sg := range e.SecurityGroups {
securityGroupIDs = append(securityGroupIDs, sg.ID)
}
request.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
{
DeviceIndex: aws.Int64(0),
AssociatePublicIpAddress: e.AssociatePublicIP,
SubnetId: e.Subnet.ID,
PrivateIpAddress: e.PrivateIPAddress,
Groups: securityGroupIDs,
},
}
if e.BlockDeviceMappings != nil {
request.BlockDeviceMappings = []*ec2.BlockDeviceMapping{}
for deviceName, bdm := range e.BlockDeviceMappings {
request.BlockDeviceMappings = append(request.BlockDeviceMappings, bdm.ToEC2(deviceName))
}
}
if e.UserData != nil {
d, err := fi.ResourceAsBytes(e.UserData)
if err != nil {
return fmt.Errorf("error rendering Instance UserData: %v", err)
}
if len(d) > MaxUserDataSize {
// TODO: Re-enable gzip?
// But it exposes some bugs in the AWS console, so if we can avoid it, we should
//d, err = fi.GzipBytes(d)
//if err != nil {
// return fmt.Errorf("error while gzipping UserData: %v", err)
//}
return fmt.Errorf("Instance UserData was too large (%d bytes)", len(d))
}
request.UserData = aws.String(base64.StdEncoding.EncodeToString(d))
}
if e.IAMInstanceProfile != nil {
request.IamInstanceProfile = &ec2.IamInstanceProfileSpecification{
Name: e.IAMInstanceProfile.Name,
}
}
response, err := t.Cloud.EC2.RunInstances(request)
if err != nil {
return fmt.Errorf("error creating Instance: %v", err)
}
e.ID = response.Instances[0].InstanceId
}
return t.AddAWSTags(*e.ID, e.Tags)
}