libvirt

package
v0.4.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 21, 2024 License: Apache-2.0 Imports: 7 Imported by: 3

Documentation

Overview

A Pulumi package for creating and managing libvirt cloud resources.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CloudInitDisk 

type CloudInitDisk struct {
	pulumi.CustomResourceState

	// cloud-init user data.
	MetaData pulumi.StringPtrOutput `pulumi:"metaData"`
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringOutput `pulumi:"name"`
	// cloud-init network-config data.
	NetworkConfig pulumi.StringPtrOutput `pulumi:"networkConfig"`
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	// For user_data, networkConfig and metaData parameters have a look at upstream doc:
	// http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud
	Pool pulumi.StringPtrOutput `pulumi:"pool"`
	// cloud-init user data.
	UserData pulumi.StringPtrOutput `pulumi:"userData"`
}

func GetCloudInitDisk 

func GetCloudInitDisk(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *CloudInitDiskState, opts ...pulumi.ResourceOption) (*CloudInitDisk, error)

GetCloudInitDisk gets an existing CloudInitDisk resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewCloudInitDisk 

func NewCloudInitDisk(ctx *pulumi.Context,
	name string, args *CloudInitDiskArgs, opts ...pulumi.ResourceOption) (*CloudInitDisk, error)

NewCloudInitDisk registers a new resource with the given unique name, arguments, and options.

func (*CloudInitDisk) ElementType 

func (*CloudInitDisk) ElementType() reflect.Type

func (*CloudInitDisk) ToCloudInitDiskOutput 

func (i *CloudInitDisk) ToCloudInitDiskOutput() CloudInitDiskOutput

func (*CloudInitDisk) ToCloudInitDiskOutputWithContext 

func (i *CloudInitDisk) ToCloudInitDiskOutputWithContext(ctx context.Context) CloudInitDiskOutput

type CloudInitDiskArgs 

type CloudInitDiskArgs struct {
	// cloud-init user data.
	MetaData pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// cloud-init network-config data.
	NetworkConfig pulumi.StringPtrInput
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	// For user_data, networkConfig and metaData parameters have a look at upstream doc:
	// http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud
	Pool pulumi.StringPtrInput
	// cloud-init user data.
	UserData pulumi.StringPtrInput
}

The set of arguments for constructing a CloudInitDisk resource.

func (CloudInitDiskArgs) ElementType 

func (CloudInitDiskArgs) ElementType() reflect.Type

type CloudInitDiskArray 

type CloudInitDiskArray []CloudInitDiskInput

func (CloudInitDiskArray) ElementType 

func (CloudInitDiskArray) ElementType() reflect.Type

func (CloudInitDiskArray) ToCloudInitDiskArrayOutput 

func (i CloudInitDiskArray) ToCloudInitDiskArrayOutput() CloudInitDiskArrayOutput

func (CloudInitDiskArray) ToCloudInitDiskArrayOutputWithContext 

func (i CloudInitDiskArray) ToCloudInitDiskArrayOutputWithContext(ctx context.Context) CloudInitDiskArrayOutput

type CloudInitDiskArrayInput 

type CloudInitDiskArrayInput interface {
	pulumi.Input

	ToCloudInitDiskArrayOutput() CloudInitDiskArrayOutput
	ToCloudInitDiskArrayOutputWithContext(context.Context) CloudInitDiskArrayOutput
}

CloudInitDiskArrayInput is an input type that accepts CloudInitDiskArray and CloudInitDiskArrayOutput values. You can construct a concrete instance of `CloudInitDiskArrayInput` via: 

CloudInitDiskArray{ CloudInitDiskArgs{...} }

type CloudInitDiskArrayOutput 

type CloudInitDiskArrayOutput struct{ *pulumi.OutputState }

func (CloudInitDiskArrayOutput) ElementType 

func (CloudInitDiskArrayOutput) ElementType() reflect.Type

func (CloudInitDiskArrayOutput) Index 

func (o CloudInitDiskArrayOutput) Index(i pulumi.IntInput) CloudInitDiskOutput

func (CloudInitDiskArrayOutput) ToCloudInitDiskArrayOutput 

func (o CloudInitDiskArrayOutput) ToCloudInitDiskArrayOutput() CloudInitDiskArrayOutput

func (CloudInitDiskArrayOutput) ToCloudInitDiskArrayOutputWithContext 

func (o CloudInitDiskArrayOutput) ToCloudInitDiskArrayOutputWithContext(ctx context.Context) CloudInitDiskArrayOutput

type CloudInitDiskInput 

type CloudInitDiskInput interface {
	pulumi.Input

	ToCloudInitDiskOutput() CloudInitDiskOutput
	ToCloudInitDiskOutputWithContext(ctx context.Context) CloudInitDiskOutput
}

type CloudInitDiskMap 

type CloudInitDiskMap map[string]CloudInitDiskInput

func (CloudInitDiskMap) ElementType 

func (CloudInitDiskMap) ElementType() reflect.Type

func (CloudInitDiskMap) ToCloudInitDiskMapOutput 

func (i CloudInitDiskMap) ToCloudInitDiskMapOutput() CloudInitDiskMapOutput

func (CloudInitDiskMap) ToCloudInitDiskMapOutputWithContext 

func (i CloudInitDiskMap) ToCloudInitDiskMapOutputWithContext(ctx context.Context) CloudInitDiskMapOutput

type CloudInitDiskMapInput 

type CloudInitDiskMapInput interface {
	pulumi.Input

	ToCloudInitDiskMapOutput() CloudInitDiskMapOutput
	ToCloudInitDiskMapOutputWithContext(context.Context) CloudInitDiskMapOutput
}

CloudInitDiskMapInput is an input type that accepts CloudInitDiskMap and CloudInitDiskMapOutput values. You can construct a concrete instance of `CloudInitDiskMapInput` via: 

CloudInitDiskMap{ "key": CloudInitDiskArgs{...} }

type CloudInitDiskMapOutput 

type CloudInitDiskMapOutput struct{ *pulumi.OutputState }

func (CloudInitDiskMapOutput) ElementType 

func (CloudInitDiskMapOutput) ElementType() reflect.Type

func (CloudInitDiskMapOutput) MapIndex 

func (o CloudInitDiskMapOutput) MapIndex(k pulumi.StringInput) CloudInitDiskOutput

func (CloudInitDiskMapOutput) ToCloudInitDiskMapOutput 

func (o CloudInitDiskMapOutput) ToCloudInitDiskMapOutput() CloudInitDiskMapOutput

func (CloudInitDiskMapOutput) ToCloudInitDiskMapOutputWithContext 

func (o CloudInitDiskMapOutput) ToCloudInitDiskMapOutputWithContext(ctx context.Context) CloudInitDiskMapOutput

type CloudInitDiskOutput 

type CloudInitDiskOutput struct{ *pulumi.OutputState }

func (CloudInitDiskOutput) ElementType 

func (CloudInitDiskOutput) ElementType() reflect.Type

func (CloudInitDiskOutput) MetaData added in v0.3.0 

func (o CloudInitDiskOutput) MetaData() pulumi.StringPtrOutput

cloud-init user data.

func (CloudInitDiskOutput) Name added in v0.3.0 

func (o CloudInitDiskOutput) Name() pulumi.StringOutput

A unique name for the resource, required by libvirt.

func (CloudInitDiskOutput) NetworkConfig added in v0.3.0 

func (o CloudInitDiskOutput) NetworkConfig() pulumi.StringPtrOutput

cloud-init network-config data.

func (CloudInitDiskOutput) Pool added in v0.3.0 

func (o CloudInitDiskOutput) Pool() pulumi.StringPtrOutput

The pool where the resource will be created. If not given, the `default` pool will be used. For user_data, networkConfig and metaData parameters have a look at upstream doc: http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud

func (CloudInitDiskOutput) ToCloudInitDiskOutput 

func (o CloudInitDiskOutput) ToCloudInitDiskOutput() CloudInitDiskOutput

func (CloudInitDiskOutput) ToCloudInitDiskOutputWithContext 

func (o CloudInitDiskOutput) ToCloudInitDiskOutputWithContext(ctx context.Context) CloudInitDiskOutput

func (CloudInitDiskOutput) UserData added in v0.3.0 

func (o CloudInitDiskOutput) UserData() pulumi.StringPtrOutput

cloud-init user data.

type CloudInitDiskState 

type CloudInitDiskState struct {
	// cloud-init user data.
	MetaData pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// cloud-init network-config data.
	NetworkConfig pulumi.StringPtrInput
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	// For user_data, networkConfig and metaData parameters have a look at upstream doc:
	// http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html#datasource-nocloud
	Pool pulumi.StringPtrInput
	// cloud-init user data.
	UserData pulumi.StringPtrInput
}

func (CloudInitDiskState) ElementType 

func (CloudInitDiskState) ElementType() reflect.Type

type Domain 

