machine1: Add CreateMachine call and network support

- Add CreateMachine Call

  CreateMachine() is similar to RegisterMachine(), the difference
  is CreateMachine will create a scope unit for the machine, and
  RegisterMachine will not.

- Add network support

  Add *Network Call for both CreateMachine and RegisterMachine which
  allow user choose the network interface the host can be used to
  communicate with the guest.

- Refactor Machine tests

  Currently, we have four ways to start a machine for now. Machine
  tests are refactored to make sure all ways have test covered.

Author: Xuanwo

machine1/dbus.go

@@ -24,6 +24,8 @@ import (
 	"syscall"
 
 	"github.com/godbus/dbus"
+
+	sd_dbus "github.com/coreos/go-systemd/dbus"
 )
 
 const (
@@ -110,6 +112,16 @@ func (c *Conn) getPath(method string, args ...interface{}) (dbus.ObjectPath, err
 	return path, nil
 }
 
+// CreateMachine creates a new virtual machine or container with systemd-machined, generating a scope unit for it
+func (c *Conn) CreateMachine(name string, id []byte, service string, class string, pid int, root_directory string, scope_properties []sd_dbus.Property) error {
+	return c.object.Call(dbusInterface+".CreateMachine", 0, name, id, service, class, uint32(pid), root_directory, scope_properties).Err
+}
+
+// CreateMachineWithNetwork creates the container with its network config with systemd-machined
+func (c *Conn) CreateMachineWithNetwork(name string, id []byte, service string, class string, pid int, root_directory string, ifindices []int, scope_properties []sd_dbus.Property) error {
+	return c.object.Call(dbusInterface+".CreateMachineWithNetwork", 0, name, id, service, class, uint32(pid), root_directory, ifindices, scope_properties).Err
+}
+
 // GetMachine gets a specific container with systemd-machined
 func (c *Conn) GetMachine(name string) (dbus.ObjectPath, error) {
 	return c.getPath("GetMachine", name)
@@ -164,6 +176,11 @@ func (c *Conn) RegisterMachine(name string, id []byte, service string, class str
 	return c.object.Call(dbusInterface+".RegisterMachine", 0, name, id, service, class, uint32(pid), root_directory).Err
 }
 
+// RegisterMachineWithNetwork registers the container with its network with systemd-machined
+func (c *Conn) RegisterMachineWithNetwork(name string, id []byte, service string, class string, pid int, root_directory string, ifindices []int) error {
+	return c.object.Call(dbusInterface+".RegisterMachineWithNetwork", 0, name, id, service, class, uint32(pid), root_directory, ifindices).Err
+}
+
 func machineFromInterfaces(machine []interface{}) (*MachineStatus, error) {
 	if len(machine) < 4 {
 		return nil, fmt.Errorf("invalid number of machine fields: %d", len(machine))

machine1/dbus_test.go

@@ -25,7 +25,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/coreos/go-systemd/dbus"
+	sd_dbus "github.com/coreos/go-systemd/dbus"
+	"github.com/godbus/dbus"
 )
 
 const (
@@ -47,7 +48,7 @@ func mustCreateTestProcess(machineName string) (pid int) {
 	if err != nil {
 		panic(fmt.Errorf("systemd-run failed: %q", out))
 	}
-	dbusConn, err := dbus.New()
+	dbusConn, err := sd_dbus.New()
 	if err != nil {
 		panic(err.Error())
 	}
@@ -61,53 +62,86 @@ func mustCreateTestProcess(machineName string) (pid int) {
 }
 
 func TestMachine(t *testing.T) {
-	machineName := machinePrefix + generateRandomLabel(8)
-	leader := mustCreateTestProcess(machineName)
+	machineNames := []string{
+		machinePrefix + "register-" + generateRandomLabel(8),
+		machinePrefix + "register-with-network-" + generateRandomLabel(8),
+		machinePrefix + "create-" + generateRandomLabel(8),
+		machinePrefix + "create-with-network-" + generateRandomLabel(8),
+	}
+	leaders := []int{
+		mustCreateTestProcess(machineNames[0]),
+		mustCreateTestProcess(machineNames[1]),
+		mustCreateTestProcess(machineNames[2]),
+		mustCreateTestProcess(machineNames[3]),
+	}
 
 	conn, newErr := New()
 	if newErr != nil {
 		t.Fatal(newErr)
 	}
 
-	regErr := conn.RegisterMachine(machineName, nil, "go-systemd", "container", leader, "")
+	regErr := conn.RegisterMachine(machineNames[0], nil, "go-systemd", "container", leaders[0], "")
 	if regErr != nil {
 		t.Fatal(regErr)
 	}
 
-	machine, getErr := conn.GetMachine(machineName)
-	if getErr != nil {
-		t.Fatal(getErr)
+	regWithNetworkErr := conn.RegisterMachineWithNetwork(machineNames[1], nil, "go-systemd", "container", leaders[1], "", nil)
+	if regWithNetworkErr != nil {
+		t.Fatal(regWithNetworkErr)
 	}
-	if len(machine) == 0 {
-		t.Fatalf("did not find machine named %s", machineName)
+
+	createErr := conn.CreateMachine(machineNames[2], nil, "go-systemd", "container", leaders[2], "", nil)
+	if createErr != nil {
+		t.Fatal(createErr)
+	}
+
+	createWithNetworkErr := conn.CreateMachineWithNetwork(machineNames[3], nil, "go-systemd", "container", leaders[3], "", nil, nil)
+	if createWithNetworkErr != nil {
+		t.Fatal(createWithNetworkErr)
+	}
+
+	machines := make([]dbus.ObjectPath, 0)
+	for _, v := range machineNames {
+		machine, getErr := conn.GetMachine(v)
+		if getErr != nil {
+			t.Fatal(getErr)
+		}
+		if machine != "" {
+			machines = append(machines, machine)
+		}
+	}
+	if len(machines) != 4 {
+		t.Fatalf("did not find all machine nameds %s", machineNames)
 	}
 
 	listMachines, getErr := conn.ListMachines()
 	if getErr != nil {
 		t.Fatal(getErr)
 	}
 
-	// listMachines includes also `.host`, so by default the length should be greater than 1
-	if len(listMachines) <= 1 {
+	// listMachines includes also `.host`, so by default the length should be greater than 2
+	if len(listMachines) <= 4 {
 		t.Fatalf("did not find any machine")
 	}
 
-	tErr := conn.TerminateMachine(machineName)
-	if tErr != nil {
-		t.Fatal(tErr)
-	}
-
-	for i := 1; i <= 10; i++ {
-		machine, getErr = conn.GetMachine(machineName)
-		if len(machine) == 0 && getErr != nil {
-			break
+	for _, v := range machineNames {
+		tErr := conn.TerminateMachine(v)
+		if tErr != nil {
+			t.Fatal(tErr)
+		}
+		var machine dbus.ObjectPath
+		for i := 1; i <= 10; i++ {
+			machine, getErr = conn.GetMachine(v)
+			if len(machine) == 0 && getErr != nil {
+				break
+			}
+			time.Sleep(1 * time.Second)
+		}
+		if len(machine) != 0 {
+			t.Fatalf("unexpectedly found machine named %s", v)
+		} else if getErr == nil {
+			t.Fatal("expected error but got nil")
 		}
-		time.Sleep(1 * time.Second)
-	}
-	if len(machine) != 0 {
-		t.Fatalf("unexpectedly found machine named %s", machineName)
-	} else if getErr == nil {
-		t.Fatal("expected error but got nil")
 	}
 }