mirror of
https://github.com/containers/podman.git
synced 2025-11-30 01:58:46 +08:00
0dac214f56
with libhvee, we are able to do the basics of podman machine management on hyperv. The basic functions like init, rm, stop, and start are all functional. Start and stop will periodically throw a benign error processing the hyperv message being returned from the action. The error is described in the todo's below. notable items: * no podman commands will work (like ps, images, etc) * the machine must be initialized with --image-path and fed a custom image. * disk size is set to 100GB statically. * the vm joins the default hyperv network which is TCP/IP network based. * podman machine ssh does not work * podman machine set does not work * you can grab the ip address from hyperv and fake a machine connection with `podman system connection`. * when booting, use the hyperv console to know the boot is complete. TODOs: * podman machine ssh * podman machine set * podman machine rm needs force bool * disk size in NewMachine is set to 100GB * podman start needs to wait until fully booted * establish a boot complete signal from guest * implement gvproxy like user networking * fix benign failures in stop/start -> Error: error 2147749890 (FormatMessage failed with: The system cannot find message text for message number 0x%1 in the message file for %2.) [NO NEW TESTS NEEDED] Signed-off-by: Brent Baude <bbaude@redhat.com>
95 lines
2.9 KiB
Go
95 lines
2.9 KiB
Go
package ole
|
|
|
|
import "unsafe"
|
|
|
|
type IDispatch struct {
|
|
IUnknown
|
|
}
|
|
|
|
type IDispatchVtbl struct {
|
|
IUnknownVtbl
|
|
GetTypeInfoCount uintptr
|
|
GetTypeInfo uintptr
|
|
GetIDsOfNames uintptr
|
|
Invoke uintptr
|
|
}
|
|
|
|
func (v *IDispatch) VTable() *IDispatchVtbl {
|
|
return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable))
|
|
}
|
|
|
|
func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) {
|
|
dispid, err = getIDsOfName(v, names)
|
|
return
|
|
}
|
|
|
|
func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
|
|
result, err = invoke(v, dispid, dispatch, params...)
|
|
return
|
|
}
|
|
|
|
func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) {
|
|
c, err = getTypeInfoCount(v)
|
|
return
|
|
}
|
|
|
|
func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) {
|
|
tinfo, err = getTypeInfo(v)
|
|
return
|
|
}
|
|
|
|
// GetSingleIDOfName is a helper that returns single display ID for IDispatch name.
|
|
//
|
|
// This replaces the common pattern of attempting to get a single name from the list of available
|
|
// IDs. It gives the first ID, if it is available.
|
|
func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) {
|
|
var displayIDs []int32
|
|
displayIDs, err = v.GetIDsOfName([]string{name})
|
|
if err != nil {
|
|
return
|
|
}
|
|
displayID = displayIDs[0]
|
|
return
|
|
}
|
|
|
|
// InvokeWithOptionalArgs accepts arguments as an array, works like Invoke.
|
|
//
|
|
// Accepts name and will attempt to retrieve Display ID to pass to Invoke.
|
|
//
|
|
// Passing params as an array is a workaround that could be fixed in later versions of Go that
|
|
// prevent passing empty params. During testing it was discovered that this is an acceptable way of
|
|
// getting around not being able to pass params normally.
|
|
func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) {
|
|
displayID, err := v.GetSingleIDOfName(name)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if len(params) < 1 {
|
|
result, err = v.Invoke(displayID, dispatch)
|
|
} else {
|
|
result, err = v.Invoke(displayID, dispatch, params...)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// CallMethod invokes named function with arguments on object.
|
|
func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) {
|
|
return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params)
|
|
}
|
|
|
|
// GetProperty retrieves the property with the name with the ability to pass arguments.
|
|
//
|
|
// Most of the time you will not need to pass arguments as most objects do not allow for this
|
|
// feature. Or at least, should not allow for this feature. Some servers don't follow best practices
|
|
// and this is provided for those edge cases.
|
|
func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) {
|
|
return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params)
|
|
}
|
|
|
|
// PutProperty attempts to mutate a property in the object.
|
|
func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) {
|
|
return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params)
|
|
}
|