Пример #1
0
        public void LoadNonExistingManifest()
        {
            // Arrange
            var             selectedProject = VsUtils.GetSelectedProject();
            PushEnvironment environment     = new PushEnvironment(selectedProject);

            environment.ProjectDirectory = @"c:\somedirthatdoesntexist";
            environment.ProfileFilePath  = @"c:\foo-bar.cf.pubxml";
            environment.ProjectName      = "foo-bar";

            // Act
            PublishProfile publishProfile = PublishProfile.Load(environment);

            // Assert
            Assert.AreEqual(string.Empty, publishProfile.Application.BuildpackUrl);
            Assert.AreEqual(null, publishProfile.Application.Command);
            Assert.AreEqual(null, publishProfile.Application.DiskQuota);
            Assert.AreEqual(0, publishProfile.Application.Domains.Count);
            Assert.AreEqual(0, publishProfile.Application.EnvironmentVariables.Count);
            Assert.AreEqual(null, publishProfile.Application.HealthCheckTimeout);
            Assert.AreEqual(environment.ProjectName.ToLowerInvariant(), publishProfile.Application.Hosts[0]);
            Assert.AreEqual(1, publishProfile.Application.InstanceCount);
            Assert.AreEqual(256, publishProfile.Application.Memory);
            Assert.AreEqual(environment.ProjectName, publishProfile.Application.Name);
            Assert.AreEqual(false, publishProfile.Application.NoHostName);
            Assert.AreEqual(false, publishProfile.Application.NoRoute);
            Assert.AreEqual(null, publishProfile.Application.Path);
            Assert.AreEqual(0, publishProfile.Application.Services.Count);
            Assert.AreEqual(string.Empty, publishProfile.Application.StackName);
            Assert.AreEqual(false, publishProfile.Application.UseRandomHostName);
        }
        private object UpdateAzureFunctionsAsync(OperationRunner context)
        {
            AzureClient client = new AzureClient(WizardContext.TokenProvider);

            client.SetLogger(context.Logger);

            PublishData publishingProfiles = client.GetAppServicePublishingProfileAsync(
                DataModel.InstallationConfiguration.Azure.SelectedSubscription.Id,
                DataModel.InstallationConfiguration.Azure.ResourceGroupName,
                DataModel.InstallationConfiguration.Azure.FunctionApp.AppName).Result;
            PublishProfile webDeployProfile =
                publishingProfiles
                .Profiles
                .Where(x => x.ProfileName.Contains("Web Deploy"))
                .FirstOrDefault();

            SecureString publishingProfilePassword = new SecureString();

            foreach (char c in webDeployProfile.Password)
            {
                publishingProfilePassword.AppendChar(c);
            }

            publishingProfilePassword.MakeReadOnly();

            return(client.ZipDeployAppServiceAsync(
                       DataModel.InstallationConfiguration.Azure.FunctionApp.AppName,
                       DataModel.InstallationConfiguration.Azure.FunctionApp.AppDeploymentSourceUrl,
                       new NetworkCredential(webDeployProfile.UserName, publishingProfilePassword)).Result);
        }
Пример #3
0
        public void LoadExistingProfileTest()
        {
            // Arrange
            var             selectedProject = VsUtils.GetSelectedProject();
            PushEnvironment environment     = new PushEnvironment(selectedProject);

            environment.ProjectDirectory = Util.PublishProfileProjectDir;
            environment.ProfileFilePath  = Util.PublishProfilePath;
            environment.ProjectName      = "foobar-project";

            // Act
            PublishProfile publishProfile = PublishProfile.Load(environment);

            // Assert
            Assert.AreEqual("user", publishProfile.User);
            Assert.AreEqual(string.Empty, publishProfile.Password);
            Assert.AreEqual(string.Empty, publishProfile.RefreshToken);
            Assert.AreEqual("https://api.1.2.3.4.xip.io/", publishProfile.ServerUri.ToString());
            Assert.AreEqual(true, publishProfile.SkipSSLValidation);
            Assert.AreEqual("numenor", publishProfile.Organization);
            Assert.AreEqual("arandor", publishProfile.Space);
            Assert.AreEqual(string.Empty, publishProfile.DeployTargetFile);
            Assert.AreEqual("CloudFoundry", publishProfile.WebPublishMethod);
            Assert.AreEqual(@"..\..\push.yml", publishProfile.Manifest);
        }
