.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "gomod" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "daily"

.github/release.yml

@@ -1,14 +0,0 @@
-changelog:
-  categories:
-    - title: Breaking Changes 🛠
-      labels:
-        - breaking-change
-    - title: New Features 🎉
-      labels:
-        - enhancement
-    - title: Bug fixes
-      labels:
-        - bug
-    - title: Other Changes
-      labels:
-        - "*"

.github/workflows/go-test.yml

@@ -1,24 +0,0 @@
-name: go-test
-on:
-  push:
-    branches:
-      - 'main'
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  go-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Unshallow
-        run: git fetch --prune --unshallow
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: "1.20"
-      - name: Run go tests
-        run: go test -race -count 1 ./... -timeout=3m

.github/workflows/release.yml

@@ -1,46 +0,0 @@
-# This GitHub action can publish assets for release when a tag is created.
-# Currently its setup to run on any tag that matches the pattern "v*" (ie. v0.1.0).
-#
-# This uses an action (hashicorp/ghaction-import-gpg) that assumes you set your
-# private key in the `GPG_PRIVATE_KEY` secret and passphrase in the `GPG_PASSPHRASE`
-# secret. If you would rather own your own GPG handling, please fork this action
-# or use an alternative one for key handling.
-#
-# You will need to pass the `--batch` flag to `gpg` in your signing step
-# in `goreleaser` to indicate this is being used in a non-interactive mode.
-#
-name: release
-on:
-  push:
-    tags:
-      - 'v*'
-jobs:
-  goreleaser:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Unshallow
-        run: git fetch --prune --unshallow
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: "1.20"
-      - name: Describe plugin
-        id: plugin_describe
-        run: echo "::set-output name=api_version::$(go run . describe | jq -r '.api_version')"
-      - name: Import GPG key
-        id: import_gpg
-        uses: crazy-max/ghaction-import-gpg@v5.0.0
-        with:
-          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
-          passphrase: ${{ secrets.GPG_PASSPHRASE }}
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@f82d6c1c344bcacabba2c841718984797f664a6b # v4.2.0
-        with:
-          version: latest
-          args: release --clean
-        env:
-          GPG_FINGERPRINT: ${{ steps.import_gpg.outputs.fingerprint }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          API_VERSION: ${{ steps.plugin_describe.outputs.api_version }}

.gitignore

@@ -1,10 +1,2 @@
 *.swp
 *~
-bin
-pkg
-crash.log
-packer_cache/*
-builder-*
-dist/*
-vendor/*
-packer-plugin-xenserver

.go-version

@@ -1 +0,0 @@
-1.20.11

.goreleaser.yml

@@ -1,74 +0,0 @@
-version: 2
-# This is an example goreleaser.yaml file with some sane defaults.
-# Make sure to check the documentation at http://goreleaser.com
-env:
-  - CGO_ENABLED=0
-before:
-  hooks:
-    - go test ./...
-    # As part of the release doc files are included as a separate deliverable for
-    # consumption by Packer.io. To include a separate docs.zip uncomment the following command.
-    #- make ci-release-docs
-    # Check plugin compatibility with required version of the Packer SDK
-    - make plugin-check
-builds:
-  # A separated build to run the packer-plugins-check only once for a linux_amd64 binary
-  -
-    id: plugin-check
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    flags:
-      - -trimpath #removes all file system paths from the compiled executable
-    ldflags:
-      - '-s -w -X {{ .ModulePath }}/version.Version={{.Version}} -X {{ .ModulePath }}/version.VersionPrerelease= '
-    goos:
-      - linux
-    goarch:
-      - amd64
-    binary: '{{ .ProjectName }}_v{{ .Version }}_{{ .Env.API_VERSION }}_{{ .Os }}_{{ .Arch }}'
-  -
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    flags:
-      - -trimpath #removes all file system paths from the compiled executable
-    ldflags:
-      - '-s -w -X {{ .ModulePath }}/version.Version={{.Version}} -X {{ .ModulePath }}/version.VersionPrerelease= '
-    goos:
-      - freebsd
-      - windows
-      - linux
-      - darwin
-    goarch:
-      - amd64
-      - '386'
-      - arm
-      - arm64
-    ignore:
-      - goos: darwin
-        goarch: '386'
-      - goos: linux
-        goarch: amd64
-    binary: '{{ .ProjectName }}_v{{ .Version }}_{{ .Env.API_VERSION }}_{{ .Os }}_{{ .Arch }}'
-archives:
-- format: zip
-  files:
-    - none*
-  name_template: '{{ .ProjectName }}_v{{ .Version }}_{{ .Env.API_VERSION }}_{{ .Os }}_{{ .Arch }}'
-checksum:
-  name_template: '{{ .ProjectName }}_v{{ .Version }}_SHA256SUMS'
-  algorithm: sha256
-signs:
-  - artifacts: checksum
-    args:
-      # if you are using this is in a GitHub action or some other automated pipeline, you
-      # need to pass the batch flag to indicate its not interactive.
-      - "--batch"
-      - "--local-user"
-      - "{{ .Env.GPG_FINGERPRINT }}"
-      - "--output"
-      - "${signature}"
-      - "--detach-sign"
-      - "${artifact}"
-release:
-  draft: false
-
-changelog:
-  disable: true

GNUmakefile

@@ -1,34 +0,0 @@
-NAME=xenserver
-BINARY=packer-plugin-${NAME}
-
-COUNT?=1
-TEST?=$(shell go list ./...)
-HASHICORP_PACKER_PLUGIN_SDK_VERSION?=$(shell go list -m github.com/hashicorp/packer-plugin-sdk | cut -d " " -f2)
-
-.PHONY: dev
-
-build:
-	@go build -o ${BINARY}
-
-dev: build
-	@mkdir -p ~/.packer.d/plugins/
-	@mv ${BINARY} ~/.packer.d/plugins/${BINARY}
-
-test:
-	@go test -race -count $(COUNT) $(TEST) -timeout=3m
-
-install-packer-sdc: ## Install packer sofware development command
-	@go install github.com/hashicorp/packer-plugin-sdk/cmd/packer-sdc@${HASHICORP_PACKER_PLUGIN_SDK_VERSION}
-
-ci-release-docs: install-packer-sdc
-	@packer-sdc renderdocs -src docs -partials docs-partials/ -dst docs/
-	@/bin/sh -c "[ -d docs ] && zip -r docs.zip docs/"
-
-plugin-check: install-packer-sdc build
-	@packer-sdc plugin-check ${BINARY}
-
-testacc: dev
-	@PACKER_ACC=1 go test -count $(COUNT) -v $(TEST) -timeout=120m
-
-generate: install-packer-sdc
-	@go generate ./...

README.md

@@ -2,86 +2,6 @@
 
 This builder plugin extends packer.io to support building images for XenServer. 
 
-This is a fork of the original builder since the original project was abandoned and no longer compiled with recent versions of Go or worked with Xenserver 7.6 and later.
+You can check out packer [here](https://packer.io).
 
-It improves the original project in the following ways:
-1. Developed alongside the [Xenorchestra terraform provider](https://github.com/ddelnano/terraform-provider-xenorchestra) to ensure the hashicorp ecosystem is interoperable.
-2. Reimplements how the boot commands are sent over VNC to be compatible with later versions of Xenserver (Citrix hypervisor) and XCP
 
-## Status
-
-At the time of this writing the packer builder has been verified to work with Xenserver 7.6 and can launch VMs with the packer output through the xenorchestra terraform provider.
-
-The following list contains things that are incomplete but will be worked on soon:
-
-- The documentation is still in an inconsistent state with upstream
-- XVA builder is untested
-- Lots of dead code to remove from upstream
-
-## Using the builder
-
-The packer builder can be installed via `packer init` as long as the packer template includes the following in it's `pkr.hcl` file
-```
-packer {
-  required_plugins {
-   xenserver= {
-      version = ">= v0.6.0"
-      source = "github.com/ddelnano/xenserver"
-    }
-  }
-}
-```
-
-The following command will install the packer plugin using the Ubuntu example provided in this repository.
-
-```
-packer init examples/ubuntu/ubuntu-2004.pkr.hcl
-```
-
-If you are using an older version of packer or are still using json templates you will need to download the relevant release from the project's [releases page](https://github.com/ddelnano/packer-builder-xenserver/releases) and copy the binary to `~/.packer.d/plugins/packer-builder-xenserver-iso`.
-
-## Developing the builder
-
-### Dependencies
-* Packer >= v1.7.1 (https://packer.io)
-* XenServer / Citrix Hypervisor > 7.6
-* Golang 1.20
-
-## Compile the plugin
-
-Once you have installed Packer, you must compile this plugin and install the
-resulting binary.
-
-Documentation for Plugins directory: [Official Docs](https://developer.hashicorp.com/packer/docs/configure#packer-s-plugin-directory)
-
-### Linux/MacOS
-
-```shell
-go build -o packer-plugin-xenserver
-
-# Add the plugin to the location packer expects it to be installed in
-mkdir -p ~/.packer.d/plugins/
-cp packer-plugin-xenserver  ~/.packer.d/plugins
-```
-
-### Windows (Powershell)
-
-```powershell
-go build -o packer-plugin-xenserver
-
-mkdir "%APPDATA%\packer.d\plugins"
-cp packer-plugin-xenserver  "%APPDATA%\packer.d\plugins"
-```
-
-# Documentation
-
-For complete documentation on configuration commands, see [the
-xenserver-iso docs](docs/builders/iso/xenserver-iso.html.markdown)
-
-## Support
-
-You can discuss any issues you have or feature requests in [Discord](https://discord.gg/ZpNq8ez).
-
-If you'd like to support my effort on the project, please consider buying me a coffee
-
-[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/ddelnano)

build.sh

@@ -0,0 +1 @@
+go build -o $PACKERPATH/packer-builder-xenserver main.go 

builder/xenserver/artifact.go

@@ -0,0 +1,57 @@
+package xenserver
+
+import (
+    "fmt"
+    "os"
+    "github.com/mitchellh/packer/packer"
+    "path/filepath"
+)
+
+
+type LocalArtifact struct {
+    dir string
+    f []string
+}
+
+
+func NewArtifact(dir string) (packer.Artifact, error) {
+    files := make([]string, 0, 1)
+    visit := func(path string, info os.FileInfo, err error) error {
+        if !info.IsDir() {
+            files = append(files, path)
+        }
+        return err
+    }
+    if err := filepath.Walk(dir, visit); err != nil {
+        return nil, err
+    }
+
+    return &LocalArtifact{
+        dir: dir,
+        f: files,
+    }, nil
+}
+
+func (*LocalArtifact) BuilderId() string {
+    return BuilderId
+}
+
+func (a *LocalArtifact) Files() []string {
+    return a.f
+}
+
+func (*LocalArtifact) Id() string {
+    return "VM"
+}
+
+func (a *LocalArtifact) String() string {
+    return fmt.Sprintf("VM files in directory: %s", a.dir)
+}
+
+func (a *LocalArtifact) State(name string) interface{} {
+    return nil
+}
+
+func (a *LocalArtifact) Destroy() error {
+    return os.RemoveAll(a.dir)
+}

builder/xenserver/builder.go

@@ -0,0 +1,387 @@
+package xenserver
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "github.com/mitchellh/packer/common"
+    "fmt"
+    "log"
+    "errors"
+    "time"
+    "os"
+    commonssh "github.com/mitchellh/packer/common/ssh"
+)
+
+
+// Set the unique ID for this builder
+const BuilderId = "packer.xenserver"
+
+
+type config struct {
+    common.PackerConfig `mapstructure:",squash"`
+
+    Username        string      `mapstructure:"username"`
+    Password        string      `mapstructure:"password"`
+    HostIp          string      `mapstructure:"host_ip"`
+    IsoUrl          string      `mapstructure:"iso_url"`
+
+    InstanceName    string      `mapstructure:"instance_name"`
+    InstanceMemory  string      `mapstructure:"instance_memory"`
+    RootDiskSize    string      `mapstructure:"root_disk_size"`
+    CloneTemplate   string      `mapstructure:"clone_template"`
+    IsoName         string      `mapstructure:"iso_name"`
+    SrName          string      `mapstructure:"sr_name"`
+    NetworkName     string      `mapstructure:"network_name"`
+
+    HostPortMin      uint        `mapstructure:"host_port_min"`
+    HostPortMax      uint        `mapstructure:"host_port_max"`
+
+    BootCommand     []string    `mapstructure:"boot_command"`
+    RawBootWait     string      `mapstructure:"boot_wait"`
+
+    BootWait        time.Duration ``
+    sshWaitTimeout  time.Duration ``
+
+    ISOChecksum     string      `mapstructure:"iso_checksum"`
+    ISOChecksumType string      `mapstructure:"iso_checksum_type"`
+    ISOUrls         []string    `mapstructure:"iso_urls"`
+    ISOUrl          string      `mapstructure:"iso_url"`
+
+    HTTPDir         string      `mapstructure:"http_directory"`
+    HTTPPortMin     uint        `mapstructure:"http_port_min"`
+    HTTPPortMax     uint        `mapstructure:"http_port_max"`
+
+    LocalIp         string      `mapstructure:"local_ip"`
+    PlatformArgs    map[string]string `mapstructure:"platform_args"`
+
+    RawSSHWaitTimeout string    `mapstructure:"ssh_wait_timeout"`
+
+    SSHPassword     string      `mapstructure:"ssh_password"`
+    SSHUser         string      `mapstructure:"ssh_username"`
+    SSHKeyPath      string      `mapstructure:"ssh_key_path"`
+
+    OutputDir       string      `mapstructure:"output_directory"`
+
+    tpl *packer.ConfigTemplate
+}
+
+
+type Builder struct {
+    config config
+    runner multistep.Runner
+}
+
+
+func (self *Builder) Prepare (raws ...interface{}) (params []string, retErr error) {
+
+    md, err := common.DecodeConfig(&self.config, raws...)
+    if err != nil {
+        return nil, err
+    }
+
+    errs := common.CheckUnusedConfig(md)
+    if errs == nil {
+        errs = &packer.MultiError{}
+    }
+
+    self.config.tpl, err = packer.NewConfigTemplate()
+
+    if err != nil {
+        return nil, err
+    }
+
+    // Set default vaules
+
+    if self.config.HostPortMin == 0 {
+        self.config.HostPortMin = 5900
+    }
+
+    if self.config.HostPortMax == 0 {
+        self.config.HostPortMax = 6000
+    }
+
+    if self.config.RawBootWait == "" {
+        self.config.RawBootWait = "5s"
+    }
+
+    if self.config.HTTPPortMin == 0 {
+        self.config.HTTPPortMin = 8000
+    }
+
+    if self.config.HTTPPortMax == 0 {
+        self.config.HTTPPortMax = 9000
+    }
+
+    if self.config.RawSSHWaitTimeout == "" {
+        self.config.RawSSHWaitTimeout = "200m"
+    }
+
+    if self.config.OutputDir == "" {
+        self.config.OutputDir = fmt.Sprintf("output-%s", self.config.PackerBuildName)
+    }
+
+    templates := map[string]*string {
+        "username":             &self.config.Username,
+        "password":             &self.config.Password,
+        "host_ip":              &self.config.HostIp,
+        "iso_url":              &self.config.IsoUrl,
+        "instance_name":        &self.config.InstanceName,
+        "instance_memory":      &self.config.InstanceMemory,
+        "root_disk_size":       &self.config.RootDiskSize,
+        "clone_template":       &self.config.CloneTemplate,
+        "iso_name":             &self.config.IsoName,
+        "sr_name":              &self.config.SrName,
+        "network_name":         &self.config.NetworkName,
+        "boot_wait":            &self.config.RawBootWait,
+        "iso_checksum":         &self.config.ISOChecksum,
+        "iso_checksum_type":    &self.config.ISOChecksumType,
+        "http_directory":       &self.config.HTTPDir,
+        "local_ip":             &self.config.LocalIp,
+        "ssh_wait_timeout":     &self.config.RawSSHWaitTimeout,
+        "ssh_username":         &self.config.SSHUser,
+        "ssh_password":         &self.config.SSHPassword,
+        "ssh_key_path":         &self.config.SSHKeyPath,
+        "output_directory":     &self.config.OutputDir,
+    }
+
+
+    for n, ptr := range templates {
+        var err error
+        *ptr, err = self.config.tpl.Process(*ptr, nil)
+        if err != nil {
+            errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing %s: %s", n, err))
+        }
+    }
+
+/*
+    if self.config.IsoUrl == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("a iso url must be specified"))
+    }
+*/
+
+    self.config.BootWait, err = time.ParseDuration(self.config.RawBootWait)
+    if err != nil {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("Failed to parse boot_wait."))
+    }
+
+    self.config.sshWaitTimeout, err = time.ParseDuration(self.config.RawSSHWaitTimeout)
+    if err != nil {
+        errs = packer.MultiErrorAppend(
+                errs, fmt.Errorf("Failed to parse ssh_wait_timeout: %s", err))
+    }
+
+    for i, command := range self.config.BootCommand {
+        if err := self.config.tpl.Validate(command); err != nil {
+            errs = packer.MultiErrorAppend(errs,
+                    fmt.Errorf("Error processing boot_command[%d]: %s", i, err))
+        }
+    }
+
+    if self.config.SSHUser == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("An ssh_username must be specified."))
+    }
+
+    if self.config.SSHKeyPath != "" {
+        if _, err := os.Stat(self.config.SSHKeyPath); err != nil {
+            errs = packer.MultiErrorAppend(
+                    errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
+        } else if _, err := commonssh.FileSigner(self.config.SSHKeyPath); err != nil {
+            errs = packer.MultiErrorAppend(
+                    errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
+        }
+    }
+
+    if self.config.Username == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("A username for the xenserver host must be specified."))
+    }
+
+    if self.config.Password == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("A password for the xenserver host must be specified."))
+    }
+
+    if self.config.HostIp == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("An ip for the xenserver host must be specified."))
+    }
+
+    if self.config.InstanceName == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("An insatnce name must be specified."))
+    }
+
+    if self.config.InstanceMemory == "" {
+        self.config.InstanceMemory = "1024000000"
+    }
+
+    if self.config.RootDiskSize == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("A root disk size must be specified."))
+    }
+
+    if self.config.CloneTemplate == "" {
+        self.config.CloneTemplate = "Other install media"
+    }
+
+/*
+    if self.config.LocalIp == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("A local IP visible to XenServer's mangement interface is required to serve files."))
+    }
+*/
+
+    if len(self.config.PlatformArgs) == 0 {
+        pargs := make(map[string]string)
+        pargs["viridian"] = "false"
+        pargs["nx"] = "true"
+        pargs["pae"] = "true"
+        pargs["apic"] = "true"
+        pargs["timeoffset"] = "0"
+        pargs["acpi"] = "1"
+        self.config.PlatformArgs = pargs
+    }
+
+    if self.config.HTTPPortMin > self.config.HTTPPortMax {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("the HTTP min port must be less than the max"))
+    }
+
+    if self.config.HostPortMin > self.config.HostPortMax {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("the host min port must be less than the max"))
+    }
+/*
+    if self.config.ISOChecksumType == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("The iso_checksum_type must be specified."))
+    } else {
+        self.config.ISOChecksumType = strings.ToLower(self.config.ISOChecksumType)
+        if self.config.ISOChecksumType != "none" {
+            if self.config.ISOChecksum == "" {
+                errs = packer.MultiErrorAppend(
+                        errs, errors.New("Due to the file size being large, an iso_checksum is required."))
+            } else {
+                self.config.ISOChecksum = strings.ToLower(self.config.ISOChecksum)
+            }
+
+            if hash := common.HashForType(self.config.ISOChecksumType); hash == nil {
+                errs = packer.MultiErrorAppend(
+                        errs, fmt.Errorf("Unsupported checksum type: %s", self.config.ISOChecksumType))
+            }
+
+        }
+    }
+
+    if self.config.ISOUrl == "" {
+        errs = packer.MultiErrorAppend(
+                errs, errors.New("A ISO URL must be specfied."))
+    } else {
+        self.config.ISOUrls = []string{self.config.ISOUrl}
+    }
+
+    for i, url := range self.config.ISOUrls {
+        self.config.ISOUrls[i], err = common.DownloadableURL(url)
+        if err != nil {
+            errs = packer.MultiErrorAppend(
+                    errs, fmt.Errorf("Failed to parse the iso_url (%d): %s", i, err))
+        }
+    }
+*/
+    if len(errs.Errors) > 0 {
+        retErr = errors.New(errs.Error())
+    }
+
+    return nil, retErr
+
+}
+
+func (self *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+    //Setup XAPI client
+    client := NewXenAPIClient(self.config.HostIp, self.config.Username, self.config.Password)
+
+    err := client.Login()
+    if err != nil {
+        return nil, err.(error)
+    }
+    ui.Say("XAPI client session established")
+
+    client.GetHosts()
+
+    //Share state between the other steps using a statebag
+    state := new(multistep.BasicStateBag)
+    state.Put("cache", cache)
+    state.Put("client", client)
+    state.Put("config", self.config)
+    state.Put("hook", hook)
+    state.Put("ui", ui)
+
+
+    //Build the steps
+    steps := []multistep.Step{
+        /*
+        &common.StepDownload{
+            Checksum:       self.config.ISOChecksum,
+            ChecksumType:   self.config.ISOChecksumType,
+            Description:    "ISO",
+            ResultKey:      "iso_path",
+            Url:            self.config.ISOUrls,
+        },
+        */
+        new(stepPrepareOutputDir),
+        new(stepHTTPServer),
+        //new(stepUploadIso),
+        new(stepCreateInstance),
+        new(stepStartVmPaused),
+        new(stepGetVNCPort),
+        &stepForwardPortOverSSH{
+            RemotePort: instanceVNCPort,
+            RemoteDest: instanceVNCIP,
+            HostPortMin: self.config.HostPortMin,
+            HostPortMax: self.config.HostPortMax,
+            ResultKey: "local_vnc_port",
+        },
+        new(stepBootWait),
+        new(stepTypeBootCommand),
+        new(stepWait),
+        new(stepStartOnHIMN),
+        &stepForwardPortOverSSH{
+            RemotePort: himnSSHPort,
+            RemoteDest: himnSSHIP,
+            HostPortMin: self.config.HostPortMin,
+            HostPortMax: self.config.HostPortMax,
+            ResultKey: "local_ssh_port",
+        },
+        &common.StepConnectSSH{
+            SSHAddress: sshLocalAddress,
+            SSHConfig:  sshConfig,
+            SSHWaitTimeout: self.config.sshWaitTimeout,
+        },
+        new(common.StepProvision),
+        new(stepShutdownAndExport),
+    }
+
+    self.runner = &multistep.BasicRunner{Steps: steps}
+    self.runner.Run(state)
+
+    artifact, _ := NewArtifact(self.config.OutputDir)
+
+    if rawErr, ok := state.GetOk("error"); ok {
+        return nil, rawErr.(error)
+    }
+
+    return artifact, nil
+}
+
+
+func (self *Builder) Cancel() {
+    if self.runner != nil {
+        log.Println("Cancelling the step runner...")
+        self.runner.Cancel()
+    }
+    fmt.Println("Cancelling the builder")
+}
+

builder/xenserver/client.go

@@ -0,0 +1,761 @@
+package xenserver
+
+import (
+    "github.com/nilshell/xmlrpc"
+    "log"
+    "fmt"
+    "errors"
+)
+
+func check(err error) {
+    if err != nil {
+        log.Fatal(err)
+    }
+}
+
+
+type XenAPIClient struct {
+    Session     interface{}
+    Host        string
+    Url         string
+    Username    string
+    Password    string
+    RPC         *xmlrpc.Client
+}
+
+
+type APIResult struct {
+    Status string
+    Value interface{}
+    ErrorDescription string
+}
+
+type VM struct {
+    Ref     string
+    Client  *XenAPIClient
+}
+
+type SR struct {
+    Ref     string
+    Client  *XenAPIClient
+}
+
+type VDI struct {
+    Ref     string
+    Client  *XenAPIClient
+}
+
+type Network struct {
+    Ref     string
+    Client  *XenAPIClient
+}
+
+type VBD struct {
+    Ref string
+    Client *XenAPIClient
+}
+
+type VIF struct {
+    Ref string
+    Client *XenAPIClient
+}
+
+type PIF struct {
+    Ref string
+    Client *XenAPIClient
+}
+
+type Pool struct {
+    Ref string
+    Client *XenAPIClient
+}
+
+func (c *XenAPIClient) RPCCall (result interface{}, method string, params []interface{}) (err error) {
+    fmt.Println(params)
+    p := new(xmlrpc.Params)
+    p.Params = params
+    err = c.RPC.Call(method, *p, result)
+    return err
+}
+
+
+func (client *XenAPIClient) Login () (err error) {
+    //Do loging call
+    result := xmlrpc.Struct{}
+
+    params := make([]interface{}, 2)
+    params[0] = client.Username
+    params[1] = client.Password
+
+    err = client.RPCCall(&result, "session.login_with_password", params)
+    client.Session = result["Value"]
+    return err
+}
+
+func (client *XenAPIClient) APICall (result *APIResult, method string, params ...interface{}) (err error) {
+    if client.Session == nil {
+        fmt.Println("Error: no session")
+        return fmt.Errorf("No session. Unable to make call")
+    }
+
+    //Make a params slice which will include the session
+    p := make([]interface{}, len(params) + 1)
+    p[0] = client.Session
+
+    if params != nil {
+        for idx, element := range params {
+            p[idx+1] = element
+        }
+    }
+
+    res := xmlrpc.Struct{}
+
+    err = client.RPCCall(&res, method, p)
+
+    if err != nil {
+        return err
+    }
+
+    result.Status = res["Status"].(string)
+
+    if result.Status != "Success" {
+        fmt.Println("Encountered an API error: ", result.Status)
+        fmt.Println(res["ErrorDescription"])
+        log.Fatal(res["ErrorDescription"])
+        return errors.New("API Error occurred")
+    } else {
+        result.Value = res["Value"]
+    }
+    return
+}
+
+
+func (client *XenAPIClient) GetHosts () (err error) {
+    result := APIResult{}
+    _ = client.APICall(&result, "host.get_all")
+    hosts := result.Value
+    fmt.Println(hosts)
+    return nil
+}
+
+
+func (client *XenAPIClient) GetPools () (pools []*Pool, err error) {
+    pools = make([]*Pool, 0)
+    result := APIResult{}
+    err = client.APICall(&result, "pool.get_all")
+    if err != nil {
+        return pools, err
+    }
+
+    for _, elem := range result.Value.([]interface{}) {
+        pool := new(Pool)
+        pool.Ref = elem.(string)
+        pool.Client = client
+        pools = append(pools, pool)
+    }
+
+    return pools, nil
+}
+
+
+func (client *XenAPIClient) GetDefaultSR () (sr *SR, err error) {
+    pools, err := client.GetPools()
+
+    if err != nil {
+        return nil, err
+    }
+
+    pool_rec, err := pools[0].GetRecord()
+
+    if err != nil {
+        return nil, err
+    }
+
+    if pool_rec["default_SR"] == "" {
+        return nil, errors.New("No default_SR specified for the pool.")
+    }
+
+    sr = new(SR)
+    sr.Ref = pool_rec["default_SR"].(string)
+    sr.Client = client
+
+    return sr, nil
+}
+
+
+func (client *XenAPIClient) GetVMByUuid (vm_uuid string) (vm *VM, err error) {
+    vm = new(VM)
+    result := APIResult{}
+    err = client.APICall(&result, "VM.get_by_uuid", vm_uuid)
+    if err != nil {
+        return nil, err
+    }
+    vm.Ref = result.Value.(string)
+    vm.Client = client
+    return
+}
+
+
+func (client *XenAPIClient) GetVMByNameLabel (name_label string) (vms []*VM, err error) {
+    vms = make([]*VM, 0)
+    result := APIResult{}
+    err = client.APICall(&result, "VM.get_by_name_label", name_label)
+    if err != nil {
+        return vms, err
+    }
+
+    for _, elem := range result.Value.([]interface{}) {
+        vm := new(VM)
+        vm.Ref = elem.(string)
+        vm.Client = client
+        vms = append(vms, vm)
+    }
+
+    return vms, nil
+}
+
+
+func (client *XenAPIClient) GetSRByNameLabel (name_label string) (srs []*SR, err error) {
+    srs = make([]*SR, 0)
+    result := APIResult{}
+    err = client.APICall(&result, "SR.get_by_name_label", name_label)
+    if err != nil {
+        return srs, err
+    }
+
+    for _, elem := range result.Value.([]interface{}) {
+        sr := new(SR)
+        sr.Ref = elem.(string)
+        sr.Client = client
+        srs = append(srs, sr)
+    }
+
+    return srs, nil
+}
+
+func (client *XenAPIClient) GetNetworkByUuid (network_uuid string) (network *Network, err error) {
+    network = new(Network)
+    result := APIResult{}
+    err = client.APICall(&result, "network.get_by_uuid", network_uuid)
+    if err != nil {
+        return nil, err
+    }
+    network.Ref = result.Value.(string)
+    network.Client = client
+    return
+}
+
+
+func (client *XenAPIClient) GetNetworkByNameLabel (name_label string) (networks []*Network, err error) {
+    networks = make([]*Network, 0)
+    result := APIResult{}
+    err = client.APICall(&result, "network.get_by_name_label", name_label)
+    if err != nil {
+        return networks, err
+    }
+
+    for _, elem := range result.Value.([]interface{}) {
+        network := new(Network)
+        network.Ref = elem.(string)
+        network.Client = client
+        networks = append(networks, network)
+    }
+
+    return networks, nil
+}
+
+func (client *XenAPIClient) GetVdiByNameLabel (name_label string) (vdis []*VDI, err error) {
+    vdis = make([]*VDI, 0)
+    result := APIResult{}
+    err = client.APICall(&result, "VDI.get_by_name_label", name_label)
+    if err != nil {
+        return vdis, err
+    }
+
+    for _, elem := range result.Value.([]interface{}) {
+        vdi := new(VDI)
+        vdi.Ref = elem.(string)
+        vdi.Client = client
+        vdis = append(vdis, vdi)
+    }
+
+    return vdis, nil
+}
+
+
+func (client *XenAPIClient) GetSRByUuid (sr_uuid string) (sr *SR, err error) {
+    sr = new(SR)
+    result := APIResult{}
+    err = client.APICall(&result, "SR.get_by_uuid", sr_uuid)
+    if err != nil {
+        return nil, err
+    }
+    sr.Ref = result.Value.(string)
+    sr.Client = client
+    return
+}
+
+func (client *XenAPIClient) GetVdiByUuid (vdi_uuid string) (vdi *VDI, err error) {
+    vdi = new(VDI)
+    result := APIResult{}
+    err = client.APICall(&result, "VDI.get_by_uuid", vdi_uuid)
+    if err != nil {
+        return nil, err
+    }
+    vdi.Ref = result.Value.(string)
+    vdi.Client = client
+    return
+}
+
+func (client *XenAPIClient) GetPIFs() (pifs []*PIF, err error) {
+    pifs = make([]*PIF, 0)
+    result := APIResult{}
+    err = client.APICall(&result, "PIF.get_all")
+    if err != nil {
+        return pifs, err
+    }
+    for _, elem := range result.Value.([]interface{}) {
+        pif := new(PIF)
+        pif.Ref = elem.(string)
+        pif.Client = client
+        pifs = append(pifs, pif)
+    }
+
+    return pifs, nil
+}
+
+// VM associated functions
+
+func (self *VM) Clone (label string) (new_instance *VM, err error) {
+    new_instance = new(VM)
+
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.clone", self.Ref, label)
+    if err != nil {
+        return nil, err
+    }
+    new_instance.Ref = result.Value.(string)
+    new_instance.Client = self.Client
+    return
+}
+
+func (self *VM) Start(paused, force bool) (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.start", self.Ref, paused, force)
+    if err != nil {
+        return err
+    }
+    return
+}
+
+func (self *VM) CleanShutdown() (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.clean_shutdown", self.Ref)
+    if err != nil {
+        return err
+    }
+    return
+}
+
+func (self *VM) Unpause () (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.unpause", self.Ref)
+    if err != nil {
+        return err
+    }
+    return
+}
+
+func (self *VM) SetPVBootloader(pv_bootloader, pv_args string) (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.set_PV_bootloader", self.Ref, pv_bootloader)
+    if err != nil {
+        return err
+    }
+    result = APIResult{}
+    err = self.Client.APICall(&result, "VM.set_PV_bootloader_args", self.Ref, pv_args)
+    if err != nil {
+        return err
+    }
+    return
+}
+
+func (self *VM) GetDomainId() (domid string, err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.get_domid", self.Ref)
+    if err != nil {
+        return "", err
+    }
+    domid = result.Value.(string)
+    return domid, nil
+}
+
+func (self *VM) GetPowerState() (state string, err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.get_power_state", self.Ref)
+    if err != nil {
+        return "", err
+    }
+    state = result.Value.(string)
+    return state, nil
+}
+
+func (self *VM) GetUuid() (uuid string, err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.get_uuid", self.Ref)
+    if err != nil {
+        return "", err
+    }
+    uuid = result.Value.(string)
+    return uuid, nil
+}
+
+func (self *VM) GetVBDs() (vbds []VBD, err error) {
+    vbds = make([]VBD, 0)
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.get_VBDs", self.Ref)
+    if err != nil {
+        return vbds, err
+    }
+    for _, elem := range result.Value.([]interface{}) {
+        vbd := VBD{}
+        vbd.Ref = elem.(string)
+        vbd.Client = self.Client
+        vbds = append(vbds, vbd)
+    }
+
+    return vbds, nil
+}
+
+
+func (self *VM) GetVIFs() (vifs []VIF, err error) {
+    vifs = make([]VIF, 0)
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.get_VIFs", self.Ref)
+    if err != nil {
+        return vifs, err
+    }
+    for _, elem := range result.Value.([]interface{}) {
+        vif := VIF{}
+        vif.Ref = elem.(string)
+        vif.Client = self.Client
+        vifs = append(vifs, vif)
+    }
+
+    return vifs, nil
+}
+
+func (self *VM) GetDisks() (vdis []*VDI, err error) {
+    // Return just data disks (non-isos)
+    vdis = make([]*VDI, 0)
+    vbds, err := self.GetVBDs()
+    if err != nil {
+        return nil, err
+    }
+
+    for _, vbd := range vbds {
+        rec, err := vbd.GetRecord()
+        if err != nil {
+            return nil, err
+        }
+        if rec["type"] == "Disk" {
+
+            vdi, err := vbd.GetVDI()
+            if err != nil {
+                return nil, err
+            }
+            vdis = append(vdis, vdi)
+
+        }
+    }
+    return vdis, nil
+}
+
+func (self *VM) GetGuestMetricsRef() (ref string, err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.get_guest_metrics", self.Ref)
+    if err != nil {
+        return "", nil
+    }
+    ref = result.Value.(string)
+    return ref, err
+}
+
+func (self *VM) GetGuestMetrics() (metrics map[string]interface{}, err error) {
+    metrics = make(map[string]interface{})
+    metrics_ref, err := self.GetGuestMetricsRef()
+    if err != nil {
+        return metrics, err
+    }
+
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM_guest_metrics.get_record", metrics_ref)
+    if err != nil {
+        return metrics, nil
+    }
+    for k, v := range result.Value.(xmlrpc.Struct) {
+        metrics[k] = v
+    }
+    return metrics, nil
+}
+
+func (self *VM) SetStaticMemoryRange(min, max string) (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.set_memory_limits", self.Ref, min, max, min, max)
+    if err != nil {
+        return err
+    }
+    return
+}
+
+func (self *VM) ConnectVdi (vdi *VDI, iso bool) (err error) {
+
+    // 1. Create a VBD
+
+    vbd_rec := make(xmlrpc.Struct)
+    vbd_rec["VM"] = self.Ref
+    vbd_rec["VDI"] = vdi.Ref
+    vbd_rec["userdevice"] = "autodetect"
+    vbd_rec["unpluggable"] = false
+    vbd_rec["empty"] = false
+    vbd_rec["other_config"] = make(xmlrpc.Struct)
+    vbd_rec["qos_algorithm_type"] = ""
+    vbd_rec["qos_algorithm_params"] = make(xmlrpc.Struct)
+
+    if iso {
+        vbd_rec["mode"] = "RO"
+        vbd_rec["bootable"] = true
+        vbd_rec["type"] = "CD"
+    } else {
+        vbd_rec["mode"] = "RW"
+        vbd_rec["bootable"] = false
+        vbd_rec["type"] = "Disk"
+    }
+
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VBD.create", vbd_rec)
+
+    if err != nil {
+        return err
+    }
+
+    vbd_ref := result.Value.(string)
+    fmt.Println("VBD Ref:", vbd_ref)
+
+    result = APIResult{}
+    err = self.Client.APICall(&result, "VBD.get_uuid", vbd_ref) 
+
+    fmt.Println("VBD UUID: ", result.Value.(string))
+/*
+    // 2. Plug VBD (Non need - the VM hasn't booted.
+    // @todo - check VM state
+    result = APIResult{}
+    err = self.Client.APICall(&result, "VBD.plug", vbd_ref)
+
+    if err != nil {
+        return err
+    }
+*/
+    return
+}
+
+func (self *VM) SetPlatform(params map[string]string) (err error) {
+    result := APIResult{}
+    platform_rec := make(xmlrpc.Struct)
+    for key, value := range params {
+        platform_rec[key] = value
+    }
+
+    err = self.Client.APICall(&result, "VM.set_platform", self.Ref, platform_rec)
+
+    if err != nil {
+        return err
+    }
+    return
+}
+
+
+func (self *VM) ConnectNetwork (network *Network, device string) (vif *VIF, err error) {
+    // Create the VIF
+
+    vif_rec := make(xmlrpc.Struct)
+    vif_rec["network"] = network.Ref
+    vif_rec["VM"] = self.Ref
+    vif_rec["MAC"] = ""
+    vif_rec["device"] = device
+    vif_rec["MTU"] = "1504"
+    vif_rec["other_config"] = make(xmlrpc.Struct)
+    vif_rec["qos_algorithm_type"] = ""
+    vif_rec["qos_algorithm_params"] = make(xmlrpc.Struct)
+
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VIF.create", vif_rec)
+
+    if err != nil {
+        return nil, err
+    }
+
+    vif = new(VIF)
+    vif.Ref = result.Value.(string)
+    vif.Client = self.Client
+
+    return vif, nil
+}
+
+//      Setters
+
+func (self *VM) SetIsATemplate (is_a_template bool) (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VM.set_is_a_template", self.Ref, is_a_template)
+    if err != nil {
+        return err
+    }
+    return
+}
+
+// SR associated functions
+
+func (self *SR) CreateVdi (name_label, size string) (vdi *VDI, err error) {
+    vdi = new(VDI)
+
+    vdi_rec := make(xmlrpc.Struct)
+    vdi_rec["name_label"] = name_label
+    vdi_rec["SR"] = self.Ref
+    vdi_rec["virtual_size"] = size
+    vdi_rec["type"] = "user"
+    vdi_rec["sharable"] = false
+    vdi_rec["read_only"] = false
+
+    oc := make(xmlrpc.Struct)
+    oc["temp"] = "temp"
+    vdi_rec["other_config"] = oc
+
+
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VDI.create", vdi_rec)
+    if err != nil {
+        return nil, err
+    }
+
+    vdi.Ref = result.Value.(string)
+    vdi.Client = self.Client
+
+    return
+}
+
+// Network associated functions
+
+func (self *Network) GetAssignedIPs () (ip_map map[string]string, err error) {
+    ip_map = make(map[string]string, 0)
+    result := APIResult{}
+    err = self.Client.APICall(&result, "network.get_assigned_ips", self.Ref)
+    if err != nil {
+        return ip_map, err
+    }
+    for k, v := range result.Value.(xmlrpc.Struct) {
+        ip_map[k] = v.(string)
+    }
+    return ip_map, nil
+}
+
+// PIF associated functions
+
+func (self *PIF) GetRecord () (record map[string]interface{}, err error) {
+    record = make(map[string]interface{})
+    result := APIResult{}
+    err = self.Client.APICall(&result, "PIF.get_record", self.Ref)
+    if err != nil {
+        return record, err
+    }
+    for k, v := range result.Value.(xmlrpc.Struct) {
+        record[k] = v
+    }
+    return record, nil
+}
+
+// Pool associated functions
+
+func (self *Pool) GetRecord () (record map[string]interface{}, err error) {
+    record = make(map[string]interface{})
+    result := APIResult{}
+    err = self.Client.APICall(&result, "pool.get_record", self.Ref)
+    if err != nil {
+        return record, err
+    }
+    for k, v := range result.Value.(xmlrpc.Struct) {
+        record[k] = v
+    }
+    return record, nil
+}
+
+
+// VBD associated functions
+func (self *VBD) GetRecord () (record map[string]interface{}, err error) {
+    record = make(map[string]interface{})
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VBD.get_record", self.Ref)
+    if err != nil {
+        return record, err
+    }
+    for k, v := range result.Value.(xmlrpc.Struct) {
+        record[k] = v
+    }
+    return record, nil
+}
+
+func (self *VBD) GetVDI () (vdi *VDI, err error) {
+    vbd_rec, err := self.GetRecord()
+    if err != nil {
+        return nil, err
+    }
+
+    vdi = new(VDI)
+    vdi.Ref = vbd_rec["VDI"].(string)
+    vdi.Client = self.Client
+
+    return vdi, nil
+}
+
+func (self *VBD) Eject () (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VBD.eject", self.Ref)
+    if err != nil {
+        return err
+    }
+    return nil
+}
+
+// VIF associated functions
+
+func (self *VIF) Destroy () (err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VIF.destroy", self.Ref)
+    if err != nil {
+        return err
+    }
+    return nil
+}
+
+// VDI associated functions
+
+func (self *VDI) GetUuid () (vdi_uuid string, err error) {
+    result := APIResult{}
+    err = self.Client.APICall(&result, "VDI.get_uuid", self.Ref)
+    if err != nil {
+        return "", err
+    }
+    vdi_uuid = result.Value.(string)
+    return vdi_uuid, nil
+}
+
+
+// Client Initiator
+
+func NewXenAPIClient (host, username, password string) (client XenAPIClient) {
+    client.Host = host
+    client.Url = "http://" + host
+    client.Username = username
+    client.Password = password
+    client.RPC, _ = xmlrpc.NewClient(client.Url, nil)
+    return
+}

