private async Task <string> CheckHost(string host, ConfiguratorSettings configuratorSettings)
        {
            string hostToCheckAgainst = null;

            switch (configuratorSettings.DeploymentSettings.DeploymentType)
            {
            case DeploymentType.Manual:
                break;

            case DeploymentType.ThisMachine:
                hostToCheckAgainst = new WebClient().DownloadString("http://icanhazip.com");
                break;

            case DeploymentType.RemoteMachine:
                hostToCheckAgainst = configuratorSettings.DeploymentSettings.Host;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            var errorMessage = string.IsNullOrEmpty(hostToCheckAgainst)
                ? "The domain was invalid."
                : $"The domain was either invalid or the DNS record did not seem to point to {hostToCheckAgainst}";

            if (!string.IsNullOrEmpty(host))
            {
                if (!await CheckHostDNSIsCorrect(host, hostToCheckAgainst))
                {
                    return(errorMessage);
                }
            }

            return(null);
        }
 private void SetConfiguratorSettings(ConfiguratorSettings settings)
 {
     if (TempData.ContainsKey(nameof(ConfiguratorSettings)))
     {
         TempData.Remove(nameof(ConfiguratorSettings));
     }
     TempData.Add(nameof(ConfiguratorSettings), JsonSerializer.Serialize(settings));
 }
        public async Task <ConfiguratorSettings> LoadSettingsThroughSSH(DeploymentSettings settings)
        {
            SSHSettings sshSettings = null;
            var         result      = new ConfiguratorSettings()
            {
                DeploymentSettings = settings
            };

            switch (settings.DeploymentType)
            {
            case DeploymentType.RemoteMachine when ModelState.IsValid:
            {
                sshSettings = new SSHSettings()
                {
                    Password = settings.Password,
                    Server   = settings.Host,
                    Username = settings.Username
                };

                break;
            }

            case DeploymentType.ThisMachine when ModelState.IsValid:
            {
                if (IsVerified)
                {
                    sshSettings = _options.Value.ParseSSHConfiguration();
                }
                break;
            }
            }

            using var ssh = await sshSettings.ConnectAsync();

            result.AdvancedSettings ??= new AdvancedSettings();
//                await ssh.RunBash(SSHClientExtensions.LoginAsRoot());

            var x = await ssh.RunBash("cat .env");

            Dictionary <string, string> preloadedEnvVars = new Dictionary <string, string>();

            if (x.ExitStatus == 0)
            {
                preloadedEnvVars = x.Output.Split("\n", StringSplitOptions.RemoveEmptyEntries)
                                   .Select(s => s.Split("=", StringSplitOptions.None)).ToDictionary(strings => strings[0],
                                                                                                    strings => strings.Length > 1 ? strings[1] : "");
            }
            x = await ssh.RunBash("cat /etc/profile.d/btcpay-env.sh");

            if (x.ExitStatus == 0)
            {
                preloadedEnvVars = x.Output.Split("\n", StringSplitOptions.RemoveEmptyEntries)
                                   .Where(s => s.Contains("=") && !s.Contains("==") && s.Contains("export"))
                                   .Select(s => s.Split("=", StringSplitOptions.None)).ToDictionary(strings => strings[0].Replace("export ", ""),
                                                                                                    strings => strings.Length > 1 ? strings[1].Trim('"') : "").Concat(preloadedEnvVars)
                                   .ToDictionary(pair => pair.Key, pair => pair.Value);
            }
            var branch = await
                         ssh.RunBash(
                "if [ -d \"btcpayserver-docker\" ]; then  git -C \"btcpayserver-docker\" rev-parse --abbrev-ref HEAD; fi");

            if (branch.ExitStatus == 0)
            {
                result.AdvancedSettings.BTCPayDockerBranch = branch.Output;
            }

            var repo = await
                       ssh.RunBash(
                "if [ -d \"btcpayserver-docker\" ]; then git -C \"btcpayserver-docker\" config --get remote.origin.url;  fi");

            if (repo.ExitStatus == 0)
            {
                result.AdvancedSettings.BTCPayDockerRepository = repo.Output;
            }


            result.AdvancedSettings.CustomBTCPayImage = await GetVar(preloadedEnvVars, ssh, "BTCPAY_IMAGE");

            result.AdvancedSettings.AdditionalFragments =
                (await GetVar(preloadedEnvVars, ssh, "BTCPAYGEN_ADDITIONAL_FRAGMENTS"))
                .Split(';', StringSplitOptions.RemoveEmptyEntries).Distinct().ToList();
            result.AdvancedSettings.ExcludedFragments =
                (await GetVar(preloadedEnvVars, ssh, "BTCPAYGEN_EXCLUDE_FRAGMENTS"))
                .Split(';', StringSplitOptions.RemoveEmptyEntries).Distinct().ToList();


            result.AdditionalServices ??= new AdditionalServices();
            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-librepatron"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-librepatron");
                result.AdditionalServices.LibrePatronSettings.Enabled = true;
                result.AdditionalServices.LibrePatronSettings.Host    =
                    await GetVar(preloadedEnvVars, ssh, "LIBREPATRON_HOST");
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-woocommerce"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-woocommerce");
                result.AdditionalServices.WooCommerceSettings.Enabled = true;
                result.AdditionalServices.WooCommerceSettings.Host    =
                    await GetVar(preloadedEnvVars, ssh, "WOOCOMMERCE_HOST");
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-btctransmuter"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-btctransmuter");
                result.AdditionalServices.BTCTransmuterSettings.Enabled = true;
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-configurator"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-configurator");
                result.AdditionalServices.ConfiguratorAddonSettings.Enabled = true;
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-electrum-ps"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-electrum-ps");
                result.AdditionalServices.ElectrumPersonalServerSettings.Enabled = true;
                result.AdditionalServices.ElectrumPersonalServerSettings.Xpub    =
                    await GetVar(preloadedEnvVars, ssh, "EPS_XPUB ");
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-electrumx"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-electrumx");
                result.AdditionalServices.ElectrumXSettings.Enabled = true;
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-thunderhub"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-thunderhub");
                result.AdditionalServices.ThunderHubSettings.Enabled = true;
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-tor-relay"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-tor-relay");
                result.AdditionalServices.TorRelaySettings.Enabled  = true;
                result.AdditionalServices.TorRelaySettings.Nickname =
                    await GetVar(preloadedEnvVars, ssh, "TOR_RELAY_NICKNAME");

                result.AdditionalServices.TorRelaySettings.Email =
                    await GetVar(preloadedEnvVars, ssh, "TOR_RELAY_EMAIL");
            }

            if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-pihole"))
            {
                result.AdvancedSettings.AdditionalFragments.Remove("opt-add-pihole");
                result.AdditionalServices.PiHoleSettings.Enabled  = true;
                result.AdditionalServices.PiHoleSettings.ServerIp =
                    await GetVar(preloadedEnvVars, ssh, "PIHOLE_SERVERIP");
            }

            result.LightningSettings ??= new LightningSettings();
            result.LightningSettings.Implementation = await GetVar(preloadedEnvVars, ssh, "BTCPAYGEN_LIGHTNING");

            if (string.IsNullOrEmpty(result.LightningSettings.Implementation))
            {
                result.LightningSettings.Implementation = "none";
            }
            result.LightningSettings.Alias = await GetVar(preloadedEnvVars, ssh, "LIGHTNING_ALIAS");

            var index = 1;

            result.ChainSettings ??= new ChainSettings();
            result.ChainSettings.Bitcoin = false;
            while (true)
            {
                var chain = await GetVar(preloadedEnvVars, ssh, $"BTCPAYGEN_CRYPTO{index}");

                if (string.IsNullOrEmpty(chain))
                {
                    break;
                }

                if (chain.Equals("btc", StringComparison.InvariantCultureIgnoreCase))
                {
                    result.ChainSettings.Bitcoin = true;
                }
                else
                {
                    result.ChainSettings.AltChains.Add(chain);
                }

                index++;
            }

            var matching =
                result.AdvancedSettings.AdditionalFragments.FirstOrDefault(s => s.StartsWith("opt-save-storage"));

            if (string.IsNullOrEmpty(matching))
            {
                result.ChainSettings.PruneMode = PruneMode.NoPruning;
            }
            else
            {
                result.AdvancedSettings.AdditionalFragments.Remove(matching);
                result.ChainSettings.PruneMode = matching.Replace("opt-save-storage", "") switch
                {
                    "" => PruneMode.Minimal,
                    "-s" => PruneMode.Small,
                    "-xs" => PruneMode.ExtraSmall,
                    "-xxs" => PruneMode.ExtraExtraSmall,
                    _ => result.ChainSettings.PruneMode
                };
            }

            if (Enum.TryParse <NetworkType>(await GetVar(preloadedEnvVars, ssh, "NBITCOIN_NETWORK"), true,
                                            out var networkType))
            {
                result.ChainSettings.Network = networkType;
            }

            result.DomainSettings ??= new DomainSettings();
            result.DomainSettings.Domain = await GetVar(preloadedEnvVars, ssh, "BTCPAY_HOST");

            result.DomainSettings.AdditionalDomains =
                (await GetVar(preloadedEnvVars, ssh, "BTCPAY_ADDITIONAL_HOSTS"))
                .Split(',', StringSplitOptions.RemoveEmptyEntries).ToList();

            result.ServerData = await ServerData.Load(ssh);

            return(result);
        }
    }
