private void Common_action_Completed(ActionBase sender)
        {
            Program.Invoke(this, delegate()
            {
                if (cancelled)
                {
                    return;
                }

                GetSystemStatusCapabilities caps = sender as GetSystemStatusCapabilities;
                if (caps == null)
                {
                    return;
                }

                hostCapabilities[caps.Host] =
                    caps.Succeeded ? parseXMLToList(caps) : null;

                if (hostCapabilities.Count >= _hostList.Count)
                {
                    dialog.Close();
                    CombineCapabilitiesLists();
                }
            });
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="HostList"></param>
        /// <returns>If success of not - false with stop moving to next page</returns>
        public bool GetCommonCapabilities(List <Host> HostList)
        {
            if (!cancelled && Helpers.ListsContentsEqual <Host>(_hostList, HostList))
            {
                return(true);
            }

            _hostList = HostList;
            dataGridViewItems.Rows.Clear();

            if (dialog != null && dialog.Visible)
            {
                dialog.Close();
            }

            hostCapabilities      = new Dictionary <Host, List <Capability> >();
            actions               = new List <GetSystemStatusCapabilities>();
            cancelled             = false;
            dialog                = new ActionProgressDialog(Messages.SERVER_STATUS_REPORT_GET_CAPABILITIES);
            dialog.ShowCancel     = true;
            dialog.CancelClicked += new EventHandler(dialog_CancelClicked);

            foreach (Host host in _hostList)
            {
                GetSystemStatusCapabilities action = new GetSystemStatusCapabilities(host);
                actions.Add(action);
                action.Completed += Common_action_Completed;
                action.RunAsync();
            }

            if (_hostList.Count > 0)
            {
                dialog.ShowDialog(this);
            }

            return(!cancelled);
        }
        public void RunBugtool(IXenConnection connection, Session session)
        {
            if (connection == null || session == null)
            {
                return;
            }

            // Fetch the common capabilities of all hosts.
            Dictionary <Host, List <string> > hostCapabilities = new Dictionary <Host, List <string> >();

            foreach (Host host in connection.Cache.Hosts)
            {
                GetSystemStatusCapabilities action = new GetSystemStatusCapabilities(host);
                action.RunExternal(session);
                if (!action.Succeeded)
                {
                    return;
                }

                List <string> keys = new List <string>();
                XmlDocument   doc  = new XmlDocument();
                doc.LoadXml(action.Result);
                foreach (XmlNode node in doc.GetElementsByTagName("capability"))
                {
                    foreach (XmlAttribute a in node.Attributes)
                    {
                        if (a.Name == "key")
                        {
                            keys.Add(a.Value);
                        }
                    }
                }
                hostCapabilities[host] = keys;
            }

            List <string> combination = null;

            foreach (List <string> capabilities in hostCapabilities.Values)
            {
                if (capabilities == null)
                {
                    continue;
                }

                if (combination == null)
                {
                    combination = capabilities;
                    continue;
                }

                combination = Helpers.ListsCommonItems <string>(combination, capabilities);
            }

            if (combination == null || combination.Count <= 0)
            {
                return;
            }

            // The list of the reports which are required in Health Check Report.
            List <string> reportIncluded = combination.Except(reportExcluded).ToList();

            // Verbosity works for xen-bugtool since Dundee.
            if (Helpers.DundeeOrGreater(connection))
            {
                List <string> verbReport = new List <string>(reportWithVerbosity.Keys);
                int           idx        = -1;
                for (int x = 0; x < verbReport.Count; x++)
                {
                    idx = reportIncluded.IndexOf(verbReport[x]);
                    if (idx >= 0)
                    {
                        reportIncluded[idx] = reportIncluded[idx] + ":" + reportWithVerbosity[verbReport[x]].ToString();
                    }
                }
            }

            // Ensure downloaded filenames are unique even for hosts with the same hostname: append a counter to the timestring
            string filepath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

            if (Directory.Exists(filepath))
            {
                Directory.Delete(filepath);
            }
            Directory.CreateDirectory(filepath);

            string timestring = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");

            // Collect all master/slave information to output as a separate text file with the report
            List <string> mastersInfo = new List <string>();

            int  i = 0;
            Pool p = Helpers.GetPool(connection);

            foreach (Host host in connection.Cache.Hosts)
            {
                // master/slave information
                if (p == null)
                {
                    mastersInfo.Add(string.Format("Server '{0}' is a stand alone server",
                                                  host.Name));
                }
                else
                {
                    mastersInfo.Add(string.Format("Server '{0}' is a {1} of pool '{2}'",
                                                  host.Name,
                                                  p.master.opaque_ref == host.opaque_ref ? "master" : "slave",
                                                  p.Name));
                }

                HostWithStatus         hostWithStatus = new HostWithStatus(host, 0);
                SingleHostStatusAction statAction     = new SingleHostStatusAction(hostWithStatus, reportIncluded, filepath, timestring + "-" + ++i);
                statAction.RunExternal(session);
            }

            // output the slave/master info
            string mastersDestination = string.Format("{0}\\{1}-Masters.txt", filepath, timestring);

            WriteExtraInfoToFile(mastersInfo, mastersDestination);

            // output the XenCenter metadata
            var    metadata            = XenAdminConfigManager.Provider.GetXenCenterMetadata(false);
            string metadataDestination = string.Format("{0}\\{1}-Metadata.json", filepath, timestring);

            WriteExtraInfoToFile(new List <string> {
                metadata
            }, metadataDestination);

            // Finish the collection of logs with bugtool.
            // Start to zip the files.
            ZipStatusReportAction zipAction = new ZipStatusReportAction(filepath, outputFile);

            zipAction.RunExternal(session);
            log.InfoFormat("Server Status Report is collected: {0}", outputFile);
        }