builder/xenserver/common/artifact.go

@@ -1,58 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	"os"
-	"path/filepath"
-)
-
-// This is the common builder ID to all of these artifacts.
-const BuilderId = "packer.xenserver"
-
-type LocalArtifact struct {
-	dir string
-	f   []string
-}
-
-func NewArtifact(dir string) (packer.Artifact, error) {
-	files := make([]string, 0, 1)
-	visit := func(path string, info os.FileInfo, err error) error {
-		if !info.IsDir() {
-			files = append(files, path)
-		}
-		return err
-	}
-	if err := filepath.Walk(dir, visit); err != nil {
-		return nil, err
-	}
-
-	return &LocalArtifact{
-		dir: dir,
-		f:   files,
-	}, nil
-}
-
-func (*LocalArtifact) BuilderId() string {
-	return BuilderId
-}
-
-func (a *LocalArtifact) Files() []string {
-	return a.f
-}
-
-func (*LocalArtifact) Id() string {
-	return "VM"
-}
-
-func (a *LocalArtifact) String() string {
-	return fmt.Sprintf("VM files in directory: %s", a.dir)
-}
-
-func (a *LocalArtifact) State(name string) interface{} {
-	return nil
-}
-
-func (a *LocalArtifact) Destroy() error {
-	return os.RemoveAll(a.dir)
-}

builder/xenserver/common/client.go