Пример #4
0
        public void LoadExistingManifestTest()
        {
            // Arrange
            var             selectedProject = VsUtils.GetSelectedProject();
            PushEnvironment environment     = new PushEnvironment(selectedProject);

            environment.ProjectDirectory = Util.PublishProfileProjectDir;
            environment.ProfileFilePath  = Util.PublishProfilePath;
            environment.ProjectName      = "foobar-project";

            // Act
            PublishProfile publishProfile = PublishProfile.Load(environment);

            // Assert
            Assert.AreEqual("test-bp", publishProfile.Application.BuildpackUrl);
            Assert.AreEqual("cmd", publishProfile.Application.Command);
            Assert.AreEqual(null, publishProfile.Application.DiskQuota);
            Assert.AreEqual("app.example.com", publishProfile.Application.Domains[0]);
            Assert.AreEqual("first", publishProfile.Application.EnvironmentVariables["env1"]);
            Assert.AreEqual("second", publishProfile.Application.EnvironmentVariables["env2"]);
            Assert.AreEqual(500, publishProfile.Application.HealthCheckTimeout);
            Assert.AreEqual("home", publishProfile.Application.Hosts[0]);
            Assert.AreEqual(1, publishProfile.Application.InstanceCount);
            Assert.AreEqual(128, publishProfile.Application.Memory);
            Assert.AreEqual("app-name", publishProfile.Application.Name);
            Assert.AreEqual(false, publishProfile.Application.NoHostName);
            Assert.AreEqual(false, publishProfile.Application.NoRoute);
            Assert.AreEqual(@"c:\path\to\app", publishProfile.Application.Path);
            Assert.AreEqual("mysql", publishProfile.Application.Services[0]);
            Assert.AreEqual("mssql", publishProfile.Application.Services[1]);
            Assert.AreEqual(null, publishProfile.Application.StackName);
            Assert.AreEqual(false, publishProfile.Application.UseRandomHostName);
        }
Пример #5
0
        public void LoadNonExistingProfile()
        {
            // Arrange
            var             selectedProject = VsUtils.GetSelectedProject();
            PushEnvironment environment     = new PushEnvironment(selectedProject);

            environment.ProjectDirectory = @"c:\somedirthatdoesntexist\";
            environment.ProfileFilePath  = @"c:\foo-bar.cf.pubxml";
            environment.ProjectName      = "foo-bar";

            // Act
            PublishProfile publishProfile = PublishProfile.Load(environment);

            // Assert
            Assert.AreEqual(string.Empty, publishProfile.User);
            Assert.AreEqual(null, publishProfile.Password);
            Assert.AreEqual(null, publishProfile.RefreshToken);
            Assert.AreEqual(null, publishProfile.ServerUri);
            Assert.AreEqual(false, publishProfile.SkipSSLValidation);
            Assert.AreEqual(string.Empty, publishProfile.Organization);
            Assert.AreEqual(string.Empty, publishProfile.Space);
            Assert.AreEqual(null, publishProfile.DeployTargetFile);
            Assert.AreEqual("CloudFoundry", publishProfile.WebPublishMethod);
            Assert.AreEqual("foo-bar.yml", publishProfile.Manifest);
        }
Пример #6
0
        public PushDialog(PublishProfile package)
        {
            this.cancellationToken       = new CancellationToken();
            this.publishProfileResources = new PublishProfileEditorResources(package, this.cancellationToken);
            this.DataContext             = this.publishProfileResources;

            this.InitializeComponent();
        }
Пример #7
0
 public PushDialog(PublishProfile package)
 {
     this.cancellationToken       = new CancellationToken();
     this.publishProfileResources = new PublishProfileEditorResources(package, this.cancellationToken);
     this.DataContext             = this.publishProfileResources;
     this.Owner = System.Windows.Application.Current.MainWindow;
     this.InitializeComponent();
 }
Пример #8
0
        private PublishProfile ParseAndDisplayProfileInfo(string pathToProfileFile)
        {
            var pub = new PublishProfile(pathToProfileFile);

            tsTargetDbValue.Text      = pub.TargetDatabaseName;
            tsTargetConnStrValue.Text = pub.TargetConnectionString;

            return(pub);
        }
Пример #9
0
 KuduSiteSettings _pub2Kudu(PublishProfile pubSetting)
 {
     return(new KuduSiteSettings
     {
         ApiUrl = pubSetting.PublishUrl,
         LiveUrl = pubSetting.DestinationAppUrl,
         Password = pubSetting.UserPWD,
         SiteName = pubSetting.MsdeploySite,
         UserName = pubSetting.UserName,
         ProfileName = pubSetting.ProfileName
     });
 }
        public void CreateNewDatabase_Get_Set()
        {
            // Arrange
            var instance = new PublishProfile
            {
                CreateNewDatabase = false
            };

            // Act
            instance.CreateNewDatabase = true;

            // Assert
            Assert.IsTrue(instance.CreateNewDatabase);
        }
