public void QueryMachines()
{
List <VagrantMachine> machines = new List <VagrantMachine>();
if (this.HasVagrantFile())
{
Process p = new Process {
StartInfo = new ProcessStartInfo {
FileName = "cmd",
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true,
Arguments = String.Format("/C cd /d {0} && vagrant status", Util.EscapeShellArg(_Path)),
UseShellExecute = false,
RedirectStandardOutput = true,
}
};
p.Start();
string outputString = p.StandardOutput.ReadToEnd();
p.WaitForExit();
Regex regex = new Regex("([\\w-_\\.]+)\\s+([\\w\\s]+) \\(\\w+\\)");
MatchCollection matchCollection = regex.Matches(outputString);
foreach (Match match in matchCollection)
{
VagrantMachine machine = new VagrantMachine(this, Util.TrimWhitespaceAndNewlines(match.Groups[1].Value), VagrantMachineState.UnknownState);
machine.StateString = Util.TrimWhitespaceAndNewlines(match.Groups[2].Value);
machines.Add(machine);
}
}
_Machines = machines;
}
public VagrantMachine(VagrantInstance instance, string name, VagrantMachineState state)
{
Instance = instance;
Name = name;
State = state;
StateString = VagrantMachine.GetStringForState(state);
}
public void QueryMachines() {
List<VagrantMachine> machines = new List<VagrantMachine>();
if (this.HasVagrantFile()) {
Process p = new Process {
StartInfo = new ProcessStartInfo {
FileName = "cmd",
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true,
Arguments = String.Format("/C cd /d {0} && vagrant status", Util.EscapeShellArg(_Path)),
UseShellExecute = false,
RedirectStandardOutput = true,
}
};
p.Start();
p.WaitForExit();
string outputString = p.StandardOutput.ReadToEnd();
Regex regex = new Regex("([\\w-_\\.]+)\\s+([\\w\\s]+) \\(\\w+\\)");
MatchCollection matchCollection = regex.Matches(outputString);
foreach (Match match in matchCollection) {
VagrantMachine machine = new VagrantMachine(this, Util.TrimWhitespaceAndNewlines(match.Groups[1].Value), VagrantMachineState.UnknownState);
machine.StateString = Util.TrimWhitespaceAndNewlines(match.Groups[2].Value);
machines.Add(machine);
}
}
_Machines = machines;
}
private void RunVagrantAction(string action, VagrantMachine machine)
{
string command;
if (action == "up")
{
command = String.Format("vagrant up{0}", !String.IsNullOrEmpty(machine.Instance.ProviderIdentifier) ? String.Format(" --provider={0}", machine.Instance.ProviderIdentifier) : "virtualbox");
}
else if (action == "reload")
{
command = "vagrant reload";
}
else if (action == "suspend")
{
command = "vagrant suspend";
}
else if (action == "halt")
{
command = "vagrant halt";
}
else if (action == "provision")
{
command = "vagrant provision";
}
else if (action == "destroy")
{
command = "vagrant destroy -f";
}
else {
return;
}
Process process = new Process();
process.StartInfo.FileName = "cmd";
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.Arguments = String.Format("/C cd /d {0} && {1} {2}", Util.EscapeShellArg(machine.Instance.Path), command, Util.EscapeShellArg(machine.Name));
TaskOutputWindow outputWindow = new TaskOutputWindow();
outputWindow.Task = process;
outputWindow.TaskCommand = process.StartInfo.Arguments;
outputWindow.TaskAction = command;
outputWindow.Target = machine;
outputWindow.Show();
_TaskOutputWindows.Add(outputWindow);
}
public void PerformVagrantAction(string action, VagrantMachine machine)
{
if (action == "ssh")
{
action = String.Format("cd /d {0} && vagrant ssh {1}", Util.EscapeShellArg(machine.Instance.Path), machine.Name);
this.RunTerminalCommand(action);
}
else {
this.RunVagrantAction(action, machine);
}
}
private void PerformAction(string action, VagrantMachine machine)
{
Delegate.PerformVagrantAction(action, machine);
}
public void NativeMenuItemProvisionMachine(VagrantMachine machine)
{
this.PerformAction("provision", machine);
}
public void NativeMenuItemDestroyMachine(VagrantMachine machine)
{
DialogResult dialogResult = MessageBox.Show("Are you sure you want to destroy this machine?", "Confirm Destructive Action", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
this.PerformAction("destroy", machine);
}
}
public void NativeMenuItemHaltMachine(VagrantMachine machine)
{
this.PerformAction("halt", machine);
}
public void NativeMenuItemReloadMachine(VagrantMachine machine)
{
this.PerformAction("reload", machine);
}
public void NativeMenuItemSuspendMachine(VagrantMachine machine)
{
this.PerformAction("suspend", machine);
}
public void NativeMenuItemSSHMachine(VagrantMachine machine)
{
this.PerformAction("ssh", machine);
}
public void NativeMenuItemUpMachine(VagrantMachine machine)
{
this.PerformAction("up", machine);
}
public void RefreshInstances()
{
List <VagrantInstance> instances = new List <VagrantInstance>();
// create instance for each bookmark
List <Bookmark> bookmarks = BookmarkManager.Instance.GetBookmarks();
bookmarks.ForEach(bookmark => instances.Add(new VagrantInstance(bookmark.Path, bookmark.ProviderIdentifier, bookmark.DisplayName)));
List <string> allPaths = new List <string>();
// scan vagrant global-status output
VagrantGlobalStatusScanner globalStatusScanner = new VagrantGlobalStatusScanner();
Array.ForEach(globalStatusScanner.GetInstancePaths(), (path) => {
if (BookmarkManager.Instance.GetBookmarkWithPath(path) == null && !allPaths.Contains(path))
{
allPaths.Add(path);
instances.Add(new VagrantInstance(path, null));
}
});
// create instance for each detected path
Dictionary <string, string[]> detectedPaths = this.DetectInstancePaths();
detectedPaths.Keys.ToList().ForEach(providerIdentifier => {
string[] paths = detectedPaths[providerIdentifier];
paths.ToList().ForEach(path => {
if (BookmarkManager.Instance.GetBookmarkWithPath(path) == null && !allPaths.Contains(path))
{
allPaths.Add(path);
instances.Add(new VagrantInstance(path, providerIdentifier));
}
});
});
List <string> validPaths = new List <string>();
List <Task> tasks = new List <Task>();
instances.ForEach(instance => {
Task task = Task.Run(() => {
instance.QueryMachines();
lock (_Instances) {
VagrantInstance existingInstance = this.GetInstanceForPath(instance.Path);
if (existingInstance != null)
{
// instance already exists, check for changes
int idx = _Instances.IndexOf(existingInstance);
if (instance.Machines.Length != existingInstance.Machines.Length || existingInstance.DisplayName != instance.DisplayName || existingInstance.ProviderIdentifier != instance.ProviderIdentifier)
{
_Instances[idx] = instance;
Delegate.InstanceUpdated(this, existingInstance, instance);
}
else
{
Array.ForEach(instance.Machines, machine => {
VagrantMachine existingMachine = existingInstance.GetMachineWithName(machine.Name);
if (existingMachine == null || existingMachine.StateString != machine.StateString)
{
_Instances[idx] = instance;
Delegate.InstanceUpdated(this, existingInstance, instance);
}
});
}
}
else
{
//new instance
_Instances.Add(instance);
Delegate.InstanceAdded(this, instance);
}
validPaths.Add(instance.Path);
}
});
tasks.Add(task);
});
Task.WaitAll(tasks.ToArray());
for (int i = _Instances.Count - 1; i >= 0; --i)
{
VagrantInstance instance = _Instances.ElementAt(i);
if (!validPaths.Contains(instance.Path))
{
_Instances.RemoveAt(i);
Delegate.InstanceRemoved(this, instance);
}
}
}