@@ -1,985 +0,0 @@
-package common
-
-import (
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"log"
-
-	xmlrpc "github.com/amfranz/go-xmlrpc-client"
-	xenapi "github.com/terra-farm/go-xen-api-client"
-)
-
-type XenAPIClient struct {
-	Session  interface{}
-	Host     string
-	Url      string
-	Username string
-	Password string
-	RPC      *xmlrpc.Client
-}
-
-type APIResult struct {
-	Status           string
-	Value            interface{}
-	ErrorDescription string
-}
-
-type XenAPIObject struct {
-	Ref    string
-	Client *XenAPIClient
-}
-
-type Host XenAPIObject
-type VM XenAPIObject
-type SR XenAPIObject
-type VDI XenAPIObject
-type Network XenAPIObject
-type VBD XenAPIObject
-type VIF XenAPIObject
-type PIF XenAPIObject
-type Pool XenAPIObject
-type Task XenAPIObject
-
-type VDIType int
-
-const (
-	_ VDIType = iota
-	Disk
-	CD
-	Floppy
-)
-
-type TaskStatusType int
-
-const (
-	_ TaskStatusType = iota
-	Pending
-	Success
-	Failure
-	Cancelling
-	Cancelled
-)
-
-func (c *XenAPIClient) RPCCall(result interface{}, method string, params []interface{}) (err error) {
-	fmt.Println(params)
-	p := xmlrpc.Params{Params: params}
-	err = c.RPC.Call(method, p, result)
-	return err
-}
-
-func (client *XenAPIClient) Login() (err error) {
-	//Do loging call
-	result := xmlrpc.Struct{}
-
-	params := make([]interface{}, 2)
-	params[0] = client.Username
-	params[1] = client.Password
-
-	err = client.RPCCall(&result, "session.login_with_password", params)
-	client.Session = result["Value"]
-	return err
-}
-
-func (client *XenAPIClient) APICall(result *APIResult, method string, params ...interface{}) (err error) {
-	if client.Session == nil {
-		fmt.Println("Error: no session")
-		return fmt.Errorf("No session. Unable to make call")
-	}
-
-	//Make a params slice which will include the session
-	p := make([]interface{}, len(params)+1)
-	p[0] = client.Session
-
-	if params != nil {
-		for idx, element := range params {
-			p[idx+1] = element
-		}
-	}
-
-	res := xmlrpc.Struct{}
-
-	err = client.RPCCall(&res, method, p)
-
-	if err != nil {
-		return err
-	}
-
-	result.Status = res["Status"].(string)
-
-	if result.Status != "Success" {
-		fmt.Println("Encountered an API error: ", result.Status)
-		fmt.Println(res["ErrorDescription"])
-		return fmt.Errorf("API Error: %s", res["ErrorDescription"])
-	} else {
-		result.Value = res["Value"]
-	}
-	return
-}
-
-func (client *XenAPIClient) GetHosts() (hosts []*Host, err error) {
-	hosts = make([]*Host, 0)
-	result := APIResult{}
-	_ = client.APICall(&result, "host.get_all")
-	for _, elem := range result.Value.([]interface{}) {
-		host := new(Host)
-		host.Ref = elem.(string)
-		host.Client = client
-		hosts = append(hosts, host)
-	}
-	return
-}
-
-func (client *XenAPIClient) GetPools() (pools []*Pool, err error) {
-	pools = make([]*Pool, 0)
-	result := APIResult{}
-	err = client.APICall(&result, "pool.get_all")
-	if err != nil {
-		return pools, err
-	}
-
-	for _, elem := range result.Value.([]interface{}) {
-		pool := new(Pool)
-		pool.Ref = elem.(string)
-		pool.Client = client
-		pools = append(pools, pool)
-	}
-
-	return pools, nil
-}
-
-func (client *XenAPIClient) GetDefaultSR() (sr *SR, err error) {
-	pools, err := client.GetPools()
-
-	if err != nil {
-		return nil, err
-	}
-
-	pool_rec, err := pools[0].GetRecord()
-
-	if err != nil {
-		return nil, err
-	}
-
-	if pool_rec["default_SR"] == "" {
-		return nil, errors.New("No default_SR specified for the pool.")
-	}
-
-	sr = new(SR)
-	sr.Ref = pool_rec["default_SR"].(string)
-	sr.Client = client
-
-	return sr, nil
-}
-
-func (client *XenAPIClient) GetVMByUuid(vm_uuid string) (vm *VM, err error) {
-	vm = new(VM)
-	result := APIResult{}
-	err = client.APICall(&result, "VM.get_by_uuid", vm_uuid)
-	if err != nil {
-		return nil, err
-	}
-	vm.Ref = result.Value.(string)
-	vm.Client = client
-	return
-}
-
-func (client *XenAPIClient) GetVMByNameLabel(name_label string) (vms []*VM, err error) {
-	vms = make([]*VM, 0)
-	result := APIResult{}
-	err = client.APICall(&result, "VM.get_by_name_label", name_label)
-	if err != nil {
-		return vms, err
-	}
-
-	for _, elem := range result.Value.([]interface{}) {
-		vm := new(VM)
-		vm.Ref = elem.(string)
-		vm.Client = client
-		vms = append(vms, vm)
-	}
-
-	return vms, nil
-}
-
-func (client *XenAPIClient) GetNetworkByUuid(network_uuid string) (network *Network, err error) {
-	network = new(Network)
-	result := APIResult{}
-	err = client.APICall(&result, "network.get_by_uuid", network_uuid)
-	if err != nil {
-		return nil, err
-	}
-	network.Ref = result.Value.(string)
-	network.Client = client
-	return
-}
-
-func (client *XenAPIClient) GetNetworkByNameLabel(name_label string) (networks []*Network, err error) {
-	networks = make([]*Network, 0)
-	result := APIResult{}
-	err = client.APICall(&result, "network.get_by_name_label", name_label)
-	if err != nil {
-		return networks, err
-	}
-
-	for _, elem := range result.Value.([]interface{}) {
-		network := new(Network)
-		network.Ref = elem.(string)
-		network.Client = client
-		networks = append(networks, network)
-	}
-
-	return networks, nil
-}
-
-func (client *XenAPIClient) GetVdiByNameLabel(name_label string) (vdis []*VDI, err error) {
-	vdis = make([]*VDI, 0)
-	result := APIResult{}
-	err = client.APICall(&result, "VDI.get_by_name_label", name_label)
-	if err != nil {
-		return vdis, err
-	}
-
-	for _, elem := range result.Value.([]interface{}) {
-		vdi := new(VDI)
-		vdi.Ref = elem.(string)
-		vdi.Client = client
-		vdis = append(vdis, vdi)
-	}
-
-	return vdis, nil
-}
-
-func (client *XenAPIClient) GetVdiByUuid(vdi_uuid string) (vdi *VDI, err error) {
-	vdi = new(VDI)
-	result := APIResult{}
-	err = client.APICall(&result, "VDI.get_by_uuid", vdi_uuid)
-	if err != nil {
-		return nil, err
-	}
-	vdi.Ref = result.Value.(string)
-	vdi.Client = client
-	return
-}
-
-func (client *XenAPIClient) GetPIFs() (pifs []*PIF, err error) {
-	pifs = make([]*PIF, 0)
-	result := APIResult{}
-	err = client.APICall(&result, "PIF.get_all")
-	if err != nil {
-		return pifs, err
-	}
-	for _, elem := range result.Value.([]interface{}) {
-		pif := new(PIF)
-		pif.Ref = elem.(string)
-		pif.Client = client
-		pifs = append(pifs, pif)
-	}
-
-	return pifs, nil
-}
-
-// Host associated functions
-
-func (self *Host) GetSoftwareVersion() (versions map[string]interface{}, err error) {
-	versions = make(map[string]interface{})
-
-	result := APIResult{}
-	err = self.Client.APICall(&result, "host.get_software_version", self.Ref)
-	if err != nil {
-		return nil, err
-	}
-
-	for k, v := range result.Value.(xmlrpc.Struct) {
-		versions[k] = v.(string)
-	}
-	return
-}
-
-func (self *Host) CallPlugin(plugin, function string, args map[string]string) (res string, err error) {
-
-	args_rec := make(xmlrpc.Struct)
-	for key, value := range args {
-		args_rec[key] = value
-	}
-
-	result := APIResult{}
-	err = self.Client.APICall(&result, "host.call_plugin", self.Ref, plugin, function, args_rec)
-	if err != nil {
-		return "", err
-	}
-
-	// The plugin should return a string value
-	res = result.Value.(string)
-	return
-}
-
-// VM associated functions
-
-func (self *VM) Clone(label string) (new_instance *VM, err error) {
-	new_instance = new(VM)
-
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.clone", self.Ref, label)
-	if err != nil {
-		return nil, err
-	}
-	new_instance.Ref = result.Value.(string)
-	new_instance.Client = self.Client
-	return
-}
-
-func (self *VM) Destroy() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.destroy", self.Ref)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func (self *VM) Start(paused, force bool) (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.start", self.Ref, paused, force)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func (self *VM) CleanShutdown() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.clean_shutdown", self.Ref)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func Unpause(c *Connection, vmRef xenapi.VMRef) (err error) {
-	err = c.client.VM.Unpause(c.session, vmRef)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func (self *VM) SetHVMBoot(policy, bootOrder string) (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.set_HVM_boot_policy", self.Ref, policy)
-	if err != nil {
-		return err
-	}
-	result = APIResult{}
-	params := make(xmlrpc.Struct)
-	params["order"] = bootOrder
-	err = self.Client.APICall(&result, "VM.set_HVM_boot_params", self.Ref, params)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func (self *VM) SetPVBootloader(pv_bootloader, pv_args string) (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.set_PV_bootloader", self.Ref, pv_bootloader)
-	if err != nil {
-		return err
-	}
-	result = APIResult{}
-	err = self.Client.APICall(&result, "VM.set_PV_bootloader_args", self.Ref, pv_args)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func (self *VM) GetDomainId() (domid string, err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.get_domid", self.Ref)
-	if err != nil {
-		return "", err
-	}
-	domid = result.Value.(string)
-	return domid, nil
-}
-
-func (self *VM) GetPowerState() (state string, err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.get_power_state", self.Ref)
-	if err != nil {
-		return "", err
-	}
-	state = result.Value.(string)
-	return state, nil
-}
-
-func (self *VM) GetUuid() (uuid string, err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.get_uuid", self.Ref)
-	if err != nil {
-		return "", err
-	}
-	uuid = result.Value.(string)
-	return uuid, nil
-}
-
-func (self *VM) GetVBDs() (vbds []VBD, err error) {
-	vbds = make([]VBD, 0)
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.get_VBDs", self.Ref)
-	if err != nil {
-		return vbds, err
-	}
-	for _, elem := range result.Value.([]interface{}) {
-		vbd := VBD{}
-		vbd.Ref = elem.(string)
-		vbd.Client = self.Client
-		vbds = append(vbds, vbd)
-	}
-
-	return vbds, nil
-}
-
-func GetDisks(c *Connection, vmRef xenapi.VMRef) (vdis []xenapi.VDIRef, err error) {
-	// Return just data disks (non-isos)
-	vdis = make([]xenapi.VDIRef, 0)
-	vbds, err := c.client.VM.GetVBDs(c.session, vmRef)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, vbd := range vbds {
-		rec, err := c.client.VBD.GetRecord(c.session, vbd)
-		if err != nil {
-			return nil, err
-		}
-		if rec.Type == "Disk" {
-
-			vdi, err := c.client.VBD.GetVDI(c.session, vbd)
-			if err != nil {
-				return nil, err
-			}
-			vdis = append(vdis, vdi)
-
-		}
-	}
-	return vdis, nil
-}
-
-func (self *VM) GetGuestMetricsRef() (ref string, err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.get_guest_metrics", self.Ref)
-	if err != nil {
-		return "", nil
-	}
-	ref = result.Value.(string)
-	return ref, err
-}
-
-func (self *VM) GetGuestMetrics() (metrics map[string]interface{}, err error) {
-	metrics_ref, err := self.GetGuestMetricsRef()
-	if err != nil {
-		return nil, err
-	}
-	if metrics_ref == "OpaqueRef:NULL" {
-		return nil, nil
-	}
-
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM_guest_metrics.get_record", metrics_ref)
-	if err != nil {
-		return nil, err
-	}
-	return result.Value.(xmlrpc.Struct), nil
-}
-
-func (self *VM) SetStaticMemoryRange(min, max uint) (err error) {
-	result := APIResult{}
-	strMin := fmt.Sprintf("%d", min)
-	strMax := fmt.Sprintf("%d", max)
-	err = self.Client.APICall(&result, "VM.set_memory_limits", self.Ref, strMin, strMax, strMin, strMax)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func ConnectVdi(c *Connection, vmRef xenapi.VMRef, vdiRef xenapi.VDIRef, vbdType xenapi.VbdType) (err error) {
-
-	var mode xenapi.VbdMode
-	var unpluggable bool
-	var bootable bool
-	var t xenapi.VbdType
-	switch vbdType {
-	case xenapi.VbdTypeCD:
-		mode = xenapi.VbdModeRO
-		bootable = true
-		unpluggable = false
-		t = xenapi.VbdTypeCD
-	case xenapi.VbdTypeDisk:
-		mode = xenapi.VbdModeRW
-		bootable = false
-		unpluggable = false
-		t = xenapi.VbdTypeDisk
-	case xenapi.VbdTypeFloppy:
-		mode = xenapi.VbdModeRW
-		bootable = false
-		unpluggable = true
-		t = xenapi.VbdTypeFloppy
-	}
-
-	vbd_ref, err := c.client.VBD.Create(c.session, xenapi.VBDRecord{
-		VM:         xenapi.VMRef(vmRef),
-		VDI:        xenapi.VDIRef(vdiRef),
-		Userdevice: "autodetect",
-		Empty:      false,
-		// OtherConfig: map[string]interface{{}},
-		QosAlgorithmType: "",
-		// QosAlgorithmParams: map[string]interface{{}},
-		Mode:        mode,
-		Unpluggable: unpluggable,
-		Bootable:    bootable,
-		Type:        t,
-	})
-
-	if err != nil {
-		return err
-	}
-
-	fmt.Println("VBD Ref:", vbd_ref)
-
-	uuid, err := c.client.VBD.GetUUID(c.session, vbd_ref)
-
-	fmt.Println("VBD UUID: ", uuid)
-	/*
-	   // 2. Plug VBD (Non need - the VM hasn't booted.
-	   // @todo - check VM state
-	   result = APIResult{}
-	   err = self.Client.APICall(&result, "VBD.plug", vbd_ref)
-
-	   if err != nil {
-	       return err
-	   }
-	*/
-	return
-}
-
-func DisconnectVdi(c *Connection, vmRef xenapi.VMRef, vdi xenapi.VDIRef) error {
-	vbds, err := c.client.VM.GetVBDs(c.session, vmRef)
-	if err != nil {
-		return fmt.Errorf("Unable to get VM VBDs: %s", err.Error())
-	}
-
-	for _, vbd := range vbds {
-		rec, err := c.client.VBD.GetRecord(c.session, vbd)
-		if err != nil {
-			return fmt.Errorf("Could not get record for VBD '%s': %s", vbd, err.Error())
-		}
-		recVdi := rec.VDI
-		if recVdi == vdi {
-			_ = c.client.VBD.Unplug(c.session, vbd)
-			err = c.client.VBD.Destroy(c.session, vbd)
-			if err != nil {
-				return fmt.Errorf("Could not destroy VBD '%s': %s", vbd, err.Error())
-			}
-
-			return nil
-		} else {
-			log.Printf("Could not find VDI record in VBD '%s'", vbd)
-		}
-	}
-
-	return fmt.Errorf("Could not find VBD for VDI '%s'", vdi)
-}
-
-func (self *VM) SetPlatform(params map[string]string) (err error) {
-	result := APIResult{}
-	platform_rec := make(xmlrpc.Struct)
-	for key, value := range params {
-		platform_rec[key] = value
-	}
-
-	err = self.Client.APICall(&result, "VM.set_platform", self.Ref, platform_rec)
-
-	if err != nil {
-		return err
-	}
-	return
-}
-
-func ConnectNetwork(c *Connection, networkRef xenapi.NetworkRef, vmRef xenapi.VMRef, device string) (*xenapi.VIFRef, error) {
-	vif, err := c.client.VIF.Create(c.session, xenapi.VIFRecord{
-		Network:     networkRef,
-		VM:          vmRef,
-		Device:      device,
-		LockingMode: xenapi.VifLockingModeNetworkDefault,
-	})
-
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("Created the following VIF: %s", vif)
-
-	return &vif, nil
-}
-
-func AddVMTags(c *Connection, vmRef xenapi.VMRef, tags []string) error {
-	for _, tag := range tags {
-		log.Printf("Adding tag %s to VM %s\n", tag, vmRef)
-		err := c.GetClient().VM.AddTags(c.session, vmRef, tag)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-//      Setters
-
-func (self *VM) SetIsATemplate(is_a_template bool) (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VM.set_is_a_template", self.Ref, is_a_template)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-// SR associated functions
-
-func (self *SR) CreateVdi(name_label string, size int64) (vdi *VDI, err error) {
-	vdi = new(VDI)
-
-	vdi_rec := make(xmlrpc.Struct)
-	vdi_rec["name_label"] = name_label
-	vdi_rec["SR"] = self.Ref
-	vdi_rec["virtual_size"] = fmt.Sprintf("%d", size)
-	vdi_rec["type"] = "user"
-	vdi_rec["sharable"] = false
-	vdi_rec["read_only"] = false
-
-	oc := make(xmlrpc.Struct)
-	oc["temp"] = "temp"
-	vdi_rec["other_config"] = oc
-
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VDI.create", vdi_rec)
-	if err != nil {
-		return nil, err
-	}
-
-	vdi.Ref = result.Value.(string)
-	vdi.Client = self.Client
-
-	return
-}
-
-// Network associated functions
-
-func (self *Network) GetAssignedIPs() (ip_map map[string]string, err error) {
-	ip_map = make(map[string]string, 0)
-	result := APIResult{}
-	err = self.Client.APICall(&result, "network.get_assigned_ips", self.Ref)
-	if err != nil {
-		return ip_map, err
-	}
-	for k, v := range result.Value.(xmlrpc.Struct) {
-		ip_map[k] = v.(string)
-	}
-	return ip_map, nil
-}
-
-// PIF associated functions
-
-func (self *PIF) GetRecord() (record map[string]interface{}, err error) {
-	record = make(map[string]interface{})
-	result := APIResult{}
-	err = self.Client.APICall(&result, "PIF.get_record", self.Ref)
-	if err != nil {
-		return record, err
-	}
-	for k, v := range result.Value.(xmlrpc.Struct) {
-		record[k] = v
-	}
-	return record, nil
-}
-
-// Pool associated functions
-
-func (self *Pool) GetRecord() (record map[string]interface{}, err error) {
-	record = make(map[string]interface{})
-	result := APIResult{}
-	err = self.Client.APICall(&result, "pool.get_record", self.Ref)
-	if err != nil {
-		return record, err
-	}
-	for k, v := range result.Value.(xmlrpc.Struct) {
-		record[k] = v
-	}
-	return record, nil
-}
-
-// VBD associated functions
-func (self *VBD) GetRecord() (record map[string]interface{}, err error) {
-	record = make(map[string]interface{})
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VBD.get_record", self.Ref)
-	if err != nil {
-		return record, err
-	}
-	for k, v := range result.Value.(xmlrpc.Struct) {
-		record[k] = v
-	}
-	return record, nil
-}
-
-func (self *VBD) GetVDI() (vdi *VDI, err error) {
-	vbd_rec, err := self.GetRecord()
-	if err != nil {
-		return nil, err
-	}
-
-	vdi = new(VDI)
-	vdi.Ref = vbd_rec["VDI"].(string)
-	vdi.Client = self.Client
-
-	return vdi, nil
-}
-
-func (self *VBD) Eject() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VBD.eject", self.Ref)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (self *VBD) Unplug() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VBD.unplug", self.Ref)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (self *VBD) Destroy() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VBD.destroy", self.Ref)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// VIF associated functions
-
-func (self *VIF) Destroy() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VIF.destroy", self.Ref)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// VDI associated functions
-
-func (self *VDI) GetUuid() (vdi_uuid string, err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VDI.get_uuid", self.Ref)
-	if err != nil {
-		return "", err
-	}
-	vdi_uuid = result.Value.(string)
-	return vdi_uuid, nil
-}
-
-func (self *VDI) GetVBDs() (vbds []VBD, err error) {
-	vbds = make([]VBD, 0)
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VDI.get_VBDs", self.Ref)
-	if err != nil {
-		return vbds, err
-	}
-	for _, elem := range result.Value.([]interface{}) {
-		vbd := VBD{}
-		vbd.Ref = elem.(string)
-		vbd.Client = self.Client
-		vbds = append(vbds, vbd)
-	}
-
-	return vbds, nil
-}
-
-func (self *VDI) Destroy() (err error) {
-	result := APIResult{}
-	err = self.Client.APICall(&result, "VDI.destroy", self.Ref)
-	if err != nil {
-		return err
-	}
-	return
-}
-
-// Expose a VDI using the Transfer VM
-// (Legacy VHD export)
-
-type TransferRecord struct {
-	UrlFull string `xml:"url_full,attr"`
-}
-
-func Expose(c *Connection, vdiRef xenapi.VDIRef, format string) (url string, err error) {
-
-	hosts, err := c.client.Host.GetAll(c.session)
-
-	if err != nil {
-		err = errors.New(fmt.Sprintf("Could not retrieve hosts in the pool: %s", err.Error()))
-		return "", err
-	}
-	host := hosts[0]
-
-	if err != nil {
-		err = errors.New(fmt.Sprintf("Failed to get VDI uuid for %s: %s", vdiRef, err.Error()))
-		return "", err
-	}
-
-	args := make(map[string]string)
-	args["transfer_mode"] = "http"
-	args["vdi_uuid"] = string(vdiRef)
-	args["expose_vhd"] = "true"
-	args["network_uuid"] = "management"
-	args["timeout_minutes"] = "5"
-
-	handle, err := c.client.Host.CallPlugin(c.session, host, "transfer", "expose", args)
-
-	if err != nil {
-		err = errors.New(fmt.Sprintf("Error whilst exposing VDI %s: %s", vdiRef, err.Error()))
-		return "", err
-	}
-
-	args = make(map[string]string)
-	args["record_handle"] = handle
-	record_xml, err := c.client.Host.CallPlugin(c.session, host, "transfer", "get_record", args)
-
-	if err != nil {
-		err = errors.New(fmt.Sprintf("Unable to retrieve transfer record for VDI %s: %s", vdiRef, err.Error()))
-		return "", err
-	}
-
-	var record TransferRecord
-	xml.Unmarshal([]byte(record_xml), &record)
-
-	if record.UrlFull == "" {
-		return "", errors.New(fmt.Sprintf("Error: did not parse XML properly: '%s'", record_xml))
-	}
-
-	// Handles either raw or VHD formats
-
-	switch format {
-	case "vhd":
-		url = fmt.Sprintf("%s.vhd", record.UrlFull)
-
-	case "raw":
-		url = record.UrlFull
-	}
-
-	return
-}
-
-func Unexpose(c *Connection, vdiRef xenapi.VDIRef) (err error) {
-
-	disk_uuid, err := c.client.VDI.GetUUID(c.session, vdiRef)
-
-	if err != nil {
-		return err
-	}
-
-	hosts, err := c.client.Host.GetAll(c.session)
-
-	if err != nil {
-		err = errors.New(fmt.Sprintf("Could not retrieve hosts in the pool: %s", err.Error()))
-		return err
-	}
-
-	host := hosts[0]
-
-	args := make(map[string]string)
-	args["vdi_uuid"] = disk_uuid
-
-	result, err := c.client.Host.CallPlugin(c.session, host, "transfer", "unexpose", args)
-
-	if err != nil {
-		return err
-	}
-
-	log.Println(fmt.Sprintf("Unexpose result: %s", result))
-
-	return nil
-}
-
-// Task associated functions
-
-// func (self *Task) GetResult() (object *XenAPIObject, err error) {
-// 	result := APIResult{}
-// 	err = self.Client.APICall(&result, "task.get_result", self.Ref)
-// 	if err != nil {
-// 		return
-// 	}
-// 	switch ref := result.Value.(type) {
-// 	case string:
-// 		// @fixme: xapi currently sends us an xmlrpc-encoded string via xmlrpc.
-// 		// This seems to be a bug in xapi. Remove this workaround when it's fixed
-// 		re := regexp.MustCompile("^<value><array><data><value>([^<]*)</value>.*</data></array></value>$")
-// 		match := re.FindStringSubmatch(ref)
-// 		if match == nil {
-// 			object = nil
-// 		} else {
-// 			object = &XenAPIObject{
-// 				Ref:    match[1],
-// 				Client: self.Client,
-// 			}
-// 		}
-// 	case nil:
-// 		object = nil
-// 	default:
-// 		err = fmt.Errorf("task.get_result: unknown value type %T (expected string or nil)", ref)
-// 	}
-// 	return
-// }
-
-// Client Initiator
-type Connection struct {
-	client   *xenapi.Client
-	session  xenapi.SessionRef
-	Host     string
-	Username string
-	Password string
-}
-
-func (c Connection) GetSession() string {
-	return string(c.session)
-}
-
-func NewXenAPIClient(host, username, password string) (*Connection, error) {
-	client, err := xenapi.NewClient("https://"+host, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	session, err := client.Session.LoginWithPassword(username, password, "1.0", "packer")
-	if err != nil {
-		return nil, err
-	}
-
-	return &Connection{client, session, host, username, password}, nil
-}
-
-func (c *Connection) GetClient() *xenapi.Client {
-	return c.client
-}
-
-func (c *Connection) GetSessionRef() xenapi.SessionRef {
-	return c.session
-}

builder/xenserver/common/common_config.go

@@ -1,304 +0,0 @@
-package common
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/common"
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
-	xenapi "github.com/terra-farm/go-xen-api-client"
-)
-
-type CommonConfig struct {
-	Username    string `mapstructure:"remote_username"`
-	Password    string `mapstructure:"remote_password"`
-	HostIp      string `mapstructure:"remote_host"`
-	HostSshPort uint   `mapstructure:"remote_ssh_port"`
-
-	VMName             string   `mapstructure:"vm_name"`
-	VMDescription      string   `mapstructure:"vm_description"`
-	SrName             string   `mapstructure:"sr_name"`
-	SrISOName          string   `mapstructure:"sr_iso_name" required:"false"`
-	FloppyFiles        []string `mapstructure:"floppy_files"`
-	NetworkNames       []string `mapstructure:"network_names"`
-	ExportNetworkNames []string `mapstructure:"export_network_names"`
-	VMTags             []string `mapstructure:"vm_tags"`
-
-	HostPortMin uint `mapstructure:"host_port_min"`
-	HostPortMax uint `mapstructure:"host_port_max"`
-
-	BootCommand     []string `mapstructure:"boot_command"`
-	ShutdownCommand string   `mapstructure:"shutdown_command"`
-
-	RawBootWait string `mapstructure:"boot_wait"`
-	BootWait    time.Duration
-
-	ToolsIsoName string `mapstructure:"tools_iso_name"`
-
-	HTTPDir     string `mapstructure:"http_directory"`
-	HTTPPortMin uint   `mapstructure:"http_port_min"`
-	HTTPPortMax uint   `mapstructure:"http_port_max"`
-
-	//	SSHHostPortMin    uint   `mapstructure:"ssh_host_port_min"`
-	//	SSHHostPortMax    uint   `mapstructure:"ssh_host_port_max"`
-	SSHKeyPath  string `mapstructure:"ssh_key_path"`
-	SSHPassword string `mapstructure:"ssh_password"`
-	SSHPort     uint   `mapstructure:"ssh_port"`
-	SSHUser     string `mapstructure:"ssh_username"`
-	SSHConfig   `mapstructure:",squash"`
-
-	RawSSHWaitTimeout string `mapstructure:"ssh_wait_timeout"`
-	SSHWaitTimeout    time.Duration
-
-	OutputDir string `mapstructure:"output_directory"`
-	Format    string `mapstructure:"format"`
-	KeepVM    string `mapstructure:"keep_vm"`
-	IPGetter  string `mapstructure:"ip_getter"`
-}
-
-func (c *CommonConfig) Prepare(ctx *interpolate.Context, pc *common.PackerConfig) []error {
-	var err error
-	var errs []error
-
-	// Set default values
-
-	if c.HostSshPort == 0 {
-		c.HostSshPort = 22
-	}
-
-	if c.HostPortMin == 0 {
-		c.HostPortMin = 5900
-	}
-
-	if c.HostPortMax == 0 {
-		c.HostPortMax = 6000
-	}
-
-	if c.RawBootWait == "" {
-		c.RawBootWait = "5s"
-	}
-
-	if c.HTTPPortMin == 0 {
-		c.HTTPPortMin = 8000
-	}
-
-	if c.HTTPPortMax == 0 {
-		c.HTTPPortMax = 9000
-	}
-
-	if c.RawSSHWaitTimeout == "" {
-		c.RawSSHWaitTimeout = "200m"
-	}
-
-	if c.FloppyFiles == nil {
-		c.FloppyFiles = make([]string, 0)
-	}
-
-	/*
-		if c.SSHHostPortMin == 0 {
-			c.SSHHostPortMin = 2222
-		}
-
-		if c.SSHHostPortMax == 0 {
-			c.SSHHostPortMax = 4444
-		}
-	*/
-
-	if c.SSHPort == 0 {
-		c.SSHPort = 22
-	}
-
-	if c.RawSSHWaitTimeout == "" {
-		c.RawSSHWaitTimeout = "20m"
-	}
-
-	if c.OutputDir == "" {
-		c.OutputDir = fmt.Sprintf("output-%s", pc.PackerBuildName)
-	}
-
-	if c.VMName == "" {
-		c.VMName = fmt.Sprintf("packer-%s-{{timestamp}}", pc.PackerBuildName)
-	}
-
-	if c.Format == "" {
-		c.Format = "xva"
-	}
-
-	if c.KeepVM == "" {
-		c.KeepVM = "never"
-	}
-
-	if c.IPGetter == "" {
-		c.IPGetter = "auto"
-	}
-
-	// Validation
-
-	if c.Username == "" {
-		errs = append(errs, errors.New("remote_username must be specified."))
-	}
-
-	if c.Password == "" {
-		errs = append(errs, errors.New("remote_password must be specified."))
-	}
-
-	if c.HostIp == "" {
-		errs = append(errs, errors.New("remote_host must be specified."))
-	}
-
-	if c.HostPortMin > c.HostPortMax {
-		errs = append(errs, errors.New("the host min port must be less than the max"))
-	}
-
-	if c.HTTPPortMin > c.HTTPPortMax {
-		errs = append(errs, errors.New("the HTTP min port must be less than the max"))
-	}
-
-	c.BootWait, err = time.ParseDuration(c.RawBootWait)
-	if err != nil {
-		errs = append(errs, fmt.Errorf("Failed to parse boot_wait: %s", err))
-	}
-
-	if c.SSHKeyPath != "" {
-		if _, err := os.Stat(c.SSHKeyPath); err != nil {
-			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		} else if _, err := FileSigner(c.SSHKeyPath); err != nil {
-			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		}
-	}
-
-	/*
-		if c.SSHHostPortMin > c.SSHHostPortMax {
-			errs = append(errs,
-				errors.New("ssh_host_port_min must be less than ssh_host_port_max"))
-		}
-	*/
-
-	if c.SSHUser == "" {
-		errs = append(errs, errors.New("An ssh_username must be specified."))
-	}
-
-	c.SSHWaitTimeout, err = time.ParseDuration(c.RawSSHWaitTimeout)
-	if err != nil {
-		errs = append(errs, fmt.Errorf("Failed to parse ssh_wait_timeout: %s", err))
-	}
-
-	switch c.Format {
-	case "xva", "xva_compressed", "vdi_raw", "vdi_vhd", "none":
-	default:
-		errs = append(errs, errors.New("format must be one of 'xva', 'vdi_raw', 'vdi_vhd', 'none'"))
-	}
-
-	switch c.KeepVM {
-	case "always", "never", "on_success":
-	default:
-		errs = append(errs, errors.New("keep_vm must be one of 'always', 'never', 'on_success'"))
-	}
-
-	switch c.IPGetter {
-	case "auto", "tools", "http":
-	default:
-		errs = append(errs, errors.New("ip_getter must be one of 'auto', 'tools', 'http'"))
-	}
-
-	return errs
-}
-
-// steps should check config.ShouldKeepVM first before cleaning up the VM
-func (c CommonConfig) ShouldKeepVM(state multistep.StateBag) bool {
-	switch c.KeepVM {
-	case "always":
-		return true
-	case "never":
-		return false
-	case "on_success":
-		// only keep instance if build was successful
-		_, cancelled := state.GetOk(multistep.StateCancelled)
-		_, halted := state.GetOk(multistep.StateHalted)
-		return !(cancelled || halted)
-	default:
-		panic(fmt.Sprintf("Unknown keep_vm value '%s'", c.KeepVM))
-	}
-}
-
-func (config CommonConfig) GetSR(c *Connection) (xenapi.SRRef, error) {
-	if config.SrName == "" {
-		return getDefaultSR(c)
-	} else {
-		var srRef xenapi.SRRef
-
-		// Use the provided name label to find the SR to use
-		srs, err := c.GetClient().SR.GetByNameLabel(c.session, config.SrName)
-
-		if err != nil {
-			return srRef, err
-		}
-
-		switch {
-		case len(srs) == 0:
-			return srRef, fmt.Errorf("Couldn't find a SR with the specified name-label '%s'", config.SrName)
-		case len(srs) > 1:
-			return srRef, fmt.Errorf("Found more than one SR with the name '%s'. The name must be unique", config.SrName)
-		}
-
-		return srs[0], nil
-	}
-}
-
-func (config CommonConfig) GetISOSR(c *Connection) (xenapi.SRRef, error) {
-	var srRef xenapi.SRRef
-	if config.SrISOName == "" {
-		return getDefaultSR(c)
-
-	} else {
-		// Use the provided name label to find the SR to use
-		srs, err := c.GetClient().SR.GetByNameLabel(c.session, config.SrISOName)
-
-		if err != nil {
-			return srRef, err
-		}
-
-		switch {
-		case len(srs) == 0:
-			return srRef, fmt.Errorf("Couldn't find a SR with the specified name-label '%s'", config.SrISOName)
-		case len(srs) > 1:
-			return srRef, fmt.Errorf("Found more than one SR with the name '%s'. The name must be unique", config.SrISOName)
-		}
-
-		return srs[0], nil
-	}
-}
-
-func getDefaultSR(c *Connection) (xenapi.SRRef, error) {
-	var srRef xenapi.SRRef
-	client := c.GetClient()
-	hostRef, err := client.Session.GetThisHost(c.session, c.session)
-
-	if err != nil {
-		return srRef, err
-	}
-
-	// The current version of the go-xen-api-client does not fully support XenAPI version 8.2
-	// In particular, some values for the pool `allowed_operations` are not recognised, resulting
-	// in a parse error when retrieving pool records. As a workaround, we only fetch pool refs.
-	pool_refs, err := client.Pool.GetAll(c.session)
-
-	if err != nil {
-		return srRef, err
-	}
-
-	for _, pool_ref := range pool_refs {
-		pool_master, err := client.Pool.GetMaster(c.session, pool_ref)
-		if err != nil {
-			return srRef, err
-		}
-		if pool_master == hostRef {
-			return client.Pool.GetDefaultSR(c.session, pool_ref)
-		}
-	}
-
-	return srRef, errors.New(fmt.Sprintf("failed to find default SR on host '%s'", hostRef))
-}

builder/xenserver/common/config.go

@@ -1,45 +0,0 @@
-//go:generate packer-sdc mapstructure-to-hcl2 -type Config
-package common
-
-import (
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/common"
-	"github.com/hashicorp/packer-plugin-sdk/communicator"
-	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
-)
-
-type Config struct {
-	common.PackerConfig `mapstructure:",squash"`
-	CommonConfig        `mapstructure:",squash"`
-	Comm                communicator.Config `mapstructure:",squash"`
-
-	VCPUsMax       uint              `mapstructure:"vcpus_max"`
-	VCPUsAtStartup uint              `mapstructure:"vcpus_atstartup"`
-	VMMemory       uint              `mapstructure:"vm_memory"`
-	DiskName       string            `mapstructure:"disk_name"`
-	DiskSize       uint              `mapstructure:"disk_size"`
-	CloneTemplate  string            `mapstructure:"clone_template"`
-	VMOtherConfig  map[string]string `mapstructure:"vm_other_config"`
-	VMTags         []string          `mapstructure:"vm_tags"`
-
-	ISOChecksum string   `mapstructure:"iso_checksum"`
-	ISOUrls     []string `mapstructure:"iso_urls"`
-	ISOUrl      string   `mapstructure:"iso_url"`
-	ISOName     string   `mapstructure:"iso_name"`
-
-	PlatformArgs map[string]string `mapstructure:"platform_args"`
-
-	RawInstallTimeout string        `mapstructure:"install_timeout"`
-	InstallTimeout    time.Duration ``
-	SourcePath        string        `mapstructure:"source_path"`
-
-	Firmware string `mapstructure:"firmware"`
-	SkipSetTemplate bool `mapstructure:"skip_set_template"`
-
-	ctx interpolate.Context
-}
-
-func (c Config) GetInterpContext() *interpolate.Context {
-	return &c.ctx
-}

builder/xenserver/common/config.hcl2spec.go

@@ -1,233 +0,0 @@
-// Code generated by "packer-sdc mapstructure-to-hcl2"; DO NOT EDIT.
-
-package common
-
-import (
-	"github.com/hashicorp/hcl/v2/hcldec"
-	"github.com/zclconf/go-cty/cty"
-)
-
-// FlatConfig is an auto-generated flat version of Config.
-// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
-type FlatConfig struct {
-	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name" hcl:"packer_build_name"`
-	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type" hcl:"packer_builder_type"`
-	PackerCoreVersion         *string           `mapstructure:"packer_core_version" cty:"packer_core_version" hcl:"packer_core_version"`
-	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug" hcl:"packer_debug"`
-	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force" hcl:"packer_force"`
-	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error" hcl:"packer_on_error"`
-	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables" hcl:"packer_user_variables"`
-	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables" hcl:"packer_sensitive_variables"`
-	Username                  *string           `mapstructure:"remote_username" cty:"remote_username" hcl:"remote_username"`
-	Password                  *string           `mapstructure:"remote_password" cty:"remote_password" hcl:"remote_password"`
-	HostIp                    *string           `mapstructure:"remote_host" cty:"remote_host" hcl:"remote_host"`
-	HostSshPort               *uint             `mapstructure:"remote_ssh_port" cty:"remote_ssh_port" hcl:"remote_ssh_port"`
-	VMName                    *string           `mapstructure:"vm_name" cty:"vm_name" hcl:"vm_name"`
-	VMDescription             *string           `mapstructure:"vm_description" cty:"vm_description" hcl:"vm_description"`
-	SrName                    *string           `mapstructure:"sr_name" cty:"sr_name" hcl:"sr_name"`
-	SrISOName                 *string           `mapstructure:"sr_iso_name" required:"false" cty:"sr_iso_name" hcl:"sr_iso_name"`
-	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files" hcl:"floppy_files"`
-	NetworkNames              []string          `mapstructure:"network_names" cty:"network_names" hcl:"network_names"`
-	ExportNetworkNames        []string          `mapstructure:"export_network_names" cty:"export_network_names" hcl:"export_network_names"`
-	VMTags                    []string          `mapstructure:"vm_tags" cty:"vm_tags" hcl:"vm_tags"`
-	HostPortMin               *uint             `mapstructure:"host_port_min" cty:"host_port_min" hcl:"host_port_min"`
-	HostPortMax               *uint             `mapstructure:"host_port_max" cty:"host_port_max" hcl:"host_port_max"`
-	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command" hcl:"boot_command"`
-	ShutdownCommand           *string           `mapstructure:"shutdown_command" cty:"shutdown_command" hcl:"shutdown_command"`
-	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait" hcl:"boot_wait"`
-	ToolsIsoName              *string           `mapstructure:"tools_iso_name" cty:"tools_iso_name" hcl:"tools_iso_name"`
-	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory" hcl:"http_directory"`
-	HTTPPortMin               *uint             `mapstructure:"http_port_min" cty:"http_port_min" hcl:"http_port_min"`
-	HTTPPortMax               *uint             `mapstructure:"http_port_max" cty:"http_port_max" hcl:"http_port_max"`
-	SSHKeyPath                *string           `mapstructure:"ssh_key_path" cty:"ssh_key_path" hcl:"ssh_key_path"`
-	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password" hcl:"ssh_password"`
-	SSHPort                   *uint             `mapstructure:"ssh_port" cty:"ssh_port" hcl:"ssh_port"`
-	SSHUser                   *string           `mapstructure:"ssh_username" cty:"ssh_username" hcl:"ssh_username"`
-	Type                      *string           `mapstructure:"communicator" cty:"communicator" hcl:"communicator"`
-	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting" hcl:"pause_before_connecting"`
-	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host" hcl:"ssh_host"`
-	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" undocumented:"true" cty:"ssh_keypair_name" hcl:"ssh_keypair_name"`
-	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" undocumented:"true" cty:"temporary_key_pair_name" hcl:"temporary_key_pair_name"`
-	SSHTemporaryKeyPairType   *string           `mapstructure:"temporary_key_pair_type" cty:"temporary_key_pair_type" hcl:"temporary_key_pair_type"`
-	SSHTemporaryKeyPairBits   *int              `mapstructure:"temporary_key_pair_bits" cty:"temporary_key_pair_bits" hcl:"temporary_key_pair_bits"`
-	SSHCiphers                []string          `mapstructure:"ssh_ciphers" cty:"ssh_ciphers" hcl:"ssh_ciphers"`
-	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys" hcl:"ssh_clear_authorized_keys"`
-	SSHKEXAlgos               []string          `mapstructure:"ssh_key_exchange_algorithms" cty:"ssh_key_exchange_algorithms" hcl:"ssh_key_exchange_algorithms"`
-	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" undocumented:"true" cty:"ssh_private_key_file" hcl:"ssh_private_key_file"`
-	SSHCertificateFile        *string           `mapstructure:"ssh_certificate_file" cty:"ssh_certificate_file" hcl:"ssh_certificate_file"`
-	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty" hcl:"ssh_pty"`
-	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout" hcl:"ssh_timeout"`
-	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" undocumented:"true" cty:"ssh_wait_timeout" hcl:"ssh_wait_timeout"`
-	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" undocumented:"true" cty:"ssh_agent_auth" hcl:"ssh_agent_auth"`
-	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding" hcl:"ssh_disable_agent_forwarding"`
-	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts" hcl:"ssh_handshake_attempts"`
-	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host" hcl:"ssh_bastion_host"`
-	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port" hcl:"ssh_bastion_port"`
-	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth" hcl:"ssh_bastion_agent_auth"`
-	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username" hcl:"ssh_bastion_username"`
-	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password" hcl:"ssh_bastion_password"`
-	SSHBastionInteractive     *bool             `mapstructure:"ssh_bastion_interactive" cty:"ssh_bastion_interactive" hcl:"ssh_bastion_interactive"`
-	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file" hcl:"ssh_bastion_private_key_file"`
-	SSHBastionCertificateFile *string           `mapstructure:"ssh_bastion_certificate_file" cty:"ssh_bastion_certificate_file" hcl:"ssh_bastion_certificate_file"`
-	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method" hcl:"ssh_file_transfer_method"`
-	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host" hcl:"ssh_proxy_host"`
-	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port" hcl:"ssh_proxy_port"`
-	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username" hcl:"ssh_proxy_username"`
-	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password" hcl:"ssh_proxy_password"`
-	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval" hcl:"ssh_keep_alive_interval"`
-	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout" hcl:"ssh_read_write_timeout"`
-	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels" hcl:"ssh_remote_tunnels"`
-	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels" hcl:"ssh_local_tunnels"`
-	SSHPublicKey              []byte            `mapstructure:"ssh_public_key" undocumented:"true" cty:"ssh_public_key" hcl:"ssh_public_key"`
-	SSHPrivateKey             []byte            `mapstructure:"ssh_private_key" undocumented:"true" cty:"ssh_private_key" hcl:"ssh_private_key"`
-	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username" hcl:"winrm_username"`
-	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password" hcl:"winrm_password"`
-	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host" hcl:"winrm_host"`
-	WinRMNoProxy              *bool             `mapstructure:"winrm_no_proxy" cty:"winrm_no_proxy" hcl:"winrm_no_proxy"`
-	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port" hcl:"winrm_port"`
-	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout" hcl:"winrm_timeout"`
-	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl" hcl:"winrm_use_ssl"`
-	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure" hcl:"winrm_insecure"`
-	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm" hcl:"winrm_use_ntlm"`
-	SSHHostPortMin            *uint             `mapstructure:"ssh_host_port_min" cty:"ssh_host_port_min" hcl:"ssh_host_port_min"`
-	SSHHostPortMax            *uint             `mapstructure:"ssh_host_port_max" cty:"ssh_host_port_max" hcl:"ssh_host_port_max"`
-	SSHSkipNatMapping         *bool             `mapstructure:"ssh_skip_nat_mapping" cty:"ssh_skip_nat_mapping" hcl:"ssh_skip_nat_mapping"`
-	OutputDir                 *string           `mapstructure:"output_directory" cty:"output_directory" hcl:"output_directory"`
-	Format                    *string           `mapstructure:"format" cty:"format" hcl:"format"`
-	KeepVM                    *string           `mapstructure:"keep_vm" cty:"keep_vm" hcl:"keep_vm"`
-	IPGetter                  *string           `mapstructure:"ip_getter" cty:"ip_getter" hcl:"ip_getter"`
-	VCPUsMax                  *uint             `mapstructure:"vcpus_max" cty:"vcpus_max" hcl:"vcpus_max"`
-	VCPUsAtStartup            *uint             `mapstructure:"vcpus_atstartup" cty:"vcpus_atstartup" hcl:"vcpus_atstartup"`
-	VMMemory                  *uint             `mapstructure:"vm_memory" cty:"vm_memory" hcl:"vm_memory"`
-	DiskName                  *string           `mapstructure:"disk_name" cty:"disk_name" hcl:"disk_name"`
-	DiskSize                  *uint             `mapstructure:"disk_size" cty:"disk_size" hcl:"disk_size"`
-	CloneTemplate             *string           `mapstructure:"clone_template" cty:"clone_template" hcl:"clone_template"`
-	VMOtherConfig             map[string]string `mapstructure:"vm_other_config" cty:"vm_other_config" hcl:"vm_other_config"`
-	ISOChecksum               *string           `mapstructure:"iso_checksum" cty:"iso_checksum" hcl:"iso_checksum"`
-	ISOUrls                   []string          `mapstructure:"iso_urls" cty:"iso_urls" hcl:"iso_urls"`
-	ISOUrl                    *string           `mapstructure:"iso_url" cty:"iso_url" hcl:"iso_url"`
-	ISOName                   *string           `mapstructure:"iso_name" cty:"iso_name" hcl:"iso_name"`
-	PlatformArgs              map[string]string `mapstructure:"platform_args" cty:"platform_args" hcl:"platform_args"`
-	RawInstallTimeout         *string           `mapstructure:"install_timeout" cty:"install_timeout" hcl:"install_timeout"`
-	SourcePath                *string           `mapstructure:"source_path" cty:"source_path" hcl:"source_path"`
-	Firmware                  *string           `mapstructure:"firmware" cty:"firmware" hcl:"firmware"`
-	SkipSetTemplate           *bool             `mapstructure:"skip_set_template" cty:"skip_set_template" hcl:"skip_set_template"`
-}
-
-// FlatMapstructure returns a new FlatConfig.
-// FlatConfig is an auto-generated flat version of Config.
-// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
-func (*Config) FlatMapstructure() interface{ HCL2Spec() map[string]hcldec.Spec } {
-	return new(FlatConfig)
-}
-
-// HCL2Spec returns the hcl spec of a Config.
-// This spec is used by HCL to read the fields of Config.
-// The decoded values from this spec will then be applied to a FlatConfig.
-func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
-	s := map[string]hcldec.Spec{
-		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
-		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
-		"packer_core_version":          &hcldec.AttrSpec{Name: "packer_core_version", Type: cty.String, Required: false},
-		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
-		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
-		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
-		"packer_user_variables":        &hcldec.AttrSpec{Name: "packer_user_variables", Type: cty.Map(cty.String), Required: false},
-		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
-		"remote_username":              &hcldec.AttrSpec{Name: "remote_username", Type: cty.String, Required: false},
-		"remote_password":              &hcldec.AttrSpec{Name: "remote_password", Type: cty.String, Required: false},
-		"remote_host":                  &hcldec.AttrSpec{Name: "remote_host", Type: cty.String, Required: false},
-		"remote_ssh_port":              &hcldec.AttrSpec{Name: "remote_ssh_port", Type: cty.Number, Required: false},
-		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
-		"vm_description":               &hcldec.AttrSpec{Name: "vm_description", Type: cty.String, Required: false},
-		"sr_name":                      &hcldec.AttrSpec{Name: "sr_name", Type: cty.String, Required: false},
-		"sr_iso_name":                  &hcldec.AttrSpec{Name: "sr_iso_name", Type: cty.String, Required: false},
-		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
-		"network_names":                &hcldec.AttrSpec{Name: "network_names", Type: cty.List(cty.String), Required: false},
-		"export_network_names":         &hcldec.AttrSpec{Name: "export_network_names", Type: cty.List(cty.String), Required: false},
-		"vm_tags":                      &hcldec.AttrSpec{Name: "vm_tags", Type: cty.List(cty.String), Required: false},
-		"host_port_min":                &hcldec.AttrSpec{Name: "host_port_min", Type: cty.Number, Required: false},
-		"host_port_max":                &hcldec.AttrSpec{Name: "host_port_max", Type: cty.Number, Required: false},
-		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
-		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
-		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
-		"tools_iso_name":               &hcldec.AttrSpec{Name: "tools_iso_name", Type: cty.String, Required: false},
-		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
-		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
-		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
-		"ssh_key_path":                 &hcldec.AttrSpec{Name: "ssh_key_path", Type: cty.String, Required: false},
-		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
-		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
-		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
-		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
-		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
-		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
-		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
-		"temporary_key_pair_type":      &hcldec.AttrSpec{Name: "temporary_key_pair_type", Type: cty.String, Required: false},
-		"temporary_key_pair_bits":      &hcldec.AttrSpec{Name: "temporary_key_pair_bits", Type: cty.Number, Required: false},
-		"ssh_ciphers":                  &hcldec.AttrSpec{Name: "ssh_ciphers", Type: cty.List(cty.String), Required: false},
-		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
-		"ssh_key_exchange_algorithms":  &hcldec.AttrSpec{Name: "ssh_key_exchange_algorithms", Type: cty.List(cty.String), Required: false},
-		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
-		"ssh_certificate_file":         &hcldec.AttrSpec{Name: "ssh_certificate_file", Type: cty.String, Required: false},
-		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
-		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
-		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
-		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
-		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
-		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
-		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
-		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
-		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
-		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
-		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
-		"ssh_bastion_interactive":      &hcldec.AttrSpec{Name: "ssh_bastion_interactive", Type: cty.Bool, Required: false},
-		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
-		"ssh_bastion_certificate_file": &hcldec.AttrSpec{Name: "ssh_bastion_certificate_file", Type: cty.String, Required: false},
-		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
-		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
-		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
-		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
-		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
-		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
-		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
-		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
-		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
-		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
-		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
-		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
-		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
-		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
-		"winrm_no_proxy":               &hcldec.AttrSpec{Name: "winrm_no_proxy", Type: cty.Bool, Required: false},
-		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
-		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
-		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
-		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
-		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
-		"ssh_host_port_min":            &hcldec.AttrSpec{Name: "ssh_host_port_min", Type: cty.Number, Required: false},
-		"ssh_host_port_max":            &hcldec.AttrSpec{Name: "ssh_host_port_max", Type: cty.Number, Required: false},
-		"ssh_skip_nat_mapping":         &hcldec.AttrSpec{Name: "ssh_skip_nat_mapping", Type: cty.Bool, Required: false},
-		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
-		"format":                       &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
-		"keep_vm":                      &hcldec.AttrSpec{Name: "keep_vm", Type: cty.String, Required: false},
-		"ip_getter":                    &hcldec.AttrSpec{Name: "ip_getter", Type: cty.String, Required: false},
-		"vcpus_max":                    &hcldec.AttrSpec{Name: "vcpus_max", Type: cty.Number, Required: false},
-		"vcpus_atstartup":              &hcldec.AttrSpec{Name: "vcpus_atstartup", Type: cty.Number, Required: false},
-		"vm_memory":                    &hcldec.AttrSpec{Name: "vm_memory", Type: cty.Number, Required: false},
-		"disk_name":                    &hcldec.AttrSpec{Name: "disk_name", Type: cty.String, Required: false},
-		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
-		"clone_template":               &hcldec.AttrSpec{Name: "clone_template", Type: cty.String, Required: false},
-		"vm_other_config":              &hcldec.AttrSpec{Name: "vm_other_config", Type: cty.Map(cty.String), Required: false},
-		"iso_checksum":                 &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
-		"iso_urls":                     &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
-		"iso_url":                      &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
-		"iso_name":                     &hcldec.AttrSpec{Name: "iso_name", Type: cty.String, Required: false},
-		"platform_args":                &hcldec.AttrSpec{Name: "platform_args", Type: cty.Map(cty.String), Required: false},
-		"install_timeout":              &hcldec.AttrSpec{Name: "install_timeout", Type: cty.String, Required: false},
-		"source_path":                  &hcldec.AttrSpec{Name: "source_path", Type: cty.String, Required: false},
-		"firmware":                     &hcldec.AttrSpec{Name: "firmware", Type: cty.String, Required: false},
-		"skip_set_template":            &hcldec.AttrSpec{Name: "skip_set_template", Type: cty.Bool, Required: false},
-	}
-	return s
-}

builder/xenserver/common/find_port.go

@@ -1,25 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"log"
-	"net"
-)
-
-// FindPort finds and starts listening on a port in the range [portMin, portMax]
-// returns the listener and the port number on success, or nil, 0 on failure
-func FindPort(portMin uint, portMax uint) (net.Listener, uint) {
-	log.Printf("Looking for an available port between %d and %d", portMin, portMax)
-
-	for port := portMin; port <= portMax; port++ {
-		log.Printf("Trying port: %d", port)
-		l, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
-		if err == nil {
-			return l, port
-		} else {
-			log.Printf("Port %d unavailable: %s", port, err.Error())
-		}
-	}
-
-	return nil, 0
-}

builder/xenserver/common/http_upload.go

@@ -1,127 +0,0 @@
-package common
-
-import (
-	"crypto/tls"
-	"fmt"
-	"log"
-	"net/http"
-	"net/url"
-	"os"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	xsclient "github.com/terra-farm/go-xen-api-client"
-)
-
-func appendQuery(urlstring, k, v string) (string, error) {
-	u, err := url.Parse(urlstring)
-	if err != nil {
-		return "", fmt.Errorf("Unable to parse URL '%s': %s", urlstring, err.Error())
-	}
-	m := u.Query()
-	m.Add(k, v)
-	u.RawQuery = m.Encode()
-	return u.String(), err
-}
-
-func HTTPUpload(import_url string, fh *os.File, state multistep.StateBag) (result string, err error) {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	task, err := c.client.Task.Create(c.session, "packer-task", "Packer task")
-	if err != nil {
-		err = fmt.Errorf("Unable to create task: %s", err.Error())
-		return
-	}
-	defer c.client.Task.Destroy(c.session, task)
-
-	import_task_url, err := appendQuery(import_url, "task_id", string(task))
-	if err != nil {
-		return
-	}
-
-	// Get file length
-	fstat, err := fh.Stat()
-	if err != nil {
-		err = fmt.Errorf("Unable to stat '%s': %s", fh.Name(), err.Error())
-		return
-	}
-	fileLength := fstat.Size()
-
-	// Define a new transport which allows self-signed certs
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-
-	// Create a client
-	httpClient := &http.Client{Transport: tr}
-
-	// Create request and download file
-	request, err := http.NewRequest("PUT", import_task_url, fh)
-	request.ContentLength = fileLength
-
-	ui.Say(fmt.Sprintf("PUT '%s'", import_task_url))
-
-	resp, err := httpClient.Do(request) // Do closes fh for us, according to docs
-	if err != nil {
-		return
-	}
-
-	if resp.StatusCode != 200 {
-		err = fmt.Errorf("PUT request got non-200 status code: %s", resp.Status)
-		return
-	}
-
-	logIteration := 0
-	err = InterruptibleWait{
-		Predicate: func() (bool, error) {
-			status, err := c.client.Task.GetStatus(c.session, task)
-			if err != nil {
-				return false, fmt.Errorf("Failed to get task status: %s", err.Error())
-			}
-			switch status {
-			case xsclient.TaskStatusTypePending:
-				progress, err := c.client.Task.GetProgress(c.session, task)
-				if err != nil {
-					return false, fmt.Errorf("Failed to get progress: %s", err.Error())
-				}
-				logIteration = logIteration + 1
-				if logIteration%5 == 0 {
-					log.Printf("Upload %.0f%% complete", progress*100)
-				}
-				return false, nil
-			case xsclient.TaskStatusTypeSuccess:
-				return true, nil
-			case xsclient.TaskStatusTypeFailure:
-				errorInfo, err := c.client.Task.GetErrorInfo(c.session, task)
-				if err != nil {
-					errorInfo = []string{fmt.Sprintf("furthermore, failed to get error info: %s", err.Error())}
-				}
-				return false, fmt.Errorf("Task failed: %s", errorInfo)
-			case xsclient.TaskStatusTypeCancelling, xsclient.TaskStatusTypeCancelled:
-				return false, fmt.Errorf("Task cancelled")
-			default:
-				return false, fmt.Errorf("Unknown task status %v", status)
-			}
-		},
-		PredicateInterval: 1 * time.Second,
-		Timeout:           24 * time.Hour,
-	}.Wait(state)
-
-	resp.Body.Close()
-
-	if err != nil {
-		err = fmt.Errorf("Error uploading: %s", err.Error())
-		return
-	}
-
-	result, err = c.client.Task.GetResult(c.session, task)
-	if err != nil {
-		err = fmt.Errorf("Error getting result: %s", err.Error())
-		return
-	}
-
-	log.Printf("Upload complete")
-	return
-}

builder/xenserver/common/interruptible_wait.go

@@ -1,86 +0,0 @@
-package common
-
-import (
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"time"
-)
-
-type InterruptibleWait struct {
-	Timeout time.Duration
-
-	// optional:
-	Predicate         func() (result bool, err error)
-	PredicateInterval time.Duration
-}
-
-type TimeoutError struct{}
-
-func (err TimeoutError) Error() string {
-	return "Timed out"
-}
-
-type InterruptedError struct{}
-
-func (err InterruptedError) Error() string {
-	return "Interrupted"
-}
-
-type PredicateResult struct {
-	complete bool
-	err      error
-}
-
-/* Wait waits for up to Timeout duration, checking an optional Predicate every PredicateInterval duration.
-   The first run of Predicate is immediately after Wait is called.
-   If the command is interrupted by the user, then an InterruptedError is returned.
-   If Predicate is not nil, a timeout leads to TimeoutError being returned, and a successful Predicate run leads to nil being returned.
-   If Predicate is nil, a timeout is not an error, and nil is returned.
-*/
-func (wait InterruptibleWait) Wait(state multistep.StateBag) error {
-	predicateResult := make(chan PredicateResult, 1)
-	stopWaiting := make(chan struct{})
-	defer close(stopWaiting)
-
-	if wait.Predicate != nil {
-		go func() {
-			for {
-				if complete, err := wait.Predicate(); err != nil || complete {
-					predicateResult <- PredicateResult{complete, err}
-					return
-				}
-
-				select {
-				case <-time.After(wait.PredicateInterval):
-					continue
-				case <-stopWaiting:
-					return
-				}
-			}
-		}()
-	}
-
-	timeout := time.After(wait.Timeout)
-	for {
-		// wait for either install to complete/error,
-		// an interrupt to come through, or a timeout to occur
-
-		if _, ok := state.GetOk(multistep.StateCancelled); ok {
-			return InterruptedError{}
-		}
-
-		select {
-		case result := <-predicateResult:
-			return result.err
-
-		case <-time.After(1 * time.Second):
-			continue
-
-		case <-timeout:
-			if wait.Predicate != nil {
-				return TimeoutError{}
-			} else {
-				return nil
-			}
-		}
-	}
-}

builder/xenserver/common/ssh.go

@@ -1,217 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"encoding/pem"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"os"
-	"strings"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	gossh "golang.org/x/crypto/ssh"
-)
-
-func SSHAddress(state multistep.StateBag) (string, error) {
-	sshIP := state.Get("ssh_address").(string)
-	sshHostPort := state.Get("ssh_port").(uint)
-	return fmt.Sprintf("%s:%d", sshIP, sshHostPort), nil
-}
-
-func SSHLocalAddress(state multistep.StateBag) (string, error) {
-	sshLocalPort, ok := state.Get("local_ssh_port").(uint)
-	if !ok {
-		return "", fmt.Errorf("SSH port forwarding hasn't been set up yet")
-	}
-	conn_str := fmt.Sprintf("%s:%d", "127.0.0.1", sshLocalPort)
-	return conn_str, nil
-}
-
-func SSHPort(state multistep.StateBag) (int, error) {
-	sshHostPort := state.Get("local_ssh_port").(uint)
-	return int(sshHostPort), nil
-}
-
-func CommHost(state multistep.StateBag) (string, error) {
-	return "127.0.0.1", nil
-}
-
-func SSHConfigFunc(config SSHConfig) func(multistep.StateBag) (*gossh.ClientConfig, error) {
-	return func(state multistep.StateBag) (*gossh.ClientConfig, error) {
-		config := state.Get("commonconfig").(CommonConfig)
-		auth := []gossh.AuthMethod{
-			gossh.Password(config.SSHPassword),
-		}
-
-		if config.SSHKeyPath != "" {
-			signer, err := FileSigner(config.SSHKeyPath)
-			if err != nil {
-				return nil, err
-			}
-
-			auth = append(auth, gossh.PublicKeys(signer))
-		}
-
-		return &gossh.ClientConfig{
-			User:            config.SSHUser,
-			Auth:            auth,
-			HostKeyCallback: gossh.InsecureIgnoreHostKey(),
-		}, nil
-	}
-}
-
-func doExecuteSSHCmd(cmd, target string, config *gossh.ClientConfig) (stdout string, err error) {
-	client, err := gossh.Dial("tcp", target, config)
-	if err != nil {
-		return "", err
-	}
-
-	//Create session
-	session, err := client.NewSession()
-	if err != nil {
-		return "", err
-	}
-
-	defer session.Close()
-
-	var b bytes.Buffer
-	session.Stdout = &b
-	if err := session.Run(cmd); err != nil {
-		return "", err
-	}
-
-	return strings.Trim(b.String(), "\n"), nil
-}
-
-func ExecuteHostSSHCmd(state multistep.StateBag, cmd string) (stdout string, err error) {
-	config := state.Get("commonconfig").(CommonConfig)
-	sshAddress, _ := SSHAddress(state)
-	// Setup connection config
-	sshConfig := &gossh.ClientConfig{
-		User: config.Username,
-		Auth: []gossh.AuthMethod{
-			gossh.Password(config.Password),
-		},
-		HostKeyCallback: gossh.InsecureIgnoreHostKey(),
-	}
-	return doExecuteSSHCmd(cmd, sshAddress, sshConfig)
-}
-
-func ExecuteGuestSSHCmd(state multistep.StateBag, cmd string) (stdout string, err error) {
-	config := state.Get("commonconfig").(CommonConfig)
-	localAddress, err := SSHLocalAddress(state)
-	if err != nil {
-		return
-	}
-	sshConfig, err := SSHConfigFunc(config.SSHConfig)(state)
-	if err != nil {
-		return
-	}
-
-	return doExecuteSSHCmd(cmd, localAddress, sshConfig)
-}
-
-func forward(local_conn net.Conn, config *gossh.ClientConfig, server string, server_ssh_port int, remote_dest string, remote_port uint) error {
-	defer local_conn.Close()
-
-	ssh_client_conn, err := gossh.Dial("tcp", fmt.Sprintf("%s:%d", server, server_ssh_port), config)
-	if err != nil {
-		log.Printf("local ssh.Dial error: %s", err)
-		return err
-	}
-	defer ssh_client_conn.Close()
-
-	remote_loc := fmt.Sprintf("%s:%d", remote_dest, remote_port)
-	ssh_conn, err := ssh_client_conn.Dial("tcp", remote_loc)
-	if err != nil {
-		log.Printf("ssh.Dial error: %s", err)
-		return err
-	}
-	defer ssh_conn.Close()
-
-	txDone := make(chan struct{})
-	rxDone := make(chan struct{})
-
-	go func() {
-		_, err = io.Copy(ssh_conn, local_conn)
-		if err != nil {
-			log.Printf("io.copy failed: %v", err)
-		}
-		close(txDone)
-	}()
-
-	go func() {
-		_, err = io.Copy(local_conn, ssh_conn)
-		if err != nil {
-			log.Printf("io.copy failed: %v", err)
-		}
-		close(rxDone)
-	}()
-
-	<-txDone
-	<-rxDone
-
-	return nil
-}
-
-func ssh_port_forward(local_listener net.Listener, remote_port int, remote_dest, host string, host_ssh_port int, username, password string) error {
-
-	config := &gossh.ClientConfig{
-		User: username,
-		Auth: []gossh.AuthMethod{
-			gossh.Password(password),
-		},
-		HostKeyCallback: gossh.InsecureIgnoreHostKey(),
-	}
-
-	for {
-		local_connection, err := local_listener.Accept()
-
-		if err != nil {
-			log.Printf("Local accept failed: %s", err)
-			return err
-		}
-
-		// Forward to a remote port
-		go forward(local_connection, config, host, host_ssh_port, remote_dest, uint(remote_port))
-	}
-
-	return nil
-}
-
-// FileSigner returns an gossh.Signer for a key file.
-func FileSigner(path string) (gossh.Signer, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	keyBytes, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, err
-	}
-
-	// We parse the private key on our own first so that we can
-	// show a nicer error if the private key has a password.
-	block, _ := pem.Decode(keyBytes)
-	if block == nil {
-		return nil, fmt.Errorf(
-			"Failed to read key '%s': no key found", path)
-	}
-	if block.Headers["Proc-Type"] == "4,ENCRYPTED" {
-		return nil, fmt.Errorf(
-			"Failed to read key '%s': password protected keys are\n"+
-				"not supported. Please decrypt the key prior to use.", path)
-	}
-
-	signer, err := gossh.ParsePrivateKey(keyBytes)
-	if err != nil {
-		return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-	}
-
-	return signer, nil
-}

builder/xenserver/common/ssh_config.go

@@ -1,48 +0,0 @@
-package common
-
-import (
-	"errors"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/communicator"
-	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
-)
-
-type SSHConfig struct {
-	Comm communicator.Config `mapstructure:",squash"`
-
-	SSHHostPortMin    uint `mapstructure:"ssh_host_port_min"`
-	SSHHostPortMax    uint `mapstructure:"ssh_host_port_max"`
-	SSHSkipNatMapping bool `mapstructure:"ssh_skip_nat_mapping"`
-
-	// These are deprecated, but we keep them around for BC
-	// TODO(@mitchellh): remove
-	SSHKeyPath     string        `mapstructure:"ssh_key_path"`
-	SSHWaitTimeout time.Duration `mapstructure:"ssh_wait_timeout"`
-}
-
-func (c *SSHConfig) Prepare(ctx *interpolate.Context) []error {
-	if c.SSHHostPortMin == 0 {
-		c.SSHHostPortMin = 2222
-	}
-
-	if c.SSHHostPortMax == 0 {
-		c.SSHHostPortMax = 4444
-	}
-
-	// TODO: backwards compatibility, write fixer instead
-	if c.SSHKeyPath != "" {
-		c.Comm.SSHPrivateKeyFile = c.SSHKeyPath
-	}
-	if c.SSHWaitTimeout != 0 {
-		c.Comm.SSHTimeout = c.SSHWaitTimeout
-	}
-
-	errs := c.Comm.Prepare(ctx)
-	if c.SSHHostPortMin > c.SSHHostPortMax {
-		errs = append(errs,
-			errors.New("ssh_host_port_min must be less than ssh_host_port_max"))
-	}
-
-	return errs
-}

builder/xenserver/common/step_attach_vdi.go

@@ -1,84 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	xsclient "github.com/terra-farm/go-xen-api-client"
-)
-
-type StepAttachVdi struct {
-	VdiUuidKey string
-	VdiType    xsclient.VbdType
-
-	vdi xsclient.VDIRef
-}
-
-func (self *StepAttachVdi) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	log.Printf("Running attach vdi for key %s\n", self.VdiUuidKey)
-	var vdiUuid string
-	if vdiUuidRaw, ok := state.GetOk(self.VdiUuidKey); ok {
-		vdiUuid = vdiUuidRaw.(string)
-	} else {
-		log.Printf("Skipping attach of '%s'", self.VdiUuidKey)
-		return multistep.ActionContinue
-	}
-
-	var err error
-	self.vdi, err = c.client.VDI.GetByUUID(c.session, vdiUuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VDI from UUID '%s': %s", vdiUuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = ConnectVdi(c, instance, self.vdi, self.VdiType)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error attaching VDI '%s': '%s'", vdiUuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	log.Printf("Attached VDI '%s'", vdiUuid)
-
-	return multistep.ActionContinue
-}
-
-func (self *StepAttachVdi) Cleanup(state multistep.StateBag) {
-	config := state.Get("commonconfig").(CommonConfig)
-	c := state.Get("client").(*Connection)
-	if config.ShouldKeepVM(state) {
-		return
-	}
-
-	if self.vdi == "" {
-		return
-	}
-
-	uuid := state.Get("instance_uuid").(string)
-	vmRef, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		log.Printf("Unable to get VM from UUID '%s': %s", uuid, err.Error())
-		return
-	}
-
-	vdiUuid := state.Get(self.VdiUuidKey).(string)
-
-	err = DisconnectVdi(c, vmRef, self.vdi)
-	if err != nil {
-		log.Printf("Unable to disconnect VDI '%s': %s", vdiUuid, err.Error())
-		return
-	}
-	log.Printf("Detached VDI '%s'", vdiUuid)
-}