Пример #11
0
        public int CreateEditorInstance(uint grfCreateDoc, string pszMkDocument, string pszPhysicalView, IVsHierarchy ppvHier, uint itemid, IntPtr punkDocDataExisting, out IntPtr ppunkDocView, out IntPtr ppunkDocData, out string pbstrEditorCaption, out Guid pguidCmdUI, out int pgrfCDW)
        {
            ppunkDocData       = IntPtr.Zero;
            ppunkDocView       = IntPtr.Zero;
            pguidCmdUI         = new Guid("41d526d3-6281-42ff-ba9f-e5746623233f");
            pgrfCDW            = 0;
            pbstrEditorCaption = "Stackato Publish Profile";

            var project = VsUtils.GetSelectedProject();

            var fileInfo = new FileInfo(pszMkDocument);

            if (project == null)
            {
                return(VSConstants.VS_E_UNSUPPORTEDFORMAT);
            }

            if (project.Name.Contains("Miscellaneous Files"))
            {
                return(VSConstants.VS_E_UNSUPPORTEDFORMAT);
            }

            if (!fileInfo.Name.ToUpperInvariant().EndsWith(PushEnvironment.Extension, StringComparison.OrdinalIgnoreCase))
            {
                return(VSConstants.VS_E_UNSUPPORTEDFORMAT);
            }

            PublishProfile packageFile;

            try
            {
                var             selectedProject = VsUtils.GetSelectedProject();
                PushEnvironment environment     = new PushEnvironment(selectedProject);
                environment.ProjectName     = project.Name;
                environment.ProfileFilePath = pszMkDocument;

                packageFile = PublishProfile.Load(environment);
            }
            catch (Exception ex)
            {
                MessageBoxHelper.DisplayError(string.Format(CultureInfo.InvariantCulture, "Cannot load {0}. {1}.", pszMkDocument, ex.Message));
                Logger.Error("Exception loading package file", ex);
                return(VSConstants.VS_E_INCOMPATIBLEDOCDATA);
            }

            var dialog = new PushDialog(packageFile);

            dialog.ShowModal();
            return(VSConstants.S_OK);
        }
        public void ScriptDeployStateChecks_Get_Set()
        {
            // Arrange
            var instance = new PublishProfile
            {
                ScriptDeployStateChecks = false
            };

            // Act
            instance.ScriptDeployStateChecks = true;

            // Assert
            Assert.IsTrue(instance.ScriptDeployStateChecks);
        }
Пример #13
0
        public void PublishProfile_FeedFile_VerifyParsedData()
        {
            const string expectedDbName  = "DatabaseName";
            const string expectedConnStr = @"Data Source=SqlServer\Instance;Integrated Security=True;Pooling=False;Initial Catalog=DatabaseName";

            var pathToProfileFile = Path.Combine(TestContext.DeploymentDirectory, "PublishProfile.publish.xml");
            var target            = new PublishProfile(pathToProfileFile);

            var dbName  = target.TargetDatabaseName;
            var connStr = target.TargetConnectionString;

            Assert.AreEqual(expectedDbName, dbName);
            Assert.AreEqual(expectedConnStr, connStr);
        }
        public void ScriptDatabaseOptions_Get_Set()
        {
            // Arrange
            var instance = new PublishProfile
            {
                ScriptDatabaseOptions = false
            };

            // Act
            instance.ScriptDatabaseOptions = true;

            // Assert
            Assert.IsTrue(instance.ScriptDatabaseOptions);
        }
        public void BackupDatabaseBeforeChanges_Get_Set()
        {
            // Arrange
            var instance = new PublishProfile
            {
                BackupDatabaseBeforeChanges = false
            };

            // Act
            instance.BackupDatabaseBeforeChanges = true;

            // Assert
            Assert.IsTrue(instance.BackupDatabaseBeforeChanges);
        }
        public AppsResult UpsertPublishProfile([FromBody] PublishProfile publishProfile)
        {
            var result = new AppsResult();

            try
            {
                var objs = _db.GetCollection <PublishProfile>("PublishProfiles");
                objs.Upsert(publishProfile);

                result.Success = true;
            }
            catch (System.Exception ex)
            {
                new AppFlows.Publish.Exception(ex, ref result);
            }

            return(result);
        }
        public void Constructor_Contents_CorrectInitialization()
        {
            // Arrange
            const string script         = "script";
            const string report         = "report";
            const string pre            = "pre";
            const string post           = "post";
            var          publishProfile = new PublishProfile();

            // Act
            var result = new CreateDeployFilesResult(script, report, pre, post, publishProfile);

            // Assert
            Assert.AreEqual(script, result.DeployScriptContent);
            Assert.AreEqual(report, result.DeployReportContent);
            Assert.AreEqual(pre, result.PreDeploymentScript);
            Assert.AreEqual(post, result.PostDeploymentScript);
            Assert.AreSame(publishProfile, result.UsedPublishProfile);
            Assert.IsNull(result.Errors);
        }
