Merge pull request digitalocean#150 from adamwg/awg/package-version

domain: Add a function to get the qemu package version

Author: JenniGriesmann

qemu/domain.go

@@ -346,6 +346,17 @@ func (d *Domain) Version() (string, error) {
 	return response.Return.String(), nil
 }
 
+// PackageVersion returns the domain's QEMU package version, the full build
+// information for QEMU.
+func (d *Domain) PackageVersion() (string, error) {
+	vers, err := d.rm.QueryVersion()
+	if err != nil {
+		return "", err
+	}
+
+	return vers.Package, nil
+}
+
 // Events streams QEMU QMP events.
 // Two channels are returned, the first contains events emitted by the domain.
 // The second is used to signal completion of event processing.

qemu/version_test.go

@@ -18,6 +18,7 @@ import (
 	"testing"
 
 	"github.com/digitalocean/go-qemu/qmp"
+	"github.com/digitalocean/go-qemu/qmp/raw"
 )
 
 func TestVersion(t *testing.T) {
@@ -48,3 +49,33 @@ func TestVersion(t *testing.T) {
 		t.Errorf("expected version %q, instead got %q", expected, v)
 	}
 }
+
+func TestPackageVersion(t *testing.T) {
+	result := raw.VersionInfo{}
+	result.Qemu.Major = 2
+	result.Qemu.Minor = 8
+	result.Qemu.Micro = 0
+	result.Package = "(Debian 1:2.8+dfsg-3ubuntu2.4)"
+
+	d, done := testDomain(t, func(cmd qmp.Command) (interface{}, error) {
+		if want, got := "query-version", cmd.Execute; want != got {
+			t.Fatalf("unexpected QMP command:\n- want: %q\n-  got: %q",
+				want, got)
+		}
+
+		return success{
+			Return: result,
+		}, nil
+	})
+	defer done()
+
+	v, err := d.PackageVersion()
+	if err != nil {
+		t.Error(err)
+	}
+
+	expected := "(Debian 1:2.8+dfsg-3ubuntu2.4)"
+	if v != expected {
+		t.Errorf("expected package version %q, instead got %q", expected, v)
+	}
+}

qmp/raw/autogen.go

@@ -9765,6 +9765,13 @@ type String struct {
 	Str string `json:"str"`
 }
 
+// TPMEmulatorOptions -> TPMEmulatorOptions (struct)
+
+// TPMEmulatorOptions implements the "TPMEmulatorOptions" QMP API type.
+type TPMEmulatorOptions struct {
+	Chardev string `json:"chardev"`
+}
+
 // TPMInfo -> TPMInfo (struct)
 
 // TPMInfo implements the "TPMInfo" QMP API type.
@@ -9863,13 +9870,16 @@ type TPMType int
 // Known values of TPMType.
 const (
 	TPMTypePassthrough TPMType = iota
+	TPMTypeEmulator
 )
 
 // String implements fmt.Stringer.
 func (e TPMType) String() string {
 	switch e {
 	case TPMTypePassthrough:
 		return "passthrough"
+	case TPMTypeEmulator:
+		return "emulator"
 	default:
 		return fmt.Sprintf("TPMType(%d)", e)
 	}
@@ -9880,6 +9890,8 @@ func (e TPMType) MarshalJSON() ([]byte, error) {
 	switch e {
 	case TPMTypePassthrough:
 		return json.Marshal("passthrough")
+	case TPMTypeEmulator:
+		return json.Marshal("emulator")
 	default:
 		return nil, fmt.Errorf("unknown enum value %q for TPMType", e)
 	}
@@ -9894,6 +9906,8 @@ func (e *TPMType) UnmarshalJSON(bs []byte) error {
 	switch s {
 	case "passthrough":
 		*e = TPMTypePassthrough
+	case "emulator":
+		*e = TPMTypeEmulator
 	default:
 		return fmt.Errorf("unknown enum value %q for TPMType", s)
 	}
@@ -9905,11 +9919,26 @@ func (e *TPMType) UnmarshalJSON(bs []byte) error {
 // TPMTypeOptions implements the "TpmTypeOptions" QMP API type.
 //
 // Can be one of:
+//   - TPMTypeOptionsEmulator
 //   - TPMTypeOptionsPassthrough
 type TPMTypeOptions interface {
 	isTPMTypeOptions()
 }
 
+// TPMTypeOptionsEmulator is an implementation of TPMTypeOptions.
+type TPMTypeOptionsEmulator TPMEmulatorOptions
+
+func (TPMTypeOptionsEmulator) isTPMTypeOptions() {}
+
+// MarshalJSON implements json.Marshaler.
+func (s TPMTypeOptionsEmulator) MarshalJSON() ([]byte, error) {
+	v := map[string]interface{}{
+		"type": "emulator",
+		"data": s,
+	}
+	return json.Marshal(v)
+}
+
 // TPMTypeOptionsPassthrough is an implementation of TPMTypeOptions.
 type TPMTypeOptionsPassthrough TPMPassthroughOptions
 
@@ -9933,6 +9962,12 @@ func decodeTPMTypeOptions(bs json.RawMessage) (TPMTypeOptions, error) {
 		return nil, err
 	}
 	switch v.T {
+	case "emulator":
+		var ret TPMTypeOptionsEmulator
+		if err := json.Unmarshal([]byte(v.V), &ret); err != nil {
+			return nil, err
+		}
+		return ret, nil
 	case "passthrough":
 		var ret TPMTypeOptionsPassthrough
 		if err := json.Unmarshal([]byte(v.V), &ret); err != nil {

qmp/raw/spec.txt

@@ -9513,13 +9513,16 @@
 # An enumeration of TPM types
 #
 # @passthrough: TPM passthrough type
+# @emulator: Software Emulator TPM type
+#            Since: 2.11
 #
 # Since: 1.5
 ##
 {
   "enum": "TpmType",
   "data": [
-    "passthrough"
+    "passthrough",
+    "emulator"
   ]
 }
 
@@ -9535,7 +9538,7 @@
 # Example:
 #
 # -> { "execute": "query-tpm-types" }
-# <- { "return": [ "passthrough" ] }
+# <- { "return": [ "passthrough", "emulator" ] }
 #
 ##
 {
@@ -9565,19 +9568,37 @@
   }
 }
 
+##
+# @TPMEmulatorOptions:
+#
+# Information about the TPM emulator type
+#
+# @chardev: Name of a unix socket chardev
+#
+# Since: 2.11
+##
+{
+  "struct": "TPMEmulatorOptions",
+  "data": {
+    "chardev": "str"
+  }
+}
+
 ##
 # @TpmTypeOptions:
 #
 # A union referencing different TPM backend types' configuration options
 #
 # @type: 'passthrough' The configuration options for the TPM passthrough type
+#        'emulator' The configuration options for TPM emulator backend type
 #
 # Since: 1.5
 ##
 {
   "union": "TpmTypeOptions",
   "data": {
-    "passthrough": "TPMPassthroughOptions"
+    "passthrough": "TPMPassthroughOptions",
+    "emulator": "TPMEmulatorOptions"
   }
 }