builder/xenserver/common/step_boot_wait.go

@@ -1,33 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepBootWait struct{}
-
-func (self *StepBootWait) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	c := state.Get("client").(*Connection)
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-
-	instance, _ := c.client.VM.GetByUUID(c.session, state.Get("instance_uuid").(string))
-	ui.Say("Unpausing VM " + state.Get("instance_uuid").(string))
-	Unpause(c, instance)
-
-	if int64(config.BootWait) > 0 {
-		ui.Say(fmt.Sprintf("Waiting %s for boot...", config.BootWait))
-		err := InterruptibleWait{Timeout: config.BootWait}.Wait(state)
-		if err != nil {
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-	}
-	return multistep.ActionContinue
-}
-
-func (self *StepBootWait) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_create_instance.go

@@ -1,262 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	xenapi "github.com/terra-farm/go-xen-api-client"
-	xsclient "github.com/terra-farm/go-xen-api-client"
-)
-
-type StepCreateInstance struct {
-	// The XVA builder assumes it will boot an instance with an OS installed on its disks
-	// while the ISO builder needs packer to create a disk for an OS to be installed on.
-	AssumePreInstalledOS bool
-
-	instance *xsclient.VMRef
-	vdi      *xsclient.VDIRef
-}
-
-func (self *StepCreateInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-
-	c := state.Get("client").(*Connection)
-	config := state.Get("config").(Config)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Step: Create Instance")
-
-	// Get the template to clone from
-
-	vms, err := c.GetClient().VM.GetByNameLabel(c.GetSessionRef(), config.CloneTemplate)
-
-	switch {
-	case len(vms) == 0:
-		ui.Error(fmt.Sprintf("Couldn't find a template with the name-label '%s'. Aborting.", config.CloneTemplate))
-		return multistep.ActionHalt
-	case len(vms) > 1:
-		ui.Error(fmt.Sprintf("Found more than one template with the name '%s'. The name must be unique. Aborting.", config.CloneTemplate))
-		return multistep.ActionHalt
-	}
-
-	template := vms[0]
-
-	// Clone that VM template
-	instance, err := c.GetClient().VM.Clone(c.GetSessionRef(), template, config.VMName)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error cloning VM: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-	self.instance = &instance
-
-	err = c.GetClient().VM.SetIsATemplate(c.GetSessionRef(), instance, false)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting is_a_template=false: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.GetClient().VM.SetVCPUsMax(c.GetSessionRef(), instance, int(config.VCPUsMax))
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM VCPUs Max=%d: %s", config.VCPUsMax, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.GetClient().VM.SetVCPUsAtStartup(c.GetSessionRef(), instance, int(config.VCPUsAtStartup))
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM VCPUs At Startup=%d: %s", config.VCPUsAtStartup, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	memory := int(config.VMMemory * 1024 * 1024)
-	err = c.GetClient().VM.SetMemoryLimits(c.GetSessionRef(), instance, memory, memory, memory, memory)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM memory=%d: %s", memory, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.GetClient().VM.SetPlatform(c.GetSessionRef(), instance, config.PlatformArgs)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM platform: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.GetClient().VM.SetNameDescription(c.GetSessionRef(), instance, config.VMDescription)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM description: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	if len(config.VMOtherConfig) != 0 {
-		vm_other_config, err := c.GetClient().VM.GetOtherConfig(c.GetSessionRef(), instance)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Error getting VM other-config: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-		for key, value := range config.VMOtherConfig {
-			vm_other_config[key] = value
-		}
-		err = c.GetClient().VM.SetOtherConfig(c.GetSessionRef(), instance, vm_other_config)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Error setting VM other-config: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-	}
-
-	if !self.AssumePreInstalledOS {
-		err = c.GetClient().VM.RemoveFromOtherConfig(c.GetSessionRef(), instance, "disks")
-		if err != nil {
-			ui.Error(fmt.Sprintf("Error removing disks from VM other-config: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-
-		// Create VDI for the instance
-		sr, err := config.GetSR(c)
-
-		if err != nil {
-			ui.Error(fmt.Sprintf("Unable to get SR: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-
-		ui.Say(fmt.Sprintf("Using the following SR for the VM: %s", sr))
-
-		vdi, err := c.GetClient().VDI.Create(c.GetSessionRef(), xenapi.VDIRecord{
-			NameLabel:   config.DiskName,
-			VirtualSize: int(config.DiskSize * 1024 * 1024),
-			Type:        "user",
-			Sharable:    false,
-			ReadOnly:    false,
-			SR:          sr,
-			OtherConfig: map[string]string{
-				"temp": "temp",
-			},
-		})
-		if err != nil {
-			ui.Error(fmt.Sprintf("Unable to create packer disk VDI: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-		self.vdi = &vdi
-
-		err = ConnectVdi(c, instance, vdi, xsclient.VbdTypeDisk)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Unable to connect packer disk VDI: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-	}
-
-	// Connect Network
-
-	var network xsclient.NetworkRef
-
-	if len(config.NetworkNames) == 0 {
-		// No network has be specified. Use the management interface
-		log.Println("No network name given, attempting to use management interface")
-		pifs, err := c.GetClient().PIF.GetAll(c.GetSessionRef())
-
-		if err != nil {
-			ui.Error(fmt.Sprintf("Error getting PIFs: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-
-		for _, pif := range pifs {
-			pif_rec, err := c.GetClient().PIF.GetRecord(c.GetSessionRef(), pif)
-
-			if err != nil {
-				ui.Error(fmt.Sprintf("Error getting PIF record: %s", err.Error()))
-				return multistep.ActionHalt
-			}
-
-			if pif_rec.Management {
-				network = pif_rec.Network
-			}
-
-		}
-
-		if string(network) == "" {
-			ui.Error("Error: couldn't find management network. Aborting.")
-			return multistep.ActionHalt
-		}
-
-		log.Printf("Creating VIF on network '%s' on VM '%s'\n", network, instance)
-		_, err = ConnectNetwork(c, network, instance, "0")
-
-		if err != nil {
-			ui.Error(fmt.Sprintf("Failed to create VIF with error: %v", err))
-			return multistep.ActionHalt
-		}
-
-	} else {
-		log.Printf("Using provided network names: %v\n", config.NetworkNames)
-		// Look up each network by it's name label
-		for i, networkNameLabel := range config.NetworkNames {
-			networks, err := c.GetClient().Network.GetByNameLabel(c.GetSessionRef(), networkNameLabel)
-
-			if err != nil {
-				ui.Error(fmt.Sprintf("Error occured getting Network by name-label: %s", err.Error()))
-				return multistep.ActionHalt
-			}
-
-			switch {
-			case len(networks) == 0:
-				ui.Error(fmt.Sprintf("Couldn't find a network with the specified name-label '%s'. Aborting.", networkNameLabel))
-				return multistep.ActionHalt
-			case len(networks) > 1:
-				ui.Error(fmt.Sprintf("Found more than one network with the name '%s'. The name must be unique. Aborting.", networkNameLabel))
-				return multistep.ActionHalt
-			}
-
-			//we need the VIF index string
-			vifIndexString := fmt.Sprintf("%d", i)
-			_, err = ConnectNetwork(c, networks[0], instance, vifIndexString)
-
-			if err != nil {
-				ui.Say(fmt.Sprintf("Failed to connect VIF with error: %v", err.Error()))
-			}
-		}
-	}
-
-	err = AddVMTags(c, instance, config.VMTags)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Failed to add tags: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	instanceId, err := c.GetClient().VM.GetUUID(c.GetSessionRef(), instance)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM UUID: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	state.Put("instance_uuid", instanceId)
-	ui.Say(fmt.Sprintf("Created instance '%s'", instanceId))
-
-	return multistep.ActionContinue
-}
-
-func (self *StepCreateInstance) Cleanup(state multistep.StateBag) {
-	config := state.Get("config").(Config)
-	if config.ShouldKeepVM(state) {
-		return
-	}
-
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	if self.instance != nil {
-		ui.Say("Destroying VM")
-		_ = c.GetClient().VM.HardShutdown(c.GetSessionRef(), *self.instance) // redundant, just in case
-		err := c.GetClient().VM.Destroy(c.GetSessionRef(), *self.instance)
-		if err != nil {
-			ui.Error(err.Error())
-		}
-	}
-
-	if self.vdi != nil {
-		ui.Say("Destroying VDI")
-		err := c.GetClient().VDI.Destroy(c.GetSessionRef(), *self.vdi)
-		if err != nil {
-			ui.Error(err.Error())
-		}
-	}
-}

builder/xenserver/common/step_detach_vdi.go

@@ -1,53 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepDetachVdi struct {
-	VdiUuidKey string
-}
-
-func (self *StepDetachVdi) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	var vdiUuid string
-	if vdiUuidRaw, ok := state.GetOk(self.VdiUuidKey); ok {
-		vdiUuid = vdiUuidRaw.(string)
-	} else {
-		log.Printf("Skipping detach of '%s'", self.VdiUuidKey)
-		return multistep.ActionContinue
-	}
-
-	vdi, err := c.client.VDI.GetByUUID(c.session, vdiUuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VDI from UUID '%s': %s", vdiUuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = DisconnectVdi(c, instance, vdi)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to detach VDI '%s': %s", vdiUuid, err.Error()))
-		//return multistep.ActionHalt
-		return multistep.ActionContinue
-	}
-
-	log.Printf("Detached VDI '%s'", vdiUuid)
-
-	return multistep.ActionContinue
-}
-
-func (self *StepDetachVdi) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_export.go

@@ -1,278 +0,0 @@
-package common
-
-import (
-	"context"
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"os/exec"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepExport struct{}
-
-func downloadFile(url, filename string, ui packer.Ui) (err error) {
-
-	// Create the file
-	fh, err := os.Create(filename)
-	if err != nil {
-		return err
-	}
-	defer fh.Close()
-
-	// Define a new transport which allows self-signed certs
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-
-	// Create a client
-	client := &http.Client{Transport: tr}
-
-	// Create request and download file
-
-	resp, err := client.Get(url)
-	if err != nil {
-		return err
-	}
-
-	defer resp.Body.Close()
-
-	var progress uint
-	var total uint
-	var percentage uint
-	var marker_len uint
-
-	progress = uint(0)
-	total = uint(resp.ContentLength)
-	percentage = uint(0)
-	marker_len = uint(5)
-
-	var buffer [4096]byte
-	for {
-		n, err := resp.Body.Read(buffer[:])
-		if err != nil && err != io.EOF {
-			return err
-		}
-
-		progress += uint(n)
-
-		if _, write_err := fh.Write(buffer[:n]); write_err != nil {
-			return write_err
-		}
-
-		if err == io.EOF {
-			break
-		}
-
-		// Increment percentage in multiples of marker_len
-		cur_percentage := ((progress * 100 / total) / marker_len) * marker_len
-		if cur_percentage > percentage {
-			percentage = cur_percentage
-			ui.Message(fmt.Sprintf("Downloading... %d%%", percentage))
-		}
-
-	}
-
-	return nil
-}
-
-func (StepExport) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-	instance_uuid := state.Get("instance_uuid").(string)
-	suffix := ".vhd"
-	extrauri := "&format=vhd"
-
-	instance, err := c.client.VM.GetByUUID(c.session, instance_uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Could not get VM with UUID '%s': %s", instance_uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	if len(config.ExportNetworkNames) > 0 {
-		vifs, err := c.client.VM.GetVIFs(c.session, instance)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Error occured getting VIFs: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-
-		for _, vif := range vifs {
-			err := c.client.VIF.Destroy(c.session, vif)
-			if err != nil {
-				ui.Error(fmt.Sprintf("Destroy vif fail: '%s': %s", vif, err.Error()))
-				return multistep.ActionHalt
-			}
-		}
-		for i, networkNameLabel := range config.ExportNetworkNames {
-			networks, err := c.client.Network.GetByNameLabel(c.session, networkNameLabel)
-
-			if err != nil {
-				ui.Error(fmt.Sprintf("Error occured getting Network by name-label: %s", err.Error()))
-				return multistep.ActionHalt
-			}
-
-			switch {
-			case len(networks) == 0:
-				ui.Error(fmt.Sprintf("Couldn't find a network with the specified name-label '%s'. Aborting.", networkNameLabel))
-				return multistep.ActionHalt
-			case len(networks) > 1:
-				ui.Error(fmt.Sprintf("Found more than one network with the name '%s'. The name must be unique. Aborting.", networkNameLabel))
-				return multistep.ActionHalt
-			}
-
-			//we need the VIF index string
-			vifIndexString := fmt.Sprintf("%d", i)
-			_, err = ConnectNetwork(c, networks[0], instance, vifIndexString)
-
-			if err != nil {
-				ui.Say(err.Error())
-			}
-		}
-	}
-
-	ui.Say("Step: export artifact")
-
-	compress_option_xe := "compress=false"
-	compress_option_url := ""
-
-	switch config.Format {
-	case "none":
-		ui.Say("Skipping export")
-		return multistep.ActionContinue
-
-	case "xva_compressed":
-		compress_option_xe = "compress=true"
-		compress_option_url = "use_compression=true&"
-		fallthrough
-	case "xva":
-		// export the VM
-
-		export_filename := fmt.Sprintf("%s/%s.xva", config.OutputDir, config.VMName)
-
-		use_xe := os.Getenv("USE_XE") == "1"
-		if xe, e := exec.LookPath("xe"); e == nil && use_xe {
-			cmd := exec.Command(
-				xe,
-				"-s", c.Host,
-				"-p", "443",
-				"-u", c.Username,
-				"-pw", c.Password,
-				"vm-export",
-				"vm="+instance_uuid,
-				compress_option_xe,
-				"filename="+export_filename,
-			)
-
-			ui.Say(fmt.Sprintf("Getting XVA %+v %+v", cmd.Path, cmd.Args))
-
-			err = cmd.Run()
-		} else {
-			export_url := fmt.Sprintf("https://%s/export?%suuid=%s&session_id=%s",
-				c.Host,
-				compress_option_url,
-				instance_uuid,
-				c.GetSession(),
-			)
-
-			ui.Say("Getting XVA " + export_url)
-			err = downloadFile(export_url, export_filename, ui)
-		}
-
-		if err != nil {
-			ui.Error(fmt.Sprintf("Could not download XVA: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-
-	case "vdi_raw":
-		suffix = ".raw"
-		extrauri = ""
-		fallthrough
-	case "vdi_vhd":
-		// export the disks
-
-		disks, err := GetDisks(c, instance)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Could not get VM disks: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-		for _, disk := range disks {
-			disk_uuid, err := c.client.VDI.GetUUID(c.session, disk)
-			if err != nil {
-				ui.Error(fmt.Sprintf("Could not get disk with UUID '%s': %s", disk_uuid, err.Error()))
-				return multistep.ActionHalt
-			}
-
-			// Work out XenServer version
-			hosts, err := c.client.Host.GetAll(c.session)
-
-			if err != nil {
-				ui.Error(fmt.Sprintf("Could not retrieve hosts in the pool: %s", err.Error()))
-				return multistep.ActionHalt
-			}
-			host := hosts[0]
-			host_software_versions, err := c.client.Host.GetSoftwareVersion(c.session, host)
-			xs_version := host_software_versions["product_version"]
-
-			if err != nil {
-				ui.Error(fmt.Sprintf("Could not get the software version: %s", err.Error()))
-				return multistep.ActionHalt
-			}
-
-			var disk_export_url string
-
-			// @todo: check for 6.5 SP1
-			if xs_version <= "6.5.0" && config.Format == "vdi_vhd" {
-				// Export the VHD using a Transfer VM
-
-				disk_export_url, err = Expose(c, disk, "vhd")
-
-				if err != nil {
-					ui.Error(fmt.Sprintf("Failed to expose disk %s: %s", disk_uuid, err.Error()))
-					return multistep.ActionHalt
-				}
-
-			} else {
-
-				// Use the preferred direct export from XAPI
-				// Basic auth in URL request is required as session token is not
-				// accepted for some reason.
-				// @todo: raise with XAPI team.
-				disk_export_url = fmt.Sprintf("https://%s:%s@%s/export_raw_vdi?vdi=%s%s",
-					c.Username,
-					c.Password,
-					c.Host,
-					disk_uuid,
-					extrauri)
-
-			}
-
-			disk_export_filename := fmt.Sprintf("%s/%s%s", config.OutputDir, disk_uuid, suffix)
-
-			ui.Say("Getting VDI " + disk_export_url)
-			err = downloadFile(disk_export_url, disk_export_filename, ui)
-			if err != nil {
-				ui.Error(fmt.Sprintf("Could not download VDI: %s", err.Error()))
-				return multistep.ActionHalt
-			}
-
-			// Call unexpose in case a TVM was used. The call is harmless
-			// if that is not the case.
-			Unexpose(c, disk)
-
-		}
-
-	default:
-		panic(fmt.Sprintf("Unknown export format '%s'", config.Format))
-	}
-
-	ui.Say("Download completed: " + config.OutputDir)
-
-	return multistep.ActionContinue
-}
-
-func (StepExport) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_find_or_upload_vdi.go

@@ -1,44 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepFindOrUploadVdi struct {
-	StepUploadVdi
-}
-
-func (self *StepFindOrUploadVdi) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-	vdiName := self.VdiNameFunc()
-
-	ui.Say(fmt.Sprintf("Attemping to find VDI '%s'", vdiName))
-
-	vdis, err := c.client.VDI.GetByNameLabel(c.session, vdiName)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Failed to find VDI '%s' by name label: %s", vdiName, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	if len(vdis) > 1 {
-		ui.Error(fmt.Sprintf("Found more than one VDI with name '%s'. Name must be unique", vdiName))
-		return multistep.ActionHalt
-	} else if len(vdis) == 1 {
-
-		vdi := vdis[0]
-
-		vdiUuid, err := c.client.VDI.GetUUID(c.session, vdi)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Unable to get UUID of VDI '%s': %s", vdiName, err.Error()))
-			return multistep.ActionHalt
-		}
-		state.Put(self.VdiUuidKey, vdiUuid)
-		return multistep.ActionContinue
-	}
-	return self.uploadVdi(ctx, state)
-}

builder/xenserver/common/step_find_vdi.go

@@ -1,49 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepFindVdi struct {
-	VdiName       string
-	ImagePathFunc func() string
-	VdiUuidKey    string
-}
-
-func (self *StepFindVdi) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	// Ignore if VdiName is not specified
-	if self.VdiName == "" {
-		return multistep.ActionContinue
-	}
-
-	vdis, err := c.client.VDI.GetByNameLabel(c.session, self.VdiName)
-
-	switch {
-	case len(vdis) == 0:
-		ui.Error(fmt.Sprintf("Couldn't find a VDI named '%s'", self.VdiName))
-		return multistep.ActionHalt
-	case len(vdis) > 1:
-		ui.Error(fmt.Sprintf("Found more than one VDI with name '%s'. Name must be unique", self.VdiName))
-		return multistep.ActionHalt
-	}
-
-	vdi := vdis[0]
-
-	vdiUuid, err := c.client.VDI.GetUUID(c.session, vdi)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get UUID of VDI '%s': %s", self.VdiName, err.Error()))
-		return multistep.ActionHalt
-	}
-	state.Put(self.VdiUuidKey, vdiUuid)
-
-	return multistep.ActionContinue
-}
-
-func (self *StepFindVdi) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_forward_port_over_ssh.go

@@ -1,51 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepForwardPortOverSSH struct {
-	RemotePort func(state multistep.StateBag) (int, error)
-	RemoteDest func(state multistep.StateBag) (string, error)
-
-	HostPortMin uint
-	HostPortMax uint
-
-	ResultKey string
-}
-
-func (self *StepForwardPortOverSSH) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-
-	// Find a free local port:
-
-	l, sshHostPort := FindPort(self.HostPortMin, self.HostPortMax)
-
-	if l == nil || sshHostPort == 0 {
-		ui.Error("Error: unable to find free host port. Try providing a larger range [host_port_min, host_port_max]")
-		return multistep.ActionHalt
-	}
-
-	ui.Say(fmt.Sprintf("Creating a local port forward over SSH on local port %d", sshHostPort))
-
-	hostAddress, _ := state.Get("ssh_address").(string)
-	hostSshPort, _ := state.Get("ssh_port").(int)
-	remotePort, _ := self.RemotePort(state)
-	remoteDest, _ := self.RemoteDest(state)
-
-	go ssh_port_forward(l, remotePort, remoteDest, hostAddress, hostSshPort, config.Username, config.Password)
-	ui.Say(fmt.Sprintf("Port forward setup. %d ---> %s:%d on %s", sshHostPort, remoteDest, remotePort, hostAddress))
-
-	// Provide the local port to future steps.
-	state.Put(self.ResultKey, sshHostPort)
-
-	return multistep.ActionContinue
-}
-
-func (self *StepForwardPortOverSSH) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_get_vnc_port.go

@@ -1,51 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepGetVNCPort struct{}
-
-func (self *StepGetVNCPort) Run(state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Step: forward the instances VNC port over SSH")
-
-	domid := state.Get("domid").(int)
-	cmd := fmt.Sprintf("xenstore-read /local/domain/%d/console/vnc-port", domid)
-
-	remote_vncport, err := ExecuteHostSSHCmd(state, cmd)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VNC port (is the VM running?): %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	remote_port, err := strconv.ParseUint(remote_vncport, 10, 16)
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to convert '%s' to an int", remote_vncport))
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	state.Put("instance_vnc_port", uint(remote_port))
-
-	return multistep.ActionContinue
-}
-
-func (self *StepGetVNCPort) Cleanup(state multistep.StateBag) {
-}
-
-func InstanceVNCPort(state multistep.StateBag) (uint, error) {
-	vncPort := state.Get("instance_vnc_port").(uint)
-	return vncPort, nil
-}
-
-func InstanceVNCIP(state multistep.StateBag) (string, error) {
-	// The port is in Dom0, so we want to forward from localhost
-	return "127.0.0.1", nil
-}

builder/xenserver/common/step_http_server.go

@@ -1,96 +0,0 @@
-package common
-
-// Taken from hashicorp/packer/builder/qemu/step_http_server.go
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-// This step creates and runs the HTTP server that is serving files from the
-// directory specified by the 'http_directory` configuration parameter in the
-// template.
-//
-// Uses:
-//   config *config
-//   ui     packer.Ui
-//
-// Produces:
-//   http_port int - The port the HTTP server started on.
-type StepHTTPServer struct {
-	Chan chan<- string
-
-	l net.Listener
-}
-
-type IPSnooper struct {
-	ch      chan<- string
-	handler http.Handler
-}
-
-func (snooper IPSnooper) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
-	log.Printf("HTTP: %s %s %s", req.RemoteAddr, req.Method, req.URL)
-	ip, _, err := net.SplitHostPort(req.RemoteAddr)
-	if err == nil && ip != "" {
-		select {
-		case snooper.ch <- ip:
-			log.Printf("Remembering remote address '%s'", ip)
-		default:
-			// if ch is already full, don't block waiting to send the address, just drop it
-		}
-	}
-	snooper.handler.ServeHTTP(resp, req)
-}
-
-func (s *StepHTTPServer) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-
-	var httpPort uint = 0
-	if config.HTTPDir == "" {
-		// the packer provision steps assert this type is an int
-		// so this cannot be a uint like the rest of the code
-		state.Put("http_port", int(httpPort))
-		return multistep.ActionContinue
-	}
-
-	s.l, httpPort = FindPort(config.HTTPPortMin, config.HTTPPortMax)
-
-	if s.l == nil || httpPort == 0 {
-		ui.Error("Error: unable to find free HTTP server port. Try providing a larger range [http_port_min, http_port_max]")
-		return multistep.ActionHalt
-	}
-
-	ui.Say(fmt.Sprintf("Starting HTTP server on port %d", httpPort))
-
-	// Start the HTTP server and run it in the background
-	fileServer := http.FileServer(http.Dir(config.HTTPDir))
-	server := &http.Server{
-		Addr: fmt.Sprintf(":%d", httpPort),
-		Handler: IPSnooper{
-			ch:      s.Chan,
-			handler: fileServer,
-		},
-	}
-	go server.Serve(s.l)
-
-	// Save the address into the state so it can be accessed in the future
-	// the packer provision steps assert this type is an int
-	// so this cannot be a uint like the rest of the code
-	state.Put("http_port", int(httpPort))
-
-	return multistep.ActionContinue
-}
-
-func (s *StepHTTPServer) Cleanup(multistep.StateBag) {
-	if s.l != nil {
-		// Close the listener so that the HTTP server stops
-		s.l.Close()
-	}
-}

builder/xenserver/common/step_set_vm_host_ssh_address.go

@@ -1,47 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepSetVmHostSshAddress struct{}
-
-func (self *StepSetVmHostSshAddress) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-
-	c := state.Get("client").(*Connection)
-	config := state.Get("config").(Config)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Step: Set SSH address to VM host IP")
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	host, err := c.client.VM.GetResidentOn(c.session, instance)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM Host for VM '%s': %s", uuid, err.Error()))
-	}
-
-	address, err := c.client.Host.GetAddress(c.session, host)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get address from VM Host: %s", err.Error()))
-	}
-
-	state.Put("ssh_address", address)
-	ui.Say(fmt.Sprintf("Set host SSH address to '%s'.", address))
-
-	state.Put("ssh_port", config.HostSshPort)
-	ui.Say(fmt.Sprintf("Set host SSH port to %d.", config.HostSshPort))
-
-	return multistep.ActionContinue
-}
-
-func (self *StepSetVmHostSshAddress) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_set_vm_to_template.go

@@ -1,35 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepSetVmToTemplate struct{}
-
-func (StepSetVmToTemplate) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-	instance_uuid := state.Get("instance_uuid").(string)
-
-	instance, err := c.client.VM.GetByUUID(c.session, instance_uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Could not get VM with UUID '%s': %s", instance_uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.client.VM.SetIsATemplate(c.session, instance, true)
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("failed to set VM '%s' as a template with error: %v", instance_uuid, err))
-		return multistep.ActionHalt
-	}
-
-	ui.Message("Successfully set VM as a template")
-	return multistep.ActionContinue
-}
-
-func (StepSetVmToTemplate) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_shutdown.go

@@ -1,82 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	xenapi "github.com/terra-farm/go-xen-api-client"
-)
-
-type StepShutdown struct{}
-
-func (StepShutdown) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-	instance_uuid := state.Get("instance_uuid").(string)
-
-	instance, err := c.client.VM.GetByUUID(c.session, instance_uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Could not get VM with UUID '%s': %s", instance_uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	ui.Say("Step: Shutting down VM")
-
-	// Shutdown the VM
-	success := func() bool {
-		if config.ShutdownCommand != "" {
-			ui.Message("Executing shutdown command...")
-
-			_, err := ExecuteGuestSSHCmd(state, config.ShutdownCommand)
-			if err != nil {
-				ui.Error(fmt.Sprintf("Shutdown command failed: %s", err.Error()))
-				return false
-			}
-
-			ui.Message("Waiting for VM to enter Halted state...")
-
-			err = InterruptibleWait{
-				Predicate: func() (bool, error) {
-					power_state, err := c.client.VM.GetPowerState(c.session, instance)
-					return power_state == xenapi.VMPowerStateHalted, err
-				},
-				PredicateInterval: 5 * time.Second,
-				Timeout:           300 * time.Second,
-			}.Wait(state)
-
-			if err != nil {
-				ui.Error(fmt.Sprintf("Error waiting for VM to halt: %s", err.Error()))
-				return false
-			}
-
-		} else {
-			ui.Message("Attempting to cleanly shutdown the VM...")
-
-			err = c.client.VM.CleanShutdown(c.session, instance)
-			if err != nil {
-				ui.Error(fmt.Sprintf("Could not shut down VM: %s", err.Error()))
-				return false
-			}
-
-		}
-		return true
-	}()
-
-	if !success {
-		ui.Say("WARNING: Forcing hard shutdown of the VM...")
-		err = c.client.VM.HardShutdown(c.session, instance)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Could not hard shut down VM -- giving up: %s", err.Error()))
-			return multistep.ActionHalt
-		}
-	}
-
-	ui.Message("Successfully shut down VM")
-	return multistep.ActionContinue
-}
-
-func (StepShutdown) Cleanup(state multistep.StateBag) {}

builder/xenserver/common/step_start_on_himn.go

