xenadmin/XenAdmin/TabPages/DockerDetailsPage.cs

/* Copyright (c) Citrix Systems Inc. 
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, 
 * with or without modification, are permitted provided 
 * that the following conditions are met: 
 * 
 * *   Redistributions of source code must retain the above 
 *     copyright notice, this list of conditions and the 
 *     following disclaimer. 
 * *   Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the 
 *     following disclaimer in the documentation and/or other 
 *     materials provided with the distribution. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
 * SUCH DAMAGE.
 */

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using XenAdmin.Actions;
using XenAPI;
using XenAdmin.Model;
using System.Xml;
using System.Collections;

namespace XenAdmin.TabPages
{
    public partial class DockerDetailsPage : BaseTabPage
    {
        private const int REFRESH_INTERVAL = 20000;

        private IXenObject _xenObject;
        private VM _vmResideOn;
        private Host _hostResideOn;
        private string _resultCache;

        public IXenObject XenObject
        {
            get
            {
                Program.AssertOnEventThread();
                return _xenObject;
            }
            set
            {
                Program.AssertOnEventThread();

                if (value == null)
                    return;

                if (_xenObject != value)
                {
                    _xenObject = value;
                    if (_xenObject is DockerContainer)
                    {
                        var container = _xenObject as DockerContainer;

                        _vmResideOn = container.Parent;
                        if (_vmResideOn.resident_on == null || string.IsNullOrEmpty(_vmResideOn.resident_on.opaque_ref) || (_vmResideOn.resident_on.opaque_ref.ToLower().Contains("null")))
                            return;

                        _hostResideOn = container.Connection.Resolve(_vmResideOn.resident_on);
                        RefreshTime.Text = Messages.LAST_REFRESH_IN_PROGRESS;
                        StartUpdating();
                    }
                }
            }
        }

        private void StartUpdating()
        {
            var args = new Dictionary<string, string>();
            args["vmuuid"] = _vmResideOn.uuid;
            args["object"] = ((DockerContainer)_xenObject).uuid;

            var action = new ExecutePluginAction(_xenObject.Connection, _hostResideOn,
                        "xscontainer", "get_inspect", args, true);

            action.Completed += action_Completed;
            action.RunAsync();
        }

        private void action_Completed(ActionBase sender)
        {
            var action = (AsyncAction)sender;
            Program.Invoke(Program.MainWindow, () =>
            {
                if (action.Succeeded)
                    Rebuild(action.Result);
                else
                    ShowInvalidInfo();
            });
        }

        private void CreateTree(XmlNode node, TreeNode rootNode)
        {
            Program.AssertOnEventThread();

            if (node.NodeType == XmlNodeType.Text)
                rootNode.Text = node.Value;
            else
            {
                if (node.Name == "SPECIAL_XS_ENCODED_ELEMENT" && node.Attributes != null)
                {
                    rootNode.Text = node.Attributes["name"].Value;
                }
                else
                    rootNode.Text = node.Name;
            }
            IEnumerator ienum = node.GetEnumerator();
            while (ienum.MoveNext())
            {
                XmlNode current = (XmlNode)ienum.Current;
                TreeNode currentNode = new TreeNode();
                CreateTree(current, currentNode);
                rootNode.Nodes.Add(currentNode);
            }
        }

        public void Rebuild(string currentResult)
        {
            Program.AssertOnEventThread();
            RefreshTime.Text = String.Format(Messages.LAST_REFRESH_SUCCESS, DateTime.Now.ToString("HH:mm:ss"));
            try
            {
                if (_resultCache == currentResult)
                    return;
                _resultCache = currentResult;
                DetailtreeView.Nodes.Clear();

                XmlDocument doc = new XmlDocument();
                doc.LoadXml(currentResult);
                IEnumerator ienum = doc.GetEnumerator();
                XmlNode docker_inspect;
                while (ienum.MoveNext())
                {
                    docker_inspect = (XmlNode) ienum.Current;
                    if (docker_inspect.NodeType != XmlNodeType.XmlDeclaration)
                    {
                        TreeNode rootNode = new TreeNode();
                        CreateTree(docker_inspect, rootNode);
                        DetailtreeView.Nodes.Add(rootNode);
                    }
                }
            }
            catch (Failure)
            {
                ShowInvalidInfo();
            }
        }

        public DockerDetailsPage()
        {
            InitializeComponent();
            base.Text = Messages.DOCKER_DETAIL_TAB_TITLE;
            RefreshTimer.Interval = REFRESH_INTERVAL;
        }

        private void ShowInvalidInfo()
        {
            RefreshTime.Text = Messages.LAST_REFRESH_FAIL;
            DetailtreeView.Nodes.Clear();
        }

        private void RefreshButton_Click(object sender, EventArgs e)
        {
            StartUpdating();
        }

        public void PauseRefresh()
        {
            RefreshTimer.Enabled = false;
        }

        public void ResumeRefresh()
        {
            RefreshTimer.Enabled = true;
        }
    }
}