func ConvertAs2_0_0(in Config) (types.Config, error) {
out := types.Config{
Ignition: types.Ignition{
Version: types.IgnitionVersion{Major: 2, Minor: 0},
},
}
for _, ref := range in.Ignition.Config.Append {
newRef, err := convertConfigReference(ref)
if err != nil {
return types.Config{}, err
}
out.Ignition.Config.Append = append(out.Ignition.Config.Append, newRef)
}
if in.Ignition.Config.Replace != nil {
newRef, err := convertConfigReference(*in.Ignition.Config.Replace)
if err != nil {
return types.Config{}, err
}
out.Ignition.Config.Replace = &newRef
}
for _, disk := range in.Storage.Disks {
newDisk := types.Disk{
Device: types.Path(disk.Device),
WipeTable: disk.WipeTable,
}
for _, partition := range disk.Partitions {
size, err := convertPartitionDimension(partition.Size)
if err != nil {
return types.Config{}, err
}
start, err := convertPartitionDimension(partition.Start)
if err != nil {
return types.Config{}, err
}
newDisk.Partitions = append(newDisk.Partitions, types.Partition{
Label: types.PartitionLabel(partition.Label),
Number: partition.Number,
Size: size,
Start: start,
TypeGUID: types.PartitionTypeGUID(partition.TypeGUID),
})
}
out.Storage.Disks = append(out.Storage.Disks, newDisk)
}
for _, array := range in.Storage.Arrays {
newArray := types.Raid{
Name: array.Name,
Level: array.Level,
Spares: array.Spares,
}
for _, device := range array.Devices {
newArray.Devices = append(newArray.Devices, types.Path(device))
}
out.Storage.Arrays = append(out.Storage.Arrays, newArray)
}
for _, filesystem := range in.Storage.Filesystems {
newFilesystem := types.Filesystem{
Name: filesystem.Name,
Path: func(p types.Path) *types.Path {
if p == "" {
return nil
}
return &p
}(types.Path(filesystem.Path)),
}
if filesystem.Mount != nil {
newFilesystem.Mount = &types.FilesystemMount{
Device: types.Path(filesystem.Mount.Device),
Format: types.FilesystemFormat(filesystem.Mount.Format),
}
if filesystem.Mount.Create != nil {
newFilesystem.Mount.Create = &types.FilesystemCreate{
Force: filesystem.Mount.Create.Force,
Options: types.MkfsOptions(filesystem.Mount.Create.Options),
}
}
}
out.Storage.Filesystems = append(out.Storage.Filesystems, newFilesystem)
}
for _, file := range in.Storage.Files {
newFile := types.File{
Filesystem: file.Filesystem,
Path: types.Path(file.Path),
Mode: types.FileMode(file.Mode),
User: types.FileUser{Id: file.User.Id},
Group: types.FileGroup{Id: file.Group.Id},
}
if file.Contents.Inline != "" {
newFile.Contents = types.FileContents{
Source: types.Url{
Scheme: "data",
Opaque: "," + dataurl.EscapeString(file.Contents.Inline),
},
}
}
if file.Contents.Remote.Url != "" {
source, err := url.Parse(file.Contents.Remote.Url)
if err != nil {
return types.Config{}, err
}
newFile.Contents = types.FileContents{Source: types.Url(*source)}
}
if newFile.Contents == (types.FileContents{}) {
newFile.Contents = types.FileContents{
Source: types.Url{
Scheme: "data",
Opaque: ",",
},
}
}
newFile.Contents.Compression = types.Compression(file.Contents.Remote.Compression)
newFile.Contents.Verification = convertVerification(file.Contents.Remote.Verification)
out.Storage.Files = append(out.Storage.Files, newFile)
}
for _, unit := range in.Systemd.Units {
newUnit := types.SystemdUnit{
Name: types.SystemdUnitName(unit.Name),
Enable: unit.Enable,
Mask: unit.Mask,
Contents: unit.Contents,
}
for _, dropIn := range unit.DropIns {
newUnit.DropIns = append(newUnit.DropIns, types.SystemdUnitDropIn{
Name: types.SystemdUnitDropInName(dropIn.Name),
Contents: dropIn.Contents,
})
}
out.Systemd.Units = append(out.Systemd.Units, newUnit)
}
for _, unit := range in.Networkd.Units {
out.Networkd.Units = append(out.Networkd.Units, types.NetworkdUnit{
Name: types.NetworkdUnitName(unit.Name),
Contents: unit.Contents,
})
}
for _, user := range in.Passwd.Users {
newUser := types.User{
Name: user.Name,
PasswordHash: user.PasswordHash,
SSHAuthorizedKeys: user.SSHAuthorizedKeys,
}
if user.Create != nil {
newUser.Create = &types.UserCreate{
Uid: user.Create.Uid,
GECOS: user.Create.GECOS,
Homedir: user.Create.Homedir,
NoCreateHome: user.Create.NoCreateHome,
PrimaryGroup: user.Create.PrimaryGroup,
Groups: user.Create.Groups,
NoUserGroup: user.Create.NoUserGroup,
System: user.Create.System,
NoLogInit: user.Create.NoLogInit,
Shell: user.Create.Shell,
}
}
out.Passwd.Users = append(out.Passwd.Users, newUser)
}
for _, group := range in.Passwd.Groups {
out.Passwd.Groups = append(out.Passwd.Groups, types.Group{
Name: group.Name,
Gid: group.Gid,
PasswordHash: group.PasswordHash,
System: group.System,
})
}
if err := out.AssertValid(); err != nil {
return types.Config{}, err
}
return out, nil
}
func buildFile(d *schema.ResourceData, c *cache) (string, error) {
_, hasContent := d.GetOk("content")
_, hasSource := d.GetOk("source")
if hasContent && hasSource {
return "", fmt.Errorf("content and source options are incompatible")
}
if !hasContent && !hasSource {
return "", fmt.Errorf("content or source options must be present")
}
var compression types.Compression
var source types.Url
var hash *types.Hash
var err error
if hasContent {
source, err = encodeDataURL(
d.Get("content.0.mime").(string),
d.Get("content.0.content").(string),
)
if err != nil {
return "", err
}
}
if hasSource {
source, err = buildURL(d.Get("source.0.source").(string))
if err != nil {
return "", err
}
compression = types.Compression(d.Get("source.0.compression").(string))
h, err := buildHash(d.Get("source.0.verification").(string))
if err != nil {
return "", err
}
hash = &h
}
return c.addFile(&types.File{
Filesystem: d.Get("filesystem").(string),
Path: types.Path(d.Get("path").(string)),
Contents: types.FileContents{
Compression: compression,
Source: source,
Verification: types.Verification{
Hash: hash,
},
},
User: types.FileUser{
Id: d.Get("uid").(int),
},
Group: types.FileGroup{
Id: d.Get("gid").(int),
},
Mode: types.FileMode(d.Get("mode").(int)),
}), nil
}