Beispiel #4
0
 private void SetConfiguratorSettings(ConfiguratorSettings settings)
 {
     SetTempData(nameof(ConfiguratorSettings), settings);
 }
        public async Task <ConfiguratorSettings> LoadSettingsThroughSSH(DeploymentSettings settings)
        {
            SSHSettings sshSettings = null;
            var         result      = new ConfiguratorSettings()
            {
                DeploymentSettings = settings
            };

            switch (settings.DeploymentType)
            {
            case DeploymentType.RemoteMachine when ModelState.IsValid:
            {
                sshSettings = new SSHSettings()
                {
                    Password = settings.Password,
                    Server   = settings.Host,
                    Username = settings.Username
                };

                break;
            }

            case DeploymentType.ThisMachine when ModelState.IsValid:
            {
                sshSettings = _options.Value.ParseSSHConfiguration();

                break;
            }
            }
            using (var ssh = await sshSettings.ConnectAsync())
            {
                result.AdvancedSettings ??= new AdvancedSettings();
                await ssh.RunBash(SSHClientExtensions.LoginAsRoot());

                var branch = await
                             ssh.RunBash(
                    "if [ -d \"btcpayserver-docker\" ]; then git -C \"btcpayserver-docker\" branch | grep \\* | cut -d \" \"  -f2; fi");

                if (branch.ExitStatus == 0)
                {
                    result.AdvancedSettings.BTCPayDockerBranch = branch.Output;
                }
                var repo = await
                           ssh.RunBash(
                    "if [ -d \"btcpayserver-docker\" ]; then git -C \"btcpayserver-docker\" ls-remote --get-url;  fi");

                if (branch.ExitStatus == 0)
                {
                    result.AdvancedSettings.BTCPayDockerRepository = repo.Output;
                }
                result.AdvancedSettings.CustomBTCPayImage = await ssh.GetEnvVar("BTCPAY_IMAGE");

                result.AdvancedSettings.AdditionalFragments = (await ssh.GetEnvVar("BTCPAYGEN_ADDITIONAL_FRAGMENTS"))
                                                              .Split(';', StringSplitOptions.RemoveEmptyEntries).ToList();
                result.AdvancedSettings.ExcludedFragments = (await ssh.GetEnvVar("BTCPAYGEN_EXCLUDE_FRAGMENTS"))
                                                            .Split(';', StringSplitOptions.RemoveEmptyEntries).ToList();



                result.AdditionalServices ??= new AdditionalServices();
                if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-librepatron"))
                {
                    result.AdvancedSettings.AdditionalFragments.Remove("opt-add-librepatron");
                    result.AdditionalServices.LibrePatronSettings.Enabled = true;
                    result.AdditionalServices.LibrePatronSettings.Host    = await ssh.GetEnvVar("LIBREPATRON_HOST");
                }

                if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-woocommerce"))
                {
                    result.AdvancedSettings.AdditionalFragments.Remove("opt-add-woocommerce");
                    result.AdditionalServices.WooCommerceSettings.Enabled = true;
                    result.AdditionalServices.WooCommerceSettings.Host    = await ssh.GetEnvVar("WOOCOMMERCE_HOST");
                }
                if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-btctransmuter"))
                {
                    result.AdvancedSettings.AdditionalFragments.Remove("opt-add-btctransmuter");
                    result.AdditionalServices.BTCTransmuterSettings.Enabled = true;
                    result.AdditionalServices.BTCTransmuterSettings.Host    = await ssh.GetEnvVar("BTCTRANSMUTER_HOST");
                }
                if (result.AdvancedSettings.AdditionalFragments.Contains("opt-add-tor-relay"))
                {
                    result.AdvancedSettings.AdditionalFragments.Remove("opt-add-tor-relay");
                    result.AdditionalServices.TorRelaySettings.Enabled  = true;
                    result.AdditionalServices.TorRelaySettings.Nickname = await ssh.GetEnvVar("TOR_RELAY_NICKNAME");

                    result.AdditionalServices.TorRelaySettings.Email = await ssh.GetEnvVar("TOR_RELAY_EMAIL");
                }

                result.LightningSettings ??= new LightningSettings();
                result.LightningSettings.Implementation = await ssh.GetEnvVar("BTCPAYGEN_LIGHTNING");

                result.LightningSettings.Alias = await ssh.GetEnvVar("LIGHTNING_ALIAS");

                var index = 1;
                result.ChainSettings ??= new ChainSettings();
                while (true)
                {
                    var chain = await ssh.GetEnvVar($"BTCPAYGEN_CRYPTO{index}");

                    if (string.IsNullOrEmpty(chain))
                    {
                        break;
                    }

                    if (chain.Equals("btc", StringComparison.InvariantCultureIgnoreCase))
                    {
                        result.ChainSettings.Bitcoin = true;
                    }
                    else
                    {
                        result.ChainSettings.AltChains.Add(chain);
                    }
                    index++;
                }

                var matching = result.AdvancedSettings.AdditionalFragments.FirstOrDefault(s => s.StartsWith("opt-save-storage"));
                if (string.IsNullOrEmpty(matching))
                {
                    result.ChainSettings.PruneMode = PruneMode.NoPruning;
                }
                else
                {
                    result.AdvancedSettings.AdditionalFragments.Remove(matching);
                    switch (matching.Replace("opt-save-storage-", ""))
                    {
                    case "":
                        result.ChainSettings.PruneMode = PruneMode.Minimal;
                        break;

                    case "s":
                        result.ChainSettings.PruneMode = PruneMode.Small;
                        break;

                    case "xs":
                        result.ChainSettings.PruneMode = PruneMode.ExtraSmall;
                        break;

                    case "xxs":
                        result.ChainSettings.PruneMode = PruneMode.ExtraExtraSmall;
                        break;
                    }
                }

                if (Enum.TryParse <NetworkType>(await ssh.GetEnvVar("NBITCOIN_NETWORK"), true, out var networkType))
                {
                    result.ChainSettings.Network = networkType;
                }

                result.DomainSettings ??= new DomainSettings();
                result.DomainSettings.Domain = await ssh.GetEnvVar("BTCPAY_HOST");

                result.DomainSettings.AdditionalDomains = (await ssh.GetEnvVar("BTCPAY_ADDITIONAL_HOSTS"))
                                                          .Split(',', StringSplitOptions.RemoveEmptyEntries).ToList();
            }

            return(result);
        }
 public ContentController(IOptions <ConfiguratorSettings> settings)
 {
     _settings   = settings.Value;
     _serviceUrl = _settings.Url + "ConfiguratorService/v3/ProductConfigurator.svc"; //TODO: need to sanitize URL to have an ending slash
 }