Пример #18
0
        public static PublishProfile CreatePublishProfile(string publishMethod)
        {
            PublishProfile publishProfile = null;

            switch (publishMethod)
            {
            case MSDeployPublishProfile.PublishMethod:
                publishProfile = new MSDeployPublishProfile();
                break;

            case MSDeployPackagePublishProfile.PublishMethod:
                publishProfile = new MSDeployPackagePublishProfile();
                break;

            case FileSystemPublishProfile.PublishMethod:
                publishProfile = new FileSystemPublishProfile();
                break;
            }

            return(publishProfile);
        }
Пример #19
0
        private async Task <bool> ValidatePublishProfileAgainstConfiguration(PublishProfile publishProfile,
                                                                             ConfigurationModel configuration)
        {
            if (!configuration.RemoveSqlCmdStatements)
            {
                return(true);
            }

            var valid = true;

            if (publishProfile.CreateNewDatabase)
            {
                await _logger.LogErrorAsync($"{nameof(PublishProfile.CreateNewDatabase)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true.");

                valid = false;
            }

            if (publishProfile.BackupDatabaseBeforeChanges)
            {
                await _logger.LogErrorAsync($"{nameof(PublishProfile.BackupDatabaseBeforeChanges)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true.");

                valid = false;
            }

            if (publishProfile.ScriptDatabaseOptions)
            {
                await _logger.LogErrorAsync($"{nameof(PublishProfile.ScriptDatabaseOptions)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true.");

                valid = false;
            }

            if (publishProfile.ScriptDeployStateChecks)
            {
                await _logger.LogErrorAsync($"{nameof(PublishProfile.ScriptDeployStateChecks)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true.");

                valid = false;
            }

            return(valid);
        }
