AzureSiteReplicator.WebDeployHelper.DeployContentToOneSite C# (CSharp) Method

        public DeploymentChangeSummary DeployContentToOneSite(
            IConfigRepository repository,
            string contentPath,
            string publishSettingsFile)
        {
            var sourceBaseOptions = new DeploymentBaseOptions();
            DeploymentBaseOptions destBaseOptions;
            string siteName = SetDestBaseOptions(publishSettingsFile, out destBaseOptions);
            bool success = true;
            DeploymentChangeSummary summary = null;

            AddSkips(repository.Config.SkipRules, sourceBaseOptions, destBaseOptions);

            Trace.TraceInformation("Starting WebDeploy for {0}", Path.GetFileName(publishSettingsFile));

            using (StatusFile status = new StatusFile(siteName))
            using (LogFile logFile = new LogFile(siteName, false))
            {
                sourceBaseOptions.Trace += logFile.LogEventHandler;
                destBaseOptions.Trace += logFile.LogEventHandler;

                try
                {
                    logFile.Log(TraceLevel.Info, "Beginning sync");

                    status.State = Models.DeployState.Deploying;
                    status.Save();

                    // Publish the content to the remote site
                    using (var deploymentObject = DeploymentManager.CreateObject(DeploymentWellKnownProvider.ContentPath, contentPath, sourceBaseOptions))
                    {
                        // Note: would be nice to have an async flavor of this API...
                        summary = deploymentObject.SyncTo(DeploymentWellKnownProvider.ContentPath, siteName, destBaseOptions, new DeploymentSyncOptions());
                    }

                    string summaryString = string.Format("Total Changes: {0} ({1} added, {2} deleted, {3} updated, {4} parameters changed, {5} bytes copied)",
                        summary.TotalChanges,
                        summary.ObjectsAdded,
                        summary.ObjectsDeleted,
                        summary.ObjectsUpdated,
                        summary.ParameterChanges,
                        summary.BytesCopied);

                    status.ObjectsAdded = summary.ObjectsAdded;
                    status.ObjectsDeleted = summary.ObjectsDeleted;
                    status.ObjectsUpdated = summary.ObjectsUpdated;
                    status.ParametersChanged = summary.ParameterChanges;
                    status.BytesCopied = summary.BytesCopied;

                    logFile.Log(TraceLevel.Info, summaryString);
                    logFile.Log(TraceLevel.Info, "Sync completed successfully");
                }
                catch(Exception e)
                {
                    logFile.Log(TraceLevel.Error, e.ToString());
                    success = false;
                    status.State = Models.DeployState.Failed;
                }

                if (success)
                {
                    status.State = Models.DeployState.Succeeded;
                }
            }   // Close log file and status file

            return summary;
        }

        public async Task <DeploymentChangeSummary> PublishContentToSingleSite(Site site)
        {
            string   lockPath = Path.Combine(site.FilePath, "deployment.lock");
            LockFile lockFile = null;

            Trace.TraceInformation("Sync to single site: {0}", site.Name);

            try
            {
                if (LockFile.TryGetLockFile(lockPath, out lockFile))
                {
                    WebDeployHelper webDeployHelper = new WebDeployHelper();
                    return(await Task <DeploymentChangeSummary> .Run(() =>
                                                                     webDeployHelper.DeployContentToOneSite(
                                                                         Repository,
                                                                         Environment.Instance.ContentPath,
                                                                         site.Settings.FilePath)));
                }

                return(null);
            }
            catch (Exception e)
            {
                Trace.TraceError("Error processing {0}: {1}", Path.GetFileName(site.Settings.FilePath), e.ToString());
                return(null);
            }
            finally
            {
                if (lockFile != null)
                {
                    lockFile.Dispose();
                    lockFile = null;
                }
            }
        }