コード例 #1
0
        /// <summary>
        /// Loads the specified data.
        /// </summary>
        /// <param name="data">The data.</param>
        private void Load(string data)
        {
            _data = data;
            try
            {
                Log.Write("{0} started.", MethodInfoHelper.GetCurrentMethodName());

                // Load config from XML
                var xml = XDocument.Parse(data);
                if (xml.Root.Name.LocalName != "Manifest")
                {
                    Log.Write("Root XML element '{0}' is not recognized, stopping.", xml.Root.Name);
                    return;
                }

                // Set properties.
                Version         = ParseVersion(xml.Root.Attribute("version").Value);
                CheckInterval   = int.Parse(xml.Root.Element("CheckInterval").Value);
                SecurityToken   = xml.Root.Element("SecurityToken").Value;
                RemoteConfigUri = xml.Root.Element("RemoteConfigUri").Value;
                BaseUri         = xml.Root.Element("BaseUri").Value;
                Payload         = xml.Root.Element("Payload").Value;
            }
            catch (Exception ex)
            {
                Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
            }
            finally
            {
                Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
            }
        }
コード例 #2
0
        private void StopApplication()
        {
            try
            {
                Process application = null;
                foreach (var process in Process.GetProcesses())
                {
                    if (!process.ProcessName.ToLower().Contains("quote"))
                    {
                        continue;
                    }
                    application = process;
                    break;
                }

                if (application != null && application.Responding)
                {
                    application.Kill();
                }
            }
            catch (Exception ex)
            {
                Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
            }
        }
コード例 #3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Updater"/> class.
        /// </summary>
        public Updater()
        {
            try
            {
                Log.Write("{0} started.", MethodInfoHelper.GetCurrentMethodName());

                var configFile = new FileInfo(DefaultConfigFile);
                Log.Write("Initializing using file '{0}'.", configFile.FullName);

                if (!configFile.Exists)
                {
                    throw new Exception(string.Format("Config file '{0}' does not exist, stopping.", configFile.Name));
                }

                string data = File.ReadAllText(configFile.FullName);
                _localConfig = new Manifest(data);
            }
            catch (Exception ex)
            {
                Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
            }
            finally
            {
                Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
            }
        }
コード例 #4
0
        /// <summary>
        /// Updates this instance.
        /// </summary>
        private void Update()
        {
            try
            {
                Log.Write("{0} started.", MethodInfoHelper.GetCurrentMethodName());
                string upgradeFolderPath = Path.Combine(Path.GetTempPath(), UpgradeFolderName);

                DeleteUpgradeFolder(upgradeFolderPath);
                Directory.CreateDirectory(upgradeFolderPath);

                // Download file in manifest.
                Log.Write("Fetching '{0}'.", _remoteConfig.Payload);

                var url  = _remoteConfig.BaseUri + _remoteConfig.Payload;
                var file = Fetch.Get(url);
                if (file == null)
                {
                    Log.Write("Fetch failed.");
                    return;
                }

                var zipFilePath = Path.Combine(upgradeFolderPath, _remoteConfig.Payload);

                var infoZipFilePath = new FileInfo(zipFilePath);
                Directory.CreateDirectory(infoZipFilePath.DirectoryName);

                File.WriteAllBytes(zipFilePath, file);

                Unzip(infoZipFilePath.DirectoryName, zipFilePath);

                StartUgradeProcess(infoZipFilePath.DirectoryName);
                StopApplication();
            }
            catch (Exception ex)
            {
                Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
                throw ex;
            }
            finally
            {
                Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
            }
        }
コード例 #5
0
        private void Unzip(string zipFolderPath, string zipfilePath)
        {
            if (Regex.IsMatch(_remoteConfig.Payload, @"\.zip"))
            {
                try
                {
                    using (ZipArchive archive = ZipFile.Open(zipfilePath, ZipArchiveMode.Read))
                    {
                        archive.ExtractToDirectory(zipFolderPath);
                    }

                    File.Delete(zipfilePath);
                }
                catch (Exception ex)
                {
                    Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
                    throw ex;
                }
            }
        }
コード例 #6
0
        /// <summary>
        /// Starts the monitoring.
        /// </summary>
        public void StartMonitoring()
        {
            try
            {
                Log.Write("{0} started. Monitoring every {1}s.", MethodInfoHelper.GetCurrentMethodName(), _localConfig.CheckInterval);

                if (_localConfig != null)
                {
                    _timer = new Timer(Check, null, 5000, _localConfig.CheckInterval * 1000);
                }
            }
            catch (Exception ex)
            {
                Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
            }
            finally
            {
                Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
            }
        }