type Domain struct {
	pulumi.CustomResourceState

	// The architecture for the VM (probably x8664 or i686),
	// you normally won't need to set this unless you are building a special VM
	Arch pulumi.StringOutput `pulumi:"arch"`
	// Set to `true` to start the domain on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolOutput `pulumi:"autostart"`
	// A list of devices (dev) which defines boot order. Example
	// below.
	BootDevices DomainBootDeviceArrayOutput `pulumi:"bootDevices"`
	// The `CloudInitDisk` disk that has to be used by
	// the domain. This is going to be attached as a CDROM ISO. Changing the
	// cloud-init won't cause the domain to be recreated, however the change will
	// have effect on the next reboot.
	Cloudinit pulumi.StringPtrOutput `pulumi:"cloudinit"`
	// Arguments to the kernel
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
	// 			Memory: pulumi.Int(1024),
	// 			Vcpu:   pulumi.Int(1),
	// 			Kernel: pulumi.Any(libvirt_volume.Kernel.Id),
	// 			Cmdlines: pulumi.MapArray{
	// 				pulumi.Map{
	// 					"arg1": pulumi.Any("value1"),
	// 					"arg2": pulumi.Any("value2"),
	// 					"_":    pulumi.Any("rw nosplash"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// Kernel params that don't have a keyword identifier can be specified using the
	// special `"_"` keyword. Multiple keyword-less params have to be specified using
	// the same `"_"` keyword, like in the example above.
	//
	// Also note that the `cmd` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Cmdlines pulumi.MapArrayOutput    `pulumi:"cmdlines"`
	Consoles DomainConsoleArrayOutput `pulumi:"consoles"`
	// The
	// [Ignition](https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource
	// that is to be used by the CoreOS domain.
	CoreosIgnition pulumi.StringPtrOutput `pulumi:"coreosIgnition"`
	// Configures CPU mode. See below for more
	// details.
	Cpu DomainCpuOutput `pulumi:"cpu"`
	// The description for domain.
	// Changing this forces a new resource to be created.
	// This data is not used by libvirt in any way, it can contain any information the user wants.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// An array of one or more disks to attach to the domain. The
	// `disk` object structure is documented below.
	Disks DomainDiskArrayOutput `pulumi:"disks"`
	// The path of the emulator to use
	Emulator pulumi.StringOutput `pulumi:"emulator"`
	// An array of one or more host filesystems to attach to
	// the domain. The `filesystem` object structure is documented
	// below.
	Filesystems DomainFilesystemArrayOutput `pulumi:"filesystems"`
	// The UEFI rom images for exercising UEFI secure boot in a qemu
	// environment. Users should usually specify one of the standard _Open Virtual Machine
	// Firmware_ (_OVMF_) images available for their distributions. The file will be opened
	// read-only.
	Firmware pulumi.StringPtrOutput `pulumi:"firmware"`
	// The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.
	FwCfgName pulumi.StringPtrOutput  `pulumi:"fwCfgName"`
	Graphics  DomainGraphicsPtrOutput `pulumi:"graphics"`
	// The path of the initrd to boot.
	//
	// You can use it in the same way as the kernel.
	Initrd pulumi.StringPtrOutput `pulumi:"initrd"`
	// The path of the kernel to boot
	//
	// If you are using a qcow2 volume, you can pass the id of the volume (eg. `${libvirt_volume.kernel.id}`)
	// as they are local to the hypervisor.
	//
	// Given that you can define a volume from a remote http file, this means, you can also have remote kernels.
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		kernel, err := libvirt.NewVolume(ctx, "kernel", &libvirt.VolumeArgs{
	// 			Source: pulumi.String("http://download.opensuse.org/tumbleweed/repo/oss/boot/x86_64/loader/linux"),
	// 			Pool:   pulumi.String("default"),
	// 			Format: pulumi.String("raw"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
	// 			Memory: pulumi.Int(1024),
	// 			Vcpu:   pulumi.Int(1),
	// 			Kernel: kernel.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	Kernel pulumi.StringPtrOutput `pulumi:"kernel"`
	// The machine type,
	// you normally won't need to set this unless you are running on a platform that
	// defaults to the wrong machine type for your template
	Machine pulumi.StringOutput `pulumi:"machine"`
	// The amount of memory in MiB. If not specified the domain
	// will be created with 512 MiB of memory be used.
	Memory   pulumi.IntPtrOutput    `pulumi:"memory"`
	Metadata pulumi.StringPtrOutput `pulumi:"metadata"`
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// An array of one or more network interfaces to
	// attach to the domain. The `networkInterface` object structure is documented
	// below.
	NetworkInterfaces DomainNetworkInterfaceArrayOutput `pulumi:"networkInterfaces"`
	// this block allows specifying the following attributes related to the _nvram_:
	Nvram DomainNvramPtrOutput `pulumi:"nvram"`
	// By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).
	QemuAgent pulumi.BoolPtrOutput `pulumi:"qemuAgent"`
	// Use `false` to turn off the instance. If not specified,
	// true is assumed and the instance, if stopped, will be started at next apply.
	Running pulumi.BoolPtrOutput `pulumi:"running"`
	// TPM device to attach to the domain. The `tpm` object structure is documented below.
	Tpm DomainTpmPtrOutput `pulumi:"tpm"`
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrOutput `pulumi:"type"`
	// The amount of virtual CPUs. If not specified, a single CPU
	// will be created.
	Vcpu  pulumi.IntPtrOutput  `pulumi:"vcpu"`
	Video DomainVideoPtrOutput `pulumi:"video"`
	Xml   DomainXmlPtrOutput   `pulumi:"xml"`
}

Manages a VM domain resource within libvirt. For more information see [the official documentation](https://libvirt.org/formatdomain.html).

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := libvirt.NewDomain(ctx, "default", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

func GetDomain 

func GetDomain(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainState, opts ...pulumi.ResourceOption) (*Domain, error)

GetDomain gets an existing Domain resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDomain 

func NewDomain(ctx *pulumi.Context,
	name string, args *DomainArgs, opts ...pulumi.ResourceOption) (*Domain, error)

NewDomain registers a new resource with the given unique name, arguments, and options.

func (*Domain) ElementType 

func (*Domain) ElementType() reflect.Type

func (*Domain) ToDomainOutput 

func (i *Domain) ToDomainOutput() DomainOutput

func (*Domain) ToDomainOutputWithContext 

func (i *Domain) ToDomainOutputWithContext(ctx context.Context) DomainOutput

type DomainArgs 

type DomainArgs struct {
	// The architecture for the VM (probably x8664 or i686),
	// you normally won't need to set this unless you are building a special VM
	Arch pulumi.StringPtrInput
	// Set to `true` to start the domain on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolPtrInput
	// A list of devices (dev) which defines boot order. Example
	// below.
	BootDevices DomainBootDeviceArrayInput
	// The `CloudInitDisk` disk that has to be used by
	// the domain. This is going to be attached as a CDROM ISO. Changing the
	// cloud-init won't cause the domain to be recreated, however the change will
	// have effect on the next reboot.
	Cloudinit pulumi.StringPtrInput
	// Arguments to the kernel
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
	// 			Memory: pulumi.Int(1024),
	// 			Vcpu:   pulumi.Int(1),
	// 			Kernel: pulumi.Any(libvirt_volume.Kernel.Id),
	// 			Cmdlines: pulumi.MapArray{
	// 				pulumi.Map{
	// 					"arg1": pulumi.Any("value1"),
	// 					"arg2": pulumi.Any("value2"),
	// 					"_":    pulumi.Any("rw nosplash"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// Kernel params that don't have a keyword identifier can be specified using the
	// special `"_"` keyword. Multiple keyword-less params have to be specified using
	// the same `"_"` keyword, like in the example above.
	//
	// Also note that the `cmd` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Cmdlines pulumi.MapArrayInput
	Consoles DomainConsoleArrayInput
	// The
	// [Ignition](https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource
	// that is to be used by the CoreOS domain.
	CoreosIgnition pulumi.StringPtrInput
	// Configures CPU mode. See below for more
	// details.
	Cpu DomainCpuPtrInput
	// The description for domain.
	// Changing this forces a new resource to be created.
	// This data is not used by libvirt in any way, it can contain any information the user wants.
	Description pulumi.StringPtrInput
	// An array of one or more disks to attach to the domain. The
	// `disk` object structure is documented below.
	Disks DomainDiskArrayInput
	// The path of the emulator to use
	Emulator pulumi.StringPtrInput
	// An array of one or more host filesystems to attach to
	// the domain. The `filesystem` object structure is documented
	// below.
	Filesystems DomainFilesystemArrayInput
	// The UEFI rom images for exercising UEFI secure boot in a qemu
	// environment. Users should usually specify one of the standard _Open Virtual Machine
	// Firmware_ (_OVMF_) images available for their distributions. The file will be opened
	// read-only.
	Firmware pulumi.StringPtrInput
	// The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.
	FwCfgName pulumi.StringPtrInput
	Graphics  DomainGraphicsPtrInput
	// The path of the initrd to boot.
	//
	// You can use it in the same way as the kernel.
	Initrd pulumi.StringPtrInput
	// The path of the kernel to boot
	//
	// If you are using a qcow2 volume, you can pass the id of the volume (eg. `${libvirt_volume.kernel.id}`)
	// as they are local to the hypervisor.
	//
	// Given that you can define a volume from a remote http file, this means, you can also have remote kernels.
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		kernel, err := libvirt.NewVolume(ctx, "kernel", &libvirt.VolumeArgs{
	// 			Source: pulumi.String("http://download.opensuse.org/tumbleweed/repo/oss/boot/x86_64/loader/linux"),
	// 			Pool:   pulumi.String("default"),
	// 			Format: pulumi.String("raw"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
	// 			Memory: pulumi.Int(1024),
	// 			Vcpu:   pulumi.Int(1),
	// 			Kernel: kernel.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	Kernel pulumi.StringPtrInput
	// The machine type,
	// you normally won't need to set this unless you are running on a platform that
	// defaults to the wrong machine type for your template
	Machine pulumi.StringPtrInput
	// The amount of memory in MiB. If not specified the domain
	// will be created with 512 MiB of memory be used.
	Memory   pulumi.IntPtrInput
	Metadata pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// An array of one or more network interfaces to
	// attach to the domain. The `networkInterface` object structure is documented
	// below.
	NetworkInterfaces DomainNetworkInterfaceArrayInput
	// this block allows specifying the following attributes related to the _nvram_:
	Nvram DomainNvramPtrInput
	// By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).
	QemuAgent pulumi.BoolPtrInput
	// Use `false` to turn off the instance. If not specified,
	// true is assumed and the instance, if stopped, will be started at next apply.
	Running pulumi.BoolPtrInput
	// TPM device to attach to the domain. The `tpm` object structure is documented below.
	Tpm DomainTpmPtrInput
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrInput
	// The amount of virtual CPUs. If not specified, a single CPU
	// will be created.
	Vcpu  pulumi.IntPtrInput
	Video DomainVideoPtrInput
	Xml   DomainXmlPtrInput
}

The set of arguments for constructing a Domain resource.

func (DomainArgs) ElementType 

func (DomainArgs) ElementType() reflect.Type

type DomainArray 

type DomainArray []DomainInput

func (DomainArray) ElementType 

func (DomainArray) ElementType() reflect.Type

func (DomainArray) ToDomainArrayOutput 

func (i DomainArray) ToDomainArrayOutput() DomainArrayOutput

func (DomainArray) ToDomainArrayOutputWithContext 

func (i DomainArray) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput

type DomainArrayInput 

type DomainArrayInput interface {
	pulumi.Input

	ToDomainArrayOutput() DomainArrayOutput
	ToDomainArrayOutputWithContext(context.Context) DomainArrayOutput
}

DomainArrayInput is an input type that accepts DomainArray and DomainArrayOutput values. You can construct a concrete instance of `DomainArrayInput` via: 

DomainArray{ DomainArgs{...} }

type DomainArrayOutput 

type DomainArrayOutput struct{ *pulumi.OutputState }

func (DomainArrayOutput) ElementType 

func (DomainArrayOutput) ElementType() reflect.Type

func (DomainArrayOutput) Index 

func (o DomainArrayOutput) Index(i pulumi.IntInput) DomainOutput

func (DomainArrayOutput) ToDomainArrayOutput 

func (o DomainArrayOutput) ToDomainArrayOutput() DomainArrayOutput

func (DomainArrayOutput) ToDomainArrayOutputWithContext 

func (o DomainArrayOutput) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput

type DomainBootDevice 

type DomainBootDevice struct {
	Devs []string `pulumi:"devs"`
}

type DomainBootDeviceArgs 

type DomainBootDeviceArgs struct {
	Devs pulumi.StringArrayInput `pulumi:"devs"`
}

func (DomainBootDeviceArgs) ElementType 

func (DomainBootDeviceArgs) ElementType() reflect.Type

func (DomainBootDeviceArgs) ToDomainBootDeviceOutput 

func (i DomainBootDeviceArgs) ToDomainBootDeviceOutput() DomainBootDeviceOutput

func (DomainBootDeviceArgs) ToDomainBootDeviceOutputWithContext 

func (i DomainBootDeviceArgs) ToDomainBootDeviceOutputWithContext(ctx context.Context) DomainBootDeviceOutput

type DomainBootDeviceArray 

type DomainBootDeviceArray []DomainBootDeviceInput

func (DomainBootDeviceArray) ElementType 

func (DomainBootDeviceArray) ElementType() reflect.Type

func (DomainBootDeviceArray) ToDomainBootDeviceArrayOutput 

func (i DomainBootDeviceArray) ToDomainBootDeviceArrayOutput() DomainBootDeviceArrayOutput

func (DomainBootDeviceArray) ToDomainBootDeviceArrayOutputWithContext 

func (i DomainBootDeviceArray) ToDomainBootDeviceArrayOutputWithContext(ctx context.Context) DomainBootDeviceArrayOutput

type DomainBootDeviceArrayInput 

type DomainBootDeviceArrayInput interface {
	pulumi.Input

	ToDomainBootDeviceArrayOutput() DomainBootDeviceArrayOutput
	ToDomainBootDeviceArrayOutputWithContext(context.Context) DomainBootDeviceArrayOutput
}

DomainBootDeviceArrayInput is an input type that accepts DomainBootDeviceArray and DomainBootDeviceArrayOutput values. You can construct a concrete instance of `DomainBootDeviceArrayInput` via: 

DomainBootDeviceArray{ DomainBootDeviceArgs{...} }

type DomainBootDeviceArrayOutput 

type DomainBootDeviceArrayOutput struct{ *pulumi.OutputState }

func (DomainBootDeviceArrayOutput) ElementType 

func (DomainBootDeviceArrayOutput) ElementType() reflect.Type

func (DomainBootDeviceArrayOutput) Index 

func (o DomainBootDeviceArrayOutput) Index(i pulumi.IntInput) DomainBootDeviceOutput

func (DomainBootDeviceArrayOutput) ToDomainBootDeviceArrayOutput 

func (o DomainBootDeviceArrayOutput) ToDomainBootDeviceArrayOutput() DomainBootDeviceArrayOutput

func (DomainBootDeviceArrayOutput) ToDomainBootDeviceArrayOutputWithContext 

func (o DomainBootDeviceArrayOutput) ToDomainBootDeviceArrayOutputWithContext(ctx context.Context) DomainBootDeviceArrayOutput

type DomainBootDeviceInput 

type DomainBootDeviceInput interface {
	pulumi.Input

	ToDomainBootDeviceOutput() DomainBootDeviceOutput
	ToDomainBootDeviceOutputWithContext(context.Context) DomainBootDeviceOutput
}

DomainBootDeviceInput is an input type that accepts DomainBootDeviceArgs and DomainBootDeviceOutput values. You can construct a concrete instance of `DomainBootDeviceInput` via: 

DomainBootDeviceArgs{...}

type DomainBootDeviceOutput 

type DomainBootDeviceOutput struct{ *pulumi.OutputState }

func (DomainBootDeviceOutput) Devs 

func (o DomainBootDeviceOutput) Devs() pulumi.StringArrayOutput

func (DomainBootDeviceOutput) ElementType 

func (DomainBootDeviceOutput) ElementType() reflect.Type

func (DomainBootDeviceOutput) ToDomainBootDeviceOutput 

func (o DomainBootDeviceOutput) ToDomainBootDeviceOutput() DomainBootDeviceOutput

func (DomainBootDeviceOutput) ToDomainBootDeviceOutputWithContext 

func (o DomainBootDeviceOutput) ToDomainBootDeviceOutputWithContext(ctx context.Context) DomainBootDeviceOutput

type DomainConsole 

type DomainConsole struct {
	// IP address to listen on. Defaults to 127.0.0.1.
	SourceHost *string `pulumi:"sourceHost"`
	// Source path
	//
	// Additional attributes when type is "tcp":
	SourcePath *string `pulumi:"sourcePath"`
	// Port number or a service name. Defaults to a
	// random port.
	//
	// Note that you can repeat the `console` block to create more than one console.
	// This works the same way as with the `disk` blocks (see above).
	//
	// See [libvirt Domain XML Console element](https://libvirt.org/formatdomain.html#elementsConsole)
	// for more information.
	SourceService *string `pulumi:"sourceService"`
	// Target port
	TargetPort string `pulumi:"targetPort"`
	// for the first console and defaults to `serial`.
	// Subsequent `console` blocks must have a different type - usually `virtio`.
	//
	// Additional attributes when type is "pty":
	TargetType *string `pulumi:"targetType"`
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type string `pulumi:"type"`
}

type DomainConsoleArgs 

type DomainConsoleArgs struct {
	// IP address to listen on. Defaults to 127.0.0.1.
	SourceHost pulumi.StringPtrInput `pulumi:"sourceHost"`
	// Source path
	//
	// Additional attributes when type is "tcp":
	SourcePath pulumi.StringPtrInput `pulumi:"sourcePath"`
	// Port number or a service name. Defaults to a
	// random port.
	//
	// Note that you can repeat the `console` block to create more than one console.
	// This works the same way as with the `disk` blocks (see above).
	//
	// See [libvirt Domain XML Console element](https://libvirt.org/formatdomain.html#elementsConsole)
	// for more information.
	SourceService pulumi.StringPtrInput `pulumi:"sourceService"`
	// Target port
	TargetPort pulumi.StringInput `pulumi:"targetPort"`
	// for the first console and defaults to `serial`.
	// Subsequent `console` blocks must have a different type - usually `virtio`.
	//
	// Additional attributes when type is "pty":
	TargetType pulumi.StringPtrInput `pulumi:"targetType"`
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringInput `pulumi:"type"`
}

func (DomainConsoleArgs) ElementType 

func (DomainConsoleArgs) ElementType() reflect.Type

func (DomainConsoleArgs) ToDomainConsoleOutput 

func (i DomainConsoleArgs) ToDomainConsoleOutput() DomainConsoleOutput

func (DomainConsoleArgs) ToDomainConsoleOutputWithContext 

func (i DomainConsoleArgs) ToDomainConsoleOutputWithContext(ctx context.Context) DomainConsoleOutput

type DomainConsoleArray 

type DomainConsoleArray []DomainConsoleInput

func (DomainConsoleArray) ElementType 

func (DomainConsoleArray) ElementType() reflect.Type

func (DomainConsoleArray) ToDomainConsoleArrayOutput 

func (i DomainConsoleArray) ToDomainConsoleArrayOutput() DomainConsoleArrayOutput

func (DomainConsoleArray) ToDomainConsoleArrayOutputWithContext 

func (i DomainConsoleArray) ToDomainConsoleArrayOutputWithContext(ctx context.Context) DomainConsoleArrayOutput

type DomainConsoleArrayInput 

type DomainConsoleArrayInput interface {
	pulumi.Input

	ToDomainConsoleArrayOutput() DomainConsoleArrayOutput
	ToDomainConsoleArrayOutputWithContext(context.Context) DomainConsoleArrayOutput
}

DomainConsoleArrayInput is an input type that accepts DomainConsoleArray and DomainConsoleArrayOutput values. You can construct a concrete instance of `DomainConsoleArrayInput` via: 

DomainConsoleArray{ DomainConsoleArgs{...} }

type DomainConsoleArrayOutput 

type DomainConsoleArrayOutput struct{ *pulumi.OutputState }

func (DomainConsoleArrayOutput) ElementType 

func (DomainConsoleArrayOutput) ElementType() reflect.Type

func (DomainConsoleArrayOutput) Index 

func (o DomainConsoleArrayOutput) Index(i pulumi.IntInput) DomainConsoleOutput

func (DomainConsoleArrayOutput) ToDomainConsoleArrayOutput 

func (o DomainConsoleArrayOutput) ToDomainConsoleArrayOutput() DomainConsoleArrayOutput

func (DomainConsoleArrayOutput) ToDomainConsoleArrayOutputWithContext 

func (o DomainConsoleArrayOutput) ToDomainConsoleArrayOutputWithContext(ctx context.Context) DomainConsoleArrayOutput

type DomainConsoleInput 

type DomainConsoleInput interface {
	pulumi.Input

	ToDomainConsoleOutput() DomainConsoleOutput
	ToDomainConsoleOutputWithContext(context.Context) DomainConsoleOutput
}

DomainConsoleInput is an input type that accepts DomainConsoleArgs and DomainConsoleOutput values. You can construct a concrete instance of `DomainConsoleInput` via: 

DomainConsoleArgs{...}

type DomainConsoleOutput 

type DomainConsoleOutput struct{ *pulumi.OutputState }

func (DomainConsoleOutput) ElementType 

func (DomainConsoleOutput) ElementType() reflect.Type

func (DomainConsoleOutput) SourceHost 

func (o DomainConsoleOutput) SourceHost() pulumi.StringPtrOutput

IP address to listen on. Defaults to 127.0.0.1.

func (DomainConsoleOutput) SourcePath 

func (o DomainConsoleOutput) SourcePath() pulumi.StringPtrOutput

Source path

Additional attributes when type is "tcp":

func (DomainConsoleOutput) SourceService 

func (o DomainConsoleOutput) SourceService() pulumi.StringPtrOutput

Port number or a service name. Defaults to a random port.

Note that you can repeat the `console` block to create more than one console. This works the same way as with the `disk` blocks (see above).

See [libvirt Domain XML Console element](https://libvirt.org/formatdomain.html#elementsConsole) for more information.

func (DomainConsoleOutput) TargetPort 

func (o DomainConsoleOutput) TargetPort() pulumi.StringOutput

Target port

func (DomainConsoleOutput) TargetType 

func (o DomainConsoleOutput) TargetType() pulumi.StringPtrOutput

for the first console and defaults to `serial`. Subsequent `console` blocks must have a different type - usually `virtio`.

Additional attributes when type is "pty":

func (DomainConsoleOutput) ToDomainConsoleOutput 

func (o DomainConsoleOutput) ToDomainConsoleOutput() DomainConsoleOutput

func (DomainConsoleOutput) ToDomainConsoleOutputWithContext 

func (o DomainConsoleOutput) ToDomainConsoleOutputWithContext(ctx context.Context) DomainConsoleOutput

func (DomainConsoleOutput) Type 

func (o DomainConsoleOutput) Type() pulumi.StringOutput

The type of hypervisor to use for the domain. Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)

type DomainCpu 

type DomainCpu struct {
	Mode *string `pulumi:"mode"`
}

type DomainCpuArgs 

type DomainCpuArgs struct {
	Mode pulumi.StringPtrInput `pulumi:"mode"`
}

func (DomainCpuArgs) ElementType 

func (DomainCpuArgs) ElementType() reflect.Type

func (DomainCpuArgs) ToDomainCpuOutput 

func (i DomainCpuArgs) ToDomainCpuOutput() DomainCpuOutput

func (DomainCpuArgs) ToDomainCpuOutputWithContext 

func (i DomainCpuArgs) ToDomainCpuOutputWithContext(ctx context.Context) DomainCpuOutput

func (DomainCpuArgs) ToDomainCpuPtrOutput 

func (i DomainCpuArgs) ToDomainCpuPtrOutput() DomainCpuPtrOutput

func (DomainCpuArgs) ToDomainCpuPtrOutputWithContext 

func (i DomainCpuArgs) ToDomainCpuPtrOutputWithContext(ctx context.Context) DomainCpuPtrOutput

type DomainCpuInput 

type DomainCpuInput interface {
	pulumi.Input

	ToDomainCpuOutput() DomainCpuOutput
	ToDomainCpuOutputWithContext(context.Context) DomainCpuOutput
}

DomainCpuInput is an input type that accepts DomainCpuArgs and DomainCpuOutput values. You can construct a concrete instance of `DomainCpuInput` via: 

DomainCpuArgs{...}

type DomainCpuOutput 

type DomainCpuOutput struct{ *pulumi.OutputState }

func (DomainCpuOutput) ElementType 

func (DomainCpuOutput) ElementType() reflect.Type

func (DomainCpuOutput) Mode 

func (o DomainCpuOutput) Mode() pulumi.StringPtrOutput

func (DomainCpuOutput) ToDomainCpuOutput 

func (o DomainCpuOutput) ToDomainCpuOutput() DomainCpuOutput

func (DomainCpuOutput) ToDomainCpuOutputWithContext 

func (o DomainCpuOutput) ToDomainCpuOutputWithContext(ctx context.Context) DomainCpuOutput

func (DomainCpuOutput) ToDomainCpuPtrOutput 

func (o DomainCpuOutput) ToDomainCpuPtrOutput() DomainCpuPtrOutput

func (DomainCpuOutput) ToDomainCpuPtrOutputWithContext 

func (o DomainCpuOutput) ToDomainCpuPtrOutputWithContext(ctx context.Context) DomainCpuPtrOutput

type DomainCpuPtrInput 

type DomainCpuPtrInput interface {
	pulumi.Input

	ToDomainCpuPtrOutput() DomainCpuPtrOutput
	ToDomainCpuPtrOutputWithContext(context.Context) DomainCpuPtrOutput
}

DomainCpuPtrInput is an input type that accepts DomainCpuArgs, DomainCpuPtr and DomainCpuPtrOutput values. You can construct a concrete instance of `DomainCpuPtrInput` via: 

        DomainCpuArgs{...}

or:

        nil

func DomainCpuPtr 

func DomainCpuPtr(v *DomainCpuArgs) DomainCpuPtrInput

type DomainCpuPtrOutput 

type DomainCpuPtrOutput struct{ *pulumi.OutputState }

func (DomainCpuPtrOutput) Elem 

func (o DomainCpuPtrOutput) Elem() DomainCpuOutput

func (DomainCpuPtrOutput) ElementType 

func (DomainCpuPtrOutput) ElementType() reflect.Type

func (DomainCpuPtrOutput) Mode 

func (o DomainCpuPtrOutput) Mode() pulumi.StringPtrOutput

func (DomainCpuPtrOutput) ToDomainCpuPtrOutput 

func (o DomainCpuPtrOutput) ToDomainCpuPtrOutput() DomainCpuPtrOutput

func (DomainCpuPtrOutput) ToDomainCpuPtrOutputWithContext 

func (o DomainCpuPtrOutput) ToDomainCpuPtrOutputWithContext(ctx context.Context) DomainCpuPtrOutput

type DomainDisk 

type DomainDisk struct {
	// The path to the host device to use as the block device for this disk.
	//
	// While `volumeId`, `url`, `file` and `blockDevice` are optional, it is intended that you use one of them.
	BlockDevice *string `pulumi:"blockDevice"`
	// The filename to use as the block device for this disk (read-only)
	File *string `pulumi:"file"`
	// Use a scsi controller for this disk.  The controller
	// model is set to `virtio-scsi`
	Scsi *bool `pulumi:"scsi"`
	// The http url to use as the block device for this disk (read-only)
	Url *string `pulumi:"url"`
	// The volume id to use for this disk.
	VolumeId *string `pulumi:"volumeId"`
	// Specify a WWN to use for the disk if the disk is using
	// a scsi controller, if not specified then a random wwn is generated for the disk
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		leap, err := libvirt.NewVolume(ctx, "leap", &libvirt.VolumeArgs{
	// 			Source: pulumi.String("http://someurl/openSUSE_Leap-42.1.qcow2"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		mydisk, err := libvirt.NewVolume(ctx, "mydisk", &libvirt.VolumeArgs{
	// 			BaseVolumeId: leap.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain1", &libvirt.DomainArgs{
	// 			Disks: libvirt.DomainDiskArray{
	// 				&libvirt.DomainDiskArgs{
	// 					VolumeId: mydisk.ID(),
	// 					Scsi:     pulumi.Bool(true),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					Url: pulumi.String("http://foo.com/install.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					File: pulumi.String("/absolute/path/to/disk.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					BlockDevice: pulumi.String("/dev/mapper/36005076802810e55400000000000145f"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// Also note that the `disk` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Wwn *string `pulumi:"wwn"`
}

type DomainDiskArgs 

type DomainDiskArgs struct {
	// The path to the host device to use as the block device for this disk.
	//
	// While `volumeId`, `url`, `file` and `blockDevice` are optional, it is intended that you use one of them.
	BlockDevice pulumi.StringPtrInput `pulumi:"blockDevice"`
	// The filename to use as the block device for this disk (read-only)
	File pulumi.StringPtrInput `pulumi:"file"`
	// Use a scsi controller for this disk.  The controller
	// model is set to `virtio-scsi`
	Scsi pulumi.BoolPtrInput `pulumi:"scsi"`
	// The http url to use as the block device for this disk (read-only)
	Url pulumi.StringPtrInput `pulumi:"url"`
	// The volume id to use for this disk.
	VolumeId pulumi.StringPtrInput `pulumi:"volumeId"`
	// Specify a WWN to use for the disk if the disk is using
	// a scsi controller, if not specified then a random wwn is generated for the disk
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		leap, err := libvirt.NewVolume(ctx, "leap", &libvirt.VolumeArgs{
	// 			Source: pulumi.String("http://someurl/openSUSE_Leap-42.1.qcow2"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		mydisk, err := libvirt.NewVolume(ctx, "mydisk", &libvirt.VolumeArgs{
	// 			BaseVolumeId: leap.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain1", &libvirt.DomainArgs{
	// 			Disks: libvirt.DomainDiskArray{
	// 				&libvirt.DomainDiskArgs{
	// 					VolumeId: mydisk.ID(),
	// 					Scsi:     pulumi.Bool(true),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					Url: pulumi.String("http://foo.com/install.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					File: pulumi.String("/absolute/path/to/disk.iso"),
	// 				},
	// 				&libvirt.DomainDiskArgs{
	// 					BlockDevice: pulumi.String("/dev/mapper/36005076802810e55400000000000145f"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// Also note that the `disk` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Wwn pulumi.StringPtrInput `pulumi:"wwn"`
}

func (DomainDiskArgs) ElementType 

func (DomainDiskArgs) ElementType() reflect.Type

func (DomainDiskArgs) ToDomainDiskOutput 

func (i DomainDiskArgs) ToDomainDiskOutput() DomainDiskOutput

func (DomainDiskArgs) ToDomainDiskOutputWithContext 

func (i DomainDiskArgs) ToDomainDiskOutputWithContext(ctx context.Context) DomainDiskOutput

type DomainDiskArray 

type DomainDiskArray []DomainDiskInput

func (DomainDiskArray) ElementType 

func (DomainDiskArray) ElementType() reflect.Type

func (DomainDiskArray) ToDomainDiskArrayOutput 

func (i DomainDiskArray) ToDomainDiskArrayOutput() DomainDiskArrayOutput

func (DomainDiskArray) ToDomainDiskArrayOutputWithContext 

func (i DomainDiskArray) ToDomainDiskArrayOutputWithContext(ctx context.Context) DomainDiskArrayOutput

type DomainDiskArrayInput 

type DomainDiskArrayInput interface {
	pulumi.Input

	ToDomainDiskArrayOutput() DomainDiskArrayOutput
	ToDomainDiskArrayOutputWithContext(context.Context) DomainDiskArrayOutput
}

DomainDiskArrayInput is an input type that accepts DomainDiskArray and DomainDiskArrayOutput values. You can construct a concrete instance of `DomainDiskArrayInput` via: 

DomainDiskArray{ DomainDiskArgs{...} }

type DomainDiskArrayOutput 

type DomainDiskArrayOutput struct{ *pulumi.OutputState }

func (DomainDiskArrayOutput) ElementType 

func (DomainDiskArrayOutput) ElementType() reflect.Type

func (DomainDiskArrayOutput) Index 

func (o DomainDiskArrayOutput) Index(i pulumi.IntInput) DomainDiskOutput

func (DomainDiskArrayOutput) ToDomainDiskArrayOutput 

func (o DomainDiskArrayOutput) ToDomainDiskArrayOutput() DomainDiskArrayOutput

func (DomainDiskArrayOutput) ToDomainDiskArrayOutputWithContext 

func (o DomainDiskArrayOutput) ToDomainDiskArrayOutputWithContext(ctx context.Context) DomainDiskArrayOutput

type DomainDiskInput 

type DomainDiskInput interface {
	pulumi.Input

	ToDomainDiskOutput() DomainDiskOutput
	ToDomainDiskOutputWithContext(context.Context) DomainDiskOutput
}

DomainDiskInput is an input type that accepts DomainDiskArgs and DomainDiskOutput values. You can construct a concrete instance of `DomainDiskInput` via: 

DomainDiskArgs{...}

type DomainDiskOutput 

type DomainDiskOutput struct{ *pulumi.OutputState }

func (DomainDiskOutput) BlockDevice 

func (o DomainDiskOutput) BlockDevice() pulumi.StringPtrOutput

The path to the host device to use as the block device for this disk.

While `volumeId`, `url`, `file` and `blockDevice` are optional, it is intended that you use one of them.

func (DomainDiskOutput) ElementType 

func (DomainDiskOutput) ElementType() reflect.Type

func (DomainDiskOutput) File 

func (o DomainDiskOutput) File() pulumi.StringPtrOutput

The filename to use as the block device for this disk (read-only)

func (DomainDiskOutput) Scsi 

func (o DomainDiskOutput) Scsi() pulumi.BoolPtrOutput

Use a scsi controller for this disk. The controller model is set to `virtio-scsi`

func (DomainDiskOutput) ToDomainDiskOutput 

func (o DomainDiskOutput) ToDomainDiskOutput() DomainDiskOutput

func (DomainDiskOutput) ToDomainDiskOutputWithContext 

func (o DomainDiskOutput) ToDomainDiskOutputWithContext(ctx context.Context) DomainDiskOutput

func (DomainDiskOutput) Url 

func (o DomainDiskOutput) Url() pulumi.StringPtrOutput

The http url to use as the block device for this disk (read-only)

func (DomainDiskOutput) VolumeId 

func (o DomainDiskOutput) VolumeId() pulumi.StringPtrOutput

The volume id to use for this disk.

func (DomainDiskOutput) Wwn 

func (o DomainDiskOutput) Wwn() pulumi.StringPtrOutput

Specify a WWN to use for the disk if the disk is using a scsi controller, if not specified then a random wwn is generated for the disk

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		leap, err := libvirt.NewVolume(ctx, "leap", &libvirt.VolumeArgs{
			Source: pulumi.String("http://someurl/openSUSE_Leap-42.1.qcow2"),
		})
		if err != nil {
			return err
		}
		mydisk, err := libvirt.NewVolume(ctx, "mydisk", &libvirt.VolumeArgs{
			BaseVolumeId: leap.ID(),
		})
		if err != nil {
			return err
		}
		_, err = libvirt.NewDomain(ctx, "domain1", &libvirt.DomainArgs{
			Disks: libvirt.DomainDiskArray{
				&libvirt.DomainDiskArgs{
					VolumeId: mydisk.ID(),
					Scsi:     pulumi.Bool(true),
				},
				&libvirt.DomainDiskArgs{
					Url: pulumi.String("http://foo.com/install.iso"),
				},
				&libvirt.DomainDiskArgs{
					File: pulumi.String("/absolute/path/to/disk.iso"),
				},
				&libvirt.DomainDiskArgs{
					BlockDevice: pulumi.String("/dev/mapper/36005076802810e55400000000000145f"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

Also note that the `disk` block is actually a list of maps, so it is possible to declare several of them by using either the literal list and map syntax as in the following examples:

type DomainFilesystem 

type DomainFilesystem struct {
	// specifies the security mode for accessing the source. By default
	// the `mapped` mode is chosen.
	Accessmode *string `pulumi:"accessmode"`
	// enables exporting filesystem as a readonly mount for guest, by
	// default read-only access is given.
	//
	// Example:
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// The exported filesystems can be mounted inside of the guest in this way:
	Readonly *bool `pulumi:"readonly"`
	// the directory of the host to be shared with the guest.
	Source string `pulumi:"source"`
	// an arbitrary string tag that is exported to the guest as a hint for
	// where to mount the source.
	Target string `pulumi:"target"`
}

type DomainFilesystemArgs 

type DomainFilesystemArgs struct {
	// specifies the security mode for accessing the source. By default
	// the `mapped` mode is chosen.
	Accessmode pulumi.StringPtrInput `pulumi:"accessmode"`
	// enables exporting filesystem as a readonly mount for guest, by
	// default read-only access is given.
	//
	// Example:
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// The exported filesystems can be mounted inside of the guest in this way:
	Readonly pulumi.BoolPtrInput `pulumi:"readonly"`
	// the directory of the host to be shared with the guest.
	Source pulumi.StringInput `pulumi:"source"`
	// an arbitrary string tag that is exported to the guest as a hint for
	// where to mount the source.
	Target pulumi.StringInput `pulumi:"target"`
}

func (DomainFilesystemArgs) ElementType 

func (DomainFilesystemArgs) ElementType() reflect.Type

func (DomainFilesystemArgs) ToDomainFilesystemOutput 

func (i DomainFilesystemArgs) ToDomainFilesystemOutput() DomainFilesystemOutput

func (DomainFilesystemArgs) ToDomainFilesystemOutputWithContext 

func (i DomainFilesystemArgs) ToDomainFilesystemOutputWithContext(ctx context.Context) DomainFilesystemOutput

type DomainFilesystemArray 

type DomainFilesystemArray []DomainFilesystemInput

func (DomainFilesystemArray) ElementType 

func (DomainFilesystemArray) ElementType() reflect.Type

func (DomainFilesystemArray) ToDomainFilesystemArrayOutput 

func (i DomainFilesystemArray) ToDomainFilesystemArrayOutput() DomainFilesystemArrayOutput

func (DomainFilesystemArray) ToDomainFilesystemArrayOutputWithContext 

func (i DomainFilesystemArray) ToDomainFilesystemArrayOutputWithContext(ctx context.Context) DomainFilesystemArrayOutput

type DomainFilesystemArrayInput 

type DomainFilesystemArrayInput interface {
	pulumi.Input

	ToDomainFilesystemArrayOutput() DomainFilesystemArrayOutput
	ToDomainFilesystemArrayOutputWithContext(context.Context) DomainFilesystemArrayOutput
}

DomainFilesystemArrayInput is an input type that accepts DomainFilesystemArray and DomainFilesystemArrayOutput values. You can construct a concrete instance of `DomainFilesystemArrayInput` via: 

DomainFilesystemArray{ DomainFilesystemArgs{...} }

type DomainFilesystemArrayOutput 

type DomainFilesystemArrayOutput struct{ *pulumi.OutputState }

func (DomainFilesystemArrayOutput) ElementType 

func (DomainFilesystemArrayOutput) ElementType() reflect.Type

func (DomainFilesystemArrayOutput) Index 

func (o DomainFilesystemArrayOutput) Index(i pulumi.IntInput) DomainFilesystemOutput

func (DomainFilesystemArrayOutput) ToDomainFilesystemArrayOutput 

func (o DomainFilesystemArrayOutput) ToDomainFilesystemArrayOutput() DomainFilesystemArrayOutput

func (DomainFilesystemArrayOutput) ToDomainFilesystemArrayOutputWithContext 

func (o DomainFilesystemArrayOutput) ToDomainFilesystemArrayOutputWithContext(ctx context.Context) DomainFilesystemArrayOutput

type DomainFilesystemInput 

type DomainFilesystemInput interface {
	pulumi.Input

	ToDomainFilesystemOutput() DomainFilesystemOutput
	ToDomainFilesystemOutputWithContext(context.Context) DomainFilesystemOutput
}

DomainFilesystemInput is an input type that accepts DomainFilesystemArgs and DomainFilesystemOutput values. You can construct a concrete instance of `DomainFilesystemInput` via: 

DomainFilesystemArgs{...}

type DomainFilesystemOutput 

type DomainFilesystemOutput struct{ *pulumi.OutputState }

func (DomainFilesystemOutput) Accessmode 

func (o DomainFilesystemOutput) Accessmode() pulumi.StringPtrOutput

specifies the security mode for accessing the source. By default the `mapped` mode is chosen.

func (DomainFilesystemOutput) ElementType 

func (DomainFilesystemOutput) ElementType() reflect.Type

func (DomainFilesystemOutput) Readonly 

func (o DomainFilesystemOutput) Readonly() pulumi.BoolPtrOutput

enables exporting filesystem as a readonly mount for guest, by default read-only access is given.

Example:

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

The exported filesystems can be mounted inside of the guest in this way:

func (DomainFilesystemOutput) Source 

func (o DomainFilesystemOutput) Source() pulumi.StringOutput

the directory of the host to be shared with the guest.

func (DomainFilesystemOutput) Target 

func (o DomainFilesystemOutput) Target() pulumi.StringOutput

an arbitrary string tag that is exported to the guest as a hint for where to mount the source.

func (DomainFilesystemOutput) ToDomainFilesystemOutput 

func (o DomainFilesystemOutput) ToDomainFilesystemOutput() DomainFilesystemOutput

func (DomainFilesystemOutput) ToDomainFilesystemOutputWithContext 

func (o DomainFilesystemOutput) ToDomainFilesystemOutputWithContext(ctx context.Context) DomainFilesystemOutput

type DomainGraphics 

type DomainGraphics struct {
	// defaults to "yes"
	Autoport *bool `pulumi:"autoport"`
	// IP Address where the VNC listener should be started if
	// `listenType` is set to `address`. Defaults to 127.0.0.1
	ListenAddress *string `pulumi:"listenAddress"`
	// "listen type", defaults to "none"
	ListenType *string `pulumi:"listenType"`
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type *string `pulumi:"type"`
	// Port to listen on for VNC WebSocket functionality (-1 meaning auto-allocation)
	//
	// On occasion we have found it necessary to set a `type` of `vnc` and a
	// `listenType` of `address` with certain builds of QEMU.
	//
	// With `listenAddress` it is possible to specify a listener address for the virtual
	// machines VNC server. Usually this is an IP of the host system.
	//
	// The `graphics` block will look as follows:
	Websocket *int `pulumi:"websocket"`
}

type DomainGraphicsArgs 

type DomainGraphicsArgs struct {
	// defaults to "yes"
	Autoport pulumi.BoolPtrInput `pulumi:"autoport"`
	// IP Address where the VNC listener should be started if
	// `listenType` is set to `address`. Defaults to 127.0.0.1
	ListenAddress pulumi.StringPtrInput `pulumi:"listenAddress"`
	// "listen type", defaults to "none"
	ListenType pulumi.StringPtrInput `pulumi:"listenType"`
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrInput `pulumi:"type"`
	// Port to listen on for VNC WebSocket functionality (-1 meaning auto-allocation)
	//
	// On occasion we have found it necessary to set a `type` of `vnc` and a
	// `listenType` of `address` with certain builds of QEMU.
	//
	// With `listenAddress` it is possible to specify a listener address for the virtual
	// machines VNC server. Usually this is an IP of the host system.
	//
	// The `graphics` block will look as follows:
	Websocket pulumi.IntPtrInput `pulumi:"websocket"`
}

func (DomainGraphicsArgs) ElementType 

func (DomainGraphicsArgs) ElementType() reflect.Type

func (DomainGraphicsArgs) ToDomainGraphicsOutput 

func (i DomainGraphicsArgs) ToDomainGraphicsOutput() DomainGraphicsOutput

func (DomainGraphicsArgs) ToDomainGraphicsOutputWithContext 

func (i DomainGraphicsArgs) ToDomainGraphicsOutputWithContext(ctx context.Context) DomainGraphicsOutput

func (DomainGraphicsArgs) ToDomainGraphicsPtrOutput 

func (i DomainGraphicsArgs) ToDomainGraphicsPtrOutput() DomainGraphicsPtrOutput

func (DomainGraphicsArgs) ToDomainGraphicsPtrOutputWithContext 

func (i DomainGraphicsArgs) ToDomainGraphicsPtrOutputWithContext(ctx context.Context) DomainGraphicsPtrOutput

type DomainGraphicsInput 

type DomainGraphicsInput interface {
	pulumi.Input

	ToDomainGraphicsOutput() DomainGraphicsOutput
	ToDomainGraphicsOutputWithContext(context.Context) DomainGraphicsOutput
}

DomainGraphicsInput is an input type that accepts DomainGraphicsArgs and DomainGraphicsOutput values. You can construct a concrete instance of `DomainGraphicsInput` via: 

DomainGraphicsArgs{...}

type DomainGraphicsOutput 

type DomainGraphicsOutput struct{ *pulumi.OutputState }

func (DomainGraphicsOutput) Autoport 

func (o DomainGraphicsOutput) Autoport() pulumi.BoolPtrOutput

defaults to "yes"

func (DomainGraphicsOutput) ElementType 

func (DomainGraphicsOutput) ElementType() reflect.Type

func (DomainGraphicsOutput) ListenAddress 

func (o DomainGraphicsOutput) ListenAddress() pulumi.StringPtrOutput

IP Address where the VNC listener should be started if `listenType` is set to `address`. Defaults to 127.0.0.1

func (DomainGraphicsOutput) ListenType 

func (o DomainGraphicsOutput) ListenType() pulumi.StringPtrOutput

"listen type", defaults to "none"

func (DomainGraphicsOutput) ToDomainGraphicsOutput 

func (o DomainGraphicsOutput) ToDomainGraphicsOutput() DomainGraphicsOutput

func (DomainGraphicsOutput) ToDomainGraphicsOutputWithContext 

func (o DomainGraphicsOutput) ToDomainGraphicsOutputWithContext(ctx context.Context) DomainGraphicsOutput

func (DomainGraphicsOutput) ToDomainGraphicsPtrOutput 

func (o DomainGraphicsOutput) ToDomainGraphicsPtrOutput() DomainGraphicsPtrOutput

func (DomainGraphicsOutput) ToDomainGraphicsPtrOutputWithContext 

func (o DomainGraphicsOutput) ToDomainGraphicsPtrOutputWithContext(ctx context.Context) DomainGraphicsPtrOutput

func (DomainGraphicsOutput) Type 

func (o DomainGraphicsOutput) Type() pulumi.StringPtrOutput

The type of hypervisor to use for the domain. Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)

func (DomainGraphicsOutput) Websocket added in v0.2.1 

func (o DomainGraphicsOutput) Websocket() pulumi.IntPtrOutput

Port to listen on for VNC WebSocket functionality (-1 meaning auto-allocation)

On occasion we have found it necessary to set a `type` of `vnc` and a `listenType` of `address` with certain builds of QEMU.

With `listenAddress` it is possible to specify a listener address for the virtual machines VNC server. Usually this is an IP of the host system.

The `graphics` block will look as follows:

type DomainGraphicsPtrInput 

type DomainGraphicsPtrInput interface {
	pulumi.Input

	ToDomainGraphicsPtrOutput() DomainGraphicsPtrOutput
	ToDomainGraphicsPtrOutputWithContext(context.Context) DomainGraphicsPtrOutput
}

DomainGraphicsPtrInput is an input type that accepts DomainGraphicsArgs, DomainGraphicsPtr and DomainGraphicsPtrOutput values. You can construct a concrete instance of `DomainGraphicsPtrInput` via: 

        DomainGraphicsArgs{...}

or:

        nil

func DomainGraphicsPtr 

func DomainGraphicsPtr(v *DomainGraphicsArgs) DomainGraphicsPtrInput

type DomainGraphicsPtrOutput 

type DomainGraphicsPtrOutput struct{ *pulumi.OutputState }

func (DomainGraphicsPtrOutput) Autoport 

func (o DomainGraphicsPtrOutput) Autoport() pulumi.BoolPtrOutput

defaults to "yes"

func (DomainGraphicsPtrOutput) Elem 

func (o DomainGraphicsPtrOutput) Elem() DomainGraphicsOutput

func (DomainGraphicsPtrOutput) ElementType 

func (DomainGraphicsPtrOutput) ElementType() reflect.Type

func (DomainGraphicsPtrOutput) ListenAddress 

func (o DomainGraphicsPtrOutput) ListenAddress() pulumi.StringPtrOutput

IP Address where the VNC listener should be started if `listenType` is set to `address`. Defaults to 127.0.0.1

func (DomainGraphicsPtrOutput) ListenType 

func (o DomainGraphicsPtrOutput) ListenType() pulumi.StringPtrOutput

"listen type", defaults to "none"

func (DomainGraphicsPtrOutput) ToDomainGraphicsPtrOutput 

func (o DomainGraphicsPtrOutput) ToDomainGraphicsPtrOutput() DomainGraphicsPtrOutput

func (DomainGraphicsPtrOutput) ToDomainGraphicsPtrOutputWithContext 

func (o DomainGraphicsPtrOutput) ToDomainGraphicsPtrOutputWithContext(ctx context.Context) DomainGraphicsPtrOutput

func (DomainGraphicsPtrOutput) Type 

func (o DomainGraphicsPtrOutput) Type() pulumi.StringPtrOutput

The type of hypervisor to use for the domain. Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)

func (DomainGraphicsPtrOutput) Websocket added in v0.2.1 

func (o DomainGraphicsPtrOutput) Websocket() pulumi.IntPtrOutput

Port to listen on for VNC WebSocket functionality (-1 meaning auto-allocation)

On occasion we have found it necessary to set a `type` of `vnc` and a `listenType` of `address` with certain builds of QEMU.

With `listenAddress` it is possible to specify a listener address for the virtual machines VNC server. Usually this is an IP of the host system.

The `graphics` block will look as follows:

type DomainInput 

type DomainInput interface {
	pulumi.Input

	ToDomainOutput() DomainOutput
	ToDomainOutputWithContext(ctx context.Context) DomainOutput
}

type DomainMap 

type DomainMap map[string]DomainInput

func (DomainMap) ElementType 

func (DomainMap) ElementType() reflect.Type

func (DomainMap) ToDomainMapOutput 

func (i DomainMap) ToDomainMapOutput() DomainMapOutput

func (DomainMap) ToDomainMapOutputWithContext 

func (i DomainMap) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput

type DomainMapInput 

type DomainMapInput interface {
	pulumi.Input

	ToDomainMapOutput() DomainMapOutput
	ToDomainMapOutputWithContext(context.Context) DomainMapOutput
}

DomainMapInput is an input type that accepts DomainMap and DomainMapOutput values. You can construct a concrete instance of `DomainMapInput` via: 

DomainMap{ "key": DomainArgs{...} }

type DomainMapOutput 

type DomainMapOutput struct{ *pulumi.OutputState }

func (DomainMapOutput) ElementType 

func (DomainMapOutput) ElementType() reflect.Type

func (DomainMapOutput) MapIndex 

func (o DomainMapOutput) MapIndex(k pulumi.StringInput) DomainOutput

func (DomainMapOutput) ToDomainMapOutput 

func (o DomainMapOutput) ToDomainMapOutput() DomainMapOutput

func (DomainMapOutput) ToDomainMapOutputWithContext 

func (o DomainMapOutput) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput

type DomainNetworkInterface 

type DomainNetworkInterface struct {
	// An IP address for this domain in this network.
	Addresses []string `pulumi:"addresses"`
	// Provides a bridge from the VM directly to the LAN. This assumes
	// there is a bridge device on the host which has one or more of the hosts
	// physical NICs enslaved. The guest VM will have an associated _tun_ device
	// created and enslaved to the bridge. The IP range / network configuration is
	// whatever is used on the LAN. This provides the guest VM full incoming &
	// outgoing net access just like a physical machine.
	Bridge *string `pulumi:"bridge"`
	// A hostname that will be assigned to this domain
	// resource in this network.
	Hostname *string `pulumi:"hostname"`
	// The specific MAC address to use for this interface.
	Mac *string `pulumi:"mac"`
	// Packets whose destination is on the same host as where they
	// originate from are directly delivered to the target macvtap device. Both
	// origin and destination devices need to be in bridge mode for direct delivery.
	// If either one of them is in vepa mode, a VEPA capable bridge is required.
	Macvtap     *string `pulumi:"macvtap"`
	NetworkId   *string `pulumi:"networkId"`
	NetworkName *string `pulumi:"networkName"`
	// This feature attaches a virtual function of a SRIOV capable
	// NIC directly to a VM without losing the migration capability. All packets are
	// sent to the VF/IF of the configured network device. Depending on the
	// capabilities of the device additional prerequisites or limitations may apply;
	// for example, on Linux this requires kernel 2.6.38 or newer.
	//
	// Example of a `macvtap` interface:
	Passthrough *string `pulumi:"passthrough"`
	// All VMs' packets are sent to the external bridge. Packets whose
	// destination is a VM on the same host as where the packet originates from are
	// sent back to the host by the VEPA capable bridge (today's bridges are
	// typically not VEPA capable).
	Vepa *string `pulumi:"vepa"`
	// When creating the domain resource, wait until the
	// network interface gets a DHCP lease from libvirt, so that the computed IP
	// addresses will be available when the domain is up and the plan applied.
	//
	// When connecting to a LAN, users can specify a target device with:
	WaitForLease *bool `pulumi:"waitForLease"`
}

type DomainNetworkInterfaceArgs 

type DomainNetworkInterfaceArgs struct {
	// An IP address for this domain in this network.
	Addresses pulumi.StringArrayInput `pulumi:"addresses"`
	// Provides a bridge from the VM directly to the LAN. This assumes
	// there is a bridge device on the host which has one or more of the hosts
	// physical NICs enslaved. The guest VM will have an associated _tun_ device
	// created and enslaved to the bridge. The IP range / network configuration is
	// whatever is used on the LAN. This provides the guest VM full incoming &
	// outgoing net access just like a physical machine.
	Bridge pulumi.StringPtrInput `pulumi:"bridge"`
	// A hostname that will be assigned to this domain
	// resource in this network.
	Hostname pulumi.StringPtrInput `pulumi:"hostname"`
	// The specific MAC address to use for this interface.
	Mac pulumi.StringPtrInput `pulumi:"mac"`
	// Packets whose destination is on the same host as where they
	// originate from are directly delivered to the target macvtap device. Both
	// origin and destination devices need to be in bridge mode for direct delivery.
	// If either one of them is in vepa mode, a VEPA capable bridge is required.
	Macvtap     pulumi.StringPtrInput `pulumi:"macvtap"`
	NetworkId   pulumi.StringPtrInput `pulumi:"networkId"`
	NetworkName pulumi.StringPtrInput `pulumi:"networkName"`
	// This feature attaches a virtual function of a SRIOV capable
	// NIC directly to a VM without losing the migration capability. All packets are
	// sent to the VF/IF of the configured network device. Depending on the
	// capabilities of the device additional prerequisites or limitations may apply;
	// for example, on Linux this requires kernel 2.6.38 or newer.
	//
	// Example of a `macvtap` interface:
	Passthrough pulumi.StringPtrInput `pulumi:"passthrough"`
	// All VMs' packets are sent to the external bridge. Packets whose
	// destination is a VM on the same host as where the packet originates from are
	// sent back to the host by the VEPA capable bridge (today's bridges are
	// typically not VEPA capable).
	Vepa pulumi.StringPtrInput `pulumi:"vepa"`
	// When creating the domain resource, wait until the
	// network interface gets a DHCP lease from libvirt, so that the computed IP
	// addresses will be available when the domain is up and the plan applied.
	//
	// When connecting to a LAN, users can specify a target device with:
	WaitForLease pulumi.BoolPtrInput `pulumi:"waitForLease"`
}

func (DomainNetworkInterfaceArgs) ElementType 

func (DomainNetworkInterfaceArgs) ElementType() reflect.Type

func (DomainNetworkInterfaceArgs) ToDomainNetworkInterfaceOutput 

func (i DomainNetworkInterfaceArgs) ToDomainNetworkInterfaceOutput() DomainNetworkInterfaceOutput

func (DomainNetworkInterfaceArgs) ToDomainNetworkInterfaceOutputWithContext 

func (i DomainNetworkInterfaceArgs) ToDomainNetworkInterfaceOutputWithContext(ctx context.Context) DomainNetworkInterfaceOutput

type DomainNetworkInterfaceArray 

type DomainNetworkInterfaceArray []DomainNetworkInterfaceInput

func (DomainNetworkInterfaceArray) ElementType 

func (DomainNetworkInterfaceArray) ElementType() reflect.Type

func (DomainNetworkInterfaceArray) ToDomainNetworkInterfaceArrayOutput 

func (i DomainNetworkInterfaceArray) ToDomainNetworkInterfaceArrayOutput() DomainNetworkInterfaceArrayOutput

func (DomainNetworkInterfaceArray) ToDomainNetworkInterfaceArrayOutputWithContext 

func (i DomainNetworkInterfaceArray) ToDomainNetworkInterfaceArrayOutputWithContext(ctx context.Context) DomainNetworkInterfaceArrayOutput

type DomainNetworkInterfaceArrayInput 

type DomainNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToDomainNetworkInterfaceArrayOutput() DomainNetworkInterfaceArrayOutput
	ToDomainNetworkInterfaceArrayOutputWithContext(context.Context) DomainNetworkInterfaceArrayOutput
}

DomainNetworkInterfaceArrayInput is an input type that accepts DomainNetworkInterfaceArray and DomainNetworkInterfaceArrayOutput values. You can construct a concrete instance of `DomainNetworkInterfaceArrayInput` via: 

DomainNetworkInterfaceArray{ DomainNetworkInterfaceArgs{...} }

type DomainNetworkInterfaceArrayOutput 

type DomainNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

func (DomainNetworkInterfaceArrayOutput) ElementType 

func (DomainNetworkInterfaceArrayOutput) ElementType() reflect.Type

func (DomainNetworkInterfaceArrayOutput) Index 

func (o DomainNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) DomainNetworkInterfaceOutput

func (DomainNetworkInterfaceArrayOutput) ToDomainNetworkInterfaceArrayOutput 

func (o DomainNetworkInterfaceArrayOutput) ToDomainNetworkInterfaceArrayOutput() DomainNetworkInterfaceArrayOutput

func (DomainNetworkInterfaceArrayOutput) ToDomainNetworkInterfaceArrayOutputWithContext 

func (o DomainNetworkInterfaceArrayOutput) ToDomainNetworkInterfaceArrayOutputWithContext(ctx context.Context) DomainNetworkInterfaceArrayOutput

type DomainNetworkInterfaceInput 

type DomainNetworkInterfaceInput interface {
	pulumi.Input

	ToDomainNetworkInterfaceOutput() DomainNetworkInterfaceOutput
	ToDomainNetworkInterfaceOutputWithContext(context.Context) DomainNetworkInterfaceOutput
}

DomainNetworkInterfaceInput is an input type that accepts DomainNetworkInterfaceArgs and DomainNetworkInterfaceOutput values. You can construct a concrete instance of `DomainNetworkInterfaceInput` via: 

DomainNetworkInterfaceArgs{...}

type DomainNetworkInterfaceOutput 

type DomainNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (DomainNetworkInterfaceOutput) Addresses 

func (o DomainNetworkInterfaceOutput) Addresses() pulumi.StringArrayOutput

An IP address for this domain in this network.

func (DomainNetworkInterfaceOutput) Bridge 

func (o DomainNetworkInterfaceOutput) Bridge() pulumi.StringPtrOutput

Provides a bridge from the VM directly to the LAN. This assumes there is a bridge device on the host which has one or more of the hosts physical NICs enslaved. The guest VM will have an associated _tun_ device created and enslaved to the bridge. The IP range / network configuration is whatever is used on the LAN. This provides the guest VM full incoming & outgoing net access just like a physical machine.

func (DomainNetworkInterfaceOutput) ElementType 

func (DomainNetworkInterfaceOutput) ElementType() reflect.Type

func (DomainNetworkInterfaceOutput) Hostname 

func (o DomainNetworkInterfaceOutput) Hostname() pulumi.StringPtrOutput

A hostname that will be assigned to this domain resource in this network.

func (DomainNetworkInterfaceOutput) Mac 

func (o DomainNetworkInterfaceOutput) Mac() pulumi.StringPtrOutput

The specific MAC address to use for this interface.

func (DomainNetworkInterfaceOutput) Macvtap 

func (o DomainNetworkInterfaceOutput) Macvtap() pulumi.StringPtrOutput

Packets whose destination is on the same host as where they originate from are directly delivered to the target macvtap device. Both origin and destination devices need to be in bridge mode for direct delivery. If either one of them is in vepa mode, a VEPA capable bridge is required.

func (DomainNetworkInterfaceOutput) NetworkId 

func (o DomainNetworkInterfaceOutput) NetworkId() pulumi.StringPtrOutput

func (DomainNetworkInterfaceOutput) NetworkName 

func (o DomainNetworkInterfaceOutput) NetworkName() pulumi.StringPtrOutput

func (DomainNetworkInterfaceOutput) Passthrough 

func (o DomainNetworkInterfaceOutput) Passthrough() pulumi.StringPtrOutput

This feature attaches a virtual function of a SRIOV capable NIC directly to a VM without losing the migration capability. All packets are sent to the VF/IF of the configured network device. Depending on the capabilities of the device additional prerequisites or limitations may apply; for example, on Linux this requires kernel 2.6.38 or newer.

Example of a `macvtap` interface:

func (DomainNetworkInterfaceOutput) ToDomainNetworkInterfaceOutput 

func (o DomainNetworkInterfaceOutput) ToDomainNetworkInterfaceOutput() DomainNetworkInterfaceOutput

func (DomainNetworkInterfaceOutput) ToDomainNetworkInterfaceOutputWithContext 

func (o DomainNetworkInterfaceOutput) ToDomainNetworkInterfaceOutputWithContext(ctx context.Context) DomainNetworkInterfaceOutput

func (DomainNetworkInterfaceOutput) Vepa 

func (o DomainNetworkInterfaceOutput) Vepa() pulumi.StringPtrOutput

All VMs' packets are sent to the external bridge. Packets whose destination is a VM on the same host as where the packet originates from are sent back to the host by the VEPA capable bridge (today's bridges are typically not VEPA capable).

func (DomainNetworkInterfaceOutput) WaitForLease 

func (o DomainNetworkInterfaceOutput) WaitForLease() pulumi.BoolPtrOutput

When creating the domain resource, wait until the network interface gets a DHCP lease from libvirt, so that the computed IP addresses will be available when the domain is up and the plan applied.

When connecting to a LAN, users can specify a target device with:

type DomainNvram 

type DomainNvram struct {
	// The filename to use as the block device for this disk (read-only)
	File string `pulumi:"file"`
	// path to the file used to override variables from the master NVRAM
	// store.
	//
	// So you should typically use the firmware as this,
	Template *string `pulumi:"template"`
}

type DomainNvramArgs 

type DomainNvramArgs struct {
	// The filename to use as the block device for this disk (read-only)
	File pulumi.StringInput `pulumi:"file"`
	// path to the file used to override variables from the master NVRAM
	// store.
	//
	// So you should typically use the firmware as this,
	Template pulumi.StringPtrInput `pulumi:"template"`
}

func (DomainNvramArgs) ElementType 

func (DomainNvramArgs) ElementType() reflect.Type

func (DomainNvramArgs) ToDomainNvramOutput 

func (i DomainNvramArgs) ToDomainNvramOutput() DomainNvramOutput

func (DomainNvramArgs) ToDomainNvramOutputWithContext 

func (i DomainNvramArgs) ToDomainNvramOutputWithContext(ctx context.Context) DomainNvramOutput

func (DomainNvramArgs) ToDomainNvramPtrOutput 

func (i DomainNvramArgs) ToDomainNvramPtrOutput() DomainNvramPtrOutput

func (DomainNvramArgs) ToDomainNvramPtrOutputWithContext 

func (i DomainNvramArgs) ToDomainNvramPtrOutputWithContext(ctx context.Context) DomainNvramPtrOutput

type DomainNvramInput 

type DomainNvramInput interface {
	pulumi.Input

	ToDomainNvramOutput() DomainNvramOutput
	ToDomainNvramOutputWithContext(context.Context) DomainNvramOutput
}

DomainNvramInput is an input type that accepts DomainNvramArgs and DomainNvramOutput values. You can construct a concrete instance of `DomainNvramInput` via: 

DomainNvramArgs{...}

type DomainNvramOutput 

type DomainNvramOutput struct{ *pulumi.OutputState }

func (DomainNvramOutput) ElementType 

func (DomainNvramOutput) ElementType() reflect.Type

func (DomainNvramOutput) File 

func (o DomainNvramOutput) File() pulumi.StringOutput

The filename to use as the block device for this disk (read-only)

func (DomainNvramOutput) Template 

func (o DomainNvramOutput) Template() pulumi.StringPtrOutput

path to the file used to override variables from the master NVRAM store.

So you should typically use the firmware as this,

func (DomainNvramOutput) ToDomainNvramOutput 

func (o DomainNvramOutput) ToDomainNvramOutput() DomainNvramOutput

func (DomainNvramOutput) ToDomainNvramOutputWithContext 

func (o DomainNvramOutput) ToDomainNvramOutputWithContext(ctx context.Context) DomainNvramOutput

func (DomainNvramOutput) ToDomainNvramPtrOutput 

func (o DomainNvramOutput) ToDomainNvramPtrOutput() DomainNvramPtrOutput

func (DomainNvramOutput) ToDomainNvramPtrOutputWithContext 

func (o DomainNvramOutput) ToDomainNvramPtrOutputWithContext(ctx context.Context) DomainNvramPtrOutput

type DomainNvramPtrInput 

type DomainNvramPtrInput interface {
	pulumi.Input

	ToDomainNvramPtrOutput() DomainNvramPtrOutput
	ToDomainNvramPtrOutputWithContext(context.Context) DomainNvramPtrOutput
}

DomainNvramPtrInput is an input type that accepts DomainNvramArgs, DomainNvramPtr and DomainNvramPtrOutput values. You can construct a concrete instance of `DomainNvramPtrInput` via: 

        DomainNvramArgs{...}

or:

        nil

func DomainNvramPtr 

func DomainNvramPtr(v *DomainNvramArgs) DomainNvramPtrInput

type DomainNvramPtrOutput 

type DomainNvramPtrOutput struct{ *pulumi.OutputState }

func (DomainNvramPtrOutput) Elem 

func (o DomainNvramPtrOutput) Elem() DomainNvramOutput

func (DomainNvramPtrOutput) ElementType 

func (DomainNvramPtrOutput) ElementType() reflect.Type

func (DomainNvramPtrOutput) File 

func (o DomainNvramPtrOutput) File() pulumi.StringPtrOutput

The filename to use as the block device for this disk (read-only)

func (DomainNvramPtrOutput) Template 

func (o DomainNvramPtrOutput) Template() pulumi.StringPtrOutput

path to the file used to override variables from the master NVRAM store.

So you should typically use the firmware as this,

func (DomainNvramPtrOutput) ToDomainNvramPtrOutput 

func (o DomainNvramPtrOutput) ToDomainNvramPtrOutput() DomainNvramPtrOutput

func (DomainNvramPtrOutput) ToDomainNvramPtrOutputWithContext 

func (o DomainNvramPtrOutput) ToDomainNvramPtrOutputWithContext(ctx context.Context) DomainNvramPtrOutput

type DomainOutput 

type DomainOutput struct{ *pulumi.OutputState }

func (DomainOutput) Arch added in v0.3.0 

func (o DomainOutput) Arch() pulumi.StringOutput

The architecture for the VM (probably x8664 or i686), you normally won't need to set this unless you are building a special VM

func (DomainOutput) Autostart added in v0.3.0 

func (o DomainOutput) Autostart() pulumi.BoolOutput

Set to `true` to start the domain on host boot up. If not specified `false` is assumed.

func (DomainOutput) BootDevices added in v0.3.0 

func (o DomainOutput) BootDevices() DomainBootDeviceArrayOutput

A list of devices (dev) which defines boot order. Example below.

func (DomainOutput) Cloudinit added in v0.3.0 

func (o DomainOutput) Cloudinit() pulumi.StringPtrOutput

The `CloudInitDisk` disk that has to be used by the domain. This is going to be attached as a CDROM ISO. Changing the cloud-init won't cause the domain to be recreated, however the change will have effect on the next reboot.

func (DomainOutput) Cmdlines added in v0.3.0 

func (o DomainOutput) Cmdlines() pulumi.MapArrayOutput

Arguments to the kernel

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
			Memory: pulumi.Int(1024),
			Vcpu:   pulumi.Int(1),
			Kernel: pulumi.Any(libvirt_volume.Kernel.Id),
			Cmdlines: pulumi.MapArray{
				pulumi.Map{
					"arg1": pulumi.Any("value1"),
					"arg2": pulumi.Any("value2"),
					"_":    pulumi.Any("rw nosplash"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

Kernel params that don't have a keyword identifier can be specified using the special `"_"` keyword. Multiple keyword-less params have to be specified using the same `"_"` keyword, like in the example above.

Also note that the `cmd` block is actually a list of maps, so it is possible to declare several of them by using either the literal list and map syntax as in the following examples:

func (DomainOutput) Consoles added in v0.3.0 

func (o DomainOutput) Consoles() DomainConsoleArrayOutput

func (DomainOutput) CoreosIgnition added in v0.3.0 

func (o DomainOutput) CoreosIgnition() pulumi.StringPtrOutput

The Ignition(https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource that is to be used by the CoreOS domain.

func (DomainOutput) Cpu added in v0.3.0 

func (o DomainOutput) Cpu() DomainCpuOutput

Configures CPU mode. See below for more details.

func (DomainOutput) Description added in v0.3.0 

func (o DomainOutput) Description() pulumi.StringPtrOutput

The description for domain. Changing this forces a new resource to be created. This data is not used by libvirt in any way, it can contain any information the user wants.

func (DomainOutput) Disks added in v0.3.0 

func (o DomainOutput) Disks() DomainDiskArrayOutput

An array of one or more disks to attach to the domain. The `disk` object structure is documented below.

func (DomainOutput) ElementType 

func (DomainOutput) ElementType() reflect.Type

func (DomainOutput) Emulator added in v0.3.0 

func (o DomainOutput) Emulator() pulumi.StringOutput

The path of the emulator to use

func (DomainOutput) Filesystems added in v0.3.0 

func (o DomainOutput) Filesystems() DomainFilesystemArrayOutput

An array of one or more host filesystems to attach to the domain. The `filesystem` object structure is documented below.

func (DomainOutput) Firmware added in v0.3.0 

func (o DomainOutput) Firmware() pulumi.StringPtrOutput

The UEFI rom images for exercising UEFI secure boot in a qemu environment. Users should usually specify one of the standard _Open Virtual Machine Firmware_ (_OVMF_) images available for their distributions. The file will be opened read-only.

func (DomainOutput) FwCfgName added in v0.3.0 

func (o DomainOutput) FwCfgName() pulumi.StringPtrOutput

The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.

func (DomainOutput) Graphics added in v0.3.0 

func (o DomainOutput) Graphics() DomainGraphicsPtrOutput

func (DomainOutput) Initrd added in v0.3.0 

func (o DomainOutput) Initrd() pulumi.StringPtrOutput

The path of the initrd to boot.

You can use it in the same way as the kernel.

func (DomainOutput) Kernel added in v0.3.0 

func (o DomainOutput) Kernel() pulumi.StringPtrOutput

The path of the kernel to boot

If you are using a qcow2 volume, you can pass the id of the volume (eg. `${libvirt_volume.kernel.id}`) as they are local to the hypervisor.

Given that you can define a volume from a remote http file, this means, you can also have remote kernels.

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		kernel, err := libvirt.NewVolume(ctx, "kernel", &libvirt.VolumeArgs{
			Source: pulumi.String("http://download.opensuse.org/tumbleweed/repo/oss/boot/x86_64/loader/linux"),
			Pool:   pulumi.String("default"),
			Format: pulumi.String("raw"),
		})
		if err != nil {
			return err
		}
		_, err = libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
			Memory: pulumi.Int(1024),
			Vcpu:   pulumi.Int(1),
			Kernel: kernel.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

func (DomainOutput) Machine added in v0.3.0 

func (o DomainOutput) Machine() pulumi.StringOutput

The machine type, you normally won't need to set this unless you are running on a platform that defaults to the wrong machine type for your template

func (DomainOutput) Memory added in v0.3.0 

func (o DomainOutput) Memory() pulumi.IntPtrOutput

The amount of memory in MiB. If not specified the domain will be created with 512 MiB of memory be used.

func (DomainOutput) Metadata added in v0.3.0 

func (o DomainOutput) Metadata() pulumi.StringPtrOutput

func (DomainOutput) Name added in v0.3.0 

func (o DomainOutput) Name() pulumi.StringOutput

A unique name for the resource, required by libvirt. Changing this forces a new resource to be created.

func (DomainOutput) NetworkInterfaces added in v0.3.0 

func (o DomainOutput) NetworkInterfaces() DomainNetworkInterfaceArrayOutput

An array of one or more network interfaces to attach to the domain. The `networkInterface` object structure is documented below.

func (DomainOutput) Nvram added in v0.3.0 

func (o DomainOutput) Nvram() DomainNvramPtrOutput

this block allows specifying the following attributes related to the _nvram_:

func (DomainOutput) QemuAgent added in v0.3.0 

func (o DomainOutput) QemuAgent() pulumi.BoolPtrOutput

By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).

func (DomainOutput) Running added in v0.3.0 

func (o DomainOutput) Running() pulumi.BoolPtrOutput

Use `false` to turn off the instance. If not specified, true is assumed and the instance, if stopped, will be started at next apply.

func (DomainOutput) ToDomainOutput 

func (o DomainOutput) ToDomainOutput() DomainOutput

func (DomainOutput) ToDomainOutputWithContext 

func (o DomainOutput) ToDomainOutputWithContext(ctx context.Context) DomainOutput

func (DomainOutput) Tpm added in v0.3.0 

func (o DomainOutput) Tpm() DomainTpmPtrOutput

TPM device to attach to the domain. The `tpm` object structure is documented below.

func (DomainOutput) Type added in v0.4.3 

func (o DomainOutput) Type() pulumi.StringPtrOutput

The type of hypervisor to use for the domain. Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)

func (DomainOutput) Vcpu added in v0.3.0 

func (o DomainOutput) Vcpu() pulumi.IntPtrOutput

The amount of virtual CPUs. If not specified, a single CPU will be created.

func (DomainOutput) Video added in v0.3.0 

func (o DomainOutput) Video() DomainVideoPtrOutput

func (DomainOutput) Xml added in v0.3.0 

func (o DomainOutput) Xml() DomainXmlPtrOutput

type DomainState 

type DomainState struct {
	// The architecture for the VM (probably x8664 or i686),
	// you normally won't need to set this unless you are building a special VM
	Arch pulumi.StringPtrInput
	// Set to `true` to start the domain on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolPtrInput
	// A list of devices (dev) which defines boot order. Example
	// below.
	BootDevices DomainBootDeviceArrayInput
	// The `CloudInitDisk` disk that has to be used by
	// the domain. This is going to be attached as a CDROM ISO. Changing the
	// cloud-init won't cause the domain to be recreated, however the change will
	// have effect on the next reboot.
	Cloudinit pulumi.StringPtrInput
	// Arguments to the kernel
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		_, err := libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
	// 			Memory: pulumi.Int(1024),
	// 			Vcpu:   pulumi.Int(1),
	// 			Kernel: pulumi.Any(libvirt_volume.Kernel.Id),
	// 			Cmdlines: pulumi.MapArray{
	// 				pulumi.Map{
	// 					"arg1": pulumi.Any("value1"),
	// 					"arg2": pulumi.Any("value2"),
	// 					"_":    pulumi.Any("rw nosplash"),
	// 				},
	// 			},
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	//
	// Kernel params that don't have a keyword identifier can be specified using the
	// special `"_"` keyword. Multiple keyword-less params have to be specified using
	// the same `"_"` keyword, like in the example above.
	//
	// Also note that the `cmd` block is actually a list of maps, so it is possible to
	// declare several of them by using either the literal list and map syntax as in
	// the following examples:
	Cmdlines pulumi.MapArrayInput
	Consoles DomainConsoleArrayInput
	// The
	// [Ignition](https://www.terraform.io/docs/providers/libvirt/r/coreos_ignition.html) resource
	// that is to be used by the CoreOS domain.
	CoreosIgnition pulumi.StringPtrInput
	// Configures CPU mode. See below for more
	// details.
	Cpu DomainCpuPtrInput
	// The description for domain.
	// Changing this forces a new resource to be created.
	// This data is not used by libvirt in any way, it can contain any information the user wants.
	Description pulumi.StringPtrInput
	// An array of one or more disks to attach to the domain. The
	// `disk` object structure is documented below.
	Disks DomainDiskArrayInput
	// The path of the emulator to use
	Emulator pulumi.StringPtrInput
	// An array of one or more host filesystems to attach to
	// the domain. The `filesystem` object structure is documented
	// below.
	Filesystems DomainFilesystemArrayInput
	// The UEFI rom images for exercising UEFI secure boot in a qemu
	// environment. Users should usually specify one of the standard _Open Virtual Machine
	// Firmware_ (_OVMF_) images available for their distributions. The file will be opened
	// read-only.
	Firmware pulumi.StringPtrInput
	// The name of the firmware config path where ignition file is stored: default is `opt/com.coreos/config`. If you are using [Flatcar Linux](https://docs.flatcar-linux.org/os/booting-with-libvirt/#creating-the-domain-xml), the value is `opt/org.flatcar-linux/config`.
	FwCfgName pulumi.StringPtrInput
	Graphics  DomainGraphicsPtrInput
	// The path of the initrd to boot.
	//
	// You can use it in the same way as the kernel.
	Initrd pulumi.StringPtrInput
	// The path of the kernel to boot
	//
	// If you are using a qcow2 volume, you can pass the id of the volume (eg. `${libvirt_volume.kernel.id}`)
	// as they are local to the hypervisor.
	//
	// Given that you can define a volume from a remote http file, this means, you can also have remote kernels.
	//
	// <!--Start PulumiCodeChooser -->
	// “`go
	// package main
	//
	// import (
	// 	"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
	// 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	// )
	//
	// func main() {
	// 	pulumi.Run(func(ctx *pulumi.Context) error {
	// 		kernel, err := libvirt.NewVolume(ctx, "kernel", &libvirt.VolumeArgs{
	// 			Source: pulumi.String("http://download.opensuse.org/tumbleweed/repo/oss/boot/x86_64/loader/linux"),
	// 			Pool:   pulumi.String("default"),
	// 			Format: pulumi.String("raw"),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		_, err = libvirt.NewDomain(ctx, "domain-suse", &libvirt.DomainArgs{
	// 			Memory: pulumi.Int(1024),
	// 			Vcpu:   pulumi.Int(1),
	// 			Kernel: kernel.ID(),
	// 		})
	// 		if err != nil {
	// 			return err
	// 		}
	// 		return nil
	// 	})
	// }
	// “`
	// <!--End PulumiCodeChooser -->
	Kernel pulumi.StringPtrInput
	// The machine type,
	// you normally won't need to set this unless you are running on a platform that
	// defaults to the wrong machine type for your template
	Machine pulumi.StringPtrInput
	// The amount of memory in MiB. If not specified the domain
	// will be created with 512 MiB of memory be used.
	Memory   pulumi.IntPtrInput
	Metadata pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// An array of one or more network interfaces to
	// attach to the domain. The `networkInterface` object structure is documented
	// below.
	NetworkInterfaces DomainNetworkInterfaceArrayInput
	// this block allows specifying the following attributes related to the _nvram_:
	Nvram DomainNvramPtrInput
	// By default is disabled, set to true for enabling it. More info [qemu-agent](https://wiki.libvirt.org/page/Qemu_guest_agent).
	QemuAgent pulumi.BoolPtrInput
	// Use `false` to turn off the instance. If not specified,
	// true is assumed and the instance, if stopped, will be started at next apply.
	Running pulumi.BoolPtrInput
	// TPM device to attach to the domain. The `tpm` object structure is documented below.
	Tpm DomainTpmPtrInput
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrInput
	// The amount of virtual CPUs. If not specified, a single CPU
	// will be created.
	Vcpu  pulumi.IntPtrInput
	Video DomainVideoPtrInput
	Xml   DomainXmlPtrInput
}

func (DomainState) ElementType 

func (DomainState) ElementType() reflect.Type

type DomainTpm added in v0.2.1 

type DomainTpm struct {
	// Path to TPM device on the host, ex: `/dev/tpm0`
	//
	// Additional attributes when `backendType` is "emulator":
	BackendDevicePath *string `pulumi:"backendDevicePath"`
	// [Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state
	BackendEncryptionSecret *string `pulumi:"backendEncryptionSecret"`
	// Keep the TPM state when a transient domain is powered off or undefined
	BackendPersistentState *bool `pulumi:"backendPersistentState"`
	// TPM backend, either `passthrough` or `emulator` (default: `emulator`)
	//
	// Additional attributes when `backendType` is "passthrough":
	BackendType *string `pulumi:"backendType"`
	// TPM version
	BackendVersion *string `pulumi:"backendVersion"`
	// TPM model provided to the guest
	Model *string `pulumi:"model"`
}

type DomainTpmArgs added in v0.2.1 

type DomainTpmArgs struct {
	// Path to TPM device on the host, ex: `/dev/tpm0`
	//
	// Additional attributes when `backendType` is "emulator":
	BackendDevicePath pulumi.StringPtrInput `pulumi:"backendDevicePath"`
	// [Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state
	BackendEncryptionSecret pulumi.StringPtrInput `pulumi:"backendEncryptionSecret"`
	// Keep the TPM state when a transient domain is powered off or undefined
	BackendPersistentState pulumi.BoolPtrInput `pulumi:"backendPersistentState"`
	// TPM backend, either `passthrough` or `emulator` (default: `emulator`)
	//
	// Additional attributes when `backendType` is "passthrough":
	BackendType pulumi.StringPtrInput `pulumi:"backendType"`
	// TPM version
	BackendVersion pulumi.StringPtrInput `pulumi:"backendVersion"`
	// TPM model provided to the guest
	Model pulumi.StringPtrInput `pulumi:"model"`
}

func (DomainTpmArgs) ElementType added in v0.2.1 

func (DomainTpmArgs) ElementType() reflect.Type

func (DomainTpmArgs) ToDomainTpmOutput added in v0.2.1 

func (i DomainTpmArgs) ToDomainTpmOutput() DomainTpmOutput

func (DomainTpmArgs) ToDomainTpmOutputWithContext added in v0.2.1 

func (i DomainTpmArgs) ToDomainTpmOutputWithContext(ctx context.Context) DomainTpmOutput

func (DomainTpmArgs) ToDomainTpmPtrOutput added in v0.2.1 

func (i DomainTpmArgs) ToDomainTpmPtrOutput() DomainTpmPtrOutput

func (DomainTpmArgs) ToDomainTpmPtrOutputWithContext added in v0.2.1 

func (i DomainTpmArgs) ToDomainTpmPtrOutputWithContext(ctx context.Context) DomainTpmPtrOutput

type DomainTpmInput added in v0.2.1 

type DomainTpmInput interface {
	pulumi.Input

	ToDomainTpmOutput() DomainTpmOutput
	ToDomainTpmOutputWithContext(context.Context) DomainTpmOutput
}

DomainTpmInput is an input type that accepts DomainTpmArgs and DomainTpmOutput values. You can construct a concrete instance of `DomainTpmInput` via: 

DomainTpmArgs{...}

type DomainTpmOutput added in v0.2.1 

type DomainTpmOutput struct{ *pulumi.OutputState }

func (DomainTpmOutput) BackendDevicePath added in v0.2.1 

func (o DomainTpmOutput) BackendDevicePath() pulumi.StringPtrOutput

Path to TPM device on the host, ex: `/dev/tpm0`

Additional attributes when `backendType` is "emulator":

func (DomainTpmOutput) BackendEncryptionSecret added in v0.2.1 

func (o DomainTpmOutput) BackendEncryptionSecret() pulumi.StringPtrOutput

[Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state

func (DomainTpmOutput) BackendPersistentState added in v0.2.1 

func (o DomainTpmOutput) BackendPersistentState() pulumi.BoolPtrOutput

Keep the TPM state when a transient domain is powered off or undefined

func (DomainTpmOutput) BackendType added in v0.2.1 

func (o DomainTpmOutput) BackendType() pulumi.StringPtrOutput

TPM backend, either `passthrough` or `emulator` (default: `emulator`)

Additional attributes when `backendType` is "passthrough":

func (DomainTpmOutput) BackendVersion added in v0.2.1 

func (o DomainTpmOutput) BackendVersion() pulumi.StringPtrOutput

TPM version

func (DomainTpmOutput) ElementType added in v0.2.1 

func (DomainTpmOutput) ElementType() reflect.Type

func (DomainTpmOutput) Model added in v0.2.1 

func (o DomainTpmOutput) Model() pulumi.StringPtrOutput

TPM model provided to the guest

func (DomainTpmOutput) ToDomainTpmOutput added in v0.2.1 

func (o DomainTpmOutput) ToDomainTpmOutput() DomainTpmOutput

func (DomainTpmOutput) ToDomainTpmOutputWithContext added in v0.2.1 

func (o DomainTpmOutput) ToDomainTpmOutputWithContext(ctx context.Context) DomainTpmOutput

func (DomainTpmOutput) ToDomainTpmPtrOutput added in v0.2.1 

func (o DomainTpmOutput) ToDomainTpmPtrOutput() DomainTpmPtrOutput

func (DomainTpmOutput) ToDomainTpmPtrOutputWithContext added in v0.2.1 

func (o DomainTpmOutput) ToDomainTpmPtrOutputWithContext(ctx context.Context) DomainTpmPtrOutput

type DomainTpmPtrInput added in v0.2.1 

type DomainTpmPtrInput interface {
	pulumi.Input

	ToDomainTpmPtrOutput() DomainTpmPtrOutput
	ToDomainTpmPtrOutputWithContext(context.Context) DomainTpmPtrOutput
}

DomainTpmPtrInput is an input type that accepts DomainTpmArgs, DomainTpmPtr and DomainTpmPtrOutput values. You can construct a concrete instance of `DomainTpmPtrInput` via: 

        DomainTpmArgs{...}

or:

        nil

func DomainTpmPtr added in v0.2.1 

func DomainTpmPtr(v *DomainTpmArgs) DomainTpmPtrInput

type DomainTpmPtrOutput added in v0.2.1 

type DomainTpmPtrOutput struct{ *pulumi.OutputState }

func (DomainTpmPtrOutput) BackendDevicePath added in v0.2.1 

func (o DomainTpmPtrOutput) BackendDevicePath() pulumi.StringPtrOutput

Path to TPM device on the host, ex: `/dev/tpm0`

Additional attributes when `backendType` is "emulator":

func (DomainTpmPtrOutput) BackendEncryptionSecret added in v0.2.1 

func (o DomainTpmPtrOutput) BackendEncryptionSecret() pulumi.StringPtrOutput

[Secret object](https://libvirt.org/formatsecret.html) for encrypting the TPM state

func (DomainTpmPtrOutput) BackendPersistentState added in v0.2.1 

func (o DomainTpmPtrOutput) BackendPersistentState() pulumi.BoolPtrOutput

Keep the TPM state when a transient domain is powered off or undefined

func (DomainTpmPtrOutput) BackendType added in v0.2.1 

func (o DomainTpmPtrOutput) BackendType() pulumi.StringPtrOutput

TPM backend, either `passthrough` or `emulator` (default: `emulator`)

Additional attributes when `backendType` is "passthrough":

func (DomainTpmPtrOutput) BackendVersion added in v0.2.1 

func (o DomainTpmPtrOutput) BackendVersion() pulumi.StringPtrOutput

TPM version

func (DomainTpmPtrOutput) Elem added in v0.2.1 

func (o DomainTpmPtrOutput) Elem() DomainTpmOutput

func (DomainTpmPtrOutput) ElementType added in v0.2.1 

func (DomainTpmPtrOutput) ElementType() reflect.Type

func (DomainTpmPtrOutput) Model added in v0.2.1 

func (o DomainTpmPtrOutput) Model() pulumi.StringPtrOutput

TPM model provided to the guest

func (DomainTpmPtrOutput) ToDomainTpmPtrOutput added in v0.2.1 

func (o DomainTpmPtrOutput) ToDomainTpmPtrOutput() DomainTpmPtrOutput

func (DomainTpmPtrOutput) ToDomainTpmPtrOutputWithContext added in v0.2.1 

func (o DomainTpmPtrOutput) ToDomainTpmPtrOutputWithContext(ctx context.Context) DomainTpmPtrOutput

type DomainVideo 

type DomainVideo struct {
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type *string `pulumi:"type"`
}

type DomainVideoArgs 

type DomainVideoArgs struct {
	// The type of hypervisor to use for the domain.  Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (DomainVideoArgs) ElementType 

func (DomainVideoArgs) ElementType() reflect.Type

func (DomainVideoArgs) ToDomainVideoOutput 

func (i DomainVideoArgs) ToDomainVideoOutput() DomainVideoOutput

func (DomainVideoArgs) ToDomainVideoOutputWithContext 

func (i DomainVideoArgs) ToDomainVideoOutputWithContext(ctx context.Context) DomainVideoOutput

func (DomainVideoArgs) ToDomainVideoPtrOutput 

func (i DomainVideoArgs) ToDomainVideoPtrOutput() DomainVideoPtrOutput

func (DomainVideoArgs) ToDomainVideoPtrOutputWithContext 

func (i DomainVideoArgs) ToDomainVideoPtrOutputWithContext(ctx context.Context) DomainVideoPtrOutput

type DomainVideoInput 

type DomainVideoInput interface {
	pulumi.Input

	ToDomainVideoOutput() DomainVideoOutput
	ToDomainVideoOutputWithContext(context.Context) DomainVideoOutput
}

DomainVideoInput is an input type that accepts DomainVideoArgs and DomainVideoOutput values. You can construct a concrete instance of `DomainVideoInput` via: 

DomainVideoArgs{...}

type DomainVideoOutput 

type DomainVideoOutput struct{ *pulumi.OutputState }

func (DomainVideoOutput) ElementType 

func (DomainVideoOutput) ElementType() reflect.Type

func (DomainVideoOutput) ToDomainVideoOutput 

func (o DomainVideoOutput) ToDomainVideoOutput() DomainVideoOutput

func (DomainVideoOutput) ToDomainVideoOutputWithContext 

func (o DomainVideoOutput) ToDomainVideoOutputWithContext(ctx context.Context) DomainVideoOutput

func (DomainVideoOutput) ToDomainVideoPtrOutput 

func (o DomainVideoOutput) ToDomainVideoPtrOutput() DomainVideoPtrOutput

func (DomainVideoOutput) ToDomainVideoPtrOutputWithContext 

func (o DomainVideoOutput) ToDomainVideoPtrOutputWithContext(ctx context.Context) DomainVideoPtrOutput

func (DomainVideoOutput) Type 

func (o DomainVideoOutput) Type() pulumi.StringPtrOutput

The type of hypervisor to use for the domain. Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)

type DomainVideoPtrInput 

type DomainVideoPtrInput interface {
	pulumi.Input

	ToDomainVideoPtrOutput() DomainVideoPtrOutput
	ToDomainVideoPtrOutputWithContext(context.Context) DomainVideoPtrOutput
}

DomainVideoPtrInput is an input type that accepts DomainVideoArgs, DomainVideoPtr and DomainVideoPtrOutput values. You can construct a concrete instance of `DomainVideoPtrInput` via: 

        DomainVideoArgs{...}

or:

        nil

func DomainVideoPtr 

func DomainVideoPtr(v *DomainVideoArgs) DomainVideoPtrInput

type DomainVideoPtrOutput 

type DomainVideoPtrOutput struct{ *pulumi.OutputState }

func (DomainVideoPtrOutput) Elem 

func (o DomainVideoPtrOutput) Elem() DomainVideoOutput

func (DomainVideoPtrOutput) ElementType 

func (DomainVideoPtrOutput) ElementType() reflect.Type

func (DomainVideoPtrOutput) ToDomainVideoPtrOutput 

func (o DomainVideoPtrOutput) ToDomainVideoPtrOutput() DomainVideoPtrOutput

func (DomainVideoPtrOutput) ToDomainVideoPtrOutputWithContext 

func (o DomainVideoPtrOutput) ToDomainVideoPtrOutputWithContext(ctx context.Context) DomainVideoPtrOutput

func (DomainVideoPtrOutput) Type 

func (o DomainVideoPtrOutput) Type() pulumi.StringPtrOutput

The type of hypervisor to use for the domain. Defaults to `kvm`, other values can be found [here](https://libvirt.org/formatdomain.html#id1)

type DomainXml 

type DomainXml struct {
	Xslt *string `pulumi:"xslt"`
}

type DomainXmlArgs 

type DomainXmlArgs struct {
	Xslt pulumi.StringPtrInput `pulumi:"xslt"`
}

func (DomainXmlArgs) ElementType 

func (DomainXmlArgs) ElementType() reflect.Type

func (DomainXmlArgs) ToDomainXmlOutput 

func (i DomainXmlArgs) ToDomainXmlOutput() DomainXmlOutput

func (DomainXmlArgs) ToDomainXmlOutputWithContext 

func (i DomainXmlArgs) ToDomainXmlOutputWithContext(ctx context.Context) DomainXmlOutput

func (DomainXmlArgs) ToDomainXmlPtrOutput 

func (i DomainXmlArgs) ToDomainXmlPtrOutput() DomainXmlPtrOutput

func (DomainXmlArgs) ToDomainXmlPtrOutputWithContext 

func (i DomainXmlArgs) ToDomainXmlPtrOutputWithContext(ctx context.Context) DomainXmlPtrOutput

type DomainXmlInput 

type DomainXmlInput interface {
	pulumi.Input

	ToDomainXmlOutput() DomainXmlOutput
	ToDomainXmlOutputWithContext(context.Context) DomainXmlOutput
}

DomainXmlInput is an input type that accepts DomainXmlArgs and DomainXmlOutput values. You can construct a concrete instance of `DomainXmlInput` via: 

DomainXmlArgs{...}

type DomainXmlOutput 

type DomainXmlOutput struct{ *pulumi.OutputState }

func (DomainXmlOutput) ElementType 

func (DomainXmlOutput) ElementType() reflect.Type

func (DomainXmlOutput) ToDomainXmlOutput 

func (o DomainXmlOutput) ToDomainXmlOutput() DomainXmlOutput

func (DomainXmlOutput) ToDomainXmlOutputWithContext 

func (o DomainXmlOutput) ToDomainXmlOutputWithContext(ctx context.Context) DomainXmlOutput

func (DomainXmlOutput) ToDomainXmlPtrOutput 

func (o DomainXmlOutput) ToDomainXmlPtrOutput() DomainXmlPtrOutput

func (DomainXmlOutput) ToDomainXmlPtrOutputWithContext 

func (o DomainXmlOutput) ToDomainXmlPtrOutputWithContext(ctx context.Context) DomainXmlPtrOutput

func (DomainXmlOutput) Xslt 

func (o DomainXmlOutput) Xslt() pulumi.StringPtrOutput

type DomainXmlPtrInput 

type DomainXmlPtrInput interface {
	pulumi.Input

	ToDomainXmlPtrOutput() DomainXmlPtrOutput
	ToDomainXmlPtrOutputWithContext(context.Context) DomainXmlPtrOutput
}

DomainXmlPtrInput is an input type that accepts DomainXmlArgs, DomainXmlPtr and DomainXmlPtrOutput values. You can construct a concrete instance of `DomainXmlPtrInput` via: 

        DomainXmlArgs{...}

or:

        nil

func DomainXmlPtr 

func DomainXmlPtr(v *DomainXmlArgs) DomainXmlPtrInput

type DomainXmlPtrOutput 

type DomainXmlPtrOutput struct{ *pulumi.OutputState }

func (DomainXmlPtrOutput) Elem 

func (o DomainXmlPtrOutput) Elem() DomainXmlOutput

func (DomainXmlPtrOutput) ElementType 

func (DomainXmlPtrOutput) ElementType() reflect.Type

func (DomainXmlPtrOutput) ToDomainXmlPtrOutput 

func (o DomainXmlPtrOutput) ToDomainXmlPtrOutput() DomainXmlPtrOutput

func (DomainXmlPtrOutput) ToDomainXmlPtrOutputWithContext 

func (o DomainXmlPtrOutput) ToDomainXmlPtrOutputWithContext(ctx context.Context) DomainXmlPtrOutput

func (DomainXmlPtrOutput) Xslt 

func (o DomainXmlPtrOutput) Xslt() pulumi.StringPtrOutput

type GetNetworkDnsHostTemplateArgs 

type GetNetworkDnsHostTemplateArgs struct {
	Hostname string `pulumi:"hostname"`
	Ip       string `pulumi:"ip"`
}

A collection of arguments for invoking getNetworkDnsHostTemplate.

type GetNetworkDnsHostTemplateOutputArgs added in v0.2.0 

type GetNetworkDnsHostTemplateOutputArgs struct {
	Hostname pulumi.StringInput `pulumi:"hostname"`
	Ip       pulumi.StringInput `pulumi:"ip"`
}

A collection of arguments for invoking getNetworkDnsHostTemplate.

func (GetNetworkDnsHostTemplateOutputArgs) ElementType added in v0.2.0 

func (GetNetworkDnsHostTemplateOutputArgs) ElementType() reflect.Type

type GetNetworkDnsHostTemplateResult 

type GetNetworkDnsHostTemplateResult struct {
	Hostname string `pulumi:"hostname"`
	// The provider-assigned unique ID for this managed resource.
	Id       string            `pulumi:"id"`
	Ip       string            `pulumi:"ip"`
	Rendered map[string]string `pulumi:"rendered"`
}

A collection of values returned by getNetworkDnsHostTemplate.

func GetNetworkDnsHostTemplate 

func GetNetworkDnsHostTemplate(ctx *pulumi.Context, args *GetNetworkDnsHostTemplateArgs, opts ...pulumi.InvokeOption) (*GetNetworkDnsHostTemplateResult, error)

type GetNetworkDnsHostTemplateResultOutput added in v0.2.0 

type GetNetworkDnsHostTemplateResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkDnsHostTemplate.

func GetNetworkDnsHostTemplateOutput added in v0.2.0 

func GetNetworkDnsHostTemplateOutput(ctx *pulumi.Context, args GetNetworkDnsHostTemplateOutputArgs, opts ...pulumi.InvokeOption) GetNetworkDnsHostTemplateResultOutput

func (GetNetworkDnsHostTemplateResultOutput) ElementType added in v0.2.0 

func (GetNetworkDnsHostTemplateResultOutput) ElementType() reflect.Type

func (GetNetworkDnsHostTemplateResultOutput) Hostname added in v0.2.0 

func (o GetNetworkDnsHostTemplateResultOutput) Hostname() pulumi.StringOutput

func (GetNetworkDnsHostTemplateResultOutput) Id added in v0.2.0 

func (o GetNetworkDnsHostTemplateResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkDnsHostTemplateResultOutput) Ip added in v0.2.0 

func (o GetNetworkDnsHostTemplateResultOutput) Ip() pulumi.StringOutput

func (GetNetworkDnsHostTemplateResultOutput) Rendered added in v0.2.0 

func (o GetNetworkDnsHostTemplateResultOutput) Rendered() pulumi.StringMapOutput

func (GetNetworkDnsHostTemplateResultOutput) ToGetNetworkDnsHostTemplateResultOutput added in v0.2.0 

func (o GetNetworkDnsHostTemplateResultOutput) ToGetNetworkDnsHostTemplateResultOutput() GetNetworkDnsHostTemplateResultOutput

func (GetNetworkDnsHostTemplateResultOutput) ToGetNetworkDnsHostTemplateResultOutputWithContext added in v0.2.0 

func (o GetNetworkDnsHostTemplateResultOutput) ToGetNetworkDnsHostTemplateResultOutputWithContext(ctx context.Context) GetNetworkDnsHostTemplateResultOutput

type GetNetworkDnsSrvTemplateArgs 

type GetNetworkDnsSrvTemplateArgs struct {
	Domain   *string `pulumi:"domain"`
	Port     *string `pulumi:"port"`
	Priority *string `pulumi:"priority"`
	Protocol string  `pulumi:"protocol"`
	Service  string  `pulumi:"service"`
	Target   *string `pulumi:"target"`
	Weight   *string `pulumi:"weight"`
}

A collection of arguments for invoking getNetworkDnsSrvTemplate.

type GetNetworkDnsSrvTemplateOutputArgs added in v0.2.0 

type GetNetworkDnsSrvTemplateOutputArgs struct {
	Domain   pulumi.StringPtrInput `pulumi:"domain"`
	Port     pulumi.StringPtrInput `pulumi:"port"`
	Priority pulumi.StringPtrInput `pulumi:"priority"`
	Protocol pulumi.StringInput    `pulumi:"protocol"`
	Service  pulumi.StringInput    `pulumi:"service"`
	Target   pulumi.StringPtrInput `pulumi:"target"`
	Weight   pulumi.StringPtrInput `pulumi:"weight"`
}

A collection of arguments for invoking getNetworkDnsSrvTemplate.

func (GetNetworkDnsSrvTemplateOutputArgs) ElementType added in v0.2.0 

func (GetNetworkDnsSrvTemplateOutputArgs) ElementType() reflect.Type

type GetNetworkDnsSrvTemplateResult 

type GetNetworkDnsSrvTemplateResult struct {
	Domain *string `pulumi:"domain"`
	// The provider-assigned unique ID for this managed resource.
	Id       string                 `pulumi:"id"`
	Port     *string                `pulumi:"port"`
	Priority *string                `pulumi:"priority"`
	Protocol string                 `pulumi:"protocol"`
	Rendered map[string]interface{} `pulumi:"rendered"`
	Service  string                 `pulumi:"service"`
	Target   *string                `pulumi:"target"`
	Weight   *string                `pulumi:"weight"`
}

A collection of values returned by getNetworkDnsSrvTemplate.

func GetNetworkDnsSrvTemplate 

func GetNetworkDnsSrvTemplate(ctx *pulumi.Context, args *GetNetworkDnsSrvTemplateArgs, opts ...pulumi.InvokeOption) (*GetNetworkDnsSrvTemplateResult, error)

type GetNetworkDnsSrvTemplateResultOutput added in v0.2.0 

type GetNetworkDnsSrvTemplateResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkDnsSrvTemplate.

func GetNetworkDnsSrvTemplateOutput added in v0.2.0 

func GetNetworkDnsSrvTemplateOutput(ctx *pulumi.Context, args GetNetworkDnsSrvTemplateOutputArgs, opts ...pulumi.InvokeOption) GetNetworkDnsSrvTemplateResultOutput

func (GetNetworkDnsSrvTemplateResultOutput) Domain added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Domain() pulumi.StringPtrOutput

func (GetNetworkDnsSrvTemplateResultOutput) ElementType added in v0.2.0 

func (GetNetworkDnsSrvTemplateResultOutput) ElementType() reflect.Type

func (GetNetworkDnsSrvTemplateResultOutput) Id added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkDnsSrvTemplateResultOutput) Port added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Port() pulumi.StringPtrOutput

func (GetNetworkDnsSrvTemplateResultOutput) Priority added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Priority() pulumi.StringPtrOutput

func (GetNetworkDnsSrvTemplateResultOutput) Protocol added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Protocol() pulumi.StringOutput

func (GetNetworkDnsSrvTemplateResultOutput) Rendered added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Rendered() pulumi.MapOutput

func (GetNetworkDnsSrvTemplateResultOutput) Service added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Service() pulumi.StringOutput

func (GetNetworkDnsSrvTemplateResultOutput) Target added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Target() pulumi.StringPtrOutput

func (GetNetworkDnsSrvTemplateResultOutput) ToGetNetworkDnsSrvTemplateResultOutput added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) ToGetNetworkDnsSrvTemplateResultOutput() GetNetworkDnsSrvTemplateResultOutput

func (GetNetworkDnsSrvTemplateResultOutput) ToGetNetworkDnsSrvTemplateResultOutputWithContext added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) ToGetNetworkDnsSrvTemplateResultOutputWithContext(ctx context.Context) GetNetworkDnsSrvTemplateResultOutput

func (GetNetworkDnsSrvTemplateResultOutput) Weight added in v0.2.0 

func (o GetNetworkDnsSrvTemplateResultOutput) Weight() pulumi.StringPtrOutput

type GetNetworkDnsmasqOptionsTemplateArgs added in v0.2.0 

type GetNetworkDnsmasqOptionsTemplateArgs struct {
	OptionName  string  `pulumi:"optionName"`
	OptionValue *string `pulumi:"optionValue"`
}

A collection of arguments for invoking getNetworkDnsmasqOptionsTemplate.

type GetNetworkDnsmasqOptionsTemplateOutputArgs added in v0.2.0 

type GetNetworkDnsmasqOptionsTemplateOutputArgs struct {
	OptionName  pulumi.StringInput    `pulumi:"optionName"`
	OptionValue pulumi.StringPtrInput `pulumi:"optionValue"`
}

A collection of arguments for invoking getNetworkDnsmasqOptionsTemplate.

func (GetNetworkDnsmasqOptionsTemplateOutputArgs) ElementType added in v0.2.0 

func (GetNetworkDnsmasqOptionsTemplateOutputArgs) ElementType() reflect.Type

type GetNetworkDnsmasqOptionsTemplateResult added in v0.2.0 

type GetNetworkDnsmasqOptionsTemplateResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id          string            `pulumi:"id"`
	OptionName  string            `pulumi:"optionName"`
	OptionValue *string           `pulumi:"optionValue"`
	Rendered    map[string]string `pulumi:"rendered"`
}

A collection of values returned by getNetworkDnsmasqOptionsTemplate.

func GetNetworkDnsmasqOptionsTemplate added in v0.2.0 

func GetNetworkDnsmasqOptionsTemplate(ctx *pulumi.Context, args *GetNetworkDnsmasqOptionsTemplateArgs, opts ...pulumi.InvokeOption) (*GetNetworkDnsmasqOptionsTemplateResult, error)

type GetNetworkDnsmasqOptionsTemplateResultOutput added in v0.2.0 

type GetNetworkDnsmasqOptionsTemplateResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNetworkDnsmasqOptionsTemplate.

func GetNetworkDnsmasqOptionsTemplateOutput added in v0.2.0 

func GetNetworkDnsmasqOptionsTemplateOutput(ctx *pulumi.Context, args GetNetworkDnsmasqOptionsTemplateOutputArgs, opts ...pulumi.InvokeOption) GetNetworkDnsmasqOptionsTemplateResultOutput

func (GetNetworkDnsmasqOptionsTemplateResultOutput) ElementType added in v0.2.0 

func (GetNetworkDnsmasqOptionsTemplateResultOutput) ElementType() reflect.Type

func (GetNetworkDnsmasqOptionsTemplateResultOutput) Id added in v0.2.0 

func (o GetNetworkDnsmasqOptionsTemplateResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetNetworkDnsmasqOptionsTemplateResultOutput) OptionName added in v0.2.0 

func (o GetNetworkDnsmasqOptionsTemplateResultOutput) OptionName() pulumi.StringOutput

func (GetNetworkDnsmasqOptionsTemplateResultOutput) OptionValue added in v0.2.0 

func (o GetNetworkDnsmasqOptionsTemplateResultOutput) OptionValue() pulumi.StringPtrOutput

func (GetNetworkDnsmasqOptionsTemplateResultOutput) Rendered added in v0.2.0 

func (o GetNetworkDnsmasqOptionsTemplateResultOutput) Rendered() pulumi.StringMapOutput

func (GetNetworkDnsmasqOptionsTemplateResultOutput) ToGetNetworkDnsmasqOptionsTemplateResultOutput added in v0.2.0 

func (o GetNetworkDnsmasqOptionsTemplateResultOutput) ToGetNetworkDnsmasqOptionsTemplateResultOutput() GetNetworkDnsmasqOptionsTemplateResultOutput

func (GetNetworkDnsmasqOptionsTemplateResultOutput) ToGetNetworkDnsmasqOptionsTemplateResultOutputWithContext added in v0.2.0 

func (o GetNetworkDnsmasqOptionsTemplateResultOutput) ToGetNetworkDnsmasqOptionsTemplateResultOutputWithContext(ctx context.Context) GetNetworkDnsmasqOptionsTemplateResultOutput

type Ignition 

type Ignition struct {
	pulumi.CustomResourceState

	Content pulumi.StringOutput `pulumi:"content"`
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringOutput `pulumi:"name"`
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	Pool pulumi.StringPtrOutput `pulumi:"pool"`
}

func GetIgnition 

func GetIgnition(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IgnitionState, opts ...pulumi.ResourceOption) (*Ignition, error)

GetIgnition gets an existing Ignition resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIgnition 

func NewIgnition(ctx *pulumi.Context,
	name string, args *IgnitionArgs, opts ...pulumi.ResourceOption) (*Ignition, error)

NewIgnition registers a new resource with the given unique name, arguments, and options.

func (*Ignition) ElementType 

func (*Ignition) ElementType() reflect.Type

func (*Ignition) ToIgnitionOutput 

func (i *Ignition) ToIgnitionOutput() IgnitionOutput

func (*Ignition) ToIgnitionOutputWithContext 

func (i *Ignition) ToIgnitionOutputWithContext(ctx context.Context) IgnitionOutput

type IgnitionArgs 

type IgnitionArgs struct {
	Content pulumi.StringInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	Pool pulumi.StringPtrInput
}

The set of arguments for constructing a Ignition resource.

func (IgnitionArgs) ElementType 

func (IgnitionArgs) ElementType() reflect.Type

type IgnitionArray 

type IgnitionArray []IgnitionInput

func (IgnitionArray) ElementType 

func (IgnitionArray) ElementType() reflect.Type

func (IgnitionArray) ToIgnitionArrayOutput 

func (i IgnitionArray) ToIgnitionArrayOutput() IgnitionArrayOutput

func (IgnitionArray) ToIgnitionArrayOutputWithContext 

func (i IgnitionArray) ToIgnitionArrayOutputWithContext(ctx context.Context) IgnitionArrayOutput

type IgnitionArrayInput 

type IgnitionArrayInput interface {
	pulumi.Input

	ToIgnitionArrayOutput() IgnitionArrayOutput
	ToIgnitionArrayOutputWithContext(context.Context) IgnitionArrayOutput
}

IgnitionArrayInput is an input type that accepts IgnitionArray and IgnitionArrayOutput values. You can construct a concrete instance of `IgnitionArrayInput` via: 

IgnitionArray{ IgnitionArgs{...} }

type IgnitionArrayOutput 

type IgnitionArrayOutput struct{ *pulumi.OutputState }

func (IgnitionArrayOutput) ElementType 

func (IgnitionArrayOutput) ElementType() reflect.Type

func (IgnitionArrayOutput) Index 

func (o IgnitionArrayOutput) Index(i pulumi.IntInput) IgnitionOutput

func (IgnitionArrayOutput) ToIgnitionArrayOutput 

func (o IgnitionArrayOutput) ToIgnitionArrayOutput() IgnitionArrayOutput

func (IgnitionArrayOutput) ToIgnitionArrayOutputWithContext 

func (o IgnitionArrayOutput) ToIgnitionArrayOutputWithContext(ctx context.Context) IgnitionArrayOutput

type IgnitionInput 

type IgnitionInput interface {
	pulumi.Input

	ToIgnitionOutput() IgnitionOutput
	ToIgnitionOutputWithContext(ctx context.Context) IgnitionOutput
}

type IgnitionMap 

type IgnitionMap map[string]IgnitionInput

func (IgnitionMap) ElementType 

func (IgnitionMap) ElementType() reflect.Type

func (IgnitionMap) ToIgnitionMapOutput 

func (i IgnitionMap) ToIgnitionMapOutput() IgnitionMapOutput

func (IgnitionMap) ToIgnitionMapOutputWithContext 

func (i IgnitionMap) ToIgnitionMapOutputWithContext(ctx context.Context) IgnitionMapOutput

type IgnitionMapInput 

type IgnitionMapInput interface {
	pulumi.Input

	ToIgnitionMapOutput() IgnitionMapOutput
	ToIgnitionMapOutputWithContext(context.Context) IgnitionMapOutput
}

IgnitionMapInput is an input type that accepts IgnitionMap and IgnitionMapOutput values. You can construct a concrete instance of `IgnitionMapInput` via: 

IgnitionMap{ "key": IgnitionArgs{...} }

type IgnitionMapOutput 

type IgnitionMapOutput struct{ *pulumi.OutputState }

func (IgnitionMapOutput) ElementType 

func (IgnitionMapOutput) ElementType() reflect.Type

func (IgnitionMapOutput) MapIndex 

func (o IgnitionMapOutput) MapIndex(k pulumi.StringInput) IgnitionOutput

func (IgnitionMapOutput) ToIgnitionMapOutput 

func (o IgnitionMapOutput) ToIgnitionMapOutput() IgnitionMapOutput

func (IgnitionMapOutput) ToIgnitionMapOutputWithContext 

func (o IgnitionMapOutput) ToIgnitionMapOutputWithContext(ctx context.Context) IgnitionMapOutput

type IgnitionOutput 

type IgnitionOutput struct{ *pulumi.OutputState }

func (IgnitionOutput) Content added in v0.3.0 

func (o IgnitionOutput) Content() pulumi.StringOutput

func (IgnitionOutput) ElementType 

func (IgnitionOutput) ElementType() reflect.Type

func (IgnitionOutput) Name added in v0.3.0 

func (o IgnitionOutput) Name() pulumi.StringOutput

A unique name for the resource, required by libvirt.

func (IgnitionOutput) Pool added in v0.3.0 

func (o IgnitionOutput) Pool() pulumi.StringPtrOutput

The pool where the resource will be created. If not given, the `default` pool will be used.

func (IgnitionOutput) ToIgnitionOutput 

func (o IgnitionOutput) ToIgnitionOutput() IgnitionOutput

func (IgnitionOutput) ToIgnitionOutputWithContext 

func (o IgnitionOutput) ToIgnitionOutputWithContext(ctx context.Context) IgnitionOutput

type IgnitionState 

type IgnitionState struct {
	Content pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// The pool where the resource will be created.
	// If not given, the `default` pool will be used.
	Pool pulumi.StringPtrInput
}

func (IgnitionState) ElementType 

func (IgnitionState) ElementType() reflect.Type

type Network 

type Network struct {
	pulumi.CustomResourceState

	// A list of (0 or 1) IPv4 and (0 or 1) IPv6 subnets in
	// CIDR notation.  This defines the subnets associated to that network.
	// This argument is also used to define the address on the real host.
	// If `dhcp {  enabled = true }` addresses is also used to define the address range served by
	// the DHCP server.
	// No DHCP server will be started if `addresses` is omitted.
	Addresses pulumi.StringArrayOutput `pulumi:"addresses"`
	// Set to `true` to start the network on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolOutput `pulumi:"autostart"`
	// The bridge device defines the name of a bridge
	// device which will be used to construct the virtual network (when not provided,
	// it will be automatically obtained by libvirt in `none`, `nat`, `route` and `open` modes).
	Bridge pulumi.StringOutput `pulumi:"bridge"`
	// DHCP configuration.
	// You need to use it in conjuction with the adresses variable.
	Dhcp NetworkDhcpOutput `pulumi:"dhcp"`
	// configuration of DNS specific settings for the network
	Dns NetworkDnsOutput `pulumi:"dns"`
	// configuration of Dnsmasq options for the network
	// You need to provide a list of option name and value pairs.
	DnsmasqOptions NetworkDnsmasqOptionsPtrOutput `pulumi:"dnsmasqOptions"`
	// The domain used by the DNS server.
	Domain pulumi.StringPtrOutput `pulumi:"domain"`
	// One of:
	Mode pulumi.StringPtrOutput `pulumi:"mode"`
	// The MTU to set for the underlying network interfaces. When
	// not supplied, libvirt will use the default for the interface, usually 1500.
	// Libvirt version 5.1 and greater will advertise this value to nodes via DHCP.
	Mtu pulumi.IntPtrOutput `pulumi:"mtu"`
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// a list of static routes. A `cidr` and a `gateway` must
	// be provided. The `gateway` must be reachable via the bridge interface.
	Routes NetworkRouteArrayOutput `pulumi:"routes"`
	Xml    NetworkXmlPtrOutput     `pulumi:"xml"`
}

Manages a VM network resource within libvirt. For more information see [the official documentation](https://libvirt.org/formatnetwork.html).

func GetNetwork 

func GetNetwork(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NetworkState, opts ...pulumi.ResourceOption) (*Network, error)

GetNetwork gets an existing Network resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewNetwork 

func NewNetwork(ctx *pulumi.Context,
	name string, args *NetworkArgs, opts ...pulumi.ResourceOption) (*Network, error)

NewNetwork registers a new resource with the given unique name, arguments, and options.

func (*Network) ElementType 

func (*Network) ElementType() reflect.Type

func (*Network) ToNetworkOutput 

func (i *Network) ToNetworkOutput() NetworkOutput

func (*Network) ToNetworkOutputWithContext 

func (i *Network) ToNetworkOutputWithContext(ctx context.Context) NetworkOutput

type NetworkArgs 

type NetworkArgs struct {
	// A list of (0 or 1) IPv4 and (0 or 1) IPv6 subnets in
	// CIDR notation.  This defines the subnets associated to that network.
	// This argument is also used to define the address on the real host.
	// If `dhcp {  enabled = true }` addresses is also used to define the address range served by
	// the DHCP server.
	// No DHCP server will be started if `addresses` is omitted.
	Addresses pulumi.StringArrayInput
	// Set to `true` to start the network on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolPtrInput
	// The bridge device defines the name of a bridge
	// device which will be used to construct the virtual network (when not provided,
	// it will be automatically obtained by libvirt in `none`, `nat`, `route` and `open` modes).
	Bridge pulumi.StringPtrInput
	// DHCP configuration.
	// You need to use it in conjuction with the adresses variable.
	Dhcp NetworkDhcpPtrInput
	// configuration of DNS specific settings for the network
	Dns NetworkDnsPtrInput
	// configuration of Dnsmasq options for the network
	// You need to provide a list of option name and value pairs.
	DnsmasqOptions NetworkDnsmasqOptionsPtrInput
	// The domain used by the DNS server.
	Domain pulumi.StringPtrInput
	// One of:
	Mode pulumi.StringPtrInput
	// The MTU to set for the underlying network interfaces. When
	// not supplied, libvirt will use the default for the interface, usually 1500.
	// Libvirt version 5.1 and greater will advertise this value to nodes via DHCP.
	Mtu pulumi.IntPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// a list of static routes. A `cidr` and a `gateway` must
	// be provided. The `gateway` must be reachable via the bridge interface.
	Routes NetworkRouteArrayInput
	Xml    NetworkXmlPtrInput
}

The set of arguments for constructing a Network resource.

func (NetworkArgs) ElementType 

func (NetworkArgs) ElementType() reflect.Type

type NetworkArray 

type NetworkArray []NetworkInput

func (NetworkArray) ElementType 

func (NetworkArray) ElementType() reflect.Type

func (NetworkArray) ToNetworkArrayOutput 

func (i NetworkArray) ToNetworkArrayOutput() NetworkArrayOutput

func (NetworkArray) ToNetworkArrayOutputWithContext 

func (i NetworkArray) ToNetworkArrayOutputWithContext(ctx context.Context) NetworkArrayOutput

type NetworkArrayInput 

type NetworkArrayInput interface {
	pulumi.Input

	ToNetworkArrayOutput() NetworkArrayOutput
	ToNetworkArrayOutputWithContext(context.Context) NetworkArrayOutput
}

NetworkArrayInput is an input type that accepts NetworkArray and NetworkArrayOutput values. You can construct a concrete instance of `NetworkArrayInput` via: 

NetworkArray{ NetworkArgs{...} }

type NetworkArrayOutput 

type NetworkArrayOutput struct{ *pulumi.OutputState }

func (NetworkArrayOutput) ElementType 

func (NetworkArrayOutput) ElementType() reflect.Type

func (NetworkArrayOutput) Index 

func (o NetworkArrayOutput) Index(i pulumi.IntInput) NetworkOutput

func (NetworkArrayOutput) ToNetworkArrayOutput 

func (o NetworkArrayOutput) ToNetworkArrayOutput() NetworkArrayOutput

func (NetworkArrayOutput) ToNetworkArrayOutputWithContext 

func (o NetworkArrayOutput) ToNetworkArrayOutputWithContext(ctx context.Context) NetworkArrayOutput

type NetworkDhcp 

type NetworkDhcp struct {
	// when false, disable the DHCP server
	Enabled *bool `pulumi:"enabled"`
}

type NetworkDhcpArgs 

type NetworkDhcpArgs struct {
	// when false, disable the DHCP server
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
}

func (NetworkDhcpArgs) ElementType 

func (NetworkDhcpArgs) ElementType() reflect.Type

func (NetworkDhcpArgs) ToNetworkDhcpOutput 

func (i NetworkDhcpArgs) ToNetworkDhcpOutput() NetworkDhcpOutput

func (NetworkDhcpArgs) ToNetworkDhcpOutputWithContext 

func (i NetworkDhcpArgs) ToNetworkDhcpOutputWithContext(ctx context.Context) NetworkDhcpOutput

func (NetworkDhcpArgs) ToNetworkDhcpPtrOutput 

func (i NetworkDhcpArgs) ToNetworkDhcpPtrOutput() NetworkDhcpPtrOutput

func (NetworkDhcpArgs) ToNetworkDhcpPtrOutputWithContext 

func (i NetworkDhcpArgs) ToNetworkDhcpPtrOutputWithContext(ctx context.Context) NetworkDhcpPtrOutput

type NetworkDhcpInput 

type NetworkDhcpInput interface {
	pulumi.Input

	ToNetworkDhcpOutput() NetworkDhcpOutput
	ToNetworkDhcpOutputWithContext(context.Context) NetworkDhcpOutput
}

NetworkDhcpInput is an input type that accepts NetworkDhcpArgs and NetworkDhcpOutput values. You can construct a concrete instance of `NetworkDhcpInput` via: 

NetworkDhcpArgs{...}

type NetworkDhcpOutput 

type NetworkDhcpOutput struct{ *pulumi.OutputState }

func (NetworkDhcpOutput) ElementType 

func (NetworkDhcpOutput) ElementType() reflect.Type

func (NetworkDhcpOutput) Enabled 

func (o NetworkDhcpOutput) Enabled() pulumi.BoolPtrOutput

when false, disable the DHCP server

func (NetworkDhcpOutput) ToNetworkDhcpOutput 

func (o NetworkDhcpOutput) ToNetworkDhcpOutput() NetworkDhcpOutput

func (NetworkDhcpOutput) ToNetworkDhcpOutputWithContext 

func (o NetworkDhcpOutput) ToNetworkDhcpOutputWithContext(ctx context.Context) NetworkDhcpOutput

func (NetworkDhcpOutput) ToNetworkDhcpPtrOutput 

func (o NetworkDhcpOutput) ToNetworkDhcpPtrOutput() NetworkDhcpPtrOutput

func (NetworkDhcpOutput) ToNetworkDhcpPtrOutputWithContext 

func (o NetworkDhcpOutput) ToNetworkDhcpPtrOutputWithContext(ctx context.Context) NetworkDhcpPtrOutput

type NetworkDhcpPtrInput 

type NetworkDhcpPtrInput interface {
	pulumi.Input

	ToNetworkDhcpPtrOutput() NetworkDhcpPtrOutput
	ToNetworkDhcpPtrOutputWithContext(context.Context) NetworkDhcpPtrOutput
}

NetworkDhcpPtrInput is an input type that accepts NetworkDhcpArgs, NetworkDhcpPtr and NetworkDhcpPtrOutput values. You can construct a concrete instance of `NetworkDhcpPtrInput` via: 

        NetworkDhcpArgs{...}

or:

        nil

func NetworkDhcpPtr 

func NetworkDhcpPtr(v *NetworkDhcpArgs) NetworkDhcpPtrInput

type NetworkDhcpPtrOutput 

type NetworkDhcpPtrOutput struct{ *pulumi.OutputState }

func (NetworkDhcpPtrOutput) Elem 

func (o NetworkDhcpPtrOutput) Elem() NetworkDhcpOutput

func (NetworkDhcpPtrOutput) ElementType 

func (NetworkDhcpPtrOutput) ElementType() reflect.Type

func (NetworkDhcpPtrOutput) Enabled 

func (o NetworkDhcpPtrOutput) Enabled() pulumi.BoolPtrOutput

when false, disable the DHCP server

func (NetworkDhcpPtrOutput) ToNetworkDhcpPtrOutput 

func (o NetworkDhcpPtrOutput) ToNetworkDhcpPtrOutput() NetworkDhcpPtrOutput

func (NetworkDhcpPtrOutput) ToNetworkDhcpPtrOutputWithContext 

func (o NetworkDhcpPtrOutput) ToNetworkDhcpPtrOutputWithContext(ctx context.Context) NetworkDhcpPtrOutput

type NetworkDns 

type NetworkDns struct {
	// when false, disable the DHCP server
	Enabled *bool `pulumi:"enabled"`
	// Either `address`, `domain`, or both must be set
	Forwarders []NetworkDnsForwarder `pulumi:"forwarders"`
	// a DNS host entry block. You can have one or more of these
	// blocks in your DNS definition. You must specify both `ip` and `hostname`.
	//
	// An advanced example of round-robin DNS (using DNS host templates) follows:
	Hosts []NetworkDnsHost `pulumi:"hosts"`
	// true/false: true means 'do not forward unresolved requests for this domain to the part DNS server
	LocalOnly *bool `pulumi:"localOnly"`
	// a DNS SRV entry block. You can have one or more of these blocks
	// in your DNS definition. You must specify `service` and `protocol`.
	Srvs []NetworkDnsSrv `pulumi:"srvs"`
}

type NetworkDnsArgs 

type NetworkDnsArgs struct {
	// when false, disable the DHCP server
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Either `address`, `domain`, or both must be set
	Forwarders NetworkDnsForwarderArrayInput `pulumi:"forwarders"`
	// a DNS host entry block. You can have one or more of these
	// blocks in your DNS definition. You must specify both `ip` and `hostname`.
	//
	// An advanced example of round-robin DNS (using DNS host templates) follows:
	Hosts NetworkDnsHostArrayInput `pulumi:"hosts"`
	// true/false: true means 'do not forward unresolved requests for this domain to the part DNS server
	LocalOnly pulumi.BoolPtrInput `pulumi:"localOnly"`
	// a DNS SRV entry block. You can have one or more of these blocks
	// in your DNS definition. You must specify `service` and `protocol`.
	Srvs NetworkDnsSrvArrayInput `pulumi:"srvs"`
}

func (NetworkDnsArgs) ElementType 

func (NetworkDnsArgs) ElementType() reflect.Type

func (NetworkDnsArgs) ToNetworkDnsOutput 

func (i NetworkDnsArgs) ToNetworkDnsOutput() NetworkDnsOutput

func (NetworkDnsArgs) ToNetworkDnsOutputWithContext 

func (i NetworkDnsArgs) ToNetworkDnsOutputWithContext(ctx context.Context) NetworkDnsOutput

func (NetworkDnsArgs) ToNetworkDnsPtrOutput 

func (i NetworkDnsArgs) ToNetworkDnsPtrOutput() NetworkDnsPtrOutput

func (NetworkDnsArgs) ToNetworkDnsPtrOutputWithContext 

func (i NetworkDnsArgs) ToNetworkDnsPtrOutputWithContext(ctx context.Context) NetworkDnsPtrOutput

type NetworkDnsForwarder 

type NetworkDnsForwarder struct {
	Address *string `pulumi:"address"`
	// The domain used by the DNS server.
	Domain *string `pulumi:"domain"`
}

type NetworkDnsForwarderArgs 

type NetworkDnsForwarderArgs struct {
	Address pulumi.StringPtrInput `pulumi:"address"`
	// The domain used by the DNS server.
	Domain pulumi.StringPtrInput `pulumi:"domain"`
}

func (NetworkDnsForwarderArgs) ElementType 

func (NetworkDnsForwarderArgs) ElementType() reflect.Type

func (NetworkDnsForwarderArgs) ToNetworkDnsForwarderOutput 

func (i NetworkDnsForwarderArgs) ToNetworkDnsForwarderOutput() NetworkDnsForwarderOutput

func (NetworkDnsForwarderArgs) ToNetworkDnsForwarderOutputWithContext 

func (i NetworkDnsForwarderArgs) ToNetworkDnsForwarderOutputWithContext(ctx context.Context) NetworkDnsForwarderOutput

type NetworkDnsForwarderArray 

type NetworkDnsForwarderArray []NetworkDnsForwarderInput

func (NetworkDnsForwarderArray) ElementType 

func (NetworkDnsForwarderArray) ElementType() reflect.Type

func (NetworkDnsForwarderArray) ToNetworkDnsForwarderArrayOutput 

func (i NetworkDnsForwarderArray) ToNetworkDnsForwarderArrayOutput() NetworkDnsForwarderArrayOutput

func (NetworkDnsForwarderArray) ToNetworkDnsForwarderArrayOutputWithContext 

func (i NetworkDnsForwarderArray) ToNetworkDnsForwarderArrayOutputWithContext(ctx context.Context) NetworkDnsForwarderArrayOutput

type NetworkDnsForwarderArrayInput 

type NetworkDnsForwarderArrayInput interface {
	pulumi.Input

	ToNetworkDnsForwarderArrayOutput() NetworkDnsForwarderArrayOutput
	ToNetworkDnsForwarderArrayOutputWithContext(context.Context) NetworkDnsForwarderArrayOutput
}

NetworkDnsForwarderArrayInput is an input type that accepts NetworkDnsForwarderArray and NetworkDnsForwarderArrayOutput values. You can construct a concrete instance of `NetworkDnsForwarderArrayInput` via: 

NetworkDnsForwarderArray{ NetworkDnsForwarderArgs{...} }

type NetworkDnsForwarderArrayOutput 

type NetworkDnsForwarderArrayOutput struct{ *pulumi.OutputState }

func (NetworkDnsForwarderArrayOutput) ElementType 

func (NetworkDnsForwarderArrayOutput) ElementType() reflect.Type

func (NetworkDnsForwarderArrayOutput) Index 

func (o NetworkDnsForwarderArrayOutput) Index(i pulumi.IntInput) NetworkDnsForwarderOutput

func (NetworkDnsForwarderArrayOutput) ToNetworkDnsForwarderArrayOutput 

func (o NetworkDnsForwarderArrayOutput) ToNetworkDnsForwarderArrayOutput() NetworkDnsForwarderArrayOutput

func (NetworkDnsForwarderArrayOutput) ToNetworkDnsForwarderArrayOutputWithContext 

func (o NetworkDnsForwarderArrayOutput) ToNetworkDnsForwarderArrayOutputWithContext(ctx context.Context) NetworkDnsForwarderArrayOutput

type NetworkDnsForwarderInput 

type NetworkDnsForwarderInput interface {
	pulumi.Input

	ToNetworkDnsForwarderOutput() NetworkDnsForwarderOutput
	ToNetworkDnsForwarderOutputWithContext(context.Context) NetworkDnsForwarderOutput
}

NetworkDnsForwarderInput is an input type that accepts NetworkDnsForwarderArgs and NetworkDnsForwarderOutput values. You can construct a concrete instance of `NetworkDnsForwarderInput` via: 

NetworkDnsForwarderArgs{...}

type NetworkDnsForwarderOutput 

type NetworkDnsForwarderOutput struct{ *pulumi.OutputState }

func (NetworkDnsForwarderOutput) Address 

func (o NetworkDnsForwarderOutput) Address() pulumi.StringPtrOutput

func (NetworkDnsForwarderOutput) Domain 

func (o NetworkDnsForwarderOutput) Domain() pulumi.StringPtrOutput

The domain used by the DNS server.

func (NetworkDnsForwarderOutput) ElementType 

func (NetworkDnsForwarderOutput) ElementType() reflect.Type

func (NetworkDnsForwarderOutput) ToNetworkDnsForwarderOutput 

func (o NetworkDnsForwarderOutput) ToNetworkDnsForwarderOutput() NetworkDnsForwarderOutput

func (NetworkDnsForwarderOutput) ToNetworkDnsForwarderOutputWithContext 

func (o NetworkDnsForwarderOutput) ToNetworkDnsForwarderOutputWithContext(ctx context.Context) NetworkDnsForwarderOutput

type NetworkDnsHost 

type NetworkDnsHost struct {
	Hostname *string `pulumi:"hostname"`
	Ip       *string `pulumi:"ip"`
}

type NetworkDnsHostArgs 

type NetworkDnsHostArgs struct {
	Hostname pulumi.StringPtrInput `pulumi:"hostname"`
	Ip       pulumi.StringPtrInput `pulumi:"ip"`
}

func (NetworkDnsHostArgs) ElementType 

func (NetworkDnsHostArgs) ElementType() reflect.Type

func (NetworkDnsHostArgs) ToNetworkDnsHostOutput 

func (i NetworkDnsHostArgs) ToNetworkDnsHostOutput() NetworkDnsHostOutput

func (NetworkDnsHostArgs) ToNetworkDnsHostOutputWithContext 

func (i NetworkDnsHostArgs) ToNetworkDnsHostOutputWithContext(ctx context.Context) NetworkDnsHostOutput

type NetworkDnsHostArray 

type NetworkDnsHostArray []NetworkDnsHostInput

func (NetworkDnsHostArray) ElementType 

func (NetworkDnsHostArray) ElementType() reflect.Type

func (NetworkDnsHostArray) ToNetworkDnsHostArrayOutput 

func (i NetworkDnsHostArray) ToNetworkDnsHostArrayOutput() NetworkDnsHostArrayOutput

func (NetworkDnsHostArray) ToNetworkDnsHostArrayOutputWithContext 

func (i NetworkDnsHostArray) ToNetworkDnsHostArrayOutputWithContext(ctx context.Context) NetworkDnsHostArrayOutput

type NetworkDnsHostArrayInput 

type NetworkDnsHostArrayInput interface {
	pulumi.Input

	ToNetworkDnsHostArrayOutput() NetworkDnsHostArrayOutput
	ToNetworkDnsHostArrayOutputWithContext(context.Context) NetworkDnsHostArrayOutput
}

NetworkDnsHostArrayInput is an input type that accepts NetworkDnsHostArray and NetworkDnsHostArrayOutput values. You can construct a concrete instance of `NetworkDnsHostArrayInput` via: 

NetworkDnsHostArray{ NetworkDnsHostArgs{...} }

type NetworkDnsHostArrayOutput 

type NetworkDnsHostArrayOutput struct{ *pulumi.OutputState }

func (NetworkDnsHostArrayOutput) ElementType 

func (NetworkDnsHostArrayOutput) ElementType() reflect.Type

func (NetworkDnsHostArrayOutput) Index 

func (o NetworkDnsHostArrayOutput) Index(i pulumi.IntInput) NetworkDnsHostOutput

func (NetworkDnsHostArrayOutput) ToNetworkDnsHostArrayOutput 

func (o NetworkDnsHostArrayOutput) ToNetworkDnsHostArrayOutput() NetworkDnsHostArrayOutput

func (NetworkDnsHostArrayOutput) ToNetworkDnsHostArrayOutputWithContext 

func (o NetworkDnsHostArrayOutput) ToNetworkDnsHostArrayOutputWithContext(ctx context.Context) NetworkDnsHostArrayOutput

type NetworkDnsHostInput 

type NetworkDnsHostInput interface {
	pulumi.Input

	ToNetworkDnsHostOutput() NetworkDnsHostOutput
	ToNetworkDnsHostOutputWithContext(context.Context) NetworkDnsHostOutput
}

NetworkDnsHostInput is an input type that accepts NetworkDnsHostArgs and NetworkDnsHostOutput values. You can construct a concrete instance of `NetworkDnsHostInput` via: 

NetworkDnsHostArgs{...}

type NetworkDnsHostOutput 

type NetworkDnsHostOutput struct{ *pulumi.OutputState }

func (NetworkDnsHostOutput) ElementType 

func (NetworkDnsHostOutput) ElementType() reflect.Type

func (NetworkDnsHostOutput) Hostname 

func (o NetworkDnsHostOutput) Hostname() pulumi.StringPtrOutput

func (NetworkDnsHostOutput) Ip 

func (o NetworkDnsHostOutput) Ip() pulumi.StringPtrOutput

func (NetworkDnsHostOutput) ToNetworkDnsHostOutput 

func (o NetworkDnsHostOutput) ToNetworkDnsHostOutput() NetworkDnsHostOutput

func (NetworkDnsHostOutput) ToNetworkDnsHostOutputWithContext 

func (o NetworkDnsHostOutput) ToNetworkDnsHostOutputWithContext(ctx context.Context) NetworkDnsHostOutput

type NetworkDnsInput 

type NetworkDnsInput interface {
	pulumi.Input

	ToNetworkDnsOutput() NetworkDnsOutput
	ToNetworkDnsOutputWithContext(context.Context) NetworkDnsOutput
}

NetworkDnsInput is an input type that accepts NetworkDnsArgs and NetworkDnsOutput values. You can construct a concrete instance of `NetworkDnsInput` via: 

NetworkDnsArgs{...}

type NetworkDnsOutput 

type NetworkDnsOutput struct{ *pulumi.OutputState }

func (NetworkDnsOutput) ElementType 

func (NetworkDnsOutput) ElementType() reflect.Type

func (NetworkDnsOutput) Enabled 

func (o NetworkDnsOutput) Enabled() pulumi.BoolPtrOutput

when false, disable the DHCP server

func (NetworkDnsOutput) Forwarders 

func (o NetworkDnsOutput) Forwarders() NetworkDnsForwarderArrayOutput

Either `address`, `domain`, or both must be set

func (NetworkDnsOutput) Hosts 

func (o NetworkDnsOutput) Hosts() NetworkDnsHostArrayOutput

a DNS host entry block. You can have one or more of these blocks in your DNS definition. You must specify both `ip` and `hostname`.

An advanced example of round-robin DNS (using DNS host templates) follows:

func (NetworkDnsOutput) LocalOnly 

func (o NetworkDnsOutput) LocalOnly() pulumi.BoolPtrOutput

true/false: true means 'do not forward unresolved requests for this domain to the part DNS server

func (NetworkDnsOutput) Srvs 

func (o NetworkDnsOutput) Srvs() NetworkDnsSrvArrayOutput

a DNS SRV entry block. You can have one or more of these blocks in your DNS definition. You must specify `service` and `protocol`.

func (NetworkDnsOutput) ToNetworkDnsOutput 

func (o NetworkDnsOutput) ToNetworkDnsOutput() NetworkDnsOutput

func (NetworkDnsOutput) ToNetworkDnsOutputWithContext 

func (o NetworkDnsOutput) ToNetworkDnsOutputWithContext(ctx context.Context) NetworkDnsOutput

func (NetworkDnsOutput) ToNetworkDnsPtrOutput 

func (o NetworkDnsOutput) ToNetworkDnsPtrOutput() NetworkDnsPtrOutput

func (NetworkDnsOutput) ToNetworkDnsPtrOutputWithContext 

func (o NetworkDnsOutput) ToNetworkDnsPtrOutputWithContext(ctx context.Context) NetworkDnsPtrOutput

type NetworkDnsPtrInput 

type NetworkDnsPtrInput interface {
	pulumi.Input

	ToNetworkDnsPtrOutput() NetworkDnsPtrOutput
	ToNetworkDnsPtrOutputWithContext(context.Context) NetworkDnsPtrOutput
}

NetworkDnsPtrInput is an input type that accepts NetworkDnsArgs, NetworkDnsPtr and NetworkDnsPtrOutput values. You can construct a concrete instance of `NetworkDnsPtrInput` via: 

        NetworkDnsArgs{...}

or:

        nil

func NetworkDnsPtr 

func NetworkDnsPtr(v *NetworkDnsArgs) NetworkDnsPtrInput

type NetworkDnsPtrOutput 

type NetworkDnsPtrOutput struct{ *pulumi.OutputState }

func (NetworkDnsPtrOutput) Elem 

func (o NetworkDnsPtrOutput) Elem() NetworkDnsOutput

func (NetworkDnsPtrOutput) ElementType 

func (NetworkDnsPtrOutput) ElementType() reflect.Type

func (NetworkDnsPtrOutput) Enabled 

func (o NetworkDnsPtrOutput) Enabled() pulumi.BoolPtrOutput

when false, disable the DHCP server

func (NetworkDnsPtrOutput) Forwarders 

func (o NetworkDnsPtrOutput) Forwarders() NetworkDnsForwarderArrayOutput

Either `address`, `domain`, or both must be set

func (NetworkDnsPtrOutput) Hosts 

func (o NetworkDnsPtrOutput) Hosts() NetworkDnsHostArrayOutput

a DNS host entry block. You can have one or more of these blocks in your DNS definition. You must specify both `ip` and `hostname`.

An advanced example of round-robin DNS (using DNS host templates) follows:

func (NetworkDnsPtrOutput) LocalOnly 

func (o NetworkDnsPtrOutput) LocalOnly() pulumi.BoolPtrOutput

true/false: true means 'do not forward unresolved requests for this domain to the part DNS server

func (NetworkDnsPtrOutput) Srvs 

func (o NetworkDnsPtrOutput) Srvs() NetworkDnsSrvArrayOutput

a DNS SRV entry block. You can have one or more of these blocks in your DNS definition. You must specify `service` and `protocol`.

func (NetworkDnsPtrOutput) ToNetworkDnsPtrOutput 

func (o NetworkDnsPtrOutput) ToNetworkDnsPtrOutput() NetworkDnsPtrOutput

func (NetworkDnsPtrOutput) ToNetworkDnsPtrOutputWithContext 

func (o NetworkDnsPtrOutput) ToNetworkDnsPtrOutputWithContext(ctx context.Context) NetworkDnsPtrOutput

type NetworkDnsSrv 

type NetworkDnsSrv struct {
	// The domain used by the DNS server.
	Domain   *string `pulumi:"domain"`
	Port     *string `pulumi:"port"`
	Priority *string `pulumi:"priority"`
	Protocol *string `pulumi:"protocol"`
	Service  *string `pulumi:"service"`
	Target   *string `pulumi:"target"`
	Weight   *string `pulumi:"weight"`
}

type NetworkDnsSrvArgs 

type NetworkDnsSrvArgs struct {
	// The domain used by the DNS server.
	Domain   pulumi.StringPtrInput `pulumi:"domain"`
	Port     pulumi.StringPtrInput `pulumi:"port"`
	Priority pulumi.StringPtrInput `pulumi:"priority"`
	Protocol pulumi.StringPtrInput `pulumi:"protocol"`
	Service  pulumi.StringPtrInput `pulumi:"service"`
	Target   pulumi.StringPtrInput `pulumi:"target"`
	Weight   pulumi.StringPtrInput `pulumi:"weight"`
}

func (NetworkDnsSrvArgs) ElementType 

func (NetworkDnsSrvArgs) ElementType() reflect.Type

func (NetworkDnsSrvArgs) ToNetworkDnsSrvOutput 

func (i NetworkDnsSrvArgs) ToNetworkDnsSrvOutput() NetworkDnsSrvOutput

func (NetworkDnsSrvArgs) ToNetworkDnsSrvOutputWithContext 

func (i NetworkDnsSrvArgs) ToNetworkDnsSrvOutputWithContext(ctx context.Context) NetworkDnsSrvOutput

type NetworkDnsSrvArray 

type NetworkDnsSrvArray []NetworkDnsSrvInput

func (NetworkDnsSrvArray) ElementType 

func (NetworkDnsSrvArray) ElementType() reflect.Type

func (NetworkDnsSrvArray) ToNetworkDnsSrvArrayOutput 

func (i NetworkDnsSrvArray) ToNetworkDnsSrvArrayOutput() NetworkDnsSrvArrayOutput

func (NetworkDnsSrvArray) ToNetworkDnsSrvArrayOutputWithContext 

func (i NetworkDnsSrvArray) ToNetworkDnsSrvArrayOutputWithContext(ctx context.Context) NetworkDnsSrvArrayOutput

type NetworkDnsSrvArrayInput 

type NetworkDnsSrvArrayInput interface {
	pulumi.Input

	ToNetworkDnsSrvArrayOutput() NetworkDnsSrvArrayOutput
	ToNetworkDnsSrvArrayOutputWithContext(context.Context) NetworkDnsSrvArrayOutput
}

NetworkDnsSrvArrayInput is an input type that accepts NetworkDnsSrvArray and NetworkDnsSrvArrayOutput values. You can construct a concrete instance of `NetworkDnsSrvArrayInput` via: 

NetworkDnsSrvArray{ NetworkDnsSrvArgs{...} }

type NetworkDnsSrvArrayOutput 

type NetworkDnsSrvArrayOutput struct{ *pulumi.OutputState }

func (NetworkDnsSrvArrayOutput) ElementType 

func (NetworkDnsSrvArrayOutput) ElementType() reflect.Type

func (NetworkDnsSrvArrayOutput) Index 

func (o NetworkDnsSrvArrayOutput) Index(i pulumi.IntInput) NetworkDnsSrvOutput

func (NetworkDnsSrvArrayOutput) ToNetworkDnsSrvArrayOutput 

func (o NetworkDnsSrvArrayOutput) ToNetworkDnsSrvArrayOutput() NetworkDnsSrvArrayOutput

func (NetworkDnsSrvArrayOutput) ToNetworkDnsSrvArrayOutputWithContext 

func (o NetworkDnsSrvArrayOutput) ToNetworkDnsSrvArrayOutputWithContext(ctx context.Context) NetworkDnsSrvArrayOutput

type NetworkDnsSrvInput 

type NetworkDnsSrvInput interface {
	pulumi.Input

	ToNetworkDnsSrvOutput() NetworkDnsSrvOutput
	ToNetworkDnsSrvOutputWithContext(context.Context) NetworkDnsSrvOutput
}

NetworkDnsSrvInput is an input type that accepts NetworkDnsSrvArgs and NetworkDnsSrvOutput values. You can construct a concrete instance of `NetworkDnsSrvInput` via: 

NetworkDnsSrvArgs{...}

type NetworkDnsSrvOutput 

type NetworkDnsSrvOutput struct{ *pulumi.OutputState }

func (NetworkDnsSrvOutput) Domain 

func (o NetworkDnsSrvOutput) Domain() pulumi.StringPtrOutput

The domain used by the DNS server.

func (NetworkDnsSrvOutput) ElementType 

func (NetworkDnsSrvOutput) ElementType() reflect.Type

func (NetworkDnsSrvOutput) Port 

func (o NetworkDnsSrvOutput) Port() pulumi.StringPtrOutput

func (NetworkDnsSrvOutput) Priority 

func (o NetworkDnsSrvOutput) Priority() pulumi.StringPtrOutput

func (NetworkDnsSrvOutput) Protocol 

func (o NetworkDnsSrvOutput) Protocol() pulumi.StringPtrOutput

func (NetworkDnsSrvOutput) Service 

func (o NetworkDnsSrvOutput) Service() pulumi.StringPtrOutput

func (NetworkDnsSrvOutput) Target 

func (o NetworkDnsSrvOutput) Target() pulumi.StringPtrOutput

func (NetworkDnsSrvOutput) ToNetworkDnsSrvOutput 

func (o NetworkDnsSrvOutput) ToNetworkDnsSrvOutput() NetworkDnsSrvOutput

func (NetworkDnsSrvOutput) ToNetworkDnsSrvOutputWithContext 

func (o NetworkDnsSrvOutput) ToNetworkDnsSrvOutputWithContext(ctx context.Context) NetworkDnsSrvOutput

func (NetworkDnsSrvOutput) Weight 

func (o NetworkDnsSrvOutput) Weight() pulumi.StringPtrOutput

type NetworkDnsmasqOptions added in v0.2.0 

type NetworkDnsmasqOptions struct {
	// a Dnsmasq option entry block. You can have one or more of these
	// blocks in your definition. You must specify `optionName` while `optionValue` is
	// optional to support value-less options.
	//
	// An example of setting Dnsmasq options (using Dnsmasq option templates) follows:
	Options []NetworkDnsmasqOptionsOption `pulumi:"options"`
}

type NetworkDnsmasqOptionsArgs added in v0.2.0 

type NetworkDnsmasqOptionsArgs struct {
	// a Dnsmasq option entry block. You can have one or more of these
	// blocks in your definition. You must specify `optionName` while `optionValue` is
	// optional to support value-less options.
	//
	// An example of setting Dnsmasq options (using Dnsmasq option templates) follows:
	Options NetworkDnsmasqOptionsOptionArrayInput `pulumi:"options"`
}

func (NetworkDnsmasqOptionsArgs) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsArgs) ElementType() reflect.Type

func (NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsOutput added in v0.2.0 

func (i NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsOutput() NetworkDnsmasqOptionsOutput

func (NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsOutputWithContext added in v0.2.0 

func (i NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsOutput

func (NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsPtrOutput added in v0.2.0 

func (i NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsPtrOutput() NetworkDnsmasqOptionsPtrOutput

func (NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsPtrOutputWithContext added in v0.2.0 

func (i NetworkDnsmasqOptionsArgs) ToNetworkDnsmasqOptionsPtrOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsPtrOutput

type NetworkDnsmasqOptionsInput added in v0.2.0 

type NetworkDnsmasqOptionsInput interface {
	pulumi.Input

	ToNetworkDnsmasqOptionsOutput() NetworkDnsmasqOptionsOutput
	ToNetworkDnsmasqOptionsOutputWithContext(context.Context) NetworkDnsmasqOptionsOutput
}

NetworkDnsmasqOptionsInput is an input type that accepts NetworkDnsmasqOptionsArgs and NetworkDnsmasqOptionsOutput values. You can construct a concrete instance of `NetworkDnsmasqOptionsInput` via: 

NetworkDnsmasqOptionsArgs{...}

type NetworkDnsmasqOptionsOption added in v0.2.0 

type NetworkDnsmasqOptionsOption struct {
	OptionName  *string `pulumi:"optionName"`
	OptionValue *string `pulumi:"optionValue"`
}

type NetworkDnsmasqOptionsOptionArgs added in v0.2.0 

type NetworkDnsmasqOptionsOptionArgs struct {
	OptionName  pulumi.StringPtrInput `pulumi:"optionName"`
	OptionValue pulumi.StringPtrInput `pulumi:"optionValue"`
}

func (NetworkDnsmasqOptionsOptionArgs) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsOptionArgs) ElementType() reflect.Type

func (NetworkDnsmasqOptionsOptionArgs) ToNetworkDnsmasqOptionsOptionOutput added in v0.2.0 

func (i NetworkDnsmasqOptionsOptionArgs) ToNetworkDnsmasqOptionsOptionOutput() NetworkDnsmasqOptionsOptionOutput

func (NetworkDnsmasqOptionsOptionArgs) ToNetworkDnsmasqOptionsOptionOutputWithContext added in v0.2.0 

func (i NetworkDnsmasqOptionsOptionArgs) ToNetworkDnsmasqOptionsOptionOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsOptionOutput

type NetworkDnsmasqOptionsOptionArray added in v0.2.0 

type NetworkDnsmasqOptionsOptionArray []NetworkDnsmasqOptionsOptionInput

func (NetworkDnsmasqOptionsOptionArray) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsOptionArray) ElementType() reflect.Type

func (NetworkDnsmasqOptionsOptionArray) ToNetworkDnsmasqOptionsOptionArrayOutput added in v0.2.0 

func (i NetworkDnsmasqOptionsOptionArray) ToNetworkDnsmasqOptionsOptionArrayOutput() NetworkDnsmasqOptionsOptionArrayOutput

func (NetworkDnsmasqOptionsOptionArray) ToNetworkDnsmasqOptionsOptionArrayOutputWithContext added in v0.2.0 

func (i NetworkDnsmasqOptionsOptionArray) ToNetworkDnsmasqOptionsOptionArrayOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsOptionArrayOutput

type NetworkDnsmasqOptionsOptionArrayInput added in v0.2.0 

type NetworkDnsmasqOptionsOptionArrayInput interface {
	pulumi.Input

	ToNetworkDnsmasqOptionsOptionArrayOutput() NetworkDnsmasqOptionsOptionArrayOutput
	ToNetworkDnsmasqOptionsOptionArrayOutputWithContext(context.Context) NetworkDnsmasqOptionsOptionArrayOutput
}

NetworkDnsmasqOptionsOptionArrayInput is an input type that accepts NetworkDnsmasqOptionsOptionArray and NetworkDnsmasqOptionsOptionArrayOutput values. You can construct a concrete instance of `NetworkDnsmasqOptionsOptionArrayInput` via: 

NetworkDnsmasqOptionsOptionArray{ NetworkDnsmasqOptionsOptionArgs{...} }

type NetworkDnsmasqOptionsOptionArrayOutput added in v0.2.0 

type NetworkDnsmasqOptionsOptionArrayOutput struct{ *pulumi.OutputState }

func (NetworkDnsmasqOptionsOptionArrayOutput) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsOptionArrayOutput) ElementType() reflect.Type

func (NetworkDnsmasqOptionsOptionArrayOutput) Index added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionArrayOutput) Index(i pulumi.IntInput) NetworkDnsmasqOptionsOptionOutput

func (NetworkDnsmasqOptionsOptionArrayOutput) ToNetworkDnsmasqOptionsOptionArrayOutput added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionArrayOutput) ToNetworkDnsmasqOptionsOptionArrayOutput() NetworkDnsmasqOptionsOptionArrayOutput

func (NetworkDnsmasqOptionsOptionArrayOutput) ToNetworkDnsmasqOptionsOptionArrayOutputWithContext added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionArrayOutput) ToNetworkDnsmasqOptionsOptionArrayOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsOptionArrayOutput

type NetworkDnsmasqOptionsOptionInput added in v0.2.0 

type NetworkDnsmasqOptionsOptionInput interface {
	pulumi.Input

	ToNetworkDnsmasqOptionsOptionOutput() NetworkDnsmasqOptionsOptionOutput
	ToNetworkDnsmasqOptionsOptionOutputWithContext(context.Context) NetworkDnsmasqOptionsOptionOutput
}

NetworkDnsmasqOptionsOptionInput is an input type that accepts NetworkDnsmasqOptionsOptionArgs and NetworkDnsmasqOptionsOptionOutput values. You can construct a concrete instance of `NetworkDnsmasqOptionsOptionInput` via: 

NetworkDnsmasqOptionsOptionArgs{...}

type NetworkDnsmasqOptionsOptionOutput added in v0.2.0 

type NetworkDnsmasqOptionsOptionOutput struct{ *pulumi.OutputState }

func (NetworkDnsmasqOptionsOptionOutput) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsOptionOutput) ElementType() reflect.Type

func (NetworkDnsmasqOptionsOptionOutput) OptionName added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionOutput) OptionName() pulumi.StringPtrOutput

func (NetworkDnsmasqOptionsOptionOutput) OptionValue added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionOutput) OptionValue() pulumi.StringPtrOutput

func (NetworkDnsmasqOptionsOptionOutput) ToNetworkDnsmasqOptionsOptionOutput added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionOutput) ToNetworkDnsmasqOptionsOptionOutput() NetworkDnsmasqOptionsOptionOutput

func (NetworkDnsmasqOptionsOptionOutput) ToNetworkDnsmasqOptionsOptionOutputWithContext added in v0.2.0 

func (o NetworkDnsmasqOptionsOptionOutput) ToNetworkDnsmasqOptionsOptionOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsOptionOutput

type NetworkDnsmasqOptionsOutput added in v0.2.0 

type NetworkDnsmasqOptionsOutput struct{ *pulumi.OutputState }

func (NetworkDnsmasqOptionsOutput) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsOutput) ElementType() reflect.Type

func (NetworkDnsmasqOptionsOutput) Options added in v0.2.0 

func (o NetworkDnsmasqOptionsOutput) Options() NetworkDnsmasqOptionsOptionArrayOutput

a Dnsmasq option entry block. You can have one or more of these blocks in your definition. You must specify `optionName` while `optionValue` is optional to support value-less options.

An example of setting Dnsmasq options (using Dnsmasq option templates) follows:

func (NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsOutput added in v0.2.0 

func (o NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsOutput() NetworkDnsmasqOptionsOutput

func (NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsOutputWithContext added in v0.2.0 

func (o NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsOutput

func (NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsPtrOutput added in v0.2.0 

func (o NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsPtrOutput() NetworkDnsmasqOptionsPtrOutput

func (NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsPtrOutputWithContext added in v0.2.0 

func (o NetworkDnsmasqOptionsOutput) ToNetworkDnsmasqOptionsPtrOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsPtrOutput

type NetworkDnsmasqOptionsPtrInput added in v0.2.0 

type NetworkDnsmasqOptionsPtrInput interface {
	pulumi.Input

	ToNetworkDnsmasqOptionsPtrOutput() NetworkDnsmasqOptionsPtrOutput
	ToNetworkDnsmasqOptionsPtrOutputWithContext(context.Context) NetworkDnsmasqOptionsPtrOutput
}

NetworkDnsmasqOptionsPtrInput is an input type that accepts NetworkDnsmasqOptionsArgs, NetworkDnsmasqOptionsPtr and NetworkDnsmasqOptionsPtrOutput values. You can construct a concrete instance of `NetworkDnsmasqOptionsPtrInput` via: 

        NetworkDnsmasqOptionsArgs{...}

or:

        nil

func NetworkDnsmasqOptionsPtr added in v0.2.0 

func NetworkDnsmasqOptionsPtr(v *NetworkDnsmasqOptionsArgs) NetworkDnsmasqOptionsPtrInput

type NetworkDnsmasqOptionsPtrOutput added in v0.2.0 

type NetworkDnsmasqOptionsPtrOutput struct{ *pulumi.OutputState }

func (NetworkDnsmasqOptionsPtrOutput) Elem added in v0.2.0 

func (o NetworkDnsmasqOptionsPtrOutput) Elem() NetworkDnsmasqOptionsOutput

func (NetworkDnsmasqOptionsPtrOutput) ElementType added in v0.2.0 

func (NetworkDnsmasqOptionsPtrOutput) ElementType() reflect.Type

func (NetworkDnsmasqOptionsPtrOutput) Options added in v0.2.0 

func (o NetworkDnsmasqOptionsPtrOutput) Options() NetworkDnsmasqOptionsOptionArrayOutput

a Dnsmasq option entry block. You can have one or more of these blocks in your definition. You must specify `optionName` while `optionValue` is optional to support value-less options.

An example of setting Dnsmasq options (using Dnsmasq option templates) follows:

func (NetworkDnsmasqOptionsPtrOutput) ToNetworkDnsmasqOptionsPtrOutput added in v0.2.0 

func (o NetworkDnsmasqOptionsPtrOutput) ToNetworkDnsmasqOptionsPtrOutput() NetworkDnsmasqOptionsPtrOutput

func (NetworkDnsmasqOptionsPtrOutput) ToNetworkDnsmasqOptionsPtrOutputWithContext added in v0.2.0 

func (o NetworkDnsmasqOptionsPtrOutput) ToNetworkDnsmasqOptionsPtrOutputWithContext(ctx context.Context) NetworkDnsmasqOptionsPtrOutput

type NetworkInput 

type NetworkInput interface {
	pulumi.Input

	ToNetworkOutput() NetworkOutput
	ToNetworkOutputWithContext(ctx context.Context) NetworkOutput
}

type NetworkMap 

type NetworkMap map[string]NetworkInput

func (NetworkMap) ElementType 

func (NetworkMap) ElementType() reflect.Type

func (NetworkMap) ToNetworkMapOutput 

func (i NetworkMap) ToNetworkMapOutput() NetworkMapOutput

func (NetworkMap) ToNetworkMapOutputWithContext 

func (i NetworkMap) ToNetworkMapOutputWithContext(ctx context.Context) NetworkMapOutput

type NetworkMapInput 

type NetworkMapInput interface {
	pulumi.Input

	ToNetworkMapOutput() NetworkMapOutput
	ToNetworkMapOutputWithContext(context.Context) NetworkMapOutput
}

NetworkMapInput is an input type that accepts NetworkMap and NetworkMapOutput values. You can construct a concrete instance of `NetworkMapInput` via: 

NetworkMap{ "key": NetworkArgs{...} }

type NetworkMapOutput 

type NetworkMapOutput struct{ *pulumi.OutputState }

func (NetworkMapOutput) ElementType 

func (NetworkMapOutput) ElementType() reflect.Type

func (NetworkMapOutput) MapIndex 

func (o NetworkMapOutput) MapIndex(k pulumi.StringInput) NetworkOutput

func (NetworkMapOutput) ToNetworkMapOutput 

func (o NetworkMapOutput) ToNetworkMapOutput() NetworkMapOutput

func (NetworkMapOutput) ToNetworkMapOutputWithContext 

func (o NetworkMapOutput) ToNetworkMapOutputWithContext(ctx context.Context) NetworkMapOutput

type NetworkOutput 

type NetworkOutput struct{ *pulumi.OutputState }

func (NetworkOutput) Addresses added in v0.3.0 

func (o NetworkOutput) Addresses() pulumi.StringArrayOutput

A list of (0 or 1) IPv4 and (0 or 1) IPv6 subnets in CIDR notation. This defines the subnets associated to that network. This argument is also used to define the address on the real host. If `dhcp { enabled = true }` addresses is also used to define the address range served by the DHCP server. No DHCP server will be started if `addresses` is omitted.

func (NetworkOutput) Autostart added in v0.3.0 

func (o NetworkOutput) Autostart() pulumi.BoolOutput

Set to `true` to start the network on host boot up. If not specified `false` is assumed.

func (NetworkOutput) Bridge added in v0.3.0 

func (o NetworkOutput) Bridge() pulumi.StringOutput

The bridge device defines the name of a bridge device which will be used to construct the virtual network (when not provided, it will be automatically obtained by libvirt in `none`, `nat`, `route` and `open` modes).

func (NetworkOutput) Dhcp added in v0.3.0 

func (o NetworkOutput) Dhcp() NetworkDhcpOutput

DHCP configuration. You need to use it in conjuction with the adresses variable.

func (NetworkOutput) Dns added in v0.3.0 

func (o NetworkOutput) Dns() NetworkDnsOutput

configuration of DNS specific settings for the network

func (NetworkOutput) DnsmasqOptions added in v0.3.0 

func (o NetworkOutput) DnsmasqOptions() NetworkDnsmasqOptionsPtrOutput

configuration of Dnsmasq options for the network You need to provide a list of option name and value pairs.

func (NetworkOutput) Domain added in v0.3.0 

func (o NetworkOutput) Domain() pulumi.StringPtrOutput

The domain used by the DNS server.

func (NetworkOutput) ElementType 

func (NetworkOutput) ElementType() reflect.Type

func (NetworkOutput) Mode added in v0.3.0 

func (o NetworkOutput) Mode() pulumi.StringPtrOutput

One of:

func (NetworkOutput) Mtu added in v0.3.0 

func (o NetworkOutput) Mtu() pulumi.IntPtrOutput

The MTU to set for the underlying network interfaces. When not supplied, libvirt will use the default for the interface, usually 1500. Libvirt version 5.1 and greater will advertise this value to nodes via DHCP.

func (NetworkOutput) Name added in v0.3.0 

func (o NetworkOutput) Name() pulumi.StringOutput

A unique name for the resource, required by libvirt. Changing this forces a new resource to be created.

func (NetworkOutput) Routes added in v0.3.0 

func (o NetworkOutput) Routes() NetworkRouteArrayOutput

a list of static routes. A `cidr` and a `gateway` must be provided. The `gateway` must be reachable via the bridge interface.

func (NetworkOutput) ToNetworkOutput 

func (o NetworkOutput) ToNetworkOutput() NetworkOutput

func (NetworkOutput) ToNetworkOutputWithContext 

func (o NetworkOutput) ToNetworkOutputWithContext(ctx context.Context) NetworkOutput

func (NetworkOutput) Xml added in v0.3.0 

func (o NetworkOutput) Xml() NetworkXmlPtrOutput

type NetworkRoute 

type NetworkRoute struct {
	Cidr    string `pulumi:"cidr"`
	Gateway string `pulumi:"gateway"`
}

type NetworkRouteArgs 

type NetworkRouteArgs struct {
	Cidr    pulumi.StringInput `pulumi:"cidr"`
	Gateway pulumi.StringInput `pulumi:"gateway"`
}

func (NetworkRouteArgs) ElementType 

func (NetworkRouteArgs) ElementType() reflect.Type

func (NetworkRouteArgs) ToNetworkRouteOutput 

func (i NetworkRouteArgs) ToNetworkRouteOutput() NetworkRouteOutput

func (NetworkRouteArgs) ToNetworkRouteOutputWithContext 

func (i NetworkRouteArgs) ToNetworkRouteOutputWithContext(ctx context.Context) NetworkRouteOutput

type NetworkRouteArray 

type NetworkRouteArray []NetworkRouteInput

func (NetworkRouteArray) ElementType 

func (NetworkRouteArray) ElementType() reflect.Type

func (NetworkRouteArray) ToNetworkRouteArrayOutput 

func (i NetworkRouteArray) ToNetworkRouteArrayOutput() NetworkRouteArrayOutput

func (NetworkRouteArray) ToNetworkRouteArrayOutputWithContext 

func (i NetworkRouteArray) ToNetworkRouteArrayOutputWithContext(ctx context.Context) NetworkRouteArrayOutput

type NetworkRouteArrayInput 

type NetworkRouteArrayInput interface {
	pulumi.Input

	ToNetworkRouteArrayOutput() NetworkRouteArrayOutput
	ToNetworkRouteArrayOutputWithContext(context.Context) NetworkRouteArrayOutput
}

NetworkRouteArrayInput is an input type that accepts NetworkRouteArray and NetworkRouteArrayOutput values. You can construct a concrete instance of `NetworkRouteArrayInput` via: 

NetworkRouteArray{ NetworkRouteArgs{...} }

type NetworkRouteArrayOutput 

type NetworkRouteArrayOutput struct{ *pulumi.OutputState }

func (NetworkRouteArrayOutput) ElementType 

func (NetworkRouteArrayOutput) ElementType() reflect.Type

func (NetworkRouteArrayOutput) Index 

func (o NetworkRouteArrayOutput) Index(i pulumi.IntInput) NetworkRouteOutput

func (NetworkRouteArrayOutput) ToNetworkRouteArrayOutput 

func (o NetworkRouteArrayOutput) ToNetworkRouteArrayOutput() NetworkRouteArrayOutput

func (NetworkRouteArrayOutput) ToNetworkRouteArrayOutputWithContext 

func (o NetworkRouteArrayOutput) ToNetworkRouteArrayOutputWithContext(ctx context.Context) NetworkRouteArrayOutput

type NetworkRouteInput 

type NetworkRouteInput interface {
	pulumi.Input

	ToNetworkRouteOutput() NetworkRouteOutput
	ToNetworkRouteOutputWithContext(context.Context) NetworkRouteOutput
}

NetworkRouteInput is an input type that accepts NetworkRouteArgs and NetworkRouteOutput values. You can construct a concrete instance of `NetworkRouteInput` via: 

NetworkRouteArgs{...}

type NetworkRouteOutput 

type NetworkRouteOutput struct{ *pulumi.OutputState }

func (NetworkRouteOutput) Cidr 

func (o NetworkRouteOutput) Cidr() pulumi.StringOutput

func (NetworkRouteOutput) ElementType 

func (NetworkRouteOutput) ElementType() reflect.Type

func (NetworkRouteOutput) Gateway 

func (o NetworkRouteOutput) Gateway() pulumi.StringOutput

func (NetworkRouteOutput) ToNetworkRouteOutput 

func (o NetworkRouteOutput) ToNetworkRouteOutput() NetworkRouteOutput

func (NetworkRouteOutput) ToNetworkRouteOutputWithContext 

func (o NetworkRouteOutput) ToNetworkRouteOutputWithContext(ctx context.Context) NetworkRouteOutput

type NetworkState 

type NetworkState struct {
	// A list of (0 or 1) IPv4 and (0 or 1) IPv6 subnets in
	// CIDR notation.  This defines the subnets associated to that network.
	// This argument is also used to define the address on the real host.
	// If `dhcp {  enabled = true }` addresses is also used to define the address range served by
	// the DHCP server.
	// No DHCP server will be started if `addresses` is omitted.
	Addresses pulumi.StringArrayInput
	// Set to `true` to start the network on host boot up.
	// If not specified `false` is assumed.
	Autostart pulumi.BoolPtrInput
	// The bridge device defines the name of a bridge
	// device which will be used to construct the virtual network (when not provided,
	// it will be automatically obtained by libvirt in `none`, `nat`, `route` and `open` modes).
	Bridge pulumi.StringPtrInput
	// DHCP configuration.
	// You need to use it in conjuction with the adresses variable.
	Dhcp NetworkDhcpPtrInput
	// configuration of DNS specific settings for the network
	Dns NetworkDnsPtrInput
	// configuration of Dnsmasq options for the network
	// You need to provide a list of option name and value pairs.
	DnsmasqOptions NetworkDnsmasqOptionsPtrInput
	// The domain used by the DNS server.
	Domain pulumi.StringPtrInput
	// One of:
	Mode pulumi.StringPtrInput
	// The MTU to set for the underlying network interfaces. When
	// not supplied, libvirt will use the default for the interface, usually 1500.
	// Libvirt version 5.1 and greater will advertise this value to nodes via DHCP.
	Mtu pulumi.IntPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// a list of static routes. A `cidr` and a `gateway` must
	// be provided. The `gateway` must be reachable via the bridge interface.
	Routes NetworkRouteArrayInput
	Xml    NetworkXmlPtrInput
}

func (NetworkState) ElementType 

func (NetworkState) ElementType() reflect.Type

type NetworkXml 

type NetworkXml struct {
	Xslt *string `pulumi:"xslt"`
}

type NetworkXmlArgs 

type NetworkXmlArgs struct {
	Xslt pulumi.StringPtrInput `pulumi:"xslt"`
}

func (NetworkXmlArgs) ElementType 

func (NetworkXmlArgs) ElementType() reflect.Type

func (NetworkXmlArgs) ToNetworkXmlOutput 

func (i NetworkXmlArgs) ToNetworkXmlOutput() NetworkXmlOutput

func (NetworkXmlArgs) ToNetworkXmlOutputWithContext 

func (i NetworkXmlArgs) ToNetworkXmlOutputWithContext(ctx context.Context) NetworkXmlOutput

func (NetworkXmlArgs) ToNetworkXmlPtrOutput 

func (i NetworkXmlArgs) ToNetworkXmlPtrOutput() NetworkXmlPtrOutput

func (NetworkXmlArgs) ToNetworkXmlPtrOutputWithContext 

func (i NetworkXmlArgs) ToNetworkXmlPtrOutputWithContext(ctx context.Context) NetworkXmlPtrOutput

type NetworkXmlInput 

type NetworkXmlInput interface {
	pulumi.Input

	ToNetworkXmlOutput() NetworkXmlOutput
	ToNetworkXmlOutputWithContext(context.Context) NetworkXmlOutput
}

NetworkXmlInput is an input type that accepts NetworkXmlArgs and NetworkXmlOutput values. You can construct a concrete instance of `NetworkXmlInput` via: 

NetworkXmlArgs{...}

type NetworkXmlOutput 

type NetworkXmlOutput struct{ *pulumi.OutputState }

func (NetworkXmlOutput) ElementType 

func (NetworkXmlOutput) ElementType() reflect.Type

func (NetworkXmlOutput) ToNetworkXmlOutput 

func (o NetworkXmlOutput) ToNetworkXmlOutput() NetworkXmlOutput

func (NetworkXmlOutput) ToNetworkXmlOutputWithContext 

func (o NetworkXmlOutput) ToNetworkXmlOutputWithContext(ctx context.Context) NetworkXmlOutput

func (NetworkXmlOutput) ToNetworkXmlPtrOutput 

func (o NetworkXmlOutput) ToNetworkXmlPtrOutput() NetworkXmlPtrOutput

func (NetworkXmlOutput) ToNetworkXmlPtrOutputWithContext 

func (o NetworkXmlOutput) ToNetworkXmlPtrOutputWithContext(ctx context.Context) NetworkXmlPtrOutput

func (NetworkXmlOutput) Xslt 

func (o NetworkXmlOutput) Xslt() pulumi.StringPtrOutput

type NetworkXmlPtrInput 

type NetworkXmlPtrInput interface {
	pulumi.Input

	ToNetworkXmlPtrOutput() NetworkXmlPtrOutput
	ToNetworkXmlPtrOutputWithContext(context.Context) NetworkXmlPtrOutput
}

NetworkXmlPtrInput is an input type that accepts NetworkXmlArgs, NetworkXmlPtr and NetworkXmlPtrOutput values. You can construct a concrete instance of `NetworkXmlPtrInput` via: 

        NetworkXmlArgs{...}

or:

        nil

func NetworkXmlPtr 

func NetworkXmlPtr(v *NetworkXmlArgs) NetworkXmlPtrInput

type NetworkXmlPtrOutput 

type NetworkXmlPtrOutput struct{ *pulumi.OutputState }

func (NetworkXmlPtrOutput) Elem 

func (o NetworkXmlPtrOutput) Elem() NetworkXmlOutput

func (NetworkXmlPtrOutput) ElementType 

func (NetworkXmlPtrOutput) ElementType() reflect.Type

func (NetworkXmlPtrOutput) ToNetworkXmlPtrOutput 

func (o NetworkXmlPtrOutput) ToNetworkXmlPtrOutput() NetworkXmlPtrOutput

func (NetworkXmlPtrOutput) ToNetworkXmlPtrOutputWithContext 

func (o NetworkXmlPtrOutput) ToNetworkXmlPtrOutputWithContext(ctx context.Context) NetworkXmlPtrOutput

func (NetworkXmlPtrOutput) Xslt 

func (o NetworkXmlPtrOutput) Xslt() pulumi.StringPtrOutput

type Pool 

type Pool struct {
	pulumi.CustomResourceState

	Allocation pulumi.IntOutput `pulumi:"allocation"`
	Available  pulumi.IntOutput `pulumi:"available"`
	Capacity   pulumi.IntOutput `pulumi:"capacity"`
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringOutput `pulumi:"name"`
	// The directory where the pool will keep all its volumes. This is only relevant to (and required by)
	// the "dir" type pools.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The type of the pool. Currently, only "dir" supported.
	Type pulumi.StringOutput `pulumi:"type"`
	Xml  PoolXmlPtrOutput    `pulumi:"xml"`
}

Manages a storage pool in libvirt. Currently only directory-based storage pool are supported. For more information on storage pools in libvirt, see [the official documentation](https://libvirt.org/formatstorage.html).

**WARNING:** This is experimental API and may change in the future.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// A pool for all cluster volumes
		cluster, err := libvirt.NewPool(ctx, "cluster", &libvirt.PoolArgs{
			Type: pulumi.String("dir"),
			Path: pulumi.String("/home/user/cluster_storage"),
		})
		if err != nil {
			return err
		}
		_, err = libvirt.NewVolume(ctx, "opensuseLeap", &libvirt.VolumeArgs{
			Pool:   cluster.Name,
			Source: pulumi.String("http://download.opensuse.org/repositories/Cloud:/Images:/Leap_42.1/images/openSUSE-Leap-42.1-OpenStack.x86_64.qcow2"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

func GetPool 

func GetPool(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PoolState, opts ...pulumi.ResourceOption) (*Pool, error)

GetPool gets an existing Pool resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewPool 

func NewPool(ctx *pulumi.Context,
	name string, args *PoolArgs, opts ...pulumi.ResourceOption) (*Pool, error)

NewPool registers a new resource with the given unique name, arguments, and options.

func (*Pool) ElementType 

func (*Pool) ElementType() reflect.Type

func (*Pool) ToPoolOutput 

func (i *Pool) ToPoolOutput() PoolOutput

func (*Pool) ToPoolOutputWithContext 

func (i *Pool) ToPoolOutputWithContext(ctx context.Context) PoolOutput

type PoolArgs 

type PoolArgs struct {
	Allocation pulumi.IntPtrInput
	Available  pulumi.IntPtrInput
	Capacity   pulumi.IntPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// The directory where the pool will keep all its volumes. This is only relevant to (and required by)
	// the "dir" type pools.
	Path pulumi.StringPtrInput
	// The type of the pool. Currently, only "dir" supported.
	Type pulumi.StringInput
	Xml  PoolXmlPtrInput
}

The set of arguments for constructing a Pool resource.

func (PoolArgs) ElementType 

func (PoolArgs) ElementType() reflect.Type

type PoolArray 

type PoolArray []PoolInput

func (PoolArray) ElementType 

func (PoolArray) ElementType() reflect.Type

func (PoolArray) ToPoolArrayOutput 

func (i PoolArray) ToPoolArrayOutput() PoolArrayOutput

func (PoolArray) ToPoolArrayOutputWithContext 

func (i PoolArray) ToPoolArrayOutputWithContext(ctx context.Context) PoolArrayOutput

type PoolArrayInput 

type PoolArrayInput interface {
	pulumi.Input

	ToPoolArrayOutput() PoolArrayOutput
	ToPoolArrayOutputWithContext(context.Context) PoolArrayOutput
}

PoolArrayInput is an input type that accepts PoolArray and PoolArrayOutput values. You can construct a concrete instance of `PoolArrayInput` via: 

PoolArray{ PoolArgs{...} }

type PoolArrayOutput 

type PoolArrayOutput struct{ *pulumi.OutputState }

func (PoolArrayOutput) ElementType 

func (PoolArrayOutput) ElementType() reflect.Type

func (PoolArrayOutput) Index 

func (o PoolArrayOutput) Index(i pulumi.IntInput) PoolOutput

func (PoolArrayOutput) ToPoolArrayOutput 

func (o PoolArrayOutput) ToPoolArrayOutput() PoolArrayOutput

func (PoolArrayOutput) ToPoolArrayOutputWithContext 

func (o PoolArrayOutput) ToPoolArrayOutputWithContext(ctx context.Context) PoolArrayOutput

type PoolInput 

type PoolInput interface {
	pulumi.Input

	ToPoolOutput() PoolOutput
	ToPoolOutputWithContext(ctx context.Context) PoolOutput
}

type PoolMap 

type PoolMap map[string]PoolInput

func (PoolMap) ElementType 

func (PoolMap) ElementType() reflect.Type

func (PoolMap) ToPoolMapOutput 

func (i PoolMap) ToPoolMapOutput() PoolMapOutput

func (PoolMap) ToPoolMapOutputWithContext 

func (i PoolMap) ToPoolMapOutputWithContext(ctx context.Context) PoolMapOutput

type PoolMapInput 

type PoolMapInput interface {
	pulumi.Input

	ToPoolMapOutput() PoolMapOutput
	ToPoolMapOutputWithContext(context.Context) PoolMapOutput
}

PoolMapInput is an input type that accepts PoolMap and PoolMapOutput values. You can construct a concrete instance of `PoolMapInput` via: 

PoolMap{ "key": PoolArgs{...} }

type PoolMapOutput 

type PoolMapOutput struct{ *pulumi.OutputState }

func (PoolMapOutput) ElementType 

func (PoolMapOutput) ElementType() reflect.Type

func (PoolMapOutput) MapIndex 

func (o PoolMapOutput) MapIndex(k pulumi.StringInput) PoolOutput

func (PoolMapOutput) ToPoolMapOutput 

func (o PoolMapOutput) ToPoolMapOutput() PoolMapOutput

func (PoolMapOutput) ToPoolMapOutputWithContext 

func (o PoolMapOutput) ToPoolMapOutputWithContext(ctx context.Context) PoolMapOutput

type PoolOutput 

type PoolOutput struct{ *pulumi.OutputState }

func (PoolOutput) Allocation added in v0.3.0 

func (o PoolOutput) Allocation() pulumi.IntOutput

func (PoolOutput) Available added in v0.3.0 

func (o PoolOutput) Available() pulumi.IntOutput

func (PoolOutput) Capacity added in v0.3.0 

func (o PoolOutput) Capacity() pulumi.IntOutput

func (PoolOutput) ElementType 

func (PoolOutput) ElementType() reflect.Type

func (PoolOutput) Name added in v0.3.0 

func (o PoolOutput) Name() pulumi.StringOutput

A unique name for the resource, required by libvirt.

func (PoolOutput) Path added in v0.3.0 

func (o PoolOutput) Path() pulumi.StringPtrOutput

The directory where the pool will keep all its volumes. This is only relevant to (and required by) the "dir" type pools.

func (PoolOutput) ToPoolOutput 

func (o PoolOutput) ToPoolOutput() PoolOutput

func (PoolOutput) ToPoolOutputWithContext 

func (o PoolOutput) ToPoolOutputWithContext(ctx context.Context) PoolOutput

func (PoolOutput) Type added in v0.3.0 

func (o PoolOutput) Type() pulumi.StringOutput

The type of the pool. Currently, only "dir" supported.

func (PoolOutput) Xml added in v0.3.0 

func (o PoolOutput) Xml() PoolXmlPtrOutput

type PoolState 

type PoolState struct {
	Allocation pulumi.IntPtrInput
	Available  pulumi.IntPtrInput
	Capacity   pulumi.IntPtrInput
	// A unique name for the resource, required by libvirt.
	Name pulumi.StringPtrInput
	// The directory where the pool will keep all its volumes. This is only relevant to (and required by)
	// the "dir" type pools.
	Path pulumi.StringPtrInput
	// The type of the pool. Currently, only "dir" supported.
	Type pulumi.StringPtrInput
	Xml  PoolXmlPtrInput
}

func (PoolState) ElementType 

func (PoolState) ElementType() reflect.Type

type PoolXml 

type PoolXml struct {
	Xslt *string `pulumi:"xslt"`
}

type PoolXmlArgs 

type PoolXmlArgs struct {
	Xslt pulumi.StringPtrInput `pulumi:"xslt"`
}

func (PoolXmlArgs) ElementType 

func (PoolXmlArgs) ElementType() reflect.Type

func (PoolXmlArgs) ToPoolXmlOutput 

func (i PoolXmlArgs) ToPoolXmlOutput() PoolXmlOutput

func (PoolXmlArgs) ToPoolXmlOutputWithContext 

func (i PoolXmlArgs) ToPoolXmlOutputWithContext(ctx context.Context) PoolXmlOutput

func (PoolXmlArgs) ToPoolXmlPtrOutput 

func (i PoolXmlArgs) ToPoolXmlPtrOutput() PoolXmlPtrOutput

func (PoolXmlArgs) ToPoolXmlPtrOutputWithContext 

func (i PoolXmlArgs) ToPoolXmlPtrOutputWithContext(ctx context.Context) PoolXmlPtrOutput

type PoolXmlInput 

type PoolXmlInput interface {
	pulumi.Input

	ToPoolXmlOutput() PoolXmlOutput
	ToPoolXmlOutputWithContext(context.Context) PoolXmlOutput
}

PoolXmlInput is an input type that accepts PoolXmlArgs and PoolXmlOutput values. You can construct a concrete instance of `PoolXmlInput` via: 

PoolXmlArgs{...}

type PoolXmlOutput 

type PoolXmlOutput struct{ *pulumi.OutputState }

func (PoolXmlOutput) ElementType 

func (PoolXmlOutput) ElementType() reflect.Type

func (PoolXmlOutput) ToPoolXmlOutput 

func (o PoolXmlOutput) ToPoolXmlOutput() PoolXmlOutput

func (PoolXmlOutput) ToPoolXmlOutputWithContext 

func (o PoolXmlOutput) ToPoolXmlOutputWithContext(ctx context.Context) PoolXmlOutput

func (PoolXmlOutput) ToPoolXmlPtrOutput 

func (o PoolXmlOutput) ToPoolXmlPtrOutput() PoolXmlPtrOutput

func (PoolXmlOutput) ToPoolXmlPtrOutputWithContext 

func (o PoolXmlOutput) ToPoolXmlPtrOutputWithContext(ctx context.Context) PoolXmlPtrOutput

func (PoolXmlOutput) Xslt 

func (o PoolXmlOutput) Xslt() pulumi.StringPtrOutput

type PoolXmlPtrInput 

type PoolXmlPtrInput interface {
	pulumi.Input

	ToPoolXmlPtrOutput() PoolXmlPtrOutput
	ToPoolXmlPtrOutputWithContext(context.Context) PoolXmlPtrOutput
}

PoolXmlPtrInput is an input type that accepts PoolXmlArgs, PoolXmlPtr and PoolXmlPtrOutput values. You can construct a concrete instance of `PoolXmlPtrInput` via: 

        PoolXmlArgs{...}

or:

        nil

func PoolXmlPtr 

func PoolXmlPtr(v *PoolXmlArgs) PoolXmlPtrInput

type PoolXmlPtrOutput 

type PoolXmlPtrOutput struct{ *pulumi.OutputState }

func (PoolXmlPtrOutput) Elem 

func (o PoolXmlPtrOutput) Elem() PoolXmlOutput

func (PoolXmlPtrOutput) ElementType 

func (PoolXmlPtrOutput) ElementType() reflect.Type

func (PoolXmlPtrOutput) ToPoolXmlPtrOutput 

func (o PoolXmlPtrOutput) ToPoolXmlPtrOutput() PoolXmlPtrOutput

func (PoolXmlPtrOutput) ToPoolXmlPtrOutputWithContext 

func (o PoolXmlPtrOutput) ToPoolXmlPtrOutputWithContext(ctx context.Context) PoolXmlPtrOutput

func (PoolXmlPtrOutput) Xslt 

func (o PoolXmlPtrOutput) Xslt() pulumi.StringPtrOutput

type Provider 

type Provider struct {
	pulumi.ProviderResourceState

	// libvirt connection URI for operations. See https://libvirt.org/uri.html
	Uri pulumi.StringPtrOutput `pulumi:"uri"`
}

The provider type for the libvirt package. By default, resources use package-wide configuration settings, however an explicit `Provider` instance may be created and passed during resource construction to achieve fine-grained programmatic control over provider settings. See the [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information.

func NewProvider 

func NewProvider(ctx *pulumi.Context,
	name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error)

NewProvider registers a new resource with the given unique name, arguments, and options.

func (*Provider) ElementType 

func (*Provider) ElementType() reflect.Type

func (*Provider) ToProviderOutput 

func (i *Provider) ToProviderOutput() ProviderOutput

func (*Provider) ToProviderOutputWithContext 

func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type ProviderArgs 

type ProviderArgs struct {
	// libvirt connection URI for operations. See https://libvirt.org/uri.html
	Uri pulumi.StringPtrInput
}

The set of arguments for constructing a Provider resource.

func (ProviderArgs) ElementType 

func (ProviderArgs) ElementType() reflect.Type

type ProviderInput 

type ProviderInput interface {
	pulumi.Input

	ToProviderOutput() ProviderOutput
	ToProviderOutputWithContext(ctx context.Context) ProviderOutput
}

type ProviderOutput 

type ProviderOutput struct{ *pulumi.OutputState }

func (ProviderOutput) ElementType 

func (ProviderOutput) ElementType() reflect.Type

func (ProviderOutput) ToProviderOutput 

func (o ProviderOutput) ToProviderOutput() ProviderOutput

func (ProviderOutput) ToProviderOutputWithContext 

func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

func (ProviderOutput) Uri added in v0.3.0 

func (o ProviderOutput) Uri() pulumi.StringPtrOutput

libvirt connection URI for operations. See https://libvirt.org/uri.html

type Volume 

type Volume struct {
	pulumi.CustomResourceState

	// The backing volume (CoW) to use for this volume.
	BaseVolumeId pulumi.StringPtrOutput `pulumi:"baseVolumeId"`
	// The name of the backing volume (CoW) to use
	// for this volume. Note well: when `baseVolumePool` is not specified the
	// volume is going to be searched inside of `pool`.
	BaseVolumeName pulumi.StringPtrOutput `pulumi:"baseVolumeName"`
	// The name of the storage pool containing the
	// volume defined by `baseVolumeName`.
	BaseVolumePool pulumi.StringPtrOutput `pulumi:"baseVolumePool"`
	Format         pulumi.StringOutput    `pulumi:"format"`
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringOutput `pulumi:"name"`
	// The storage pool where the resource will be created.
	// If not given, the `default` storage pool will be used.
	Pool pulumi.StringPtrOutput `pulumi:"pool"`
	// The size of the volume in bytes (if you don't like this,
	// help fix this issue.
	// If `source` is specified, `size` will be set to the source image file size.
	// `size` can be omitted if `source` is specified. `size` will then be set to the source image file size.
	// `size` can be omitted if `baseVolumeId` or `baseVolumeName` is specified. `size` will then be set to the base volume size.
	// If `size` is specified to be bigger than `baseVolumeId` or `baseVolumeName` size, you can use [cloudinit](https://cloudinit.readthedocs.io) if your OS supports it, with `CloudInitDisk` and the [growpart](https://cloudinit.readthedocs.io/en/latest/topics/modules.html#growpart) module to resize the partition.
	Size   pulumi.IntOutput       `pulumi:"size"`
	Source pulumi.StringPtrOutput `pulumi:"source"`
	Xml    VolumeXmlPtrOutput     `pulumi:"xml"`
}

Manages a storage volume in libvirt. For more information see [the official documentation](https://libvirt.org/formatstorage.html).

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-libvirt/sdk/go/libvirt"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Base OS image to use to create a cluster of different
		// nodes
		opensuseLeap, err := libvirt.NewVolume(ctx, "opensuseLeap", &libvirt.VolumeArgs{
			Source: pulumi.String("http://download.opensuse.org/repositories/Cloud:/Images:/Leap_42.1/images/openSUSE-Leap-42.1-OpenStack.x86_64.qcow2"),
		})
		if err != nil {
			return err
		}
		// volume to attach to the "master" domain as main disk
		_, err = libvirt.NewVolume(ctx, "master", &libvirt.VolumeArgs{
			BaseVolumeId: opensuseLeap.ID(),
		})
		if err != nil {
			return err
		}
		// volumes to attach to the "workers" domains as main disk
		var worker []*libvirt.Volume
		for index := 0; index < _var.Workers_count; index++ {
			key0 := index
			_ := index
			__res, err := libvirt.NewVolume(ctx, fmt.Sprintf("worker-%v", key0), &libvirt.VolumeArgs{
				BaseVolumeId: opensuseLeap.ID(),
			})
			if err != nil {
				return err
			}
			worker = append(worker, __res)
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

> **Tip:** when provisioning multiple domains using the same base image, create a `Volume` for the base image and then define the domain specific ones as based on it. This way the image will not be modified and no extra disk space is going to be used for the base image.

func GetVolume 

func GetVolume(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VolumeState, opts ...pulumi.ResourceOption) (*Volume, error)

GetVolume gets an existing Volume resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVolume 

func NewVolume(ctx *pulumi.Context,
	name string, args *VolumeArgs, opts ...pulumi.ResourceOption) (*Volume, error)

NewVolume registers a new resource with the given unique name, arguments, and options.

func (*Volume) ElementType 

func (*Volume) ElementType() reflect.Type

func (*Volume) ToVolumeOutput 

func (i *Volume) ToVolumeOutput() VolumeOutput

func (*Volume) ToVolumeOutputWithContext 

func (i *Volume) ToVolumeOutputWithContext(ctx context.Context) VolumeOutput

type VolumeArgs 

type VolumeArgs struct {
	// The backing volume (CoW) to use for this volume.
	BaseVolumeId pulumi.StringPtrInput
	// The name of the backing volume (CoW) to use
	// for this volume. Note well: when `baseVolumePool` is not specified the
	// volume is going to be searched inside of `pool`.
	BaseVolumeName pulumi.StringPtrInput
	// The name of the storage pool containing the
	// volume defined by `baseVolumeName`.
	BaseVolumePool pulumi.StringPtrInput
	Format         pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The storage pool where the resource will be created.
	// If not given, the `default` storage pool will be used.
	Pool pulumi.StringPtrInput
	// The size of the volume in bytes (if you don't like this,
	// help fix this issue.
	// If `source` is specified, `size` will be set to the source image file size.
	// `size` can be omitted if `source` is specified. `size` will then be set to the source image file size.
	// `size` can be omitted if `baseVolumeId` or `baseVolumeName` is specified. `size` will then be set to the base volume size.
	// If `size` is specified to be bigger than `baseVolumeId` or `baseVolumeName` size, you can use [cloudinit](https://cloudinit.readthedocs.io) if your OS supports it, with `CloudInitDisk` and the [growpart](https://cloudinit.readthedocs.io/en/latest/topics/modules.html#growpart) module to resize the partition.
	Size   pulumi.IntPtrInput
	Source pulumi.StringPtrInput
	Xml    VolumeXmlPtrInput
}

The set of arguments for constructing a Volume resource.

func (VolumeArgs) ElementType 

func (VolumeArgs) ElementType() reflect.Type

type VolumeArray 

type VolumeArray []VolumeInput

func (VolumeArray) ElementType 

func (VolumeArray) ElementType() reflect.Type

func (VolumeArray) ToVolumeArrayOutput 

func (i VolumeArray) ToVolumeArrayOutput() VolumeArrayOutput

func (VolumeArray) ToVolumeArrayOutputWithContext 

func (i VolumeArray) ToVolumeArrayOutputWithContext(ctx context.Context) VolumeArrayOutput

type VolumeArrayInput 

type VolumeArrayInput interface {
	pulumi.Input

	ToVolumeArrayOutput() VolumeArrayOutput
	ToVolumeArrayOutputWithContext(context.Context) VolumeArrayOutput
}

VolumeArrayInput is an input type that accepts VolumeArray and VolumeArrayOutput values. You can construct a concrete instance of `VolumeArrayInput` via: 

VolumeArray{ VolumeArgs{...} }

type VolumeArrayOutput 

type VolumeArrayOutput struct{ *pulumi.OutputState }

func (VolumeArrayOutput) ElementType 

func (VolumeArrayOutput) ElementType() reflect.Type

func (VolumeArrayOutput) Index 

func (o VolumeArrayOutput) Index(i pulumi.IntInput) VolumeOutput

func (VolumeArrayOutput) ToVolumeArrayOutput 

func (o VolumeArrayOutput) ToVolumeArrayOutput() VolumeArrayOutput

func (VolumeArrayOutput) ToVolumeArrayOutputWithContext 

func (o VolumeArrayOutput) ToVolumeArrayOutputWithContext(ctx context.Context) VolumeArrayOutput

type VolumeInput 

type VolumeInput interface {
	pulumi.Input

	ToVolumeOutput() VolumeOutput
	ToVolumeOutputWithContext(ctx context.Context) VolumeOutput
}

type VolumeMap 

type VolumeMap map[string]VolumeInput

func (VolumeMap) ElementType 

func (VolumeMap) ElementType() reflect.Type

func (VolumeMap) ToVolumeMapOutput 

func (i VolumeMap) ToVolumeMapOutput() VolumeMapOutput

func (VolumeMap) ToVolumeMapOutputWithContext 

func (i VolumeMap) ToVolumeMapOutputWithContext(ctx context.Context) VolumeMapOutput

type VolumeMapInput 

type VolumeMapInput interface {
	pulumi.Input

	ToVolumeMapOutput() VolumeMapOutput
	ToVolumeMapOutputWithContext(context.Context) VolumeMapOutput
}

VolumeMapInput is an input type that accepts VolumeMap and VolumeMapOutput values. You can construct a concrete instance of `VolumeMapInput` via: 

VolumeMap{ "key": VolumeArgs{...} }

type VolumeMapOutput 

type VolumeMapOutput struct{ *pulumi.OutputState }

func (VolumeMapOutput) ElementType 

func (VolumeMapOutput) ElementType() reflect.Type

func (VolumeMapOutput) MapIndex 

func (o VolumeMapOutput) MapIndex(k pulumi.StringInput) VolumeOutput

func (VolumeMapOutput) ToVolumeMapOutput 

func (o VolumeMapOutput) ToVolumeMapOutput() VolumeMapOutput

func (VolumeMapOutput) ToVolumeMapOutputWithContext 

func (o VolumeMapOutput) ToVolumeMapOutputWithContext(ctx context.Context) VolumeMapOutput

type VolumeOutput 

type VolumeOutput struct{ *pulumi.OutputState }

func (VolumeOutput) BaseVolumeId added in v0.3.0 

func (o VolumeOutput) BaseVolumeId() pulumi.StringPtrOutput

The backing volume (CoW) to use for this volume.

func (VolumeOutput) BaseVolumeName added in v0.3.0 

func (o VolumeOutput) BaseVolumeName() pulumi.StringPtrOutput

The name of the backing volume (CoW) to use for this volume. Note well: when `baseVolumePool` is not specified the volume is going to be searched inside of `pool`.

func (VolumeOutput) BaseVolumePool added in v0.3.0 

func (o VolumeOutput) BaseVolumePool() pulumi.StringPtrOutput

The name of the storage pool containing the volume defined by `baseVolumeName`.

func (VolumeOutput) ElementType 

func (VolumeOutput) ElementType() reflect.Type

func (VolumeOutput) Format added in v0.3.0 

func (o VolumeOutput) Format() pulumi.StringOutput

func (VolumeOutput) Name added in v0.3.0 

func (o VolumeOutput) Name() pulumi.StringOutput

A unique name for the resource, required by libvirt. Changing this forces a new resource to be created.

func (VolumeOutput) Pool added in v0.3.0 

func (o VolumeOutput) Pool() pulumi.StringPtrOutput

The storage pool where the resource will be created. If not given, the `default` storage pool will be used.

func (VolumeOutput) Size added in v0.3.0 

func (o VolumeOutput) Size() pulumi.IntOutput

The size of the volume in bytes (if you don't like this, help fix this issue. If `source` is specified, `size` will be set to the source image file size. `size` can be omitted if `source` is specified. `size` will then be set to the source image file size. `size` can be omitted if `baseVolumeId` or `baseVolumeName` is specified. `size` will then be set to the base volume size. If `size` is specified to be bigger than `baseVolumeId` or `baseVolumeName` size, you can use [cloudinit](https://cloudinit.readthedocs.io) if your OS supports it, with `CloudInitDisk` and the [growpart](https://cloudinit.readthedocs.io/en/latest/topics/modules.html#growpart) module to resize the partition.

func (VolumeOutput) Source added in v0.3.0 

func (o VolumeOutput) Source() pulumi.StringPtrOutput

func (VolumeOutput) ToVolumeOutput 

func (o VolumeOutput) ToVolumeOutput() VolumeOutput

func (VolumeOutput) ToVolumeOutputWithContext 

func (o VolumeOutput) ToVolumeOutputWithContext(ctx context.Context) VolumeOutput

func (VolumeOutput) Xml added in v0.3.0 

func (o VolumeOutput) Xml() VolumeXmlPtrOutput

type VolumeState 

type VolumeState struct {
	// The backing volume (CoW) to use for this volume.
	BaseVolumeId pulumi.StringPtrInput
	// The name of the backing volume (CoW) to use
	// for this volume. Note well: when `baseVolumePool` is not specified the
	// volume is going to be searched inside of `pool`.
	BaseVolumeName pulumi.StringPtrInput
	// The name of the storage pool containing the
	// volume defined by `baseVolumeName`.
	BaseVolumePool pulumi.StringPtrInput
	Format         pulumi.StringPtrInput
	// A unique name for the resource, required by libvirt.
	// Changing this forces a new resource to be created.
	Name pulumi.StringPtrInput
	// The storage pool where the resource will be created.
	// If not given, the `default` storage pool will be used.
	Pool pulumi.StringPtrInput
	// The size of the volume in bytes (if you don't like this,
	// help fix this issue.
	// If `source` is specified, `size` will be set to the source image file size.
	// `size` can be omitted if `source` is specified. `size` will then be set to the source image file size.
	// `size` can be omitted if `baseVolumeId` or `baseVolumeName` is specified. `size` will then be set to the base volume size.
	// If `size` is specified to be bigger than `baseVolumeId` or `baseVolumeName` size, you can use [cloudinit](https://cloudinit.readthedocs.io) if your OS supports it, with `CloudInitDisk` and the [growpart](https://cloudinit.readthedocs.io/en/latest/topics/modules.html#growpart) module to resize the partition.
	Size   pulumi.IntPtrInput
	Source pulumi.StringPtrInput
	Xml    VolumeXmlPtrInput
}

func (VolumeState) ElementType 

func (VolumeState) ElementType() reflect.Type

type VolumeXml 

type VolumeXml struct {
	Xslt *string `pulumi:"xslt"`
}

type VolumeXmlArgs 

type VolumeXmlArgs struct {
	Xslt pulumi.StringPtrInput `pulumi:"xslt"`
}

func (VolumeXmlArgs) ElementType 

func (VolumeXmlArgs) ElementType() reflect.Type

func (VolumeXmlArgs) ToVolumeXmlOutput 

func (i VolumeXmlArgs) ToVolumeXmlOutput() VolumeXmlOutput

func (VolumeXmlArgs) ToVolumeXmlOutputWithContext 

func (i VolumeXmlArgs) ToVolumeXmlOutputWithContext(ctx context.Context) VolumeXmlOutput

func (VolumeXmlArgs) ToVolumeXmlPtrOutput 

func (i VolumeXmlArgs) ToVolumeXmlPtrOutput() VolumeXmlPtrOutput

func (VolumeXmlArgs) ToVolumeXmlPtrOutputWithContext 

func (i VolumeXmlArgs) ToVolumeXmlPtrOutputWithContext(ctx context.Context) VolumeXmlPtrOutput

type VolumeXmlInput 

type VolumeXmlInput interface {
	pulumi.Input

	ToVolumeXmlOutput() VolumeXmlOutput
	ToVolumeXmlOutputWithContext(context.Context) VolumeXmlOutput
}

VolumeXmlInput is an input type that accepts VolumeXmlArgs and VolumeXmlOutput values. You can construct a concrete instance of `VolumeXmlInput` via: 

VolumeXmlArgs{...}

type VolumeXmlOutput 

type VolumeXmlOutput struct{ *pulumi.OutputState }

func (VolumeXmlOutput) ElementType 

func (VolumeXmlOutput) ElementType() reflect.Type

func (VolumeXmlOutput) ToVolumeXmlOutput 

func (o VolumeXmlOutput) ToVolumeXmlOutput() VolumeXmlOutput

func (VolumeXmlOutput) ToVolumeXmlOutputWithContext 

func (o VolumeXmlOutput) ToVolumeXmlOutputWithContext(ctx context.Context) VolumeXmlOutput

func (VolumeXmlOutput) ToVolumeXmlPtrOutput 

func (o VolumeXmlOutput) ToVolumeXmlPtrOutput() VolumeXmlPtrOutput

func (VolumeXmlOutput) ToVolumeXmlPtrOutputWithContext 

func (o VolumeXmlOutput) ToVolumeXmlPtrOutputWithContext(ctx context.Context) VolumeXmlPtrOutput

func (VolumeXmlOutput) Xslt 

func (o VolumeXmlOutput) Xslt() pulumi.StringPtrOutput

type VolumeXmlPtrInput 

type VolumeXmlPtrInput interface {
	pulumi.Input

	ToVolumeXmlPtrOutput() VolumeXmlPtrOutput
	ToVolumeXmlPtrOutputWithContext(context.Context) VolumeXmlPtrOutput
}

VolumeXmlPtrInput is an input type that accepts VolumeXmlArgs, VolumeXmlPtr and VolumeXmlPtrOutput values. You can construct a concrete instance of `VolumeXmlPtrInput` via: 

        VolumeXmlArgs{...}

or:

        nil

func VolumeXmlPtr 

func VolumeXmlPtr(v *VolumeXmlArgs) VolumeXmlPtrInput

type VolumeXmlPtrOutput 

type VolumeXmlPtrOutput struct{ *pulumi.OutputState }

func (VolumeXmlPtrOutput) Elem 

func (o VolumeXmlPtrOutput) Elem() VolumeXmlOutput

func (VolumeXmlPtrOutput) ElementType 

func (VolumeXmlPtrOutput) ElementType() reflect.Type

func (VolumeXmlPtrOutput) ToVolumeXmlPtrOutput 

func (o VolumeXmlPtrOutput) ToVolumeXmlPtrOutput() VolumeXmlPtrOutput

func (VolumeXmlPtrOutput) ToVolumeXmlPtrOutputWithContext 

func (o VolumeXmlPtrOutput) ToVolumeXmlPtrOutputWithContext(ctx context.Context) VolumeXmlPtrOutput

func (VolumeXmlPtrOutput) Xslt 

func (o VolumeXmlPtrOutput) Xslt() pulumi.StringPtrOutput

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.