FISLib_Old/Vinno.vCloud.Common.FIS/Test/RemedicalServiceTest.cs

using System;
using System.IO;
using Vinno.IUS.Common.Log;
using Vinno.IUS.Common.Network.Leaf;
using Vinno.IUS.Common.Network.Tcp;
using Vinno.IUS.Common.Network.Transfer;
using Vinno.vCloud.Common.Storage;
using Vinno.vCloud.Common.Storage.ObjectStorageInfo;
using Vinno.vCloud.Common.Storage.Upload;
using Vinno.vCloud.Protocol.Messages.Terminal.Remedical;

namespace Vinno.vCloud.Common.FIS.Test
{
    public class RemedicalServiceTest : VCloudTestItem
    {
        private static readonly string _remedicalServiceTestError1 = "RemedicalServiceTestError1";
        private static readonly string _remedicalServiceTestError2 = "RemedicalServiceTestError2";
        private static readonly string _remedicalServiceTestError3 = "RemedicalServiceTestError3";

        private ITcpCreator _tcpCreator;
        private int _port;

        private StorageInfo _terminalStorageInfo;
        private object _terminalStorageInfoLocker = new object();

        public bool IsEnable => VCloudServiceTest.EnableRemedicalService;

        public RemedicalServiceTest(VCloudServiceTest vCloudServiceTest) : base("RemedicalService", vCloudServiceTest)
        {
        }

        ~RemedicalServiceTest()
        {
            lock (_terminalStorageInfoLocker)
            {
                _terminalStorageInfo = null;
            }
        }

        public override VCloudServiceTestResult Execute()
        {
            //Check if remedical service enabled
            if (!IsEnable)
            {
                return new VCloudServiceTestResult(Id, VCloudTestItemStatus.CanSkipped, _remedicalServiceTestError1, "(201)");//ErrorCode=201
            }

            //Check remedical service url
            var result = TimeoutExecute(CheckRemedicalServiceUrl);
            if (result == VCloudSubItemTestStatus.Timeout)
            {
                return new VCloudServiceTestResult(Id, VCloudTestItemStatus.TestFailed, TimeoutError, "(202)");//ErrorCode=202
            }

            if (result == VCloudSubItemTestStatus.Failed)
            {
                return new VCloudServiceTestResult(Id, VCloudTestItemStatus.TestFailed, _remedicalServiceTestError2, "(203)");//ErrorCode=203
            }

            //Check if can store file to remedical storage server
            result = TimeoutExecute(CheckRemedicalStorageServer, 10000);
            if (result == VCloudSubItemTestStatus.Timeout)
            {
                return new VCloudServiceTestResult(Id, VCloudTestItemStatus.TestFailed, TimeoutError, "(204)");//ErrorCode=204
            }

            if (result == VCloudSubItemTestStatus.Failed)
            {
                return new VCloudServiceTestResult(Id, VCloudTestItemStatus.TestFailed, _remedicalServiceTestError3, _port);
            }

            return new VCloudServiceTestResult(Id, VCloudTestItemStatus.TestDone);
        }

        private VCloudSubItemTestStatus CheckRemedicalStorageServer()
        {
            var testFile = Path.Combine(VCloudServiceTest.WorkingFolder, "RemedicalTest");
            File.WriteAllText(testFile, "Just test for remedical storage!");
            var storageInfo = GetRemdicalStorageInfo();
            var fileToken = UploadHelper.UploadFile(storageInfo, testFile, string.Empty);
            if (string.IsNullOrEmpty(fileToken))
            {
                return VCloudSubItemTestStatus.Failed;
            }

            return VCloudSubItemTestStatus.Successful;
        }

        private VCloudSubItemTestStatus CheckRemedicalServiceUrl()
        {
            _tcpCreator = null;
            var remedicalServiceUrl = string.Empty;
            var leaf = VCloudServiceTest.GetvCloudLeaf();
            using (var request = MessagePool.GetMessage<GetTerminalDataTargetUrlRequest>())
            {
                var getTerminalDataTargetUrlResult = GetTerminalDataTargetUrlResult.Convert(leaf.Send(request));
                if (getTerminalDataTargetUrlResult != null)
                {
                    remedicalServiceUrl = getTerminalDataTargetUrlResult.ServerUrl;
                }
            }

            if (string.IsNullOrEmpty(remedicalServiceUrl))
            {
                return VCloudSubItemTestStatus.Failed;
            }

            var tempValue = remedicalServiceUrl.Split(':');
            _port = 80;
            if (tempValue.Length == 2)
            {
                _port = int.Parse(tempValue[1]);
            }
            var serverAddress = tempValue[0];
            TcpCreator tcpCreator = null;
            try
            {
                tcpCreator = new TcpCreator(serverAddress, _port);
            }
            catch (Exception e)
            {
                Logger.WriteLineInfo($"RemedicalSericeTest - TcpCreator ex:{e}");
            }

            if (tcpCreator == null)
            {
                return VCloudSubItemTestStatus.Failed;
            }

            _tcpCreator = tcpCreator;
            return VCloudSubItemTestStatus.Successful;
        }

        private StorageInfo GetRemdicalStorageInfo()
        {
            lock (_terminalStorageInfoLocker)
            {
                if (_terminalStorageInfo == null)
                {
                    using (var request = MessagePool.GetMessage<GetTerminalvCloudStorageInfoRequest>())
                    {
                        var leaf = VCloudServiceTest.GetvCloudLeaf();
                        request.TerminalVersion = VCloudServiceTest.TerminalVersion;
                        var result = leaf.Send(request);
                        var getDisplayServerInfoResult = GetTerminalvCloudStorageInfoResult.Convert(result);
                        if (getDisplayServerInfoResult != null)
                        {
                            var url = getDisplayServerInfoResult.StorageServerUrl;
                            var storageType = getDisplayServerInfoResult.StorageType;
                            var config = getDisplayServerInfoResult.CloudConfig;
                            _terminalStorageInfo = new StorageInfo()
                            {
                                Url = url,
                                StorageType = storageType,
                                Config = config
                            };
                            NodeMapping.NodeMappingInilization(_terminalStorageInfo.StorageNodeItems);
                        }
                    }
                }
                return _terminalStorageInfo;
            }
        }
    }
}