Пример #20
0
        private void ButtonBuildAndPushProjectExecuteHandler(object sender, EventArgs e)
        {
            try
            {
                var             selectedProject = VsUtils.GetSelectedProject();
                PushEnvironment environment     = new PushEnvironment(selectedProject);
                var             package         = PublishProfile.Load(environment);

                var dialog = new PushDialog(package);
                dialog.ShowModal();
            }
            catch (VisualStudioException ex)
            {
                MessageBoxHelper.DisplayError(string.Format(CultureInfo.InvariantCulture, "Error loading publish profile: {0}", ex.Message));
                Logger.Error("Error loading publish profile", ex);
            }
            catch (Exception ex)
            {
                MessageBoxHelper.DisplayError(string.Format(CultureInfo.InvariantCulture, "An error occurred while trying to load a publish profile: {0}", ex.Message));
                Logger.Error("Error loading default profile", ex);
            }
        }
        private void SetData(PublishProfile prof = null)
        {
            if (_manager == null)
            {
                return;
            }


            try {
                var selectedvidprops = Manager.CurrentCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoRecord) as VideoEncodingProperties;
                var boundvidprof     = prof != null && prof.TargetEncodingProfile != null && prof.TargetEncodingProfile.Video != null ? prof.TargetEncodingProfile.Video : selectedvidprops;

                var selectedaudprops = Manager.CurrentCapture.AudioDeviceController.GetMediaStreamProperties(MediaStreamType.Audio) as AudioEncodingProperties;
                var boundaudprof     = prof != null && prof.TargetEncodingProfile != null && prof.TargetEncodingProfile.Audio != null ? prof.TargetEncodingProfile.Audio : selectedaudprops;

                double framesizeratio =
                    (double)boundvidprof.Width / (double)boundvidprof.Height;
                if (framesizeratio == 4.0 / 3.0)
                {
                    sldrWidth.StepFrequency  = 4.0;
                    sldrHeight.StepFrequency = 3.0;
                }
                else if (framesizeratio == 16.0 / 9.0)
                {
                    sldrWidth.StepFrequency  = 16.0;
                    sldrHeight.StepFrequency = 9.0;
                }
                else if (framesizeratio == 3.0 / 2.0)
                {
                    sldrWidth.StepFrequency  = 3.0;
                    sldrHeight.StepFrequency = 2.0;
                }
                else
                {
                    sldrWidth.StepFrequency  = framesizeratio;
                    sldrHeight.StepFrequency = 1;
                }

                sldrWidth.Value   = boundvidprof.Width;
                sldrHeight.Value  = boundvidprof.Height;
                sldrBitrate.Value = boundvidprof.Bitrate / 1000;

                sldrKFInterval.Value = ((prof != null ? prof.KeyFrameInterval : 120) / (boundvidprof.FrameRate.Numerator / boundvidprof.FrameRate.Denominator));

                tbKFValue.Text = string.Format("{0:#####} frames/{1:####} secs",
                                               (prof != null ? prof.KeyFrameInterval : 120), sldrKFInterval.Value);

                sldrRTMPChunksize.Value = (prof != null ? prof.ClientChunkSize : 128);

                if (boundvidprof.ProfileId == H264ProfileIds.Baseline)
                {
                    cbxH264Profile.SelectedIndex = 0;
                }
                else if (boundvidprof.ProfileId == H264ProfileIds.Main)
                {
                    cbxH264Profile.SelectedIndex = 1;
                }
                else if (boundvidprof.ProfileId == H264ProfileIds.High)
                {
                    cbxH264Profile.SelectedIndex = 2;
                }
                else
                {
                    boundvidprof.ProfileId       = H264ProfileIds.Main;
                    cbxH264Profile.SelectedIndex = 1;
                }

                sldrAudioBitrate.Value         = boundaudprof.Bitrate;
                cbxAudioSampling.SelectedIndex = boundaudprof.SampleRate == 48000 ? 0 : (boundaudprof.SampleRate == 44100 ? 1 : 2);
                tsAudioChannels.IsOn           = boundaudprof.ChannelCount >= 2;

                tsLowLagBehavior.IsOn = (prof != null ? prof.EnableLowLatency : false);
            }
            catch
            {
            }
        }
        public object Convert(object value, Type targetType, object parameter, string language)
        {
            PublishProfile prof = value as PublishProfile;

            return(string.Format("{0} kbps, {1}x{2}, {3} fps", prof.TargetEncodingProfile.Video.Bitrate / 1000, prof.TargetEncodingProfile.Video.Width, prof.TargetEncodingProfile.Video.Height, (prof.TargetEncodingProfile.Video.FrameRate.Numerator / prof.TargetEncodingProfile.Video.FrameRate.Denominator)));
        }
        public object Convert(object value, Type targetType, object parameter, string language)
        {
            PublishProfile prof = value as PublishProfile;

            return(string.Format("{0} kbps, {1} kHz, {2}", prof.TargetEncodingProfile.Audio.Bitrate / 1000, prof.TargetEncodingProfile.Audio.SampleRate / 1000, prof.TargetEncodingProfile.Audio.ChannelCount >= 2 ? "Stereo" : "Mono"));
        }