@@ -1,137 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	gossh "golang.org/x/crypto/ssh"
-)
-
-type StepStartOnHIMN struct{}
-
-/*
- * This step starts the installed guest on the Host Internal Management Network
- * as there exists an API to obtain the IP allocated to the VM by XAPI.
- * This in turn will allow Packer to SSH into the VM, provided NATing has been
- * enabled on the host.
- *
- */
-
-func (self *StepStartOnHIMN) Run(state multistep.StateBag) multistep.StepAction {
-
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	ui.Say("Step: Start VM on the Host Internal Mangement Network")
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	// Find the HIMN Ref
-	networks, err := c.client.Network.GetByNameLabel(c.session, "Host internal management network")
-	if err != nil || len(networks) == 0 {
-		ui.Error("Unable to find a host internal management network")
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	himn := networks[0]
-
-	// Create a VIF for the HIMN
-	himn_vif, err := ConnectNetwork(c, himn, instance, "0")
-	if err != nil {
-		ui.Error("Error creating VIF")
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	// Start the VM
-	c.client.VM.Start(c.session, instance, false, false)
-
-	var himn_iface_ip string = ""
-
-	// Obtain the allocated IP
-	err = InterruptibleWait{
-		Predicate: func() (found bool, err error) {
-			ips, err := c.client.Network.GetAssignedIps(c.session, himn)
-			if err != nil {
-				return false, fmt.Errorf("Can't get assigned IPs: %s", err.Error())
-			}
-			log.Printf("IPs: %s", ips)
-			log.Printf("Ref: %s", instance)
-
-			//Check for instance.Ref in map
-			if vm_ip, ok := ips[*himn_vif]; ok && vm_ip != "" {
-				ui.Say("Found the VM's IP: " + vm_ip)
-				himn_iface_ip = vm_ip
-				return true, nil
-			}
-
-			ui.Say("Wait for IP address...")
-			return false, nil
-		},
-		PredicateInterval: 10 * time.Second,
-		Timeout:           100 * time.Second,
-	}.Wait(state)
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to find an IP on the Host-internal management interface: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	state.Put("himn_ssh_address", himn_iface_ip)
-	ui.Say("Stored VM's IP " + himn_iface_ip)
-
-	// Wait for the VM to boot, and check we can ping this interface
-
-	ping_cmd := fmt.Sprintf("ping -c 1 %s", himn_iface_ip)
-
-	err = InterruptibleWait{
-		Predicate: func() (success bool, err error) {
-			ui.Message(fmt.Sprintf("Attempting to ping interface: %s", ping_cmd))
-			_, err = ExecuteHostSSHCmd(state, ping_cmd)
-
-			switch err.(type) {
-			case nil:
-				// ping succeeded
-				return true, nil
-			case *gossh.ExitError:
-				// ping failed, try again
-				return false, nil
-			default:
-				// unknown error
-				return false, err
-			}
-		},
-		PredicateInterval: 10 * time.Second,
-		Timeout:           300 * time.Second,
-	}.Wait(state)
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to ping interface. (Has the VM not booted?): %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	ui.Message("Ping success! Continuing...")
-	return multistep.ActionContinue
-
-}
-
-func (self *StepStartOnHIMN) Cleanup(state multistep.StateBag) {}
-
-func HimnSSHIP(state multistep.StateBag) (string, error) {
-	ip := state.Get("himn_ssh_address").(string)
-	return ip, nil
-}
-
-func HimnSSHPort(state multistep.StateBag) (uint, error) {
-	config := state.Get("commonconfig").(CommonConfig)
-	return config.SSHPort, nil
-}

builder/xenserver/common/step_start_vm_paused.go

@@ -1,58 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepStartVmPaused struct {
-	VmCleanup
-}
-
-func (self *StepStartVmPaused) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-
-	c := state.Get("client").(*Connection)
-	ui := state.Get("ui").(packer.Ui)
-	config := state.Get("config").(Config)
-
-	ui.Say("Step: Start VM Paused")
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	// note that here "cd" means boot from hard drive ('c') first, then CDROM ('d')
-	err = c.client.VM.SetHVMBootPolicy(c.session, instance, "BIOS order")
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to set HVM boot params: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.client.VM.SetHVMBootParams(c.session, instance, map[string]string{"order": "cd", "firmware": config.Firmware})
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to set HVM boot params: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.client.VM.Start(c.session, instance, true, false)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to start VM with UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	domid, err := c.client.VM.GetDomid(c.session, instance)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get domid of VM with UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-	state.Put("domid", domid)
-
-	return multistep.ActionContinue
-}

builder/xenserver/common/step_type_boot_command.go

@@ -1,271 +0,0 @@
-package common
-
-/* Heavily borrowed from builder/quemu/step_type_boot_command.go */
-
-import (
-	"context"
-	"crypto/tls"
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"strings"
-	"time"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
-	"github.com/mitchellh/go-vnc"
-)
-
-const KeyLeftShift uint = 0xFFE1
-
-type bootCommandTemplateData struct {
-	Name     string
-	HTTPIP   string
-	HTTPPort uint
-}
-
-type StepTypeBootCommand struct {
-	Ctx interpolate.Context
-}
-
-func (step *StepTypeBootCommand) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(Config)
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-	httpPort := state.Get("http_port").(int)
-
-	// skip this step if we have nothing to type
-	if len(config.BootCommand) == 0 {
-		return multistep.ActionContinue
-	}
-
-	vmRef, err := c.client.VM.GetByNameLabel(c.session, config.VMName)
-
-	if err != nil {
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	if len(vmRef) != 1 {
-		ui.Error(fmt.Sprintf("expected to find a single VM, instead found '%d'. Ensure the VM name is unique", len(vmRef)))
-	}
-
-	consoles, err := c.client.VM.GetConsoles(c.session, vmRef[0])
-	if err != nil {
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	if len(consoles) != 1 {
-		ui.Error(fmt.Sprintf("expected to find a VM console, instead found '%d'. Ensure there is only one console", len(consoles)))
-		return multistep.ActionHalt
-	}
-
-	location, err := c.client.Console.GetLocation(c.session, consoles[0])
-	if err != nil {
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-	locationPieces := strings.SplitAfter(location, "/")
-	consoleHost := strings.TrimSuffix(locationPieces[2], "/")
-	ui.Say("Connecting to VNC over XAPI...")
-	log.Printf("Connecting to host: %s", consoleHost)
-	conn, err := net.Dial("tcp", fmt.Sprintf("%s:443", consoleHost))
-
-	if err != nil {
-		err := fmt.Errorf("Error connecting to VNC: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	defer conn.Close()
-
-	tlsConfig := &tls.Config{
-		InsecureSkipVerify: true,
-	}
-	tlsConn := tls.Client(conn, tlsConfig)
-
-	consoleLocation := strings.TrimSpace(fmt.Sprintf("/%s", locationPieces[len(locationPieces)-1]))
-	httpReq := fmt.Sprintf("CONNECT %s HTTP/1.0\r\nHost: %s\r\nCookie: session_id=%s\r\n\r\n", consoleLocation, consoleHost, c.session)
-	fmt.Printf("Sending the follow http req: %v", httpReq)
-
-	ui.Message(fmt.Sprintf("Making HTTP request to initiate VNC connection: %s", httpReq))
-	_, err = io.WriteString(tlsConn, httpReq)
-
-	if err != nil {
-		err := fmt.Errorf("failed to start vnc session: %v", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	buffer := make([]byte, 10000)
-	_, err = tlsConn.Read(buffer)
-	if err != nil && err != io.EOF {
-		err := fmt.Errorf("failed to read vnc session response: %v", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	ui.Message(fmt.Sprintf("Received response: %s", string(buffer)))
-
-	vncClient, err := vnc.Client(tlsConn, &vnc.ClientConfig{Exclusive: !config.PackerDebug})
-
-	if err != nil {
-		err := fmt.Errorf("Error establishing VNC session: %s", err)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
-	}
-
-	defer vncClient.Close()
-
-	log.Printf("Connected to the VNC console: %s", vncClient.DesktopName)
-
-	// find local ip
-	envVar, err := ExecuteHostSSHCmd(state, "echo $SSH_CLIENT")
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error detecting local IP: %s", err))
-		return multistep.ActionHalt
-	}
-	if envVar == "" {
-		ui.Error("Error detecting local IP: $SSH_CLIENT was empty")
-		return multistep.ActionHalt
-	}
-	localIp := strings.Split(envVar, " ")[0]
-	ui.Message(fmt.Sprintf("Found local IP: %s", localIp))
-
-	step.Ctx.Data = &bootCommandTemplateData{
-		config.VMName,
-		localIp,
-		uint(httpPort),
-	}
-
-	ui.Say("Typing boot commands over VNC...")
-	for _, command := range config.BootCommand {
-
-		command, err := interpolate.Render(command, &step.Ctx)
-		if err != nil {
-			err := fmt.Errorf("Error preparing boot command: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
-		}
-
-		// Check for interrupts
-		if _, ok := state.GetOk(multistep.StateCancelled); ok {
-			return multistep.ActionHalt
-		}
-
-		vncSendString(vncClient, command)
-	}
-
-	return multistep.ActionContinue
-}
-
-func (step *StepTypeBootCommand) Cleanup(multistep.StateBag) {}
-
-// Taken from qemu's builder plugin - not an exported function.
-func vncSendString(c *vnc.ClientConn, original string) {
-	// Scancodes reference: https://github.com/qemu/qemu/blob/master/ui/vnc_keysym.h
-	special := make(map[string]uint32)
-	special["<bs>"] = 0xFF08
-	special["<del>"] = 0xFFFF
-	special["<enter>"] = 0xFF0D
-	special["<esc>"] = 0xFF1B
-	special["<f1>"] = 0xFFBE
-	special["<f2>"] = 0xFFBF
-	special["<f3>"] = 0xFFC0
-	special["<f4>"] = 0xFFC1
-	special["<f5>"] = 0xFFC2
-	special["<f6>"] = 0xFFC3
-	special["<f7>"] = 0xFFC4
-	special["<f8>"] = 0xFFC5
-	special["<f9>"] = 0xFFC6
-	special["<f10>"] = 0xFFC7
-	special["<f11>"] = 0xFFC8
-	special["<f12>"] = 0xFFC9
-	special["<return>"] = 0xFF0D
-	special["<tab>"] = 0xFF09
-	special["<up>"] = 0xFF52
-	special["<down>"] = 0xFF54
-	special["<left>"] = 0xFF51
-	special["<right>"] = 0xFF53
-	special["<spacebar>"] = 0x020
-	special["<insert>"] = 0xFF63
-	special["<home>"] = 0xFF50
-	special["<end>"] = 0xFF57
-	special["<pageUp>"] = 0xFF55
-	special["<pageDown>"] = 0xFF56
-
-	shiftedChars := "~!@#$%^&*()_+{}|:\"<>?"
-
-	// TODO(mitchellh): Ripe for optimizations of some point, perhaps.
-	for len(original) > 0 {
-		var keyCode uint32
-		keyShift := false
-
-		if strings.HasPrefix(original, "<wait>") {
-			log.Printf("Special code '<wait>' found, sleeping one second")
-			time.Sleep(1 * time.Second)
-			original = original[len("<wait>"):]
-			continue
-		}
-
-		if strings.HasPrefix(original, "<wait5>") {
-			log.Printf("Special code '<wait5>' found, sleeping 5 seconds")
-			time.Sleep(5 * time.Second)
-			original = original[len("<wait5>"):]
-			continue
-		}
-
-		if strings.HasPrefix(original, "<wait10>") {
-			log.Printf("Special code '<wait10>' found, sleeping 10 seconds")
-			time.Sleep(10 * time.Second)
-			original = original[len("<wait10>"):]
-			continue
-		}
-
-		for specialCode, specialValue := range special {
-			if strings.HasPrefix(original, specialCode) {
-				log.Printf("Special code '%s' found, replacing with: %d", specialCode, specialValue)
-				keyCode = specialValue
-				original = original[len(specialCode):]
-				break
-			}
-		}
-
-		if keyCode == 0 {
-			r, size := utf8.DecodeRuneInString(original)
-			original = original[size:]
-			keyCode = uint32(r)
-			keyShift = unicode.IsUpper(r) || strings.ContainsRune(shiftedChars, r)
-
-			log.Printf("Sending char '%c', code %d, shift %v", r, keyCode, keyShift)
-		}
-
-		if keyShift {
-			c.KeyEvent(uint32(KeyLeftShift), true)
-		}
-
-		c.KeyEvent(keyCode, true)
-		time.Sleep(time.Second / 10)
-		c.KeyEvent(keyCode, false)
-		time.Sleep(time.Second / 10)
-
-		if keyShift {
-			c.KeyEvent(uint32(KeyLeftShift), false)
-		}
-
-		// no matter what, wait a small period
-		time.Sleep(50 * time.Millisecond)
-	}
-}

builder/xenserver/common/step_upload_vdi.go

@@ -1,147 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	xenapi "github.com/terra-farm/go-xen-api-client"
-)
-
-type StepUploadVdi struct {
-	VdiNameFunc   func() string
-	ImagePathFunc func() string
-	VdiUuidKey    string
-}
-
-func (self *StepUploadVdi) uploadVdi(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	imagePath := self.ImagePathFunc()
-	vdiName := self.VdiNameFunc()
-	if imagePath == "" {
-		// skip if no disk image to attach
-		return multistep.ActionContinue
-	}
-
-	ui.Say(fmt.Sprintf("Step: Upload VDI '%s'", vdiName))
-
-	// Create VDI for the image
-	sr, err := config.GetISOSR(c)
-	ui.Say(fmt.Sprintf("Step: Found SR for upload '%v'", sr))
-
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get SR: %v", err))
-		return multistep.ActionHalt
-	}
-
-	// Open the file for reading (NB: HTTPUpload closes the file for us)
-	fh, err := os.Open(imagePath)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to open disk image '%s': %s", imagePath, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	// Get file length
-	fstat, err := fh.Stat()
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to stat disk image '%s': %s", imagePath, err.Error()))
-		return multistep.ActionHalt
-	}
-	fileLength := fstat.Size()
-
-	// Create the VDI
-	// vdi, err := sr.CreateVdi(vdiName, fileLength)
-	vdi, err := c.client.VDI.Create(c.session, xenapi.VDIRecord{
-		NameLabel:   vdiName,
-		VirtualSize: int(fileLength),
-		Type:        "user",
-		Sharable:    false,
-		ReadOnly:    false,
-		SR:          sr,
-		OtherConfig: map[string]string{
-			"temp": "temp",
-		},
-	})
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to create VDI '%s': %s", vdiName, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	vdiUuid, err := c.client.VDI.GetUUID(c.session, vdi)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get UUID of VDI '%s': %s", vdiName, err.Error()))
-		return multistep.ActionHalt
-	}
-	state.Put(self.VdiUuidKey, vdiUuid)
-
-	_, err = HTTPUpload(fmt.Sprintf("https://%s/import_raw_vdi?vdi=%s&session_id=%s",
-		c.Host,
-		vdi,
-		c.GetSession(),
-	), fh, state)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to upload VDI: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	return multistep.ActionContinue
-}
-
-func (self *StepUploadVdi) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	return self.uploadVdi(ctx, state)
-}
-
-func (self *StepUploadVdi) Cleanup(state multistep.StateBag) {
-	config := state.Get("commonconfig").(CommonConfig)
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-
-	vdiName := self.VdiNameFunc()
-
-	if config.ShouldKeepVM(state) {
-		return
-	}
-
-	vdiUuidRaw, ok := state.GetOk(self.VdiUuidKey)
-	if !ok {
-		// VDI doesn't exist
-		return
-	}
-
-	vdiUuid := vdiUuidRaw.(string)
-	if vdiUuid == "" {
-		// VDI already cleaned up
-		return
-	}
-
-	vdi, err := c.client.VDI.GetByUUID(c.session, vdiUuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Can't get VDI '%s': %s", vdiUuid, err.Error()))
-		return
-	}
-
-	// an interrupted import_raw_vdi takes a while to release the VDI
-	// so try several times
-	for i := 0; i < 3; i++ {
-		log.Printf("Trying to destroy VDI...")
-		err = c.client.VDI.Destroy(c.session, vdi)
-		if err == nil {
-			break
-		}
-		time.Sleep(1 * time.Second)
-	}
-	if err != nil {
-		ui.Error(fmt.Sprintf("Can't destroy VDI '%s': %s", vdiUuid, err.Error()))
-		return
-	}
-	ui.Say(fmt.Sprintf("Destroyed VDI '%s'", vdiName))
-
-	state.Put(self.VdiUuidKey, "")
-}

builder/xenserver/common/step_wait_for_ip.go

@@ -1,96 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-type StepWaitForIP struct {
-	VmCleanup
-	Chan    <-chan string
-	Timeout time.Duration
-}
-
-func (self *StepWaitForIP) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	c := state.Get("client").(*Connection)
-	config := state.Get("commonconfig").(CommonConfig)
-
-	ui.Say("Step: Wait for VM's IP to become known to us.")
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	var ip string
-	err = InterruptibleWait{
-		Timeout:           self.Timeout,
-		PredicateInterval: 5 * time.Second,
-		Predicate: func() (result bool, err error) {
-
-			if config.IPGetter == "auto" || config.IPGetter == "http" {
-
-				// Snoop IP from HTTP fetch
-				select {
-				case ip = <-self.Chan:
-					ui.Message(fmt.Sprintf("Got IP '%s' from HTTP request", ip))
-					return true, nil
-				default:
-				}
-
-			}
-
-			if config.IPGetter == "auto" || config.IPGetter == "tools" {
-
-				// Look for PV IP
-				m, err := c.client.VM.GetGuestMetrics(c.session, instance)
-				if err != nil {
-					return false, err
-				}
-				if m != "" {
-					metrics, err := c.client.VMGuestMetrics.GetRecord(c.session, m)
-					if err != nil {
-						return false, err
-					}
-					networks := metrics.Networks
-					var ok bool
-					if ip, ok = networks["0/ip"]; ok {
-						if ip != "" {
-							ui.Message(fmt.Sprintf("Got IP '%s' from XenServer tools", ip))
-							return true, nil
-						}
-					}
-				}
-
-			}
-
-			return false, nil
-		},
-	}.Wait(state)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Could not get IP address of VM: %s", err.Error()))
-		// @todo: give advice on what went wrong (no HTTP server? no PV drivers?)
-		return multistep.ActionHalt
-	}
-
-	ui.Say(fmt.Sprintf("Got IP address '%s'", ip))
-	state.Put("instance_ssh_address", ip)
-
-	return multistep.ActionContinue
-}
-
-func InstanceSSHIP(state multistep.StateBag) (string, error) {
-	ip := state.Get("instance_ssh_address").(string)
-	return ip, nil
-}
-
-func InstanceSSHPort(state multistep.StateBag) (int, error) {
-	return 22, nil
-}

builder/xenserver/common/vm_cleanup.go

@@ -1,31 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"log"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-)
-
-type VmCleanup struct{}
-
-func (self *VmCleanup) Cleanup(state multistep.StateBag) {
-	config := state.Get("commonconfig").(CommonConfig)
-	c := state.Get("client").(*Connection)
-
-	if config.ShouldKeepVM(state) {
-		return
-	}
-
-	uuid := state.Get("instance_uuid").(string)
-	instance, err := c.client.VM.GetByUUID(c.session, uuid)
-	if err != nil {
-		log.Printf(fmt.Sprintf("Unable to get VM from UUID '%s': %s", uuid, err.Error()))
-		return
-	}
-
-	err = c.client.VM.HardShutdown(c.session, instance)
-	if err != nil {
-		log.Printf(fmt.Sprintf("Unable to force shutdown VM '%s': %s", uuid, err.Error()))
-	}
-}

builder/xenserver/iso/builder.go

@@ -1,337 +0,0 @@
-package iso
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/hashicorp/hcl/v2/hcldec"
-	"github.com/hashicorp/packer-plugin-sdk/communicator"
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	commonsteps "github.com/hashicorp/packer-plugin-sdk/multistep/commonsteps"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	hconfig "github.com/hashicorp/packer-plugin-sdk/template/config"
-	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
-	xsclient "github.com/terra-farm/go-xen-api-client"
-	xscommon "github.com/xenserver/packer-builder-xenserver/builder/xenserver/common"
-)
-
-type Builder struct {
-	config xscommon.Config
-	runner multistep.Runner
-}
-
-func (self *Builder) ConfigSpec() hcldec.ObjectSpec { return self.config.FlatMapstructure().HCL2Spec() }
-
-func (self *Builder) Prepare(raws ...interface{}) (params []string, warns []string, retErr error) {
-
-	var errs *packer.MultiError
-
-	err := hconfig.Decode(&self.config, &hconfig.DecodeOpts{
-		Interpolate: true,
-		InterpolateFilter: &interpolate.RenderFilter{
-			Exclude: []string{
-				"boot_command",
-			},
-		},
-	}, raws...)
-
-	if err != nil {
-		errs = packer.MultiErrorAppend(errs, err)
-	}
-
-	errs = packer.MultiErrorAppend(
-		errs, self.config.CommonConfig.Prepare(self.config.GetInterpContext(), &self.config.PackerConfig)...)
-	errs = packer.MultiErrorAppend(errs, self.config.SSHConfig.Prepare(self.config.GetInterpContext())...)
-
-	// Set default values
-
-	if self.config.RawInstallTimeout == "" {
-		self.config.RawInstallTimeout = "200m"
-	}
-
-	if self.config.DiskName == "" {
-		self.config.DiskName = "Packer-disk"
-	}
-
-	if self.config.DiskSize == 0 {
-		self.config.DiskSize = 40000
-	}
-
-	if self.config.VCPUsMax == 0 {
-		self.config.VCPUsMax = 1
-	}
-
-	if self.config.VCPUsAtStartup == 0 {
-		self.config.VCPUsAtStartup = 1
-	}
-
-	if self.config.VCPUsAtStartup > self.config.VCPUsMax {
-		self.config.VCPUsAtStartup = self.config.VCPUsMax
-	}
-
-	if self.config.VMMemory == 0 {
-		self.config.VMMemory = 1024
-	}
-
-	if self.config.CloneTemplate == "" {
-		self.config.CloneTemplate = "Other install media"
-	}
-
-	if self.config.Firmware == "" {
-		self.config.Firmware = "bios"
-	}
-
-	if len(self.config.PlatformArgs) == 0 {
-		pargs := make(map[string]string)
-		pargs["viridian"] = "false"
-		pargs["nx"] = "true"
-		pargs["pae"] = "true"
-		pargs["apic"] = "true"
-		pargs["timeoffset"] = "0"
-		pargs["acpi"] = "1"
-		self.config.PlatformArgs = pargs
-	}
-
-	// Template substitution
-
-	templates := map[string]*string{
-		"clone_template":  &self.config.CloneTemplate,
-		"iso_checksum":    &self.config.ISOChecksum,
-		"iso_url":         &self.config.ISOUrl,
-		"iso_name":        &self.config.ISOName,
-		"install_timeout": &self.config.RawInstallTimeout,
-	}
-	for i := range self.config.ISOUrls {
-		templates[fmt.Sprintf("iso_urls[%d]", i)] = &self.config.ISOUrls[i]
-	}
-
-	// Validation
-
-	self.config.InstallTimeout, err = time.ParseDuration(self.config.RawInstallTimeout)
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Failed to parse install_timeout: %s", err))
-	}
-
-	if self.config.ISOName == "" {
-		// If ISO name is not specified, assume a URL and checksum has been provided.
-		self.config.ISOChecksum = strings.ToLower(self.config.ISOChecksum)
-
-		if len(self.config.ISOUrls) == 0 {
-			if self.config.ISOUrl == "" {
-				errs = packer.MultiErrorAppend(
-					errs, errors.New("One of iso_url or iso_urls must be specified."))
-			} else {
-				self.config.ISOUrls = []string{self.config.ISOUrl}
-			}
-
-		} else if self.config.ISOUrl != "" {
-			errs = packer.MultiErrorAppend(
-				errs, errors.New("Only one of iso_url or iso_urls may be specified."))
-		}
-
-		//The SDK can validate the ISO checksum and other sanity checks on the url.
-		iso_config := commonsteps.ISOConfig{
-			ISOChecksum: self.config.ISOChecksum,
-			ISOUrls:     self.config.ISOUrls,
-		}
-
-		_, iso_errs := iso_config.Prepare(nil)
-		if iso_errs != nil {
-			for _, this_err := range iso_errs {
-				errs = packer.MultiErrorAppend(errs, this_err)
-			}
-		}
-
-	} else {
-
-		// An ISO name has been provided. It should be attached from an available SR.
-
-	}
-
-	if len(errs.Errors) > 0 {
-		retErr = errors.New(errs.Error())
-	}
-
-	return nil, nil, retErr
-
-}
-
-func (self *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
-	c, err := xscommon.NewXenAPIClient(self.config.HostIp, self.config.Username, self.config.Password)
-
-	if err != nil {
-		return nil, err
-	}
-	ui.Say("XAPI client session established")
-
-	c.GetClient().Host.GetAll(c.GetSessionRef())
-
-	//Share state between the other steps using a statebag
-	state := new(multistep.BasicStateBag)
-	state.Put("client", c)
-	state.Put("config", self.config)
-	state.Put("commonconfig", self.config.CommonConfig)
-	state.Put("hook", hook)
-	state.Put("ui", ui)
-
-	httpReqChan := make(chan string, 1)
-
-	//Build the steps
-	download_steps := []multistep.Step{
-		&commonsteps.StepDownload{
-			Checksum:    self.config.ISOChecksum,
-			Description: "ISO",
-			ResultKey:   "iso_path",
-			Url:         self.config.ISOUrls,
-		},
-	}
-	steps := []multistep.Step{
-		&xscommon.StepPrepareOutputDir{
-			Force: self.config.PackerForce,
-			Path:  self.config.OutputDir,
-		},
-		&commonsteps.StepCreateFloppy{
-			Files: self.config.FloppyFiles,
-			Label: "cidata",
-		},
-		&xscommon.StepHTTPServer{
-			Chan: httpReqChan,
-		},
-		&xscommon.StepUploadVdi{
-			VdiNameFunc: func() string {
-				return "Packer-floppy-disk"
-			},
-			ImagePathFunc: func() string {
-				if floppyPath, ok := state.GetOk("floppy_path"); ok {
-					return floppyPath.(string)
-				}
-				return ""
-			},
-			VdiUuidKey: "floppy_vdi_uuid",
-		},
-		&xscommon.StepFindOrUploadVdi{
-			xscommon.StepUploadVdi{
-				VdiNameFunc: func() string {
-					if len(self.config.ISOUrls) > 0 {
-						return path.Base(self.config.ISOUrls[0])
-					}
-					return ""
-				},
-				ImagePathFunc: func() string {
-					if isoPath, ok := state.GetOk("iso_path"); ok {
-						return isoPath.(string)
-					}
-					return ""
-				},
-				VdiUuidKey: "iso_vdi_uuid",
-			},
-		},
-		&xscommon.StepFindVdi{
-			VdiName:    self.config.ToolsIsoName,
-			VdiUuidKey: "tools_vdi_uuid",
-		},
-		&xscommon.StepFindVdi{
-			VdiName:    self.config.ISOName,
-			VdiUuidKey: "isoname_vdi_uuid",
-		},
-		&xscommon.StepCreateInstance{
-			AssumePreInstalledOS: false,
-		},
-		&xscommon.StepAttachVdi{
-			VdiUuidKey: "floppy_vdi_uuid",
-			VdiType:    xsclient.VbdTypeFloppy,
-		},
-		&xscommon.StepAttachVdi{
-			VdiUuidKey: "iso_vdi_uuid",
-			VdiType:    xsclient.VbdTypeCD,
-		},
-		&xscommon.StepAttachVdi{
-			VdiUuidKey: "isoname_vdi_uuid",
-			VdiType:    xsclient.VbdTypeCD,
-		},
-		&xscommon.StepAttachVdi{
-			VdiUuidKey: "tools_vdi_uuid",
-			VdiType:    xsclient.VbdTypeCD,
-		},
-		new(xscommon.StepStartVmPaused),
-		new(xscommon.StepSetVmHostSshAddress),
-		// &xscommon.StepForwardPortOverSSH{
-		// 	RemotePort:  xscommon.InstanceVNCPort,
-		// 	RemoteDest:  xscommon.InstanceVNCIP,
-		// 	HostPortMin: self.config.HostPortMin,
-		// 	HostPortMax: self.config.HostPortMax,
-		// 	ResultKey:   "local_vnc_port",
-		// },
-		new(xscommon.StepBootWait),
-		&xscommon.StepTypeBootCommand{
-			Ctx: *self.config.GetInterpContext(),
-		},
-		&xscommon.StepWaitForIP{
-			Chan:    httpReqChan,
-			Timeout: self.config.InstallTimeout, // @todo change this
-		},
-		&xscommon.StepForwardPortOverSSH{
-			RemotePort:  xscommon.InstanceSSHPort,
-			RemoteDest:  xscommon.InstanceSSHIP,
-			HostPortMin: self.config.HostPortMin,
-			HostPortMax: self.config.HostPortMax,
-			ResultKey:   "local_ssh_port",
-		},
-		&communicator.StepConnect{
-			Config:    &self.config.SSHConfig.Comm,
-			Host:      xscommon.InstanceSSHIP,
-			SSHConfig: self.config.Comm.SSHConfigFunc(),
-			SSHPort:   xscommon.InstanceSSHPort,
-		},
-		new(commonsteps.StepProvision),
-		new(xscommon.StepShutdown),
-	}
-
-	if !self.config.SkipSetTemplate {
-		steps = append(steps,
-			new(xscommon.StepSetVmToTemplate))
-	}
-
-	steps = append(steps,
-		&xscommon.StepDetachVdi{
-			VdiUuidKey: "iso_vdi_uuid",
-		},
-		&xscommon.StepDetachVdi{
-			VdiUuidKey: "isoname_vdi_uuid",
-		},
-		&xscommon.StepDetachVdi{
-			VdiUuidKey: "tools_vdi_uuid",
-		},
-		&xscommon.StepDetachVdi{
-			VdiUuidKey: "floppy_vdi_uuid",
-		},
-		new(xscommon.StepExport))
-
-	if self.config.ISOName == "" {
-		steps = append(download_steps, steps...)
-	}
-
-	self.runner = &multistep.BasicRunner{Steps: steps}
-	self.runner.Run(ctx, state)
-
-	if rawErr, ok := state.GetOk("error"); ok {
-		return nil, rawErr.(error)
-	}
-
-	// If we were interrupted or cancelled, then just exit.
-	if _, ok := state.GetOk(multistep.StateCancelled); ok {
-		return nil, errors.New("Build was cancelled.")
-	}
-	if _, ok := state.GetOk(multistep.StateHalted); ok {
-		return nil, errors.New("Build was halted.")
-	}
-
-	artifact, _ := xscommon.NewArtifact(self.config.OutputDir)
-
-	return artifact, nil
-}

builder/xenserver/iso/builder_test.go

@@ -1,303 +0,0 @@
-package iso
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/hashicorp/packer-plugin-sdk/common"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-func testConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"remote_host":      "localhost",
-		"remote_username":  "admin",
-		"remote_password":  "admin",
-		"vm_name":          "foo",
-		"iso_checksum":     "md5:A221725EE181A44C67E25BD6A2516742",
-		"iso_url":          "http://www.google.com/",
-		"shutdown_command": "yes",
-		"ssh_username":     "foo",
-
-		common.BuildNameConfigKey: "foo",
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Error("Builder must implement builder.")
-	}
-}
-
-func TestBuilderPrepare_Defaults(t *testing.T) {
-	var b Builder
-	config := testConfig()
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.ToolsIsoName != "" {
-		t.Errorf("bad tools ISO name: %s", b.config.ToolsIsoName)
-	}
-
-	if b.config.CloneTemplate != "Other install media" {
-		t.Errorf("bad clone template: %s", b.config.CloneTemplate)
-	}
-
-	if b.config.VMName == "" {
-		t.Errorf("bad vm name: %s", b.config.VMName)
-	}
-
-	if b.config.Format != "xva" {
-		t.Errorf("bad format: %s", b.config.Format)
-	}
-
-	if b.config.KeepVM != "never" {
-		t.Errorf("bad keep instance: %s", b.config.KeepVM)
-	}
-
-	if b.config.HostSshPort != 22 {
-		t.Errorf("bad ssh port: %d", b.config.HostSshPort)
-	}
-}
-
-func TestBuilderPrepare_DiskSize(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	delete(config, "disk_size")
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("bad err: %s", err)
-	}
-
-	if b.config.DiskSize != 40000 {
-		t.Fatalf("bad size: %d", b.config.DiskSize)
-	}
-
-	config["disk_size"] = 60000
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.DiskSize != 60000 {
-		t.Fatalf("bad size: %d", b.config.DiskSize)
-	}
-}
-
-func TestBuilderPrepare_Format(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["format"] = "foo"
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["format"] = "vdi_raw"
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_HTTPPort(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["http_port_min"] = 1000
-	config["http_port_max"] = 500
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Bad
-	config["http_port_min"] = -500
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["http_port_min"] = 500
-	config["http_port_max"] = 1000
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_InvalidKey(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Add a random key
-	config["i_should_not_be_valid"] = true
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_ISOChecksum(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Test good
-
-	b = Builder{}
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	// Test bad
-	config["iso_checksum"] = ""
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-}
-
-func TestBuilderPrepare_ISOUrl(t *testing.T) {
-	var b Builder
-	config := testConfig()
-	delete(config, "iso_url")
-	delete(config, "iso_urls")
-
-	// Test both epty
-	config["iso_url"] = ""
-	b = Builder{}
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test iso_url set
-	config["iso_url"] = "http://www.packer.io"
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Errorf("should not have error: %s", err)
-	}
-
-	expected := []string{"http://www.packer.io"}
-	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
-		t.Fatalf("bad: %#v", b.config.ISOUrls)
-	}
-
-	// Test both set
-	config["iso_url"] = "http://www.packer.io"
-	config["iso_urls"] = []string{"http://www.packer.io"}
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Test just iso_urls set
-	delete(config, "iso_url")
-	config["iso_urls"] = []string{
-		"http://www.packer.io",
-		"http://www.hashicorp.com",
-	}
-
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Errorf("should not have error: %s", err)
-	}
-
-	expected = []string{
-		"http://www.packer.io",
-		"http://www.hashicorp.com",
-	}
-	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
-		t.Fatalf("bad: %#v", b.config.ISOUrls)
-	}
-}
-
-func TestBuilderPrepare_KeepVM(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["keep_vm"] = "foo"
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["keep_vm"] = "always"
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}

builder/xenserver/ssh.go

