public VmNameId CloneVm(VmId original, string newName)
{
var guid = Guid.NewGuid().ToString(); return(CloneVm(original, new VmNameId()
{
Name = newName, Guid = guid
}));
}
public void ModifyVmDeleteNatPortForward(VmId vm, int natNo, string ruleName)
{
if (vm == null)
{
throw new ArgumentNullException(nameof(vm), nameof(ModifyVmDeleteNatPortForward) + " requires a target to delete from");
}
if (vm == "")
{
throw new ArgumentException(nameof(ModifyVmDeleteNatPortForward) + " requires a target to delete from", nameof(vm));
}
if (natNo < 1)
{
throw new ArgumentOutOfRangeException(nameof(natNo), natNo, "natNo is 1-based");
}
if (ruleName == null)
{
throw new ArgumentNullException(nameof(ruleName), nameof(ModifyVmDeleteNatPortForward) + " requires a ruleName to delete");
}
if (ruleName == "")
{
throw new ArgumentException(nameof(ModifyVmDeleteNatPortForward) + " requires a ruleName to delete", nameof(ruleName));
}
var exit = Proc.ExecIn(null, VBoxManagePath, $"modifyvm {vm} --natpf{natNo} delete \"{ruleName}\"", stdout => { }, stderr => { }, ProcessWindowStyle.Hidden);
if (exit != 0)
{
throw new ToolResultSyntaxException("VBoxManage modifyvm .... --natpf...", "Returned nonzero");
}
}
public VmNameId CloneVm(VmId original)
{
var guid = Guid.NewGuid().ToString(); return(CloneVm(original, new VmNameId()
{
Name = $"Clone of {original} {guid}", Guid = guid
}));
}
public void StartVm(VmId vm, StartVmType type)
{
var typeFlag = "";
switch (type)
{
case StartVmType.Default: break;
case StartVmType.Gui: typeFlag = "--type=gui"; break;
case StartVmType.Headless: typeFlag = "--type=headless"; break;
case StartVmType.Sdl: typeFlag = "--type=sdl"; break;
case StartVmType.Separate: typeFlag = "--type=separate"; break;
}
// Typical stdout:
// Waiting for VM "OpenBSD 64-bit" to power on...
// VM "OpenBSD 64-bit" has been successfully started.
// Note that the system has not finished booting by the time this returns!
var exit = Proc.ExecIn(null, VBoxManagePath, $"startvm {vm} {typeFlag}", stdout => { }, stderr => { }, ProcessWindowStyle.Hidden);
if (exit != 0)
{
throw new ToolResultSyntaxException("VBoxManage startvm ...", "Returned nonzero");
}
}
public void ModifyVmNatPortForward(VmId vm, int natNo, string ruleName, PortType portType, string hostIp, int hostPort, string guestIp, int guestPort)
{
if (vm == null)
{
throw new ArgumentNullException(nameof(vm), nameof(ModifyVmNatPortForward) + " requires a target");
}
if (vm == "")
{
throw new ArgumentException(nameof(ModifyVmNatPortForward) + " requires a target", nameof(vm));
}
if (natNo < 1)
{
throw new ArgumentOutOfRangeException(nameof(natNo), natNo, "natNo is 1-based");
}
ruleName = ruleName ?? "";
hostIp = hostIp ?? "";
guestIp = guestIp ?? "";
var rule = $"{ruleName},{portType.ToString().ToLowerInvariant()},{hostIp},{hostPort},{guestIp},{guestPort}";
var exit = Proc.ExecIn(null, VBoxManagePath, $"modifyvm {vm} --natpf{natNo} \"{rule}\"", stdout => { }, stderr => { }, ProcessWindowStyle.Hidden);
if (exit != 0)
{
throw new ToolResultSyntaxException("VBoxManage modifyvm .... --natpf...", "Returned nonzero");
}
}
public Dictionary <string, string> TryVmInfoDictionary(VmId vm)
{
var d = new Dictionary <string, string>(); foreach (var kv in TryVmInfo(vm))
{
d.Add(kv.Key, kv.Value);
}
return(d);
}
public void DeleteVm(VmId vm)
{
if (VBoxManagePath == null)
{
throw new MissingToolException("VBoxManage", VBoxManage_Paths);
}
// TODO: More streamy stdout parser so we can sanely parse:
// 0%...10%...20%...30%...40%...50%...60%...70%...80%...90%...100%
var exit = Proc.ExecIn(null, VBoxManagePath, $"unregistervm --delete {vm}", stdout => { }, stderr => { }, ProcessWindowStyle.Hidden);
if (exit != 0)
{
throw new ToolResultSyntaxException("VBoxManage unregistervm --delete ...", "Returned nonzero");
}
}
public VmNameId CloneVm(VmId original, VmNameId clone)
{
if (VBoxManagePath == null)
{
throw new MissingToolException("VBoxManage", VBoxManage_Paths);
}
// TODO: More streamy stdout parser so we can sanely parse:
// 0%...10%...20%...30%...40%...50%...60%...70%...80%...90%...100%
// Machine has been successfully cloned as "Name"
var exit = Proc.ExecIn(null, VBoxManagePath, $"clonevm {original} --register --uuid {clone.Guid} --name \"{clone.Name}\"", stdout => { }, stderr => { }, ProcessWindowStyle.Hidden);
if (exit != 0)
{
throw new ToolResultSyntaxException("VBoxManage clonevm ...", "Returned nonzero");
}
return(clone);
}
public override SocketAddress Serialize()
{
var sockAddress = new SocketAddress(AF_HYPERV, HYPERV_SOCK_ADDR_SIZE);
void Copy(byte[] source, int offset)
{
for (int i = 0; i < source.Length; i++)
{
sockAddress[offset + i] = source[i];
}
}
sockAddress[2] = (byte)0;
Copy(VmId.ToByteArray(), 4);
Copy(ServiceId.ToByteArray(), 20);
return(sockAddress);
}
public void ControlVm(VmId vm, ControlVmType type)
{
string args = null;
switch (type)
{
case ControlVmType.AcpiPowerButton: args = $"controlvm {vm} acpipowerbutton"; break;
case ControlVmType.PowerOff: args = $"controlvm {vm} poweroff"; break;
}
if (args == null)
{
throw new ArgumentOutOfRangeException(nameof(type), "ControlVm passed invalid ControlVmType enumeration value");
}
var exit = Proc.ExecIn(null, VBoxManagePath, args, stdout => { }, stderr => { }, ProcessWindowStyle.Hidden);
if (exit != 0)
{
throw new ToolResultSyntaxException("VBoxManage controlvm ...", "Returned nonzero");
}
}
public bool TryDeleteVm(VmId target)
{
try { DeleteVm(target); return(true); } catch (VmManagementException) { return(false); }
}
public IEnumerable <KeyValuePair <string, string> > TryVmInfo(VmId vm)
{
try { return(VmInfo(vm)); }
catch (MissingToolException) { return(new KeyValuePair <string, string> [0]); }
catch (ToolResultSyntaxException) { return(new KeyValuePair <string, string> [0]); }
}
public bool TryControlVm(VmId vm, ControlVmType type)
{
try { ControlVm(vm, type); return(true); } catch (VmManagementException) { return(false); }
}
public override int GetHashCode() => ServiceId.GetHashCode() ^ VmId.GetHashCode();
public VmNameId TryCloneVm(VmId original, VmNameId clone)
{
try { return(CloneVm(original, clone)); } catch (VmManagementException) { return(default(VmNameId)); }
}
public void StartVm(VmId vm)
{
StartVm(vm, StartVmType.Default);
}
public IEnumerable <KeyValuePair <string, string> > VmInfo(VmId vm)
{
if (VBoxManagePath == null)
{
throw new MissingToolException("VBoxManage", VBoxManage_Paths);
}
var results = new List <KeyValuePair <string, string> >();
var ambiguous = new List <string>();
// Parse the first half of the key/value pairs - e.g. before the possibly multi-line description key/value pair.
var preDescription = true;
var exit = Proc.ExecIn(null, VBoxManagePath, "showvminfo --machinereadable " + vm, stdout => {
if (preDescription)
{
var m = reShowVmInfo_SimpleKeyValue.Match(stdout);
if (m.Success)
{
results.Add(new KeyValuePair <string, string>(m.Groups["key"].Value, m.Groups["value"].Value));
}
else if (!stdout.StartsWith("description=\""))
{
throw new ToolResultSyntaxException("VBoxManage showvminfo --machinereadable ...", "Failed to match line before 'description' field with simple key/value pair");
}
else
{
preDescription = false;
}
}
if (!preDescription)
{
ambiguous.Add(stdout);
}
}, stderr => { }, ProcessWindowStyle.Hidden);
var revResults = new List <KeyValuePair <string, string> >();
// Parse the second half of the key/value pairs - e.g. everything after the possibly multi-line description key/value pair.
for (int i = ambiguous.Count; i-- > 0;)
{
var stdout = ambiguous[i];
var m = reShowVmInfo_SimpleKeyValue.Match(stdout);
if (m.Success)
{
revResults.Add(new KeyValuePair <string, string>(m.Groups["key"].Value, m.Groups["value"].Value));
}
else
{
ambiguous.RemoveRange(i + 1, ambiguous.Count - i - 1);
break;
}
}
// Hopefully 'ambiguous' is now only the description="..." field. however, this is fundamentlaly an ambiguous parsing problem. Boo!
if (ambiguous.Count > 0)
{
var firstLine = ambiguous[0];
var prefix = "description=\"";
if (!firstLine.StartsWith(prefix))
{
throw new ToolResultSyntaxException("VBoxManage showvminfo --machinereadable ...", "Remaining 'ambiguous' lines should be the start of a description - instead got '" + firstLine + "'");
}
ambiguous[0] = firstLine = firstLine.Substring(prefix.Length); // Trim prefix description="
var lastLine = ambiguous[ambiguous.Count - 1];
if (!lastLine.EndsWith("\""))
{
throw new ToolResultSyntaxException("VBoxManage showvminfo --machinereadable ...", "Remaining 'ambiguous' lines should end with a quote terminating the description field - instead got '" + lastLine + "'");
}
ambiguous[ambiguous.Count - 1] = lastLine = lastLine.Substring(0, lastLine.Length - 1); // Trim final quote mark
results.Add(new KeyValuePair <string, string>("description", string.Join("\n", ambiguous)));
}
var needCapacity = results.Count + revResults.Count;
if (results.Capacity < needCapacity)
{
results.Capacity = needCapacity;
}
for (int i = revResults.Count; i-- > 0;)
{
results.Add(revResults[i]);
}
return(results);
}
public bool TryStartVm(VmId vm, StartVmType type)
{
try { StartVm(vm, type); return(true); } catch (VmManagementException) { return(false); }
}
public override int GetHashCode()
{
int hash = 1;
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (Id.Length != 0)
{
hash ^= Id.GetHashCode();
}
if (AppEngineRelease.Length != 0)
{
hash ^= AppEngineRelease.GetHashCode();
}
if (Availability != global::Google.Cloud.AppEngine.V1.Instance.Types.Availability.Unspecified)
{
hash ^= Availability.GetHashCode();
}
if (VmName.Length != 0)
{
hash ^= VmName.GetHashCode();
}
if (VmZoneName.Length != 0)
{
hash ^= VmZoneName.GetHashCode();
}
if (VmId.Length != 0)
{
hash ^= VmId.GetHashCode();
}
if (startTime_ != null)
{
hash ^= StartTime.GetHashCode();
}
if (Requests != 0)
{
hash ^= Requests.GetHashCode();
}
if (Errors != 0)
{
hash ^= Errors.GetHashCode();
}
if (Qps != 0F)
{
hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Qps);
}
if (AverageLatency != 0)
{
hash ^= AverageLatency.GetHashCode();
}
if (MemoryUsage != 0L)
{
hash ^= MemoryUsage.GetHashCode();
}
if (VmStatus.Length != 0)
{
hash ^= VmStatus.GetHashCode();
}
if (VmDebugEnabled != false)
{
hash ^= VmDebugEnabled.GetHashCode();
}
if (VmIp.Length != 0)
{
hash ^= VmIp.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