Пример #24
0
        public void SaveNonExistingProfileAndManifest()
        {
            // Arrange
            string testProjectDir = Path.Combine(Path.GetTempPath(), string.Format("savetest-{0}\\", Guid.NewGuid().ToString("N")));

            Directory.CreateDirectory(testProjectDir);
            var             selectedProject = VsUtils.GetSelectedProject();
            PushEnvironment environment     = new PushEnvironment(selectedProject);

            environment.ProjectDirectory = testProjectDir;


            string publishProfilePath = Path.Combine(testProjectDir, "Properties", "PublishProfiles", "push.cf.pubxml");

            environment.ProfileFilePath = publishProfilePath;
            environment.ProjectName     = "mypush";

            string manifestPath = Path.Combine(testProjectDir, "push.yml");

            PublishProfile publishProfile = PublishProfile.Load(environment);

            publishProfile.Organization      = "doriath";
            publishProfile.Space             = "menegroth";
            publishProfile.User              = "******";
            publishProfile.Password          = "******";
            publishProfile.RefreshToken      = "012345";
            publishProfile.SavedPassword     = true;
            publishProfile.ServerUri         = new Uri("https://my.server.url");
            publishProfile.SkipSSLValidation = false;

            publishProfile.Application.BuildpackUrl = "https://my.buildpack.url";
            publishProfile.Application.Command      = "ls";
            publishProfile.Application.DiskQuota    = 1234;
            publishProfile.Application.Domains.Add("domain.com");
            publishProfile.Application.EnvironmentVariables.Add("my", "var");
            publishProfile.Application.HealthCheckTimeout = 54321;
            publishProfile.Application.Hosts.AddRange(new string[] { "one", "two" });
            publishProfile.Application.InstanceCount = 121;
            publishProfile.Application.Memory        = 42;
            publishProfile.Application.Name          = "myapp";
            publishProfile.Application.NoHostName    = true;
            publishProfile.Application.NoRoute       = true;
            publishProfile.Application.Path          = "/app/path";
            publishProfile.Application.Services.AddRange(new string[] { "s1", "s2" });
            publishProfile.Application.StackName         = "leo";
            publishProfile.Application.UseRandomHostName = true;


            // Act
            publishProfile.Save();

            // Assert
            Assert.IsTrue(File.Exists(publishProfilePath));
            Assert.IsTrue(File.Exists(manifestPath));

            var loadedProfile = PublishProfile.Load(environment);

            Assert.AreEqual(publishProfile.Manifest, loadedProfile.Manifest);
            Assert.AreEqual(publishProfile.Organization, loadedProfile.Organization);
            Assert.AreEqual(publishProfile.Password, loadedProfile.Password);
            Assert.AreEqual(publishProfile.RefreshToken, loadedProfile.RefreshToken);
            Assert.AreEqual(publishProfile.SavedPassword, loadedProfile.SavedPassword);
            Assert.AreEqual(publishProfile.ServerUri, loadedProfile.ServerUri);
            Assert.AreEqual(publishProfile.SkipSSLValidation, loadedProfile.SkipSSLValidation);
            Assert.AreEqual(publishProfile.Space, loadedProfile.Space);
            Assert.AreEqual(publishProfile.User, loadedProfile.User);
            Assert.AreEqual(null, loadedProfile.DeployTargetFile);
            Assert.AreEqual("CloudFoundry", publishProfile.WebPublishMethod);

            Assert.AreEqual(publishProfile.Application.BuildpackUrl, loadedProfile.Application.BuildpackUrl);
            Assert.AreEqual(publishProfile.Application.Command, loadedProfile.Application.Command);
            Assert.AreEqual(publishProfile.Application.DiskQuota, loadedProfile.Application.DiskQuota);
            Assert.AreEqual(publishProfile.Application.Domains[0], loadedProfile.Application.Domains[0]);
            Assert.AreEqual(publishProfile.Application.EnvironmentVariables["my"], loadedProfile.Application.EnvironmentVariables["my"]);
            Assert.AreEqual(publishProfile.Application.HealthCheckTimeout, loadedProfile.Application.HealthCheckTimeout);
            Assert.AreEqual(publishProfile.Application.Hosts[0], loadedProfile.Application.Hosts[0]);
            Assert.AreEqual(publishProfile.Application.Hosts[1], loadedProfile.Application.Hosts[1]);
            Assert.AreEqual(publishProfile.Application.InstanceCount, loadedProfile.Application.InstanceCount);
            Assert.AreEqual(publishProfile.Application.Memory, loadedProfile.Application.Memory);
            Assert.AreEqual(publishProfile.Application.Name, loadedProfile.Application.Name);
            Assert.AreEqual(publishProfile.Application.NoHostName, loadedProfile.Application.NoHostName);
            Assert.AreEqual(publishProfile.Application.NoRoute, loadedProfile.Application.NoRoute);
            Assert.AreEqual(publishProfile.Application.Path, loadedProfile.Application.Path);
            Assert.AreEqual(publishProfile.Application.Services[0], loadedProfile.Application.Services[0]);
            Assert.AreEqual(publishProfile.Application.Services[1], loadedProfile.Application.Services[1]);
            Assert.AreEqual(publishProfile.Application.StackName, loadedProfile.Application.StackName);
            Assert.AreEqual(publishProfile.Application.UseRandomHostName, loadedProfile.Application.UseRandomHostName);
        }