@@ -0,0 +1,152 @@
+package xenserver
+
+import (
+	"fmt"
+	gossh "code.google.com/p/go.crypto/ssh"
+	"github.com/mitchellh/multistep"
+	commonssh "github.com/mitchellh/packer/common/ssh"
+	"github.com/mitchellh/packer/communicator/ssh"
+    "strings"
+    "log"
+    "bytes"
+    "net"
+    "io"
+)
+
+func sshAddress(state multistep.StateBag) (string, error) {
+    sshIP := state.Get("ssh_address").(string)
+	sshHostPort := 22
+	return fmt.Sprintf("%s:%d", sshIP, sshHostPort), nil
+}
+
+func sshLocalAddress(state multistep.StateBag) (string, error) {
+    sshLocalPort := state.Get("local_ssh_port").(uint)
+    conn_str := fmt.Sprintf("%s:%d", "127.0.0.1", sshLocalPort)
+    log.Printf("sshLocalAddress: %s", conn_str)
+    return conn_str, nil
+}
+
+func sshConfig(state multistep.StateBag) (*gossh.ClientConfig, error) {
+	config := state.Get("config").(config)
+
+	auth := []gossh.AuthMethod{
+		gossh.Password(config.SSHPassword),
+		gossh.KeyboardInteractive(
+			ssh.PasswordKeyboardInteractive(config.SSHPassword)),
+	}
+
+	if config.SSHKeyPath != "" {
+		signer, err := commonssh.FileSigner(config.SSHKeyPath)
+		if err != nil {
+			return nil, err
+		}
+
+		auth = append(auth, gossh.PublicKeys(signer))
+	}
+
+	return &gossh.ClientConfig{
+		User: config.SSHUser,
+		Auth: auth,
+	}, nil
+}
+
+
+
+
+func execute_ssh_cmd (cmd, host, port, username, password string) (stdout string, err error) {
+    // Setup connection config
+    config := &gossh.ClientConfig {
+        User: username,
+        Auth: []gossh.AuthMethod {
+            gossh.Password(password),
+        },
+    }
+
+    client, err := gossh.Dial("tcp", host + ":" + port, config)
+
+    if err != nil {
+        return "", err
+    }
+
+    //Create session
+    session, err := client.NewSession()
+
+    if err != nil {
+        return "", err
+    }
+
+    defer session.Close()
+
+    var b bytes.Buffer
+    session.Stdout = &b
+    if err := session.Run(cmd); err != nil {
+        return "", err
+    }
+
+    session.Close()
+    return strings.Trim(b.String(), "\n"), nil
+}
+
+func forward(local_conn net.Conn, config *gossh.ClientConfig, server, remote_dest string, remote_port uint) {
+    ssh_client_conn, err := gossh.Dial("tcp", server + ":22", config)
+    if err != nil {
+        log.Fatalf("local ssh.Dial error: %s", err)
+    }
+
+    remote_loc := fmt.Sprintf("%s:%d", remote_dest, remote_port)
+    ssh_conn, err := ssh_client_conn.Dial("tcp", remote_loc) 
+    if err != nil {
+        log.Fatalf("ssh.Dial error: %s", err)
+    }
+
+    go func() {
+        _, err = io.Copy(ssh_conn, local_conn)
+        if err != nil {
+            log.Fatalf("io.copy failed: %v", err)
+        }
+    }()
+
+    go func() {
+        _, err = io.Copy(local_conn, ssh_conn)
+        if err != nil {
+            log.Fatalf("io.copy failed: %v", err)
+        }
+    }()
+}
+
+func ssh_port_forward(local_port uint, remote_port uint, remote_dest, host, username, password string) (err error) {
+
+    config := &gossh.ClientConfig {
+        User: username,
+        Auth: []gossh.AuthMethod{
+            gossh.Password(password),
+        },
+    }
+
+    // Listen on a local port
+    local_listener, err := net.Listen("tcp",
+                                      fmt.Sprintf("%s:%d",
+                                                  "127.0.0.1",
+                                                  local_port))
+    if err != nil {
+        log.Fatalf("Local listen failed: %s", err)
+        return err
+    }
+
+    for {
+        local_connection, err := local_listener.Accept()
+
+        if err != nil {
+            log.Fatalf("Local accept failed: %s", err)
+            return err
+        }
+
+
+        // Forward to a remote port
+        go forward(local_connection, config, host, remote_dest, remote_port)
+    }
+
+
+
+    return nil
+}

builder/xenserver/step_boot_wait.go

@@ -0,0 +1,30 @@
+package xenserver
+
+import (
+    "fmt"
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "time"
+)
+
+
+type stepBootWait struct{}
+
+func (self *stepBootWait) Run(state multistep.StateBag) multistep.StepAction {
+    client := state.Get("client").(XenAPIClient)
+    config := state.Get("config").(config)
+    ui := state.Get("ui").(packer.Ui)
+
+    instance, _ := client.GetVMByUuid(state.Get("instance_uuid").(string))
+    ui.Say("Unpausing VM " + state.Get("instance_uuid").(string))
+    instance.Unpause()
+
+    if int64(config.BootWait) > 0 {
+        ui.Say(fmt.Sprintf("Waiting %s for boot...", config.BootWait))
+        time.Sleep(config.BootWait)
+    }
+    return multistep.ActionContinue
+}
+
+func (self *stepBootWait) Cleanup(state multistep.StateBag) {}
+

builder/xenserver/step_create_instance.go

@@ -0,0 +1,198 @@
+package xenserver
+
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "fmt"
+    "log"
+)
+
+type stepCreateInstance struct {
+    InstanceId string
+}
+
+func (self *stepCreateInstance) Run(state multistep.StateBag) multistep.StepAction {
+
+    client := state.Get("client").(XenAPIClient)
+    config := state.Get("config").(config)
+    ui := state.Get("ui").(packer.Ui)
+
+    ui.Say("Step: Create Instance")
+
+
+    // Get the template to clone from
+
+    vms, err := client.GetVMByNameLabel(config.CloneTemplate)
+
+    switch {
+        case len(vms) == 0:
+            log.Fatal(fmt.Sprintf("Couldn't find a template with the name-label '%s'. Aborting.", config.CloneTemplate))
+            return multistep.ActionHalt
+        case len(vms) > 1:
+            log.Fatal(fmt.Sprintf("Found more than one template with the name '%s'. The name must be unique. Aborting.", config.CloneTemplate))
+            return multistep.ActionHalt
+    }
+
+    template := vms[0]
+
+    // Clone that VM template
+    instance, _ := template.Clone(config.InstanceName)
+    instance.SetIsATemplate(false)
+    instance.SetStaticMemoryRange(config.InstanceMemory, config.InstanceMemory)
+    instance.SetPlatform(config.PlatformArgs)
+
+    // Create VDI for the instance
+    var sr *SR
+
+    if config.SrName == "" {
+        // Find the default SR
+        default_sr, err := client.GetDefaultSR()
+        sr = default_sr
+
+        if err != nil {
+            log.Fatal(fmt.Sprintf("Error getting default SR: %s", err.Error()))
+            return multistep.ActionHalt
+        }
+
+
+    } else {
+        // Use the provided name label to find the SR to use
+        srs, err := client.GetSRByNameLabel(config.SrName)
+
+        if err != nil {
+            log.Fatal(fmt.Sprintf("Error getting default SR: %s", err.Error()))
+            return multistep.ActionHalt
+        }
+
+        switch {
+            case len(srs) == 0:
+                log.Fatal(fmt.Sprintf("Couldn't find a SR with the specified name-label '%s'. Aborting.", config.SrName))
+                return multistep.ActionHalt
+            case len(srs) > 1:
+                log.Fatal(fmt.Sprintf("Found more than one SR with the name '%s'. The name must be unique. Aborting.", config.SrName))
+                return multistep.ActionHalt
+        }
+
+        sr = srs[0]
+    }
+
+    vdi, _ := sr.CreateVdi("Packer-disk", config.RootDiskSize)
+
+    instance.ConnectVdi(vdi, false)
+
+    // Connect Network
+
+    var network *Network
+
+    if config.NetworkName == "" {
+        // No network has be specified. Use the management interface
+        network = new(Network)
+        network.Ref = ""
+        network.Client = &client
+
+        pifs, err := client.GetPIFs()
+
+        if err != nil {
+            log.Fatal(fmt.Sprintf("Error getting PIFs %s", err.Error()))
+            return multistep.ActionHalt
+        }
+
+        for _, pif := range pifs {
+            pif_rec, err := pif.GetRecord()
+
+            if err != nil {
+                log.Fatal(fmt.Sprintf("Error getting PIF record: %s", err.Error()))
+                return multistep.ActionHalt
+            }
+
+            if pif_rec["management"].(bool) {
+                network.Ref = pif_rec["network"].(string)
+            }
+
+        }
+
+        if network.Ref == "" {
+            log.Fatal("Error: couldn't find management network. Aborting.")
+            return multistep.ActionHalt
+        }
+
+    } else {
+        // Look up the network by it's name label
+
+        networks, err := client.GetNetworkByNameLabel(config.NetworkName)
+
+        if err != nil {
+            log.Fatal(fmt.Sprintf("Error occured getting Network by name-label: %s", err.Error()))
+            return multistep.ActionHalt
+        }
+
+        switch {
+            case len(networks) == 0:
+                log.Fatal(fmt.Sprintf("Couldn't find a network with the specified name-label '%s'. Aborting.", config.NetworkName))
+                return multistep.ActionHalt
+            case len(networks) > 1:
+                log.Fatal(fmt.Sprintf("Found more than one SR with the name '%s'. The name must be unique. Aborting.", config.NetworkName))
+                return multistep.ActionHalt
+        }
+
+        network = networks[0]
+    }
+
+    if err != nil {
+        ui.Say(err.Error())
+    }
+    _, err = instance.ConnectNetwork(network, "0")
+
+    if err != nil {
+        ui.Say(err.Error())
+    }
+
+    // Connect the ISO
+    //iso_vdi_uuid := state.Get("iso_vdi_uuid").(string)
+
+
+    isos, err := client.GetVdiByNameLabel(config.IsoName)
+
+
+    switch {
+        case len(isos) == 0:
+            log.Fatal(fmt.Sprintf("Couldn't find an ISO named '%s'. Aborting", config.IsoName))
+            return multistep.ActionHalt
+        case len(isos) > 1:
+            log.Fatal(fmt.Sprintf("Found more than one VDI with name '%s'. Name must be unique. Aborting.", config.IsoName))
+            return multistep.ActionHalt
+    }
+
+    iso := isos[0]
+
+    //iso, _ := client.GetVdiByUuid(config.IsoUuid)
+    //ui.Say("Using VDI: " + iso_vdi_uuid)
+    //iso, _ := client.GetVdiByUuid(iso_vdi_uuid)
+    instance.ConnectVdi(iso, true)
+
+    // Stash the VM reference
+    self.InstanceId, _ = instance.GetUuid()
+    state.Put("instance_uuid", self.InstanceId)
+    state.Put("instance", instance)
+    ui.Say(fmt.Sprintf("Created instance '%s'", self.InstanceId))
+
+    return multistep.ActionContinue
+}
+
+
+func (self *stepCreateInstance) Cleanup(state multistep.StateBag) {
+
+//    client := state.Get("client").(*XenAPIClient)
+//    config := state.Get("config").(config)
+//    ui := state.Get("ui").(packer.Ui)
+
+    // If instance hasn't been created, we have nothing to do.
+    if self.InstanceId == "" {
+        return
+    }
+
+    // @todo: destroy the created instance.
+
+    return
+}

builder/xenserver/step_forward_port_over_ssh.go

@@ -0,0 +1,73 @@
+package xenserver
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "log"
+    "net"
+    "fmt"
+)
+
+type stepForwardPortOverSSH struct {
+
+    RemotePort func (state multistep.StateBag) (uint, error)
+    RemoteDest func (state multistep.StateBag) (string, error)
+
+    HostPortMin uint
+    HostPortMax uint
+
+    ResultKey string
+}
+
+
+func (self *stepForwardPortOverSSH) Run(state multistep.StateBag) multistep.StepAction {
+
+    config := state.Get("config").(config)
+    ui := state.Get("ui").(packer.Ui)
+
+    // Find a free local port:
+
+    log.Printf("Looking for an available port between %d and %d",
+                self.HostPortMin,
+                self.HostPortMax)
+
+
+    var sshHostPort uint
+    var foundPort bool
+
+    foundPort = false
+
+    for i := self.HostPortMin; i < self.HostPortMax; i++ {
+        sshHostPort = i
+        log.Printf("Trying port: %d", sshHostPort)
+        l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", sshHostPort))
+        if err == nil {
+            l.Close()
+            foundPort = true
+            break
+        }
+
+    }
+
+    if !foundPort {
+        log.Fatal("Error: unable to find free host port. Try providing a larger range")
+        return multistep.ActionHalt
+    }
+
+
+    ui.Say(fmt.Sprintf("Creating a local port forward over SSH on local port %d", sshHostPort))
+
+    remotePort, _ := self.RemotePort(state)
+    remoteDest, _ := self.RemoteDest(state)
+
+
+    go ssh_port_forward(sshHostPort, remotePort, remoteDest, config.HostIp, config.Username, config.Password)
+    ui.Say(fmt.Sprintf("Port forward setup. %d ---> %s:%d on %s", sshHostPort, remoteDest, remotePort, config.HostIp))
+
+    // Provide the local port to future steps.
+    state.Put(self.ResultKey, sshHostPort)
+
+    return multistep.ActionContinue
+}
+
+func (self *stepForwardPortOverSSH) Cleanup(state multistep.StateBag) {}

builder/xenserver/step_get_vnc_port.go

@@ -0,0 +1,52 @@
+package xenserver
+
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "fmt"
+    "strconv"
+    "log"
+)
+
+type stepGetVNCPort struct {}
+
+
+func (self *stepGetVNCPort) Run(state multistep.StateBag) multistep.StepAction {
+
+    config := state.Get("config").(config)
+    ui := state.Get("ui").(packer.Ui)
+
+    ui.Say("Step: forward the instances VNC port over SSH")
+
+    domid := state.Get("domid").(string)
+    cmd := fmt.Sprintf("xenstore-read /local/domain/%s/console/vnc-port", domid)
+
+    remote_vncport, _ := execute_ssh_cmd(cmd, config.HostIp, "22", config.Username, config.Password)
+
+    remote_port, err := strconv.ParseUint(remote_vncport, 10, 16)
+
+    if err != nil {
+        log.Fatal(err.Error())
+        log.Fatal(fmt.Sprintf("Unable to convert '%s' to an int", remote_vncport))
+        return multistep.ActionHalt
+    }
+
+    state.Put("instance_vnc_port", uint(remote_port))
+
+    return multistep.ActionContinue
+}
+
+
+func (self *stepGetVNCPort) Cleanup(state multistep.StateBag) {
+}
+
+func instanceVNCPort (state multistep.StateBag) (uint, error) {
+    vncPort := state.Get("instance_vnc_port").(uint)
+    return vncPort, nil
+}
+
+func instanceVNCIP (state multistep.StateBag) (string, error) {
+    // The port is in Dom0, so we want to forward from localhost
+    return "127.0.0.1", nil
+}

builder/xenserver/step_http_server.go

@@ -0,0 +1,78 @@
+package xenserver
+
+// Taken from mitchellh/packer/builder/qemu/step_http_server.go
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"math/rand"
+	"net"
+	"net/http"
+)
+
+// This step creates and runs the HTTP server that is serving files from the
+// directory specified by the 'http_directory` configuration parameter in the
+// template.
+//
+// Uses:
+//   config *config
+//   ui     packer.Ui
+//
+// Produces:
+//   http_port int - The port the HTTP server started on.
+type stepHTTPServer struct {
+	l net.Listener
+}
+
+func (s *stepHTTPServer) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(config)
+	ui := state.Get("ui").(packer.Ui)
+
+	var httpPort uint = 0
+	if config.HTTPDir == "" {
+		state.Put("http_port", httpPort)
+		return multistep.ActionContinue
+	}
+
+	// Find an available TCP port for our HTTP server
+	var httpAddr string
+	portRange := int(config.HTTPPortMax - config.HTTPPortMin)
+	for {
+		var err error
+		var offset uint = 0
+
+		if portRange > 0 {
+			// Intn will panic if portRange == 0, so we do a check.
+			offset = uint(rand.Intn(portRange))
+		}
+
+		httpPort = offset + config.HTTPPortMin
+		httpAddr = fmt.Sprintf(":%d", httpPort)
+		log.Printf("Trying port: %d", httpPort)
+		s.l, err = net.Listen("tcp", httpAddr)
+		if err == nil {
+			break
+		}
+	}
+
+	ui.Say(fmt.Sprintf("Starting HTTP server on port %d", httpPort))
+
+	// Start the HTTP server and run it in the background
+	fileServer := http.FileServer(http.Dir(config.HTTPDir))
+	server := &http.Server{Addr: httpAddr, Handler: fileServer}
+	go server.Serve(s.l)
+
+	// Save the address into the state so it can be accessed in the future
+	state.Put("http_port", httpPort)
+
+	return multistep.ActionContinue
+}
+
+func (s *stepHTTPServer) Cleanup(multistep.StateBag) {
+	if s.l != nil {
+		// Close the listener so that the HTTP server stops
+		s.l.Close()
+	}
+}

builder/xenserver/step_prepare_output_dir.go

@@ -1,31 +1,27 @@
-package common
+package xenserver
 
-/* Taken from https://raw.githubusercontent.com/hashicorp/packer/master/builder/qemu/step_prepare_output_dir.go */
+/* Taken from https://raw.githubusercontent.com/mitchellh/packer/master/builder/qemu/step_prepare_output_dir.go */
 
 import (
-	"context"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
 	"time"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
 )
 
-type StepPrepareOutputDir struct {
-	Force bool
-	Path  string
-}
+type stepPrepareOutputDir struct{}
 
-func (self *StepPrepareOutputDir) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (stepPrepareOutputDir) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(config)
 	ui := state.Get("ui").(packer.Ui)
 
