Esempio n. 1
0
        /// <summary>
        /// Initialy uploads the application to the server
        /// </summary>
        /// <param name="app"></param>
        /// <param name="localPath">The path to the local .exe file of the application</param>
        public void InitialUpload(string appName, string localPath, List<string> bugFixes, List<string> newStuff, string ftpServer, string ftpUser, string privateKeyFile, string privateKeyPassPhrase, string pathToAppsFolder)
        {
            var app = new Application();
            app.ApplicationVersion = new Version();
            app.Name = appName;

            PublishApplication(app, localPath, bugFixes, newStuff, new List<string>(), ftpServer, ftpUser, privateKeyFile, privateKeyPassPhrase, pathToAppsFolder);
        }
Esempio n. 2
0
        /// <summary>
        /// Gets the application with the given name from the server
        /// </summary>
        /// <param name="app"></param>
        public Application GetApplication(string name, string rootUrl)
        {
            CoreTools.Logger.DebugFormat("Getting online application info for \"{0}\" from {1}", name, rootUrl);

            // Make sure that the rootUrl ends with a '/'
            if (!rootUrl.EndsWith("/"))
                rootUrl += "/";

            var application = new Application()
            {
                Name = name,
                Files = new List<string>(),
                ApplicationVersion = new Version(),
                WebRootUrl = rootUrl
            };

            // Create a Http client to download data
            using (var httpClient = new WebClient())
            {
                // Open filelist file on the server and store it in the object
                var versionRegex = new Regex(@"^[vV][0-9]*\.[0-9]*\.[0-9]*");

                var filesContent = new StreamReader(httpClient.OpenRead(string.Format("{0}{1}/files.txt", rootUrl, name)));
                while (!filesContent.EndOfStream)
                {
                    var line = filesContent.ReadLine();

                    // If line matches version format, parse version-number of current version
                    if (versionRegex.IsMatch(line))
                    {
                        var versions = line.Substring(1).Split(new string[] {"."}, StringSplitOptions.RemoveEmptyEntries);
                        application.ApplicationVersion = new Version(Convert.ToInt32(versions[0]),
                                                                    Convert.ToInt32(versions[1]),
                                                                    Convert.ToInt32(versions[2]),
                                                                    0);
                    }
                    else
                    {
                        application.Files.Add(line);
                    }
                }

                // Get changelog
                var changelogReader = new StreamReader(httpClient.OpenRead(string.Format("{0}{1}/changelog.xml", rootUrl, name)));
                var xmlContent = changelogReader.ReadToEnd();
                application.ChangeLog = System.Xml.Linq.XDocument.Parse(xmlContent);

                CoreTools.Logger.DebugFormat("Online application information for \"{0}\" loaded:", name);
                CoreTools.Logger.DebugFormat(" - Online version: {0}", application.ApplicationVersion);

                return application;
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Publishes the application to the server
        /// </summary>
        /// <param name="app"></param>
        /// <param name="localPath">The path to the local .exe file of the application</param>
        public void PublishApplication(Application app, string localPath, List<string> bugFixes, List<string> newStuff, List<string> deletedFiles, string ftpServer, string ftpUser, string privateKeyFile, string privateKeyPassPhrase, string pathToAppsFolder)
        {
            try
            {
                #region PRECONDITIONS

                if (!File.Exists(localPath))
                    throw new FileNotFoundException(string.Format("Could not find a part of the file '{0}'", localPath));

                #endregion

                app.UpdateProgress = 0;
                app.PublishingStatus = "Connecting to SFTP server";

                // Open SFTP connection to server
                using (var ftpClient = new SftpClient(ftpServer, ftpUser, new PrivateKeyFile(privateKeyFile, privateKeyPassPhrase)))
                {
                    ftpClient.Connect();

                    var newVersion = AssemblyName.GetAssemblyName(localPath).Version;
                    if (newVersion <= app.ApplicationVersion)
                        throw new InvalidOperationException("You are trying to publish an older version than the one that is on the server! You have to increase the assembly version and republish!");

                    app.PublishingStatus = "Updating changelog";

                    // Create changelog entry
                    app.AddVersionToChangelog(newVersion, bugFixes, newStuff, deletedFiles);
                    ftpClient.UploadFile(this.GenerateStreamFromString(app.ChangeLog.ToString()), string.Format("{1}/{0}/changelog.xml", app.Name, pathToAppsFolder), true);

                    app.PublishingStatus = "Gathering data";

                    // Load all files that have to get uploaded
                    var localDirectory = Path.GetDirectoryName(localPath);
                    var files = GetFileListRecursive(localDirectory, new List<string>(), localDirectory);
                    app.Files = files;

                    // Create new fileIndex with new version info at first line
                    var filesIndexContent = string.Format("v{0}.{1}.{2}\r\n", newVersion.Major, newVersion.Minor, newVersion.Build);
                    foreach (var file in app.Files)
                    {
                        filesIndexContent += file + "\r\n";
                    }

                    var filePath = string.Format("{1}/{0}/files.txt", app.Name, pathToAppsFolder);
                    ftpClient.UploadFile(GenerateStreamFromString(filesIndexContent), filePath, true, null);

                    app.PublishingStatus = "Uploading files";
                    var uploadedFiles = 0;

                    // Upload all files
                    foreach (var file in app.Files)
                    {
                        app.PublishingStatus = string.Format("Downloading file {0}", file);
                        var localFilePath = Path.Combine(localDirectory, file);
                        var remotePath = string.Format("{2}/{0}/{1}", app.Name, file, pathToAppsFolder);

                        ftpClient.UploadFile(File.Open(localFilePath, FileMode.Open, FileAccess.Read), remotePath, true);
                        uploadedFiles++;
                        app.PublishingProgress = (float)app.Files.Count / (float)uploadedFiles;
                    }

                    app.PublishingStatus = "Publishing finished";
                }
            }
            catch { app.PublishingStatus = "Error"; throw; }
        }
 /// <summary>
 /// Loads the application information from the webserver
 /// </summary>
 public void LoadApplicationData()
 {
     var updater = new SelfUpdater();
     this.SelfUpdaterApp = updater.GetApplication(SelfUpdater.UPDATER_APPNAME, SelfUpdater.SUN_UPDATER_ROOTURL);
 }
Esempio n. 5
0
        /// <summary>
        /// Downloads the application files from the server and updates it local
        /// </summary>
        /// <param name="app">The application to update</param>
        /// <param name="localPath">The local path of the application to the executable file</param>
        public void UpdateApplication(Application app, string localPath, string rootUrl)
        {
            CoreTools.Logger.InfoFormat("Updating application \"{0}\" from {1} in {2}", app.Name, rootUrl, localPath);

            try
            {
                var localDirectory = Path.GetDirectoryName(localPath);
                var oldVersion = AssemblyName.GetAssemblyName(localPath).Version;

                // Open Http client to download files from remote server
                using (var httpClient = new WebClient())
                {
                    app.UpdateProgress = 0;
                    var downloadCount = 0;

                    // Download all files from the server
                    foreach (var file in app.Files)
                    {
                        app.UpdateStatus = string.Format("Downloading file {0}", file);
                        var localFilePath = Path.Combine(localDirectory, file.Replace("/", "\\"));

                        httpClient.DownloadFile(string.Format("{2}/{0}/{1}", app.Name, file, rootUrl), localFilePath);
                        downloadCount++;
                        app.UpdateProgress = (float)downloadCount / (float)app.Files.Count;
                        CoreTools.Logger.DebugFormat("Updated file {0}", localFilePath);
                    }

                    app.UpdateStatus = "Deleting unnecessary files";

                    // Delete all deletedFiles from all newer versions
                    foreach (var version in app.GetAllVersionsFromChangeLog())
                    {
                        if (new Version(version) > oldVersion)
                        {
                            // Delete all deletedFiles
                            foreach (var deletedFile in app.GetAllDeletedFilesForVersion(new Version(version)))
                            {
                                var localFilePath = Path.Combine(localDirectory, deletedFile.Replace("/", "\\"));
                                if (File.Exists(localFilePath))
                                {
                                    File.Delete(localFilePath);
                                    CoreTools.Logger.DebugFormat("Deleted file {0}", localFilePath);
                                }
                            }
                        }
                    }

                    app.UpdateStatus = "Update finished";
                }
            }
            catch (Exception ex)
            {
                app.UpdateStatus = "Error";
                CoreTools.Logger.ErrorFormat("Error updating application \"{0}\": {1}", app.Name, ex.Message);
                throw ex;
            }
        }