Пример #25
0
        static void Main()
        {
            var mode = ModeDefiner.DefineMode();

            if (!RunsDirectly())
            {
                Logger.AppendEmptyLine();
            }

            Logger.AppendLine($"DacDeployer is started in {mode.ToString().ToUpper()} mode!"); //Console.Title = {Console.Title}
            Logger.AppendEmptyLine();

            if (mode == Mode.Help)
            {
                HelpInfo.Help();

                PressAnyKey(mode);

                Environment.Exit(0);
            }

            Logger.LogConsoleArguments();

            try
            {
                (var dacPacFolderPath, var dacPacFilePath) = PathResolver.GetDacPacPaths();

                (var publishProfileFolderPath, var publishProfileFilePath) = PathResolver.GetPublishProfilePaths();

                if (mode == Mode.Compile)
                {
                    var compilationFolderPath = PathResolver.GetCompilationFolderPath();

                    var beforeDeploymentScriptPath = PathResolver.GetBeforeDeploymentPath();

                    Logger.LogResolvedPaths(dacPacFolderPath, dacPacFilePath, publishProfileFolderPath, publishProfileFilePath, beforeDeploymentScriptPath);

                    Logger.AppendLine("DacDeployer has started compilation:");
                    Logger.AppendDividerLine();

                    CompilationSteps.CreateOrClearCompilationFolder(compilationFolderPath);

                    CompilationSteps.CopyDacDeployer(compilationFolderPath);

                    CompilationSteps.CopyDacPac(compilationFolderPath, dacPacFolderPath);

                    CompilationSteps.CopyPublishProfiles(compilationFolderPath, publishProfileFolderPath);

                    CompilationSteps.CreateBatFiles(compilationFolderPath, dacPacFilePath, beforeDeploymentScriptPath);

                    Logger.AppendEmptyLine();
                    Logger.AppendLine("DacDeployer has completed compilation.");
                }
                else if (mode == Mode.Deploy)
                {
                    var publishProfile = new PublishProfile(publishProfileFilePath);

                    var beforeDeploymentScriptPath = PathResolver.GetBeforeDeploymentPath(dacPacFolderPath);

                    Logger.LogResolvedPaths(dacPacFolderPath, dacPacFilePath, publishProfileFolderPath, publishProfileFilePath, beforeDeploymentScriptPath);

                    Logger.AppendLine("DacDeployer has started deployment:");
                    Logger.AppendEmptyLine();

                    if (DeploymentSteps.ExecuteBeforeDeployment(beforeDeploymentScriptPath, publishProfile))
                    {
                        DeploymentSteps.DeployDacPac(dacPacFilePath, publishProfile);

                        Logger.AppendEmptyLine();
                        Logger.AppendLine("DacDeployer has completed deployment.");
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.AppendEmptyLine();
                Logger.AppendLine("DacDeployer.exe exited with the following error:");
                Logger.AppendLine(ex.Message);
                Logger.AppendEmptyLine();
            }

            Logger.OutputLogToFile();

            PressAnyKey(mode);
        }
        public AppsResult Publish([FromBody] PublishProfile pp, string projectPath, string destinationFolder)
        {
            var result = new AppsResult();

            try
            {
                //Make sure there's an folder for this app
                System.IO.Directory.CreateDirectory(Environment.CurrentDirectory + "\\AppFolders\\App" + pp.AppID);

                //Pre-build
                if (pp.RunPreBuildScript)
                {
                    //Save to temp
                    string preBuildScriptPath = Environment.CurrentDirectory + "\\Business\\Ops\\PreBuildScripts\\App" + pp.AppID.ToString() + "PreBuild.csx";
                    System.IO.File.WriteAllText(preBuildScriptPath, pp.PreBuildScript);

                    Command.Exec("dotnet", "script", new Dictionary <string, string> {
                        { " ", "\"" + preBuildScriptPath + "\"" }
                    }, projectPath, ref result);

                    new AppFlows.Publish.Success("Successfully ran pre-build script for " + pp.Name + ".");
                }

                if (System.IO.File.Exists(projectPath))
                {
                    if (System.IO.Directory.Exists(destinationFolder))
                    {
                        Command.Exec("dotnet", "publish", new Dictionary <string, string> {
                            { "-o", "\"" + destinationFolder + "\"" },
                            { "", "\"" + projectPath + "\"" }
                        }, projectPath, ref result);

                        if (!result.SuccessMessages.Any(sm => sm.Contains("error")))
                        {
                            result.Success = true;
                            new AppFlows.Publish.Success("Successfully executed publish for " + pp.Name + ".");

                            if (pp.RunPostBuildScript)
                            {
                                var compileResult = Compile(pp.PostBuildScript);
                                if (compileResult.Success)
                                {
                                    //Save to temp
                                    string scriptPath = Environment.CurrentDirectory + "\\Business\\Ops\\PostBuildScripts\\App" + pp.AppID.ToString() + "PostPublish.csx";
                                    System.IO.File.WriteAllText(scriptPath, pp.PostBuildScript);

                                    Command.Exec("dotnet", "script", new Dictionary <string, string> {
                                        { " ", "\"" + scriptPath + "\"" }
                                    }, projectPath, ref result);

                                    new AppFlows.Publish.Success("Successfully ran post-publish script for " + pp.Name + ".");
                                }
                                else
                                {
                                    new AppFlows.Publish.Compile.Fail("Compile of post-publish script failed.", ref compileResult);
                                }
                            }
                            else
                            {
                                new AppFlows.Publish.Compile("Post-build scripts not enabled so not run.");
                            }
                        }
                        else
                        {
                            new AppFlows.Publish.Fail("Messages contain the work 'error'. Build and/or publish may have failed.", ref result);
                        }
                    }
                    else
                    {
                        new AppFlows.Publish.Fail("Cannot find destination folder.", ref result);
                    }
                }
                else
                {
                    new AppFlows.Publish.Fail("Cannot find project path.", ref result);
                }
            }
            catch (System.Exception ex)
            {
                new AppFlows.Publish.Exception(ex, ref result);
            }

            return(result);
        }
Пример #27
0
        public void AddPublishProfile(uint?width, uint?height, uint?kfinterval, uint?chunksize, uint?videobitrate, string profile, uint?audiobitrate, uint?audiosamplingfreqency, bool?stereo)
        {
            PublishProfile pubprof = new PublishProfile(RTMPServerType.Azure);

            pubprof.TargetEncodingProfile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.HD720p);

            pubprof.TargetEncodingProfile.Container = null;


            var srcvideoencodingprops = CurrentCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoRecord) as VideoEncodingProperties;
            var srcaudioencodingprops = CurrentCapture.AudioDeviceController.GetMediaStreamProperties(MediaStreamType.Audio) as AudioEncodingProperties;

            if (width != null)
            {
                pubprof.TargetEncodingProfile.Video.Width = width.Value;
            }
            else
            {
                pubprof.TargetEncodingProfile.Video.Width = srcvideoencodingprops.Width;
            }
            if (height != null)
            {
                pubprof.TargetEncodingProfile.Video.Height = height.Value;
            }
            else
            {
                pubprof.TargetEncodingProfile.Video.Height = srcvideoencodingprops.Height;
            }
            if (videobitrate != null)
            {
                pubprof.TargetEncodingProfile.Video.Bitrate = videobitrate.Value;
            }
            else
            {
                pubprof.TargetEncodingProfile.Video.Bitrate = srcvideoencodingprops.Bitrate;
            }

            if (kfinterval != null)
            {
                pubprof.KeyFrameInterval = kfinterval.Value;
            }

            if (chunksize != null)
            {
                pubprof.ClientChunkSize = chunksize.Value;
            }

            if (profile != null)
            {
                pubprof.TargetEncodingProfile.Video.ProfileId = profile.ToLowerInvariant() == "baseline" ? H264ProfileIds.Baseline : (profile.ToLowerInvariant() == "main" ? H264ProfileIds.Main : H264ProfileIds.High);
            }

            pubprof.TargetEncodingProfile.Video.FrameRate.Numerator   = srcvideoencodingprops.FrameRate.Numerator;
            pubprof.TargetEncodingProfile.Video.FrameRate.Denominator = srcvideoencodingprops.FrameRate.Denominator;

            if (audiobitrate != null)
            {
                pubprof.TargetEncodingProfile.Audio.Bitrate = audiobitrate.Value;
            }
            else
            {
                pubprof.TargetEncodingProfile.Audio.Bitrate = srcaudioencodingprops.Bitrate;
            }

            if (stereo != null)
            {
                pubprof.TargetEncodingProfile.Audio.ChannelCount = stereo.Value ? 2U : 1U;
            }
            else
            {
                pubprof.TargetEncodingProfile.Audio.Bitrate = srcaudioencodingprops.ChannelCount;
            }

            if (audiosamplingfreqency != null)
            {
                pubprof.TargetEncodingProfile.Audio.SampleRate = audiosamplingfreqency.Value;
            }
            else
            {
                pubprof.TargetEncodingProfile.Audio.SampleRate = srcaudioencodingprops.SampleRate;
            }



            _PublishProfiles.Add(pubprof);
        }