コード例 #7
0
 /// <summary>
 /// Stops the monitoring.
 /// </summary>
 public void StopMonitoring()
 {
     try
     {
         Log.Write("{0} started.", MethodInfoHelper.GetCurrentMethodName());
         if (_timer == null)
         {
             Log.Write("Monitoring was already stopped.");
             return;
         }
         _timer.Dispose();
     }
     catch (Exception ex)
     {
         Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
     }
     finally
     {
         Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
     }
 }
コード例 #8
0
 private void DeleteUpgradeFolder(string upgradeFolderPath)
 {
     // Clean up failed attempts.
     if (Directory.Exists(upgradeFolderPath))
     {
         Log.Write("WARNING: Work directory already exists.");
         try
         {
             Directory.Delete(upgradeFolderPath, true);
         }
         catch (IOException ex)
         {
             Log.Write("{0} failed. Cannot delete open directory {1} - Exception {2}",
                       MethodInfoHelper.GetCurrentMethodName(), upgradeFolderPath, ex.Message);
             throw ex;
         }
         catch (Exception ex)
         {
             Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
             throw ex;
         }
     }
 }
コード例 #9
0
        /// <summary>
        /// Checks the specified state.
        /// </summary>
        /// <param name="state">The state.</param>
        private void Check(object state)
        {
            try
            {
                Log.Write("{0} started.", MethodInfoHelper.GetCurrentMethodName());

                if (_updating)
                {
                    Log.Write("Updater is already updating.");
                }

                var fetch     = new Fetch(2, 5000, 500);
                var remoteUri = new Uri(_localConfig.RemoteConfigUri);
                fetch.Load(remoteUri.AbsoluteUri);

                if (!fetch.Success)
                {
                    Log.Write("Fetch error: {0}", fetch.Response.StatusDescription);
                    _remoteConfig = null;
                    return;
                }

                string data = Encoding.UTF8.GetString(fetch.ResponseData);
                _remoteConfig = new Manifest(data);

                if (_remoteConfig == null)
                {
                    return;
                }

                if (_localConfig.SecurityToken != _remoteConfig.SecurityToken)
                {
                    Log.Write("Security token mismatch.");
                    return;
                }

                Log.Write("Remote config is valid. Local version is {0}. Remote version is {1}.",
                          _localConfig.Version, _remoteConfig.Version);

                if (_remoteConfig.Version == _localConfig.Version)
                {
                    Log.Write("Versions are the same.");
                    return;
                }

                if (_remoteConfig.Version < _localConfig.Version)
                {
                    Log.Write("Remote version is older.");
                    return;
                }

                if (OnEvent(string.Format("Current version is {0}. Do you want to ugrade to version {1}?",
                                          _localConfig.Version, _remoteConfig.Version)))
                {
                    _updating = true;
                    Update();
                    _updating = false;
                }
            }
            catch (Exception ex)
            {
                Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);
            }
            finally
            {
                Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
                _updating = false;
            }
        }
コード例 #10
0
ファイル: Fetch.cs プロジェクト: RiaSolutions/QuoteInstaller
        /// <summary>
        /// Gets the specified URL.
        /// </summary>
        /// <param name="url">The URL.</param>
        /// <returns></returns>
        public void Load(string url)
        {
            for (int retry = 0; retry < _retries; retry++)
            {
                try
                {
                    Log.Write("{0} started for url = {1} and retry = {2}", MethodInfoHelper.GetCurrentMethodName(), url, retry);

                    var req = HttpWebRequest.Create(url) as HttpWebRequest;
                    req.Timeout = _timeout;

                    Response = req.GetResponse() as HttpWebResponse;
                    switch (Response.StatusCode)
                    {
                    case HttpStatusCode.Found:
                        // This is a redirect to an error page, so ignore.
                        Log.Write("Found (302), ignoring ");
                        break;

                    case HttpStatusCode.OK:
                        // This is a valid page.
                        using (var sr = Response.GetResponseStream())
                        {
                            using (var ms = new MemoryStream())
                            {
                                for (int b; (b = sr.ReadByte()) != -1;)
                                {
                                    ms.WriteByte((byte)b);
                                }

                                ResponseData = ms.ToArray();
                            }
                        }
                        break;

                    default:
                        // This is unexpected.
                        Log.Write(Response.StatusCode.ToString());
                        break;
                    }
                    Success = true;
                    break;
                }
                catch (WebException ex)
                {
                    Log.Write("{0} failed. {1}", MethodInfoHelper.GetCurrentMethodName(), ex.Message);

                    Response = ex.Response as HttpWebResponse;
                    if (ex.Status == WebExceptionStatus.Timeout)
                    {
                        Thread.Sleep(_retrySleep);
                        continue;
                    }
                    break;
                }
                finally
                {
                    Log.Write("{0} ended.", MethodInfoHelper.GetCurrentMethodName());
                }
            }
        }