-	if _, err := os.Stat(self.Path); err == nil && self.Force {
+	if _, err := os.Stat(config.OutputDir); err == nil && config.PackerForce {
 		ui.Say("Deleting previous output directory...")
-		os.RemoveAll(self.Path)
+		os.RemoveAll(config.OutputDir)
 	}
 
-	if err := os.MkdirAll(self.Path, 0755); err != nil {
+	if err := os.MkdirAll(config.OutputDir, 0755); err != nil {
 		state.Put("error", err)
 		return multistep.ActionHalt
 	}
@@ -33,16 +29,17 @@ func (self *StepPrepareOutputDir) Run(ctx context.Context, state multistep.State
 	return multistep.ActionContinue
 }
 
-func (self *StepPrepareOutputDir) Cleanup(state multistep.StateBag) {
+func (stepPrepareOutputDir) Cleanup(state multistep.StateBag) {
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
 
 	if cancelled || halted {
+		config := state.Get("config").(config)
 		ui := state.Get("ui").(packer.Ui)
 
 		ui.Say("Deleting output directory...")
 		for i := 0; i < 5; i++ {
-			err := os.RemoveAll(self.Path)
+			err := os.RemoveAll(config.OutputDir)
 			if err == nil {
 				break
 			}

builder/xenserver/step_shutdown_and_export.go

@@ -0,0 +1,100 @@
+package xenserver
+
+/* Taken from https://raw.githubusercontent.com/mitchellh/packer/master/builder/qemu/step_prepare_output_dir.go */
+
+import (
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"os"
+    "fmt"
+    "net/http"
+    "crypto/tls"
+    "io"
+)
+
+type stepShutdownAndExport struct{}
+
+func downloadFile(url, filename string) (err error) {
+
+    // Create the file
+    fh, err := os.Create(filename)
+    if err != nil {
+        return err
+    }
+
+    // Define a new transport which allows self-signed certs
+    tr := &http.Transport{
+        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+    }
+
+    // Create a client
+    client := &http.Client{Transport: tr}
+
+    // Create request and download file
+
+    resp, err := client.Get(url)
+    if err != nil {
+        return err
+    }
+
+    defer resp.Body.Close()
+    io.Copy(fh, resp.Body)
+
+    return nil
+}
+
+
+func (stepShutdownAndExport) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(config)
+	ui := state.Get("ui").(packer.Ui)
+    client := state.Get("client").(XenAPIClient)
+    instance_uuid := state.Get("instance_uuid").(string)
+
+    instance, _ := client.GetVMByUuid(instance_uuid)
+
+    ui.Say("Step: Shutdown and export VPX")
+
+    // Shutdown the VM
+    ui.Say("Shutting down the VM...")
+    instance.CleanShutdown()
+
+    //Export the VM
+
+    export_url := fmt.Sprintf("https://%s/export?vm=%s&session_id=%s",
+                              client.Host,
+                              instance.Ref,
+                              client.Session.(string),
+                              )
+
+    export_filename := fmt.Sprintf("%s/%s.xva", config.OutputDir, config.InstanceName)
+    ui.Say("Getting metadata " + export_url)
+    downloadFile(export_url, export_filename)
+
+    disks, _ := instance.GetDisks()
+    for _, disk := range disks {
+        disk_uuid, _ := disk.GetUuid()
+
+        // Basic auth in URL request is required as session token is not
+        // accepted for some reason.
+        // @todo: raise with XAPI team.
+        disk_export_url := fmt.Sprintf("https://%s:%s@%s/export_raw_vdi?vdi=%s",
+                                       client.Username,
+                                       client.Password,
+                                       client.Host,
+                                       disk_uuid,
+                                       )
+
+        ui.Say("Getting " + disk_export_url)
+        disk_export_filename := fmt.Sprintf("%s/%s.raw", config.OutputDir, disk_uuid)
+        ui.Say("Downloading " + disk_uuid)
+        downloadFile(disk_export_url, disk_export_filename)
+    }
+
+
+    ui.Say("Download complteded: " + config.OutputDir)
+
+	return multistep.ActionContinue
+}
+
+func (stepShutdownAndExport) Cleanup(state multistep.StateBag) {
+}

builder/xenserver/step_start_on_himn.go

@@ -0,0 +1,123 @@
+package xenserver
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "time"
+    "log"
+    "fmt"
+)
+
+type stepStartOnHIMN struct{}
+
+
+/*
+ * This step starts the installed guest on the Host Internal Management Network
+ * as there exists an API to obtain the IP allocated to the VM by XAPI.
+ * This in turn will allow Packer to SSH into the VM, provided NATing has been
+ * enabled on the host.
+ *
+ */
+
+func (self *stepStartOnHIMN) Run(state multistep.StateBag) multistep.StepAction {
+
+    ui := state.Get("ui").(packer.Ui)
+    client := state.Get("client").(XenAPIClient)
+    config := state.Get("config").(config)
+
+    ui.Say("Step: Start VM on the Host Internal Mangement Network")
+
+    instance := state.Get("instance").(*VM)
+
+    // Find the HIMN Ref
+    networks, err := client.GetNetworkByNameLabel("Host internal management network")
+    if err != nil || len(networks) == 0 {
+        log.Fatal("Unable to find a host internal management network")
+        log.Fatal(err.Error())
+        return multistep.ActionHalt
+    }
+
+
+    himn := networks[0]
+
+    // Create a VIF for the HIMN
+    himn_vif, err := instance.ConnectNetwork(himn, "0")
+    if err != nil {
+        log.Fatal("Error creating VIF")
+        log.Fatal(err.Error())
+        return multistep.ActionHalt
+    }
+
+    // Start the VM
+    instance.Start(false, false)
+
+
+    var himn_iface_ip string = ""
+
+    // Obtain the allocated IP
+    for i:=0; i < 10; i++ {
+        ips, _ := himn.GetAssignedIPs()
+        log.Printf("IPs: %s", ips)
+        log.Printf("Ref: %s", instance.Ref)
+
+        //Check for instance.Ref in map
+        if vm_ip, ok := ips[himn_vif.Ref]; ok {
+            ui.Say("Found the VM's IP " + vm_ip)
+            himn_iface_ip = vm_ip
+            break
+        }
+
+        ui.Say("Wait for IP address...")
+        time.Sleep(10*time.Second)
+
+    }
+
+    if himn_iface_ip != "" {
+        state.Put("himn_ssh_address", himn_iface_ip)
+        ui.Say("Stored VM's IP " + himn_iface_ip)
+    } else {
+        log.Fatal("Unable to find an IP on the Host-internal management interface")
+        return multistep.ActionHalt
+    }
+
+
+    // Wait for the VM to boot, and check we can ping this interface
+
+    ping_cmd := fmt.Sprintf("ping -c 1 %s", himn_iface_ip)
+
+    err = nil
+    for i:=0; i < 30; i++ {
+        ui.Message(fmt.Sprintf("Attempting to ping interface: %s", ping_cmd))
+        _, err := execute_ssh_cmd(ping_cmd, config.HostIp, "22", config.Username, config.Password)
+
+        if err == nil {
+            ui.Message("Ping success! Continuing...")
+            break
+        }
+
+        time.Sleep(10 * time.Second)
+    }
+
+    if err != nil {
+        log.Fatal("Unable to ping interface. Something is wrong. Has the VM not booted?")
+        log.Fatal(err.Error())
+        return multistep.ActionHalt
+    }
+
+
+    return multistep.ActionContinue
+
+}
+
+func (self *stepStartOnHIMN) Cleanup(state multistep.StateBag) {}
+
+
+func himnSSHIP (state multistep.StateBag) (string, error) {
+    ip := state.Get("himn_ssh_address").(string)
+    return ip, nil
+}
+
+
+func himnSSHPort (state multistep.StateBag) (uint, error) {
+    return 22, nil
+}

builder/xenserver/step_start_vm_paused.go

@@ -0,0 +1,30 @@
+package xenserver
+
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+)
+
+type stepStartVmPaused struct {}
+
+func (self *stepStartVmPaused) Run(state multistep.StateBag) multistep.StepAction {
+
+    client := state.Get("client").(XenAPIClient)
+    ui := state.Get("ui").(packer.Ui)
+
+    ui.Say("Step: Start VM Paused")
+
+    instance, _ := client.GetVMByUuid(state.Get("instance_uuid").(string))
+
+    instance.Start(true, false) 
+
+    domid, _ := instance.GetDomainId()
+    state.Put("domid", domid)
+
+    return multistep.ActionContinue
+}
+
+
+func (self *stepStartVmPaused) Cleanup(state multistep.StateBag) {
+}

builder/xenserver/step_type_boot_command.go

@@ -0,0 +1,186 @@
+package xenserver
+
+/* Heavily borrowed from builder/quemu/step_type_boot_command.go */
+
+import (
+    "fmt"
+    "github.com/mitchellh/go-vnc"
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "log"
+    "net"
+    "strings"
+    "time"
+    "unicode"
+    "unicode/utf8"
+)
+
+const KeyLeftShift uint = 0xFFE1
+
+type bootCommandTemplateData struct {
+    HTTPIP      string
+    HTTPPort    uint
+}
+
+
+type stepTypeBootCommand struct{}
+
+func (self *stepTypeBootCommand) Run (state multistep.StateBag) multistep.StepAction {
+    config := state.Get("config").(config)
+    ui := state.Get("ui").(packer.Ui)
+    vnc_port := state.Get("local_vnc_port").(uint)
+    http_port := state.Get("http_port").(uint)
+
+    // Connect to the local VNC port as we have set up a SSH port forward
+    ui.Say("Connecting to the VM over VNC")
+    ui.Message(fmt.Sprintf("Using local port: %d", vnc_port))
+    net_conn, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", vnc_port))
+
+    if err != nil {
+        err := fmt.Errorf("Error connecting to VNC: %s", err)
+        state.Put("error", err)
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+
+    defer net_conn.Close()
+
+    c, err := vnc.Client(net_conn, &vnc.ClientConfig{Exclusive: true})
+
+    if err != nil {
+        err := fmt.Errorf("Error establishing VNC session: %s", err)
+        state.Put("error", err)
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+
+    defer c.Close()
+
+    log.Printf("Connected to the VNC console: %s", c.DesktopName)
+
+    // @todo - include http port/ip so kickstarter files can be grabbed
+    tplData := &bootCommandTemplateData {
+                config.LocalIp,
+                http_port,
+    }
+
+    ui.Say("About to type boot commands over VNC...")
+    for _, command := range config.BootCommand {
+
+        command, err := config.tpl.Process(command, tplData)
+        if err != nil {
+            err := fmt.Errorf("Error preparing boot command: %s", err)
+            state.Put("error", err)
+            ui.Error(err.Error())
+            return multistep.ActionHalt
+        }
+
+        // Check for interrupts
+        if _, ok := state.GetOk(multistep.StateCancelled); ok {
+            return multistep.ActionHalt
+        }
+
+        vncSendString(c, command)
+    }
+
+    ui.Say("Finished typing.")
+
+    return multistep.ActionContinue
+}
+
+func (self *stepTypeBootCommand) Cleanup (multistep.StateBag) {}
+
+// Taken from qemu's builder plugin - not an exported function.
+func vncSendString(c *vnc.ClientConn, original string) {
+	// Scancodes reference: https://github.com/qemu/qemu/blob/master/ui/vnc_keysym.h
+	special := make(map[string]uint32)
+	special["<bs>"] = 0xFF08
+	special["<del>"] = 0xFFFF
+	special["<enter>"] = 0xFF0D
+	special["<esc>"] = 0xFF1B
+	special["<f1>"] = 0xFFBE
+	special["<f2>"] = 0xFFBF
+	special["<f3>"] = 0xFFC0
+	special["<f4>"] = 0xFFC1
+	special["<f5>"] = 0xFFC2
+	special["<f6>"] = 0xFFC3
+	special["<f7>"] = 0xFFC4
+	special["<f8>"] = 0xFFC5
+	special["<f9>"] = 0xFFC6
+	special["<f10>"] = 0xFFC7
+	special["<f11>"] = 0xFFC8
+	special["<f12>"] = 0xFFC9
+	special["<return>"] = 0xFF0D
+	special["<tab>"] = 0xFF09
+	special["<up>"] = 0xFF52
+	special["<down>"] = 0xFF54
+	special["<left>"] = 0xFF51
+	special["<right>"] = 0xFF53
+	special["<spacebar>"] = 0x020
+	special["<insert>"] = 0xFF63
+	special["<home>"] = 0xFF50
+	special["<end>"] = 0xFF57
+	special["<pageUp>"] = 0xFF55
+	special["<pageDown>"] = 0xFF56
+
+	shiftedChars := "~!@#$%^&*()_+{}|:\"<>?"
+
+	// TODO(mitchellh): Ripe for optimizations of some point, perhaps.
+	for len(original) > 0 {
+		var keyCode uint32
+		keyShift := false
+
+		if strings.HasPrefix(original, "<wait>") {
+			log.Printf("Special code '<wait>' found, sleeping one second")
+			time.Sleep(1 * time.Second)
+			original = original[len("<wait>"):]
+			continue
+		}
+
+		if strings.HasPrefix(original, "<wait5>") {
+			log.Printf("Special code '<wait5>' found, sleeping 5 seconds")
+			time.Sleep(5 * time.Second)
+			original = original[len("<wait5>"):]
+			continue
+		}
+
+		if strings.HasPrefix(original, "<wait10>") {
+			log.Printf("Special code '<wait10>' found, sleeping 10 seconds")
+			time.Sleep(10 * time.Second)
+			original = original[len("<wait10>"):]
+			continue
+		}
+
+		for specialCode, specialValue := range special {
+			if strings.HasPrefix(original, specialCode) {
+				log.Printf("Special code '%s' found, replacing with: %d", specialCode, specialValue)
+				keyCode = specialValue
+				original = original[len(specialCode):]
+				break
+			}
+		}
+
+		if keyCode == 0 {
+			r, size := utf8.DecodeRuneInString(original)
+			original = original[size:]
+			keyCode = uint32(r)
+			keyShift = unicode.IsUpper(r) || strings.ContainsRune(shiftedChars, r)
+
+			log.Printf("Sending char '%c', code %d, shift %v", r, keyCode, keyShift)
+		}
+
+		if keyShift {
+			c.KeyEvent(uint32(KeyLeftShift), true)
+		}
+
+		c.KeyEvent(keyCode, true)
+		c.KeyEvent(keyCode, false)
+
+		if keyShift {
+			c.KeyEvent(uint32(KeyLeftShift), false)
+		}
+
+		// qemu is picky, so no matter what, wait a small period
+		time.Sleep(100 * time.Millisecond)
+	}
+}

builder/xenserver/step_upload_iso.go

@@ -0,0 +1,81 @@
+package xenserver
+
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "os"
+    "strconv"
+    "os/exec"
+    "log"
+)
+
+type stepUploadIso struct {}
+
+func (self *stepUploadIso) Run(state multistep.StateBag) multistep.StepAction {
+
+    client := state.Get("client").(XenAPIClient)
+    config := state.Get("config").(config)
+    ui := state.Get("ui").(packer.Ui)
+
+    ui.Say("Step: Upload ISO to server")
+    iso_path := state.Get("iso_path").(string)
+
+    // Determine the ISO's filesize
+    file, err := os.Open(iso_path)
+    if err != nil {
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+    stat, err := file.Stat()
+
+    if err != nil {
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+
+    iso_filesize := stat.Size()
+
+    // Create a VDI with the write size
+    srs, err := client.GetSRByNameLabel(config.SrName)
+
+    sr := srs[0]
+
+    if err != nil {
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+
+    filesize_str := strconv.FormatInt(iso_filesize, 10)
+    log.Printf("Filesize of the ISO is %d", filesize_str)
+    vdi, err := sr.CreateVdi("Packer Gen " + stat.Name(), filesize_str)
+
+    if err != nil {
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+
+    // Upload the ISO to this VDI
+    vdi_uuid, _ := vdi.GetUuid()
+    host_url := "https://" +  client.Host
+    log.Printf("Host URL: %s", host_url)
+    ui.Say("Uploading ISO to " + vdi_uuid)
+    out, err := exec.Command("/usr/bin/importdisk.py", host_url, client.Username, client.Password, vdi_uuid, iso_path).CombinedOutput()
+    log.Printf("Output: %s", out)
+
+    if err != nil {
+        log.Printf("%s", err)
+        ui.Error(err.Error())
+        return multistep.ActionHalt
+    }
+
+    // Stash the vdi uuid to be used in preference
+    state.Put("iso_vdi_uuid", vdi_uuid)
+
+
+    return multistep.ActionContinue
+}
+
+
+func (self *stepUploadIso) Cleanup(state multistep.StateBag) {
+}

builder/xenserver/step_wait.go

@@ -0,0 +1,66 @@
+package xenserver
+
+import (
+    "github.com/mitchellh/multistep"
+    "github.com/mitchellh/packer/packer"
+    "time"
+    "reflect"
+)
+
+
+type stepWait struct{}
+
+func (self *stepWait) Run(state multistep.StateBag) multistep.StepAction {
+    ui := state.Get("ui").(packer.Ui)
+    client := state.Get("client").(XenAPIClient)
+
+    ui.Say("Step: Wait for install to complete.")
+
+
+    //Expect install to be configured to shutdown on completion
+
+    instance_id := state.Get("instance_uuid").(string)
+    instance, _ := client.GetVMByUuid(instance_id)
+
+    for {
+        time.Sleep(30 * time.Second)
+        ui.Say("Waiting for VM install...")
+
+        power_state, _ := instance.GetPowerState()
+        if power_state == "Halted" {
+            ui.Say("Install has completed. Moving on.")
+            break
+        }
+    }
+
+    // Eject ISO from drive
+    vbds, _ := instance.GetVBDs()
+    for _, vbd := range vbds {
+        rec, _ := vbd.GetRecord()
+
+        // Hack - should encapsulate this in the client really
+        // This is needed because we can't guarentee the type
+        // returned by the xmlrpc lib will be string
+        switch reflect.TypeOf(rec["type"]).Kind() {
+            case reflect.String:
+                if rec["type"].(string) == "CD" {
+                    ui.Say("Ejecting CD...")
+                    vbd.Eject()
+                }
+            default:
+                break
+        }
+    }
+
+    // Destroy all connected VIFs
+    vifs, _ := instance.GetVIFs()
+    for _, vif := range vifs {
+        ui.Message("Destroying VIF " + vif.Ref)
+        vif.Destroy()
+    }
+
+    return multistep.ActionContinue
+}
+
+func (self *stepWait) Cleanup(state multistep.StateBag) {}
+

builder/xenserver/xva/builder.go

@@ -1,209 +0,0 @@
-package xva
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"github.com/hashicorp/hcl/v2/hcldec"
-	"github.com/hashicorp/packer-plugin-sdk/communicator"
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	commonsteps "github.com/hashicorp/packer-plugin-sdk/multistep/commonsteps"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	hconfig "github.com/hashicorp/packer-plugin-sdk/template/config"
-	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
-	xsclient "github.com/terra-farm/go-xen-api-client"
-	xscommon "github.com/xenserver/packer-builder-xenserver/builder/xenserver/common"
-)
-
-type Builder struct {
-	config xscommon.Config
-	runner multistep.Runner
-}
-
-func (self *Builder) ConfigSpec() hcldec.ObjectSpec { return self.config.FlatMapstructure().HCL2Spec() }
-
-func (self *Builder) Prepare(raws ...interface{}) (params []string, warns []string, retErr error) {
-
-	var errs *packer.MultiError
-
-	err := hconfig.Decode(&self.config, &hconfig.DecodeOpts{
-		Interpolate: true,
-		InterpolateFilter: &interpolate.RenderFilter{
-			Exclude: []string{
-				"boot_command",
-			},
-		},
-	}, raws...)
-
-	if err != nil {
-		errs = packer.MultiErrorAppend(errs, err)
-	}
-
-	errs = packer.MultiErrorAppend(
-		errs, self.config.CommonConfig.Prepare(self.config.GetInterpContext(), &self.config.PackerConfig)...)
-	errs = packer.MultiErrorAppend(errs, self.config.SSHConfig.Prepare(self.config.GetInterpContext())...)
-
-	// Set default values
-	if self.config.VCPUsMax == 0 {
-		self.config.VCPUsMax = 1
-	}
-
-	if self.config.VCPUsAtStartup == 0 {
-		self.config.VCPUsAtStartup = 1
-	}
-
-	if self.config.VCPUsAtStartup > self.config.VCPUsMax {
-		self.config.VCPUsAtStartup = self.config.VCPUsMax
-	}
-
-	if self.config.VMMemory == 0 {
-		self.config.VMMemory = 1024
-	}
-
-	if len(self.config.PlatformArgs) == 0 {
-		pargs := make(map[string]string)
-		pargs["viridian"] = "false"
-		pargs["nx"] = "true"
-		pargs["pae"] = "true"
-		pargs["apic"] = "true"
-		pargs["timeoffset"] = "0"
-		pargs["acpi"] = "1"
-		self.config.PlatformArgs = pargs
-	}
-
-	// Validation
-
-	if self.config.SourcePath == "" && self.config.CloneTemplate == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("Either source_path or clone_template must be specified"))
-	} else if self.config.SourcePath != "" && self.config.CloneTemplate != "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("Only one of source_path and clone_template must be specified"))
-	}
-
-	if len(errs.Errors) > 0 {
-		retErr = errors.New(errs.Error())
-	}
-
-	return nil, nil, retErr
-
-}
-
-func (self *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
-	//Setup XAPI client
-	c, err := xscommon.NewXenAPIClient(self.config.HostIp, self.config.Username, self.config.Password)
-
-	if err != nil {
-		return nil, err
-	}
-
-	ui.Say("XAPI client session established")
-
-	c.GetClient().Host.GetAll(c.GetSessionRef())
-
-	//Share state between the other steps using a statebag
-	state := new(multistep.BasicStateBag)
-	state.Put("client", c)
-	state.Put("config", self.config)
-	state.Put("commonconfig", self.config.CommonConfig)
-	state.Put("hook", hook)
-	state.Put("ui", ui)
-
-	httpReqChan := make(chan string, 1)
-
-	//Build the steps
-	steps := []multistep.Step{
-		&xscommon.StepPrepareOutputDir{
-			Force: self.config.PackerForce,
-			Path:  self.config.OutputDir,
-		},
-		&commonsteps.StepCreateFloppy{
-			Files: self.config.FloppyFiles,
-			Label: "cidata",
-		},
-		&xscommon.StepHTTPServer{
-			Chan: httpReqChan,
-		},
-		&xscommon.StepUploadVdi{
-			VdiNameFunc: func() string {
-				return "Packer-floppy-disk"
-			},
-			ImagePathFunc: func() string {
-				if floppyPath, ok := state.GetOk("floppy_path"); ok {
-					return floppyPath.(string)
-				}
-				return ""
-			},
-			VdiUuidKey: "floppy_vdi_uuid",
-		},
-		&xscommon.StepFindVdi{
-			VdiName:    self.config.ToolsIsoName,
-			VdiUuidKey: "tools_vdi_uuid",
-		},
-		&xscommon.StepCreateInstance{
-			AssumePreInstalledOS: true,
-		},
-		new(stepImportInstance),
-		&xscommon.StepAttachVdi{
-			VdiUuidKey: "floppy_vdi_uuid",
-			VdiType:    xsclient.VbdTypeFloppy,
-		},
-		&xscommon.StepAttachVdi{
-			VdiUuidKey: "tools_vdi_uuid",
-			VdiType:    xsclient.VbdTypeCD,
-		},
-		new(xscommon.StepStartVmPaused),
-		new(xscommon.StepSetVmHostSshAddress),
-		new(xscommon.StepBootWait),
-		&xscommon.StepTypeBootCommand{
-			Ctx: *self.config.GetInterpContext(),
-		},
-		&xscommon.StepWaitForIP{
-			Chan:    httpReqChan,
-			Timeout: 300 * time.Minute, /*self.config.InstallTimeout*/ // @todo change this
-		},
-		&xscommon.StepForwardPortOverSSH{
-			RemotePort:  xscommon.InstanceSSHPort,
-			RemoteDest:  xscommon.InstanceSSHIP,
-			HostPortMin: self.config.HostPortMin,
-			HostPortMax: self.config.HostPortMax,
-			ResultKey:   "local_ssh_port",
-		},
-		&communicator.StepConnect{
-			Config:    &self.config.SSHConfig.Comm,
-			Host:      xscommon.InstanceSSHIP,
-			SSHConfig: self.config.Comm.SSHConfigFunc(),
-			SSHPort:   xscommon.InstanceSSHPort,
-		},
-		new(commonsteps.StepProvision),
-		new(xscommon.StepShutdown),
-		new(xscommon.StepSetVmToTemplate),
-		&xscommon.StepDetachVdi{
-			VdiUuidKey: "tools_vdi_uuid",
-		},
-		&xscommon.StepDetachVdi{
-			VdiUuidKey: "floppy_vdi_uuid",
-		},
-		new(xscommon.StepExport),
-	}
-
-	self.runner = &multistep.BasicRunner{Steps: steps}
-	self.runner.Run(ctx, state)
-
-	if rawErr, ok := state.GetOk("error"); ok {
-		return nil, rawErr.(error)
-	}
-
-	// If we were interrupted or cancelled, then just exit.
-	if _, ok := state.GetOk(multistep.StateCancelled); ok {
-		return nil, errors.New("Build was cancelled.")
-	}
-	if _, ok := state.GetOk(multistep.StateHalted); ok {
-		return nil, errors.New("Build was halted.")
-	}
-
-	artifact, _ := xscommon.NewArtifact(self.config.OutputDir)
-
-	return artifact, nil
-}

builder/xenserver/xva/builder_test.go

@@ -1,194 +0,0 @@
-package xva
-
-import (
-	"testing"
-
-	"github.com/hashicorp/packer-plugin-sdk/common"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-)
-
-func testConfig() map[string]interface{} {
-	return map[string]interface{}{
-		"remote_host":      "localhost",
-		"remote_username":  "admin",
-		"remote_password":  "admin",
-		"vm_name":          "foo",
-		"shutdown_command": "yes",
-		"ssh_username":     "foo",
-		"source_path":      ".",
-
-		common.BuildNameConfigKey: "foo",
-	}
-}
-
-func TestBuilder_ImplementsBuilder(t *testing.T) {
-	var raw interface{}
-	raw = &Builder{}
-	if _, ok := raw.(packer.Builder); !ok {
-		t.Error("Builder must implement builder.")
-	}
-}
-
-func TestBuilderPrepare_Defaults(t *testing.T) {
-	var b Builder
-	config := testConfig()
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	if b.config.ToolsIsoName != "" {
-		t.Errorf("bad tools ISO name: %s", b.config.ToolsIsoName)
-	}
-
-	if b.config.VMName == "" {
-		t.Errorf("bad vm name: %s", b.config.VMName)
-	}
-
-	if b.config.Format != "xva" {
-		t.Errorf("bad format: %s", b.config.Format)
-	}
-
-	if b.config.KeepVM != "never" {
-		t.Errorf("bad keep instance: %s", b.config.KeepVM)
-	}
-
-	if b.config.HostSshPort != 22 {
-		t.Errorf("bad ssh port: %d", b.config.HostSshPort)
-	}
-}
-
-func TestBuilderPrepare_Format(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["format"] = "foo"
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["format"] = "vdi_raw"
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_HTTPPort(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["http_port_min"] = 1000
-	config["http_port_max"] = 500
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Bad
-	config["http_port_min"] = -500
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["http_port_min"] = 500
-	config["http_port_max"] = 1000
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_InvalidKey(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Add a random key
-	config["i_should_not_be_valid"] = true
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestBuilderPrepare_KeepVM(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["keep_vm"] = "foo"
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["keep_vm"] = "always"
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}
-
-func TestBuilderPrepare_SourcePath(t *testing.T) {
-	var b Builder
-	config := testConfig()
-
-	// Bad
-	config["source_path"] = ""
-	_, warns, err := b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err == nil {
-		t.Fatal("should have error")
-	}
-
-	// Good
-	config["source_path"] = "."
-	b = Builder{}
-	_, warns, err = b.Prepare(config)
-	if len(warns) > 0 {
-		t.Fatalf("bad: %#v", warns)
-	}
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-}

builder/xenserver/xva/step_import_instance.go

@@ -1,126 +0,0 @@
-package xva
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-
-	"github.com/hashicorp/packer-plugin-sdk/multistep"
-	"github.com/hashicorp/packer-plugin-sdk/packer"
-	xsclient "github.com/terra-farm/go-xen-api-client"
-	xscommon "github.com/xenserver/packer-builder-xenserver/builder/xenserver/common"
-)
-
-type stepImportInstance struct {
-	instance xsclient.VMRef
-	vdi      xsclient.VDIRef
-}
-
-func (self *stepImportInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-
-	c := state.Get("client").(*xscommon.Connection)
-	config := state.Get("config").(xscommon.Config)
-	ui := state.Get("ui").(packer.Ui)
-
-	ui.Say("Step: Import Instance")
-
-	if config.SourcePath == "" {
-		log.Println("Skipping importing instance - no `source_path` configured.")
-		return multistep.ActionContinue
-	}
-
-	// find the SR
-	srs, err := c.GetClient().SR.GetAll(c.GetSessionRef())
-	sr := srs[0]
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get SR: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	// Open the file for reading (NB: httpUpload closes the file for us)
-	fh, err := os.Open(config.SourcePath)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to open XVA '%s': %s", config.SourcePath, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	result, err := xscommon.HTTPUpload(fmt.Sprintf("https://%s/import?session_id=%s&sr_id=%s",
-		c.Host,
-		c.GetSession(),
-		sr,
-	), fh, state)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to upload VDI: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-	if result == "" {
-		ui.Error("XAPI did not reply with an instance reference")
-		return multistep.ActionHalt
-	}
-
-	instance := xsclient.VMRef(result)
-
-	instanceId, err := c.GetClient().VM.GetUUID(c.GetSessionRef(), instance)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to get VM UUID: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-	state.Put("instance_uuid", instanceId)
-
-	err = c.GetClient().VM.SetVCPUsMax(c.GetSessionRef(), instance, int(config.VCPUsMax))
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM VCPUs Max=%d: %s", config.VCPUsMax, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.GetClient().VM.SetVCPUsAtStartup(c.GetSessionRef(), instance, int(config.VCPUsAtStartup))
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM VCPUs At Startup=%d: %s", config.VCPUsAtStartup, err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = c.GetClient().VM.SetNameDescription(c.GetSessionRef(), instance, config.VMDescription)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Error setting VM description: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	err = xscommon.AddVMTags(c, instance, config.VMTags)
-	if err != nil {
-		ui.Error(fmt.Sprintf("Failed to add tags: %s", err.Error()))
-		return multistep.ActionHalt
-	}
-
-	ui.Say(fmt.Sprintf("Imported instance '%s'", instanceId))
-
-	return multistep.ActionContinue
-}
-
-func (self *stepImportInstance) Cleanup(state multistep.StateBag) {
-	/*
-		config := state.Get("config").(config)
-		if config.ShouldKeepVM(state) {
-			return
-		}
-
-		ui := state.Get("ui").(packer.Ui)
-
-		if self.instance != nil {
-			ui.Say("Destroying VM")
-			_ = self.instance.HardShutdown() // redundant, just in case
-			err := self.instance.Destroy()
-			if err != nil {
-				ui.Error(err.Error())
-			}
-		}
-
-		if self.vdi != nil {
-			ui.Say("Destroying VDI")
-			err := self.vdi.Destroy()
-			if err != nil {
-				ui.Error(err.Error())
-			}
-		}
-	*/
-}

docs/builders/iso/xenserver-iso.html.markdown

@@ -1,305 +0,0 @@
----
-layout: "docs"
-page_title: "XenServer Builder (from an ISO)"
-description: |-
-  The XenServer Packer builder is able to create XenServer virtual machines and export them either as an XVA or a VDI and create VM templates starting from an ISO image.
----
-
-# XenServer Builder (from an ISO)
-
-Type: `xenserver-iso`
-
-The XenServer Packer builder is able to create [XenServer](https://www.xenserver.org/)
-virtual machines and export them either as an XVA or a VDI and create VM templates starting from an ISO image.
-
-The builder builds a virtual machine by creating a new virtual machine
-from scratch, booting it, installing an OS, provisioning software within
-the OS, then shutting it down. The result of the XenServer builder is a
-directory containing all the files necessary to run the virtual machine
-portably.
-
-## Configuration Reference
-
-There are many configuration options available for the XenServer builder.
-They are organized below into two categories: required and optional. Within
-each category, the available options are alphabetized and described.
-
-### Required:
-
-* `iso_checksum` (string) - The checksum for the OS ISO file. Because ISO
-  files are so large, this is required and Packer will verify it prior
-  to booting a virtual machine with the ISO attached. The type of
-  the checksum is specified within the checksum field as a prefix, ex:
-  "md5:{$checksum}". The type of the checksum can also be omitted and
-  Packer will try to infer it based on string length. Valid values are
-  "none", "{$checksum}", "md5:{$checksum}", "sha1:{$checksum}",
-  "sha256:{$checksum}", "sha512:{$checksum}" or "file:{$path}". Here is
-  an example list of valid checksum values:
-    * `md5:090992ba9fd140077b0661cb75f7ce13`
-    * `090992ba9fd140077b0661cb75f7ce13`
-    * `sha1:ebfb681885ddf1234c18094a45bbeafd91467911`
-    * `ebfb681885ddf1234c18094a45bbeafd91467911`
-    * `sha256:ed363350696a726b7932db864dda019bd2017365c9e299627830f06954643f93`
-    * `ed363350696a726b7932db864dda019bd2017365c9e299627830f06954643f93`
-    * `file:http://releases.ubuntu.com/20.04/SHA256SUMS`
-    * `file:file://./local/path/file.sum`
-    * `file:./local/path/file.sum`
-    * `none`
-        * Although the checksum will not be verified when it is set to "none",
-          this is not recommended since these files can be very large and
-          corruption does happen from time to time.
-
-
-* `iso_url` (string) - A URL to the ISO containing the installation image.
-  This URL can be either an HTTP URL or a file URL (or path to a file).
-  If this is an HTTP URL, Packer will download it and cache it between
-  runs.
-
-* `remote_host` (string) - The host of the Xenserver / XCP-ng pool primary. Typically, these will be specified through
-  environment variables as seen in the [examples](../../../examples).
-
-* `remote_ssh_port` (integer) - The port that SSH will be listening on in the Xenserver / XCP-ng pool primary. By default this is 22.
-
-* `remote_username` (string) - The XenServer username used to access the remote machine.
-
-* `remote_password` (string) - The XenServer password for access to the remote machine.
-
-* `ssh_username` (string) - The username to use to SSH into the machine
-  once the OS is installed.
-
-### Optional:
-
-* `boot_command` (array of strings) - This is an array of commands to type
-  when the virtual machine is first booted. The goal of these commands should
-  be to type just enough to initialize the operating system installer. Special
-  keys can be typed as well, and are covered in the section below on the boot
-  command. If this is not specified, it is assumed the installer will start
-  itself. See the [Ubuntu](../../../examples/ubuntu) and [centos](../../../examples/centos) examples to see how these
-  are used to launch autoinstall and kickstart respectively.
-
-* `boot_wait` (string) - The time to wait after booting the initial virtual
-  machine before typing the `boot_command`. The value of this should be
-  a duration. Examples are `5s` and `1m30s` which will cause Packer to wait
-  five seconds and one minute 30 seconds, respectively. If this isn't specified,
-  the default is 10 seconds.
-
-* `clone_template` (string) - The template to clone. Defaults to "Other install
-  media", this is "other", but you can get _dramatic_ performance improvements
-  by setting this to the proper value. To view all available values for this
-  run `xe template-list`. Setting the correct value hints to XenServer how to
-  optimize the virtual hardware to work best with that operating system.
-
-* `disk_name` (string) - The name of the hard disk to create for the VM.
-   By default, the name is "Packer-disk".
-
-* `disk_size` (integer) - The size, in megabytes, of the hard disk to create
-  for the VM. By default, this is 40000 (about 40 GB).
-
-* `firmware` (string) - Whether to use `bios` or `uefi` as the boot firmware
-  for the resulting VM. Defaults to `bios`.
-
-* `floppy_files` (array of strings) - A list of files to place onto a floppy
-  disk that is attached when the VM is booted. This is most useful
-  for unattended Windows installs, which look for an `Autounattend.xml` file
-  on removable media. By default, no floppy will be attached. All files
-  listed in this setting get placed into the root directory of the floppy
-  and the floppy is attached as the first floppy device. Currently, no
-  support exists for creating sub-directories on the floppy. Wildcard
-  characters (\*, ?, and []) are allowed. Directory names are also allowed,
-  which will add all the files found in the directory to the floppy.
-
-* `format` (string) - Either "xva", "xva_compressed", "vdi_raw" or "none", this specifies the
-  output format of the exported virtual machine. This defaults to "xva". Set to
-  "vdi_raw" to export just the raw disk image. Set to "none" to export nothing;
-  this is only useful with "keep_vm" set to "always" or "on_success".
-
-* `http_directory` (string) - Path to a directory to serve using an HTTP
-  server. The files in this directory will be available over HTTP which will
-  be requestable from the virtual machine. This is useful for hosting
-  kickstart files and so on. By default, this is `""`, which means no HTTP
-  server will be started. The address and port of the HTTP server will be
-  available as variables in `boot_command`. This is covered in more detail
-  below.
-
-* `http_port_min` and `http_port_max` (integer) - These are the minimum and
-  maximum port to use for the HTTP server started to serve the `http_directory`.
-  Because Packer often runs in parallel, Packer will choose a randomly available
-  port in this range to run the HTTP server. If you want to force the HTTP
-  server to be on one port, make this minimum and maximum port the same.
-  By default, the values are 8000 and 9000, respectively.
-
-* `install_timeout` (string) - The amount of time to wait after booting the VM
-  for the installer to shut itself down.
-  If it doesn't shut down in this time, it is an error. By default, the timeout
-  is "200m", or over three hours.
-
-* `iso_urls` (array of strings) - Multiple URLs for the ISO to download.
-  Packer will try these in order. If anything goes wrong attempting to download
-  or while downloading a single URL, it will move on to the next. All URLs
-  must point to the same file (same checksum). By default, this is empty
-  and `iso_url` is used. Only one of `iso_url` or `iso_urls` can be specified.
-
-* `tools_iso_name` (string) - Choose the tools iso you want to use.
-  Usually "guest-tools.iso", or "xs-tools.iso". Not setting this variable causes no tools-related
-  ISO to be attached.
-
-* `keep_vm` (string) - Determine when to keep the VM and when to clean it up. This
-  can be `always`, `never` or `on_success`. The default is `never`, and Packer
-  always deletes the VM regardless of whether the process succeeded and an artifact
-  was produced. `always` asks Packer to leave the VM at the end of the process
-  regardless of success. `on_success` requests that the VM only be cleaned up if an
-  artifact was produced. The latter is useful for debugging templates that fail.
-
-* `ip_getter` (string) - Defines the method by which the IP of the guest machine is
-  identified. Options are: `auto`, `tools`, `http`. The default is `auto`, which will
-  attempt both methods. `tools` requires that the guest tools be installed and functional
-  inside the quest machine.
-
-* `skip_set_template` (bool) - If you want to get the full XVA, to be able to import the VM directly
-  instead of using the output template, you can set this to `true`.
-
-* `network_names` (array of strings) - A list of networks identified by their name label which
-  will be used for the VM during creation. The first network will correspond to the VM's
-  first network interface (VIF), the second will correspond to the second VIF and so on.
-
-* `export_network_names` (array of strings) - A list of networks identified by their name label which
-  will be attached to the export. The first network will correspond to the VM's
-  first network interface (VIF), the second will correspond to the second VIF and so on.
-
-* `output_directory` (string) - This is the path to the directory where the
-  resulting virtual machine will be created. This may be relative or absolute.
-  If relative, the path is relative to the working directory when `packer`
-  is executed. This directory must not exist or be empty prior to running the builder.
-  By default, this is "output-BUILDNAME" where "BUILDNAME" is the name
-  of the build.
-
-* `platform_args` (object of key/value strings) - The platform args.
-  Defaults to
-
-```json
-{
-  "viridian": "false",
-  "nx": "true",
-  "pae": "true",
-  "apic": "true",
-  "timeoffset": "0",
-  "acpi": "1",
-  "cores-per-socket": "1"
-}
-```
-
-* `shutdown_command` (string) - The command to use to gracefully shut down
-  the machine once all the provisioning is done. If this is omitted, packer
-  will shut down the VM gracefully through the Xen api's vm shutdown command. Unless
-  you have special requirements this should typically be left to its default.
-
-* `sr_name` (string) - The SR to use for storing the disk for the VM that Packer
-  creates. By default, the default SR of the system will be used.
-
-* `sr_iso_name` (string) - The SR to use for uploading the provided ISO.
-  By default, the default SR of the system will be used.
-
-* `ssh_host_port_min` and `ssh_host_port_max` (integer) - The minimum and
-  maximum port to use for the SSH port on the host machine which is forwarded
-  to the SSH port on the guest machine. Because Packer often runs in parallel,
-  Packer will choose a randomly available port in this range to use as the
-  host port.
-
-* `ssh_key_path` (string) - Path to a private key to use for authenticating
-  with SSH. By default, this is not set (key-based auth won't be used).
-  The associated public key is expected to already be configured on the
-  VM being prepared by some other process (kickstart, etc.).
-
-* `ssh_password` (string) - The password for `ssh_username` to use to
-  authenticate with SSH. By default, this is the empty string.
-
-* `ssh_port` (integer) - The port that SSH will be listening on in the guest
-  virtual machine. By default, this is `22`.
-
-* `ssh_wait_timeout` (string) - The duration to wait for SSH to become
-  available. By default, this is `20m`, or 20 minutes. **Note**: that this should
-  be quite long since the timer begins as soon as the virtual machine is booted.
-
-* `tools_iso_name` (string) - The name of the XenServer Tools ISO. Defaults to
-  `xs-tools.iso`.
-
-* `vm_description` (string) - The description of the new virtual
-  machine. By default, this is an empty string.
-
-* `vm_name` (string) - This is the name of the new virtual
-  machine, without the file extension. By default, this is
-  `packer-BUILDNAME-TIMESTAMP`, where "BUILDNAME" is the name of the build.
-
-* `vcpus_max` (integer) - The maximum number of VCPUs for the VM.
-  By default, this is `1`.
-
-* `vcpus_atstartup` (integer) - The number of startup VCPUs for the VM.
-  By default, this is `1`.
-
-* `vm_memory` (integer) - The size, in megabytes, of the amount of memory to
-  allocate for the VM. By default, this is `1024` (1 GB).
-
-* `vm_tags` (array of strings) - A list of tags to add to the VM
-
-## Differences with other Packer builders
-
-Currently, the XenServer builder has some quirks when compared with other Packer builders.
-
-The builder currently only works remotely.
-
-The installer is expected to shut down the VM to indicate that it has completed. This is in contrast to other builders,
-which instead detect completion by a successful SSH connection. The reason for this difference is that currently the
-builder has no way of knowing what the IP address of the VM is without starting it on the HIMN.
-
-## Boot Command
-
-The `boot_command` configuration is very important: it specifies the keys
-to type when the virtual machine is first booted in order to start the
-OS installer. This command is typed after `boot_wait`, which gives the
-virtual machine some time to actually load the ISO.
-
-As documented above, the `boot_command` is an array of strings. The
-strings are all typed in sequence. It is an array only to improve readability
-within the template.
-
-The boot command is "typed" character by character over a VNC connection
-to the machine, simulating a human actually typing on the keyboard. There are
-a set of special keys available. If these are in your boot command, they
-will be replaced by the proper key:
-
-* `<bs>` - Backspace
-
-* `<del>` - Delete
-
-* `<enter>` and `<return>` - Simulates an actual "enter" or "return" keypress.
-
-* `<esc>` - Simulates pressing the escape key.
-
-* `<tab>` - Simulates pressing the tab key.
-
-* `<f1>` - `<f12>` - Simulates pressing a function key.
-
-* `<up>` `<down>` `<left>` `<right>` - Simulates pressing an arrow key.
-
-* `<spacebar>` - Simulates pressing the spacebar.
-
-* `<insert>` - Simulates pressing the insert key.
-
-* `<home>` `<end>` - Simulates pressing the home and end keys.
-
-* `<pageUp>` `<pageDown>` - Simulates pressing the page up and page down keys.
-
-* `<wait>` `<wait5>` `<wait10>` - Adds a 1, 5 or 10 second pause before sending any additional keys. This
-  is useful if you have to generally wait for the UI to update before typing more.
-
-In addition to the special keys, each command to type is treated as a
-configuration template.
-
-The available variables are:
-
-* `HTTPIP` and `HTTPPort` - The IP and port, respectively of an HTTP server
-  that is started serving the directory specified by the `http_directory`
-  configuration parameter. If `http_directory` isn't specified, these will be
-  blank!
-
-See the [examples](../../../examples) for working boot commands.

examples/README.md

@@ -1,36 +0,0 @@
-## Examples
-
-In order for new users to get up and running with the packer builder, a few examples of building a machine image with popular distros have been created.
-
-In order to see an exhaustive list of configuration options for the packer builder please see the [following documentation](../docs/builders/xenserver-iso.html.markdown). This doc will focus on the details relevant to the particular distro.
-
-### Running the examples
-
-In order to run the examples you will need to perform the following steps:
-1. Export those vars:
-```
-PKR_VAR_remote_host
-PKR_VAR_remote_password
-PKR_VAR_remote_username
-PKR_VAR_sr_name
-PKR_VAR_sr_iso_name
-``` 
-`PKR_VAR_remote_host` must be the resource pool primary, aka the master.
-
-2. Run `packer init path/to/defenition.pkr.hcl` to download the xenserver plugin
-
-2. Run `packer build  path/to/defenition.pkr.hcl`   
-so for example:
-`packer build  examples/centos/centos8-netinstall.pkr.hcl`
-
-### Ubuntu
-
-The Ubuntu example uses the [autoinstall tool](https://ubuntu.com/server/docs/install/autoinstallhttps://ubuntu.com/server/docs/install/autoinstall) to configure the VM template. Please see the [autoinstall docs](https://ubuntu.com/server/docs/install/autoinstall-reference) for an exhaustive list of what is supported.
-
-Packer will create a http server to serve the files as specified from the `http_directory` specified in the builder configuration. This is where the [user-data](http/ubuntu-2004/user-data) and [meta-data](http/ubuntu-2004/meta-data) for autoinstall must be present.
-
-### Centos
-
-The Centos examples use kickstart files to configure the VM template. Please see the [kickstart documentation](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/installation_guide/sect-kickstart-syntax) for the options that are supported.
-
-Packer will create a http server to serve the files as specified from the `http_directory` specified in the builder configuration. This is where the [kickstart config](http/centos8/ks-centos8.cfg) file must be present.

examples/centos-6.4.conf

@@ -0,0 +1,26 @@
+{
+    "builders": [{
+        "type": "xenserver",
+        "username": "root",
+        "password": "hostpassword",
+        "host_ip": "10.81.2.105",
+        "instance_name": "packer-centos-6-4",
+        "root_disk_size": "5000000000",
+        "clone_template": "b31a4a3a-a44f-68df-bb53-33529a9db3b7",
+        "iso_uuid": "3079a3f4-a49b-4f65-8afd-c2351b2c3399",
+        "sr_uuid": "88328079-d58d-2b43-1f28-982e0e60ec23",
+        "network_uuid": "02021c25-34b8-2a32-3f55-1d6338e869e2",
+        "iso_url": "http://mirrors.usc.edu/pub/linux/distributions/centos/6.4/isos/x86_64/CentOS-6.4-x86_64-minimal.iso",
+        "iso_checksum_type": "md5",
+        "iso_checksum": "4a5fa01c81cc300f4729136e28ebe600",
+        "http_directory": "http",
+        "local_ip": "10.80.3.223",
+        "ssh_username": "root",
+        "ssh_password": "vmpassword",
+        "boot_command": 
+            [
+                "<tab><wait>",
+                " ks=http://{{ .HTTPIP }}:{{ .HTTPPort }}/centos6-ks.cfg<enter>"
+            ]
+    }]
+}

examples/centos/centos8-local.pkr.hcl

@@ -1,80 +0,0 @@
-packer {
-  required_plugins {
-   xenserver= {
-      version = ">= v0.6.0"
-      source = "github.com/ddelnano/xenserver"
-    }
-  }
-}
-
-variable "remote_host" {
-  type        = string
-  description = "The ip or fqdn of your XenServer. This will be pulled from the env var 'PKR_VAR_remote_host'"
-  sensitive   = true
-  default     = null
-}
-
-variable "remote_password" {
-  type        = string
-  description = "The password used to interact with your XenServer. This will be pulled from the env var 'PKR_VAR_remote_password'"
-  sensitive   = true
-  default     = null
-}
-
-variable "remote_username" {
-  type        = string
-  description = "The username used to interact with your XenServer. This will be pulled from the env var 'PKR_VAR_remote_username'"
-  sensitive   = true
-  default     = null
-
-}
-
-variable "sr_iso_name" {
-  type        = string
-  default     = ""
-  description = "The ISO-SR to packer will use"
-
-}
-
-variable "sr_name" {
-  type        = string
-  default     = ""
-  description = "The name of the SR to packer will use"
-}
-
-locals {
-  timestamp = regex_replace(timestamp(), "[- TZ:]", "") 
-}
-
-source "xenserver-iso" "centos8-local" {
-  iso_checksum      = "sha1:aaf9d4b3071c16dbbda01dfe06085e5d0fdac76df323e3bbe87cce4318052247"
-  iso_url           = "http://mirrors.ocf.berkeley.edu/centos/8.3.2011/isos/x86_64/CentOS-8.3.2011-x86_64-dvd1.iso"
-
-  sr_iso_name    = var.sr_iso_name
-  sr_name        = var.sr_name
-  tools_iso_name = "guest-tools.iso"
-
-  remote_host     = var.remote_host
-  remote_password = var.remote_password
-  remote_username = var.remote_username
-
-  vm_name        = "packer-centos8-local-${local.timestamp}"
-  vm_description = "Build started: ${local.timestamp}\n This was installed from the dvd"
-  vm_memory      = 4096
-  disk_size      = 4096
-
-  http_directory = "examples/http/centos8"
-  boot_command   = ["<tab> text ks=http://{{ .HTTPIP }}:{{ .HTTPPort }}/ks-centos8-local.cfg<enter><wait>"]
-  boot_wait      = "10s"
-
-  ssh_username     = "root"
-  ssh_password     = "centos"
-  ssh_wait_timeout = "10000s"
-
-  output_directory = "packer-centos8-local"
-  keep_vm          = "always"
-}
-
-build {
-  sources = ["xenserver-iso.centos8-local"]
-}

examples/centos/centos8-netinstall.pkr.hcl

@@ -1,80 +0,0 @@
-packer {
-  required_plugins {
-   xenserver= {
-      version = ">= v0.6.0"
-      source = "github.com/ddelnano/xenserver"
-    }
-  }
-}
-
-variable "remote_host" {
-  type        = string
-  description = "The ip or fqdn of your XenServer. This will be pulled from the env var 'PKR_VAR_remote_host'"
-  sensitive   = true
-  default     = null
-}
-
-variable "remote_password" {
-  type        = string
-  description = "The password used to interact with your XenServer. This will be pulled from the env var 'PKR_VAR_remote_password'"
-  sensitive   = true
-  default     = null
-}
-
-variable "remote_username" {
-  type        = string
-  description = "The username used to interact with your XenServer. This will be pulled from the env var 'PKR_VAR_remote_username'"
-  sensitive   = true
-  default     = null
-
-}
-
-variable "sr_iso_name" {
-  type        = string
-  default     = ""
-  description = "The ISO-SR to packer will use"
-
-}
-
-variable "sr_name" {
-  type        = string
-  default     = ""
-  description = "The name of the SR to packer will use"
-}
-
-locals {
-  timestamp = regex_replace(timestamp(), "[- TZ:]", "") 
-}
-
-source "xenserver-iso" "centos8-netinstall" {
-  iso_checksum      = "sha1:07a8e59c42cc086ec4c49bdce4fae5a17b077dea"
-  iso_url           = "http://mirrors.ocf.berkeley.edu/centos/8.3.2011/isos/x86_64/CentOS-8.3.2011-x86_64-boot.iso"
-
-  sr_iso_name    = var.sr_iso_name
-  sr_name        = var.sr_name
-  tools_iso_name = "guest-tools.iso"
-
-  remote_host     = var.remote_host
-  remote_password = var.remote_password
-  remote_username = var.remote_username
-
-  vm_name        = "packer-centos8-netinstall-${local.timestamp}"
-  vm_description = "Build started: ${local.timestamp}\n This was installed with an external repository"
-  vm_memory      = 4096
-  disk_size      = 4096
-
-  http_directory = "examples/http/centos8"
-  boot_command   = ["<tab> text ks=http://{{ .HTTPIP }}:{{ .HTTPPort }}/ks-centos8-netinstall.cfg<enter><wait>"]
-  boot_wait      = "10s"
-
-  ssh_username     = "root"
-  ssh_password     = "centos"
-  ssh_wait_timeout = "10000s"
-
-  output_directory = "packer-centos8-netinstall"
-  keep_vm          = "always"
-}
-
-build {
-  sources = ["xenserver-iso.centos8-netinstall"]
-}

examples/http/centos6-ks.cfg

@@ -0,0 +1,49 @@
+install
+cdrom
+lang en_US.UTF-8
+keyboard us
+unsupported_hardware
+network --bootproto=dhcp
+rootpw --iscrypted $1$wwD0QIub$WNz1RShXh1UapQzmpF4/c1
+firewall --disabled
+authconfig --enableshadow --passalgo=sha512
+selinux --permissive
+timezone UTC
+bootloader --location=mbr
+text
+skipx
+zerombr
+clearpart --all --initlabel
+autopart
+auth  --useshadow  --enablemd5
+firstboot --disabled
+#reboot
+poweroff
+
+%packages --ignoremissing
+@Base
+@Core
+@Development Tools
+openssl-devel
+readline-devel
+zlib-devel
+kernel-devel
+vim
+wget
+%end
+
+%post
+yum -y update
+
+# update root certs
+wget -O/etc/pki/tls/certs/ca-bundle.crt http://curl.haxx.se/ca/cacert.pem
+
+# vagrant
+groupadd vagrant -g 999
+useradd vagrant -g vagrant -G wheel -u 900 -s /bin/bash
+echo "vagrant" | passwd --stdin vagrant
+
+# sudo
+echo "vagrant        ALL=(ALL)       NOPASSWD: ALL" >> /etc/sudoers
+sed -i "s/^.*requiretty/#Defaults requiretty/" /etc/sudoers
+%end

examples/http/centos8/ks-centos8-local.cfg

@@ -1,47 +0,0 @@
-eula --agreed
-lang en-US.UTF-8
-keyboard --vckeymap='de' --xlayouts='de'
-timezone Europe/Berlin
-
-cdrom
-
-text
-skipx
-firstboot --disable
-
-rootpw --plaintext centos
-
-firewall --enabled --ssh
-selinux --enforcing
-
-# Installation logging level
-logging --level=info
-
-network  --bootproto=dhcp --device=eth0 --onboot=on
-
-# System bootloader configuration
-bootloader --location=mbr
-zerombr
-clearpart --all
-
-# Disk partitioning information
-part / --asprimary --fstype="ext4" --size=1024 --grow
-
-
-%addon com_redhat_kdump --disable
-%end
-
-%packages --ignoremissing --excludedocs
-openssh-clients
-sudo
-
-# unnecessary firmware
--aic94xx-firmware*
--alsa-*
--ivtv-*
--iwl*firmware
-%end
-
-# Reboot after installation
-reboot --eject
-

examples/http/centos8/ks-centos8-netinstall.cfg

@@ -1,46 +0,0 @@
-eula --agreed
-lang en-US.UTF-8
-keyboard --vckeymap='de' --xlayouts='de'
-timezone Europe/Berlin
-
-text
-skipx
-firstboot --disable
-
-url --url="http://mirror.centos.org/centos/8.3.2011/BaseOS/x86_64/os/"
-rootpw --plaintext centos
-
-firewall --enabled --ssh
-selinux --enforcing
-
-# Installation logging level
-logging --level=info
-
-network  --bootproto=dhcp --device=eth0 --onboot=on
-
-# System bootloader configuration
-bootloader --location=mbr
-zerombr
-clearpart --all
-
-# Disk partitioning information
-part / --asprimary --fstype="ext4" --size=1024 --grow
-
-
-%addon com_redhat_kdump --disable
-%end
-
-%packages --ignoremissing --excludedocs
-openssh-clients
-sudo
-
-# unnecessary firmware
--aic94xx-firmware*
--alsa-*
--ivtv-*
--iwl*firmware
-%end
-
-# Reboot after installation
-reboot --eject
-

examples/http/ubuntu-2004/user-data

@@ -1,22 +0,0 @@
-#cloud-config
-
-# hack for cloud-init per:
-# https://github.com/leakespeake/packer/blob/3f3e361751b4be9326b66771d96f2519bc8f885e/builders/vmware/vsphere-iso/ubuntu-server-20-04/hcl2/http/ubuntu-server-subiquity/user-data
-runcmd:
-  # to enable true auto-install for Ubuntu 20.04 with cloud-init nocloud (eliminates "Continue with autoinstall?" prompt)
-  - [eval, 'echo $(cat /proc/cmdline) "autoinstall" > /root/cmdline']
-  - [eval, 'mount -n --bind -o ro /root/cmdline /proc/cmdline']
-  - [eval, 'snap restart subiquity.subiquity-service']
-
-autoinstall:
-  version: 1
-  identity:
-    hostname: ubuntu-server
-    # This is the crypted pass of 'ubuntu'
-    password: "$6$exDY1mhS4KUYCE/2$zmn9ToZwTKLhCw.b4/b.ZRTIZM30JZ4QrOQ2aOXJ8yk96xpcCof0kxKwuX1kqLG/ygbJ1f8wxED22bTL4F46P0"
-    username: testuser
-  packages:
-    - xe-guest-utilities
-  ssh:
-    install-server: yes
-    allow-pw: yes

examples/ubuntu/ubuntu-2004.pkr.hcl

@@ -1,111 +0,0 @@
-packer {
-  required_plugins {
-   xenserver= {
-      version = ">= v0.5.2"
-      source = "github.com/ddelnano/xenserver"
-    }
-  }
-}
-
-# The ubuntu_version value determines what Ubuntu iso URL and sha256 hash we lookup. Updating
-# this will allow a new version to be pulled in.
-data "null" "ubuntu_version" {
-  input = "20.04"
-}
-
-locals {
-  timestamp = regex_replace(timestamp(), "[- TZ:]", "")
-  ubuntu_version = data.null.ubuntu_version.output
-
-  # Update this map to support future releases. At this time, the Ubuntu
-  # jammy template is not available yet.
-  ubuntu_template_name = {
-    20.04 = "Ubuntu Focal Fossa 20.04"
-  }
-}
-
-# TODO(ddelnano): Update this to use a local once https://github.com/hashicorp/packer/issues/11011
-# is fixed.
-data "http" "ubuntu_sha_and_release" {
-  url = "https://releases.ubuntu.com/${data.null.ubuntu_version.output}/SHA256SUMS"
-}
-
-local "ubuntu_sha256" {
-  expression = regex("([A-Za-z0-9]+)[\\s\\*]+ubuntu-.*server", data.http.ubuntu_sha_and_release.body)
-}
-
-local "ubuntu_url_path" {
-  expression = regex("[A-Za-z0-9]+[\\s\\*]+ubuntu-${local.ubuntu_version}.(\\d+)-live-server-amd64.iso", data.http.ubuntu_sha_and_release.body)
-}
-
-variable "remote_host" {
-  type        = string
-  description = "The ip or fqdn of your XenServer. This will be pulled from the env var 'PKR_VAR_XAPI_HOST'"
-  sensitive   = true
-  default     = null
-}
-
-variable "remote_password" {
-  type        = string
-  description = "The password used to interact with your XenServer. This will be pulled from the env var 'PKR_VAR_XAPI_PASSWORD'"
-  sensitive   = true
-  default     = null
-}
-
-variable "remote_username" {
-  type        = string
-  description = "The username used to interact with your XenServer. This will be pulled from the env var 'PKR_VAR_XAPI_USERNAME'"
-  sensitive   = true
-  default     = null
-
-}
-
-variable "sr_iso_name" {
-  type        = string
-  default     = ""
-  description = "The ISO-SR to packer will use"
-
-}
-
-variable "sr_name" {
-  type        = string
-  default     = ""
-  description = "The name of the SR to packer will use"
-}
-
-source "xenserver-iso" "ubuntu-2004" {
-  iso_checksum      = "sha256:${local.ubuntu_sha256.0}"
-  iso_url           = "https://releases.ubuntu.com/${local.ubuntu_version}/ubuntu-${local.ubuntu_version}.${local.ubuntu_url_path.0}-live-server-amd64.iso"
-
-  sr_iso_name    = var.sr_iso_name
-  sr_name        = var.sr_name
-  tools_iso_name = "guest-tools.iso"
-
-  remote_host     = var.remote_host
-  remote_password = var.remote_password
-  remote_username = var.remote_username
-
-  # Change this to match the ISO of ubuntu you are using in the iso_url variable
-  clone_template = local.ubuntu_template_name[data.null.ubuntu_version.output]
-  vm_name        = "packer-ubuntu-${data.null.ubuntu_version.output}-${local.timestamp}"
-  vm_description = "Build started: ${local.timestamp}"
-  vm_memory      = 4096
-  disk_size      = 30720
-
-  floppy_files = [
-    "examples/http/ubuntu-2004/meta-data",
-    "examples/http/ubuntu-2004/user-data",
-  ]
-
-  ssh_username            = "testuser"
-  ssh_password            = "ubuntu"
-  ssh_wait_timeout        = "60000s"
-  ssh_handshake_attempts  = 10000
-
-  output_directory = "packer-ubuntu-2004-iso"
-  keep_vm          = "always"
-}
-
-build {
-  sources = ["xenserver-iso.ubuntu-2004"]
-}

go.mod

@@ -1,104 +0,0 @@
-module github.com/xenserver/packer-builder-xenserver
-
-go 1.20
-
-require (
-	github.com/amfranz/go-xmlrpc-client v0.0.0-20190612172737-76858463955d
-	github.com/hashicorp/hcl/v2 v2.20.1
-	github.com/hashicorp/packer-plugin-sdk v0.3.0
-	github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed
-	github.com/terra-farm/go-xen-api-client v0.0.2
-	github.com/zclconf/go-cty v1.14.4
-	golang.org/x/crypto v0.24.0
-)
-
-require (
-	cloud.google.com/go v0.110.0 // indirect
-	cloud.google.com/go/compute v1.19.1 // indirect
-	cloud.google.com/go/compute/metadata v0.2.3 // indirect
-	cloud.google.com/go/iam v0.13.0 // indirect
-	cloud.google.com/go/storage v1.28.1 // indirect
-	github.com/Azure/go-ntlmssp v0.0.0-20200615164410-66371956d46c // indirect
-	github.com/ChrisTrenkamp/goxpath v0.0.0-20210404020558-97928f7e12b6 // indirect
-	github.com/agext/levenshtein v1.2.3 // indirect
-	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
-	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
-	github.com/armon/go-metrics v0.3.9 // indirect
-	github.com/aws/aws-sdk-go v1.40.34 // indirect
-	github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect
-	github.com/cenkalti/backoff/v3 v3.2.2 // indirect
-	github.com/dylanmei/iso8601 v0.1.0 // indirect
-	github.com/fatih/color v1.12.0 // indirect
-	github.com/gofrs/flock v0.8.1 // indirect
-	github.com/gofrs/uuid v4.0.0+incompatible // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/googleapis/enterprise-certificate-proxy v0.2.3 // indirect
-	github.com/googleapis/gax-go/v2 v2.7.1 // indirect
-	github.com/hashicorp/consul/api v1.10.1 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-getter/gcs/v2 v2.1.0 // indirect
-	github.com/hashicorp/go-getter/s3/v2 v2.1.0 // indirect
-	github.com/hashicorp/go-getter/v2 v2.1.0 // indirect
-	github.com/hashicorp/go-hclog v0.16.2 // indirect
-	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.0 // indirect
-	github.com/hashicorp/go-rootcerts v1.0.2 // indirect
-	github.com/hashicorp/go-safetemp v1.0.0 // indirect
-	github.com/hashicorp/go-sockaddr v1.0.2 // indirect
-	github.com/hashicorp/go-version v1.3.0 // indirect
-	github.com/hashicorp/golang-lru v0.5.4 // indirect
-	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/hashicorp/serf v0.9.5 // indirect
-	github.com/hashicorp/vault/api v1.1.1 // indirect
-	github.com/hashicorp/vault/sdk v0.2.1 // indirect
-	github.com/hashicorp/yamux v0.0.0-20210826001029-26ff87cf9493 // indirect
-	github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869 // indirect
-	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/kr/fs v0.1.0 // indirect
-	github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786 // indirect
-	github.com/masterzen/winrm v0.0.0-20210623064412-3b76017826b0 // indirect
-	github.com/mattn/go-colorable v0.1.8 // indirect
-	github.com/mattn/go-isatty v0.0.13 // indirect
-	github.com/mitchellh/go-fs v0.0.0-20180402235330-b7b9ca407fff // indirect
-	github.com/mitchellh/go-homedir v1.1.0 // indirect
-	github.com/mitchellh/go-testing-interface v1.14.1 // indirect
-	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
-	github.com/mitchellh/iochan v1.0.0 // indirect
-	github.com/mitchellh/mapstructure v1.4.1 // indirect
-	github.com/mitchellh/reflectwalk v1.0.0 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
-	github.com/packer-community/winrmcp v0.0.0-20180921211025-c76d91c1e7db // indirect
-	github.com/pierrec/lz4 v2.6.1+incompatible // indirect
-	github.com/pkg/sftp v1.13.2 // indirect
-	github.com/ryanuber/go-glob v1.0.0 // indirect
-	github.com/ugorji/go/codec v1.2.6 // indirect
-	github.com/ulikunitz/xz v0.5.10 // indirect
-	go.opencensus.io v0.24.0 // indirect
-	golang.org/x/mod v0.17.0 // indirect
-	golang.org/x/net v0.25.0 // indirect
-	golang.org/x/oauth2 v0.7.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
-	golang.org/x/term v0.21.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
-	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
-	golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
-	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
-	google.golang.org/api v0.114.0 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
-	google.golang.org/grpc v1.56.3 // indirect
-	google.golang.org/protobuf v1.33.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
-	gopkg.in/square/go-jose.v2 v2.6.0 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
-)
-
-replace github.com/zclconf/go-cty => github.com/nywilken/go-cty v1.13.3 // added by packer-sdc fix as noted in github.com/hashicorp/packer-plugin-sdk/issues/187

go.sum

@@ -1,772 +0,0 @@
-bazil.org/fuse v0.0.0-20160811212531-371fbbdaa898/go.mod h1:Xbm+BRKSBEpa4q4hTSxohYNQpsxXPbPry4JJWOB3LB8=
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.110.0 h1:Zc8gqp3+a9/Eyph2KDmcGaPtbKRIoqq4YTlL4NMD0Ys=
-cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/compute v1.19.1 h1:am86mquDUgjGNWxiGn+5PGLbmgiWXlE/yNWpIpNvuXY=
-cloud.google.com/go/compute v1.19.1/go.mod h1:6ylj3a05WF8leseCdIf77NK0g1ey+nj5IKd5/kvShxE=
-cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
-cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/iam v0.13.0 h1:+CmB+K0J/33d0zSQ9SlFWUeCCEn5XJA0ZMZ3pHE9u8k=
-cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0=
-cloud.google.com/go/longrunning v0.4.1 h1:v+yFJOfKC3yZdY6ZUI933pIYdhyhV8S3NpWrXWmg7jM=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-cloud.google.com/go/storage v1.28.1 h1:F5QDG5ChchaAVQhINh24U99OWHURqrW8OmQcGKXcbgI=
-cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
-github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU=
-github.com/Azure/go-ntlmssp v0.0.0-20200615164410-66371956d46c h1:/IBSNwUN8+eKzUzbJPqhK839ygXJ82sde8x3ogr6R28=
-github.com/Azure/go-ntlmssp v0.0.0-20200615164410-66371956d46c/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022/go.mod h1:nuWgzSkT5PnyOd+272uUmV0dnAnAn42Mk7PiQC5VzN4=
-github.com/ChrisTrenkamp/goxpath v0.0.0-20210404020558-97928f7e12b6 h1:w0E0fgc1YafGEh5cROhlROMWXiNoZqApk2PDN0M1+Ns=
-github.com/ChrisTrenkamp/goxpath v0.0.0-20210404020558-97928f7e12b6/go.mod h1:nuWgzSkT5PnyOd+272uUmV0dnAnAn42Mk7PiQC5VzN4=
-github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
-github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
-github.com/Microsoft/hcsshim v0.8.9/go.mod h1:5692vkUqntj1idxauYlpoINNKeqCiG6Sg38RRsjT5y8=
-github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
-github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/amfranz/go-xmlrpc-client v0.0.0-20190612172737-76858463955d h1:39lR6Kg+GsvDpLMD2Mb7gkjXmmLexqfr7SPy4iQWDTE=
-github.com/amfranz/go-xmlrpc-client v0.0.0-20190612172737-76858463955d/go.mod h1:2NlXXRCkTbr/vZtUjcHKhbrESE4a3CDqVrgOROB16dg=
-github.com/antchfx/xpath v1.1.11 h1:WOFtK8TVAjLm3lbgqeP0arlHpvCEeTANeWZ/csPpJkQ=
-github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0 h1:JaCC8jz0zdMLk2m+qCCVLLLM/PL93p84w4pK3aJWj60=
-github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
-github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
-github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
-github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4=
-github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
-github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
-github.com/armon/go-metrics v0.3.0/go.mod h1:zXjbSimjXTd7vOpY8B0/2LpvNvDoXBuplAD+gJD3GYs=
-github.com/armon/go-metrics v0.3.3/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc=
-github.com/armon/go-metrics v0.3.9 h1:O2sNqxBdvq8Eq5xmzljcYzAORli6RWCvEym4cJf9m18=
-github.com/armon/go-metrics v0.3.9/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc=
-github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/aws/aws-sdk-go v1.25.37/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
-github.com/aws/aws-sdk-go v1.30.8/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
-github.com/aws/aws-sdk-go v1.30.27/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
-github.com/aws/aws-sdk-go v1.40.34 h1:SBYmodndE2d4AYucuuJnOXk4MD1SFbucoIdpwKVKeSA=
-github.com/aws/aws-sdk-go v1.40.34/go.mod h1:585smgzpB/KqRA+K3y/NL/oYRqQvpNJYvLm+LY1U59Q=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
-github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
-github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
-github.com/cenkalti/backoff/v3 v3.0.0/go.mod h1:cIeZDE3IrqwwJl6VUwCN6trj1oXrTS4rc0ij+ULvLYs=
-github.com/cenkalti/backoff/v3 v3.2.2 h1:cfUAAO3yvKMYKPrvhDuHSwQnhZNk/RMHKdZqKTxfm6M=
-github.com/cenkalti/backoff/v3 v3.2.2/go.mod h1:cIeZDE3IrqwwJl6VUwCN6trj1oXrTS4rc0ij+ULvLYs=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
-github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/containerd/cgroups v0.0.0-20190919134610-bf292b21730f/go.mod h1:OApqhQ4XNSNC13gXIwDjhOQxjWa/NxkwZXJ1EvqT0ko=
-github.com/containerd/console v0.0.0-20180822173158-c12b1e7919c1/go.mod h1:Tj/on1eG8kiEhd0+fhSDzsPAFESxzBBvdyEgyryXffw=
-github.com/containerd/containerd v1.3.2/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
-github.com/containerd/containerd v1.3.4/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
-github.com/containerd/continuity v0.0.0-20190426062206-aaeac12a7ffc/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
-github.com/containerd/continuity v0.0.0-20200709052629-daa8e1ccc0bc/go.mod h1:cECdGN1O8G9bgKTlLhuPJimka6Xb/Gg7vYzCTNVxhvo=
-github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI=
-github.com/containerd/go-runc v0.0.0-20180907222934-5a6d9f37cfa3/go.mod h1:IV7qH3hrUgRmyYrtgEeGWJfWbgcHL9CSRruz2Vqcph0=
-github.com/containerd/ttrpc v0.0.0-20190828154514-0e0f228740de/go.mod h1:PvCDdDGpgqzQIzDW1TphrGLssLDZp2GuS+X5DkEJB8o=
-github.com/containerd/typeurl v0.0.0-20180627222232-a93fcdb778cd/go.mod h1:Cm3kwCdlkCfMSHURc+r6fwoGH6/F1hH3S4sg0rLFWPc=
-github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
-github.com/docker/docker v1.4.2-0.20200319182547-c7ad2b866182/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
-github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/dylanmei/iso8601 v0.1.0 h1:812NGQDBcqquTfH5Yeo7lwR0nzx/cKdsmf3qMjPURUI=
-github.com/dylanmei/iso8601 v0.1.0/go.mod h1:w9KhXSgIyROl1DefbMYIE7UVSIvELTbMrCfx+QkYnoQ=
-github.com/dylanmei/winrmtest v0.0.0-20170819153634-c2fbb09e6c08 h1:0bp6/GrNOrTDtSXe9YYGCwf8jp5Fb/b+4a6MTRm4qzY=
-github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
-github.com/fatih/color v1.12.0 h1:mRhaKNwANqRgUBGKmnI5ZxEk7QXmjQeCcuYFMX2bfcc=
-github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
-github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/frankban/quicktest v1.10.0 h1:Gfh+GAJZOAoKZsIZeZbdn2JF10kN1XHNvjsvQK8gVkE=
-github.com/frankban/quicktest v1.10.0/go.mod h1:ui7WezCLWMWxVWr1GETZY3smRy0G4KWq9vcPtJmFl7Y=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/go-asn1-ber/asn1-ber v1.3.1/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-ldap/ldap/v3 v3.1.3/go.mod h1:3rbOH3jRS2u6jg2rJnKAMLE/xQyCKIveG2Sa/Cohzb8=
-github.com/go-ldap/ldap/v3 v3.1.10/go.mod h1:5Zun81jBTabRaI8lzN7E1JjyEl1g6zI6u9pd8luAK4Q=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-test/deep v1.0.2-0.20181118220953-042da051cf31/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
-github.com/go-test/deep v1.0.2/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
-github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
-github.com/godbus/dbus v0.0.0-20190422162347-ade71ed3457e/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4=
-github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
-github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
-github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw=
-github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
-github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
-github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/martian/v3 v3.3.2 h1:IqNFLAmvJOgVlpdEBiQbDc2EwKW77amAycfTuWKdfvw=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/enterprise-certificate-proxy v0.2.3 h1:yk9/cqRKtT9wXZSsRH9aurXEpJX+U6FLtpYTdC3R06k=
-github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/googleapis/gax-go/v2 v2.7.1 h1:gF4c0zjUP2H/s/hEGyLA3I0fA2ZWjzYiONAD6cvPr8A=
-github.com/googleapis/gax-go/v2 v2.7.1/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI=
-github.com/gorilla/mux v1.7.4/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
-github.com/hashicorp/consul/api v1.10.1 h1:MwZJp86nlnL+6+W1Zly4JUuVn9YHhMggBirMpHGD7kw=
-github.com/hashicorp/consul/api v1.10.1/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M=
-github.com/hashicorp/consul/sdk v0.8.0 h1:OJtKBtEjboEZvG6AOUdh4Z1Zbyu0WcxQ0qatRrZHTVU=
-github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms=
-github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
-github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
-github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
-github.com/hashicorp/go-getter/gcs/v2 v2.1.0 h1:1S1hvWgHrhUihP/Y4FVbjCWwE7EwxpksKoRcC7g+Hgs=
-github.com/hashicorp/go-getter/gcs/v2 v2.1.0/go.mod h1:dVyTnX1BynHAjbumB4Pk14GoJ+v3VbDUJtbI7G0oOlU=
-github.com/hashicorp/go-getter/s3/v2 v2.1.0 h1:8uwuP97zEQ7y7H4bLzRqiN4T8vmpXeJthigqSEjX+08=
-github.com/hashicorp/go-getter/s3/v2 v2.1.0/go.mod h1:rwzJPQaBuc5riYOucPx84DOE74xIhKENOWgBjK3XVEs=
-github.com/hashicorp/go-getter/v2 v2.1.0 h1:MsLbi7yFKGFPVmpK+un4/k5HFry0tqvo9JppsCmIutU=
-github.com/hashicorp/go-getter/v2 v2.1.0/go.mod h1:w65fE5glbccYjndAuj1kA5lnVBGZYEaH0e5qA1kpIks=
-github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd/go.mod h1:9bjs9uLqI8l75knNv3lV1kA55veR+WUPSiKIWcQHudI=
-github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
-github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
-github.com/hashicorp/go-hclog v0.14.1/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
-github.com/hashicorp/go-hclog v0.16.1/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
-github.com/hashicorp/go-hclog v0.16.2 h1:K4ev2ib4LdQETX5cSZBG0DVLk1jwGqSPXBjdah3veNs=
-github.com/hashicorp/go-hclog v0.16.2/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
-github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
-github.com/hashicorp/go-immutable-radix v1.1.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
-github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
-github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
-github.com/hashicorp/go-kms-wrapping/entropy v0.1.0/go.mod h1:d1g9WGtAunDNpek8jUIEJnBlbgKS1N2Q61QkHiZyR1g=
-github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
-github.com/hashicorp/go-msgpack v0.5.5 h1:i9R9JSrqIz0QVLz3sz+i3YJdT7TTSLcfLLzJi9aZTuI=
-github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
-github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
-github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
-github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
-github.com/hashicorp/go-plugin v1.0.1/go.mod h1:++UyYGoz3o5w9ZzAdZxtQKrWWP+iqPBn3cQptSMzBuY=
-github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
-github.com/hashicorp/go-retryablehttp v0.6.2/go.mod h1:gEx6HMUGxYYhJScX7W1Il64m6cc2C1mDaW3NQ9sY1FY=
-github.com/hashicorp/go-retryablehttp v0.6.6/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
-github.com/hashicorp/go-retryablehttp v0.7.0 h1:eu1EI/mbirUgP5C8hVsTNaGZreBDlYiwC1FZWkvQPQ4=
-github.com/hashicorp/go-retryablehttp v0.7.0/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
-github.com/hashicorp/go-rootcerts v1.0.1/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8=
-github.com/hashicorp/go-rootcerts v1.0.2 h1:jzhAVGtqPKbwpyCPELlgNWhE1znq+qwJtW5Oi2viEzc=
-github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8=
-github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
-github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
-github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
-github.com/hashicorp/go-sockaddr v1.0.2 h1:ztczhD1jLxIRjVejw8gFomI1BQZOe2WoVOu0SyteCQc=
-github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A=
-github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
-github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE=
-github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
-github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
-github.com/hashicorp/go-version v1.3.0 h1:McDWVJIU/y+u1BRV06dPaLfLCaT7fUTJLp5r04x7iNw=
-github.com/hashicorp/go-version v1.3.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
-github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/hashicorp/hcl/v2 v2.20.1 h1:M6hgdyz7HYt1UN9e61j+qKJBqR3orTWbI1HKBJEdxtc=
-github.com/hashicorp/hcl/v2 v2.20.1/go.mod h1:TZDqQ4kNKCbh1iJp99FdPiUaVDDUPivbqxZulxDYqL4=
-github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
-github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY=
-github.com/hashicorp/memberlist v0.2.2 h1:5+RffWKwqJ71YPu9mWsF7ZOscZmwfasdA8kbdC7AO2g=
-github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
-github.com/hashicorp/packer-plugin-sdk v0.3.0 h1:G4Uze/85X3n6c+8DawHdxptOZ0vHOeJ2LAAhBFLjYmg=
-github.com/hashicorp/packer-plugin-sdk v0.3.0/go.mod h1:bqpbL7w5Ee2QWrUyAsZI/MdCYpw15ls4mxgn9Ei2DZc=
-github.com/hashicorp/serf v0.9.5 h1:EBWvyu9tcRszt3Bxp3KNssBMP1KuHWyO51lz9+786iM=
-github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk=
-github.com/hashicorp/vault/api v1.0.5-0.20200519221902-385fac77e20f/go.mod h1:euTFbi2YJgwcju3imEt919lhJKF68nN1cQPq3aA+kBE=
-github.com/hashicorp/vault/api v1.1.1 h1:907ld+Z9cALyvbZK2qUX9cLwvSaEQsMVQB3x2KE8+AI=
-github.com/hashicorp/vault/api v1.1.1/go.mod h1:29UXcn/1cLOPHQNMWA7bCz2By4PSd0VKPAydKXS5yN0=
-github.com/hashicorp/vault/sdk v0.1.14-0.20200519221530-14615acda45f/go.mod h1:WX57W2PwkrOPQ6rVQk+dy5/htHIaB4aBM70EwKThu10=
-github.com/hashicorp/vault/sdk v0.2.1 h1:S4O6Iv/dyKlE9AUTXGa7VOvZmsCvg36toPKgV4f2P4M=
-github.com/hashicorp/vault/sdk v0.2.1/go.mod h1:WfUiO1vYzfBkz1TmoE4ZGU7HD0T0Cl/rZwaxjBkgN4U=
-github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
-github.com/hashicorp/yamux v0.0.0-20210826001029-26ff87cf9493 h1:brI5vBRUlAlM34VFmnLPwjnCL/FxAJp9XvOdX6Zt+XE=
-github.com/hashicorp/yamux v0.0.0-20210826001029-26ff87cf9493/go.mod h1:CtWFDAQgb7dxtzFs4tWbplKIe2jSi3+5vKbgIO0SLnQ=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869 h1:IPJ3dvxmJ4uczJe5YQdrYB16oTJlGSC/OyZDqUk9xX4=
-github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869/go.mod h1:cJ6Cj7dQo+O6GJNiMx+Pa94qKj+TG8ONdKHgMNIyyag=
-github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
-github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
-github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
-github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
-github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8=
-github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
-github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/masterzen/simplexml v0.0.0-20160608183007-4572e39b1ab9/go.mod h1:kCEbxUJlNDEBNbdQMkPSp6yaKcRXVI6f4ddk8Riv4bc=
-github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786 h1:2ZKn+w/BJeL43sCxI2jhPLRv73oVVOjEKZjKkflyqxg=
-github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786/go.mod h1:kCEbxUJlNDEBNbdQMkPSp6yaKcRXVI6f4ddk8Riv4bc=
-github.com/masterzen/winrm v0.0.0-20210623064412-3b76017826b0 h1:KqYuDbSr8I2X8H65InN8SafDEa0UaLRy6WEmxDqd0F0=
-github.com/masterzen/winrm v0.0.0-20210623064412-3b76017826b0/go.mod h1:l31LCh9VvG43RJ83A5JLkFPjuz48cZAxBSLQLaIn1p8=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
-github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-isatty v0.0.13 h1:qdl+GuBjcsKKDco5BsxPJlId98mSWNKqYA+Co0SC1yA=
-github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/miekg/dns v1.1.26 h1:gPxPSwALAeHJSjarOs00QjVdV9QoBvc1D2ujQUr5BzU=
-github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso=
-github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
-github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI=
-github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw=
-github.com/mitchellh/go-fs v0.0.0-20180402235330-b7b9ca407fff h1:bFJ74ac7ZK/jyislqiWdzrnENesFt43sNEBRh1xk/+g=
-github.com/mitchellh/go-fs v0.0.0-20180402235330-b7b9ca407fff/go.mod h1:g7SZj7ABpStq3tM4zqHiVEG5un/DZ1+qJJKO7qx1EvU=
-github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
-github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
-github.com/mitchellh/go-testing-interface v1.14.1 h1:jrgshOhYAUVNMAJiKbEu7EqAwgJJ2JqpQmpLJOu07cU=
-github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8=
-github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed h1:FI2NIv6fpef6BQl2u3IZX/Cj20tfypRF4yd+uaHOMtI=
-github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed/go.mod h1:3rdaFaCv4AyBgu5ALFM0+tSuHrBh6v692nyQe3ikrq0=
-github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
-github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
-github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
-github.com/mitchellh/iochan v1.0.0 h1:C+X3KsSTLFVBr/tK1eYN/vs4rJcvsiLU338UhYPJWeY=
-github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
-github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mitchellh/mapstructure v1.3.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag=
-github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY=
-github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/56bj7Y/xa04UccTW04VP0Qed4vnQ=
-github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
-github.com/nywilken/go-cty v1.13.3 h1:03U99oXf3j3g9xgqAE3YGpixCjM8Mg09KZ0Ji9LzX0o=
-github.com/nywilken/go-cty v1.13.3/go.mod h1:YKQzy/7pZ7iq2jNFzy5go57xdxdWoLLpaEp4u238AE0=
-github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/opencontainers/go-digest v0.0.0-20180430190053-c9281466c8b2/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
-github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
-github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
-github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
-github.com/opencontainers/runc v0.0.0-20190115041553-12f6a991201f/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
-github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
-github.com/opencontainers/runtime-spec v0.1.2-0.20190507144316-5b71a03e2700/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
-github.com/packer-community/winrmcp v0.0.0-20180921211025-c76d91c1e7db h1:9uViuKtx1jrlXLBW/pMnhOfzn3iSEdLase/But/IZRU=
-github.com/packer-community/winrmcp v0.0.0-20180921211025-c76d91c1e7db/go.mod h1:f6Izs6JvFTdnRbziASagjZ2vmf55NSIkC/weStxCHqk=
-github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
-github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
-github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
-github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
-github.com/pierrec/lz4 v2.5.2+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
-github.com/pierrec/lz4 v2.6.1+incompatible h1:9UY3+iC23yxF0UfGaYrGplQ+79Rg+h/q9FV9ix19jjM=
-github.com/pierrec/lz4 v2.6.1+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1-0.20171018195549-f15c970de5b7/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/sftp v1.13.2 h1:taJnKntsWgU+qae21Rx52lIwndAdKrj0mfUNQsz1z4Q=
-github.com/pkg/sftp v1.13.2/go.mod h1:LzqnAvaD5TWeNBsZpfKxSYn1MbjWwOsCIAFFJbpIsK8=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
-github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
-github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk=
-github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=
-github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
-github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
-github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
-github.com/sirupsen/logrus v1.0.4-0.20170822132746-89742aefa4b2/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
-github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
-github.com/spf13/cobra v0.0.2-0.20171109065643-2da4a54c5cee/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
-github.com/spf13/pflag v1.0.1-0.20171106142849-4c012f6dcd95/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/terra-farm/go-xen-api-client v0.0.2 h1:EREW0N6XqU935b005yCwbPjm8F6582j2rI5C4ew3ZTQ=
-github.com/terra-farm/go-xen-api-client v0.0.2/go.mod h1:L7+Ea6rxzK7AL4DhcEPDQxdLKb4wKq0sYbxHS2ag9YE=
-github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
-github.com/ugorji/go v1.2.6/go.mod h1:anCg0y61KIhDlPZmnH+so+RQbysYVyDko0IMgJv0Nn0=
-github.com/ugorji/go/codec v1.2.6 h1:7kbGefxLoDBuYXOms4yD7223OpNMMPNPZxXk5TvFcyQ=
-github.com/ugorji/go/codec v1.2.6/go.mod h1:V6TCNZ4PHqoHGFZuSG1W8nrCzzdgA2DozYxWFFpvxTw=
-github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8=
-github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/urfave/cli v0.0.0-20171014202726-7bc6a0acffa5/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
-github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b h1:FosyBZYxY34Wul7O/MSKey3txpPYyCqVO5ZyceuQJEI=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
-go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
-go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-golang.org/x/crypto v0.0.0-20171113213409-9f005a07e0d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190222235706-ffb98f73852f/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190418165655-df01cb2cc480/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
-golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
-golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.7.0 h1:qe6s0zUXlPX80/dITx3440hWZ7GwMwgDDyrSGTPJG/g=
-golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190514135907-3a4b5fb9f71f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac h1:7zkz7BUtwNFFqcowJ+RIgu2MaV/MapERkDIy+mwPyjs=
-golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190624222133-a101b041ded4/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
-golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
-golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.21.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.114.0 h1:1xQPji6cO2E2vLiI+C/XiFAnsn1WV3mjaEwGLhi3grE=
-google.golang.org/api v0.114.0/go.mod h1:ifYI2ZsFK6/uGddGfAD5BMxlnkBqCmqHSDUVi45N5Yg=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
-google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU=
-google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.22.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
-google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.56.3 h1:8I4C0Yq1EjstUzUJzpcRVbuYA2mODtEmpWiQoN/b2nc=
-google.golang.org/grpc v1.56.3/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
-gopkg.in/square/go-jose.v2 v2.3.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
-gopkg.in/square/go-jose.v2 v2.5.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
-gopkg.in/square/go-jose.v2 v2.6.0 h1:NGk74WTnPKBNUhNzQX7PYcTLUjoq7mzKk2OKbvwk2iI=
-gopkg.in/square/go-jose.v2 v2.6.0/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
-gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

main.go

@@ -1,24 +1,15 @@
 package main
 
 import (
-	"fmt"
-	"os"
-
-	"github.com/xenserver/packer-builder-xenserver/builder/xenserver/iso"
-	"github.com/xenserver/packer-builder-xenserver/builder/xenserver/xva"
-	"github.com/xenserver/packer-builder-xenserver/version"
-
-	"github.com/hashicorp/packer-plugin-sdk/plugin"
+    "github.com/rdobson/packer-builder-xenserver/builder/xenserver"
+    "github.com/mitchellh/packer/packer/plugin"
 )
 
 func main() {
-	pps := plugin.NewSet()
-	pps.RegisterBuilder("iso", new(iso.Builder))
-	pps.RegisterBuilder("xva", new(xva.Builder))
-	pps.SetVersion(version.PluginVersion)
-	err := pps.Run()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err.Error())
-		os.Exit(1)
-	}
+    server, err := plugin.Server()
+    if err != nil {
+        panic(err)
+    }
+    server.RegisterBuilder(new(xenserver.Builder))
+    server.Serve()
 }

version/version.go

@@ -1,19 +0,0 @@
-package version
-
-import (
-	"github.com/hashicorp/packer-plugin-sdk/version"
-)
-
-var (
-	// Version is the main version number that is being run at the moment.
-	Version = "v0.6.0"
-
-	// VersionPrerelease is A pre-release marker for the Version. If this is ""
-	// (empty string) then it means that it is a final release. Otherwise, this
-	// is a pre-release such as "dev" (in development), "beta", "rc1", etc.
-	VersionPrerelease = "dev"
-
-	// PluginVersion is used by the plugin set to allow Packer to recognize
-	// what version this plugin is.
-	PluginVersion = version.InitializePluginVersion(Version, VersionPrerelease)
-)