1  using CodexClient;
  2  using CodexContractsPlugin;
  3  using CodexPlugin;
  4  using Core;
  5  using GethPlugin;
  6  using Utils;
  7  
  8  namespace CodexNetDeployer
  9  {
 10      public class CodexNodeStarter
 11      {
 12          private readonly Configuration config;
 13          private readonly CoreInterface ci;
 14          private readonly IGethNode gethNode;
 15          private readonly ICodexContracts contracts;
 16          private ICodexNode? bootstrapNode = null;
 17          private int validatorsLeft;
 18  
 19          public CodexNodeStarter(Configuration config, CoreInterface ci, IGethNode gethNode, ICodexContracts contracts, int numberOfValidators)
 20          {
 21              this.config = config;
 22              this.ci = ci;
 23              this.gethNode = gethNode;
 24              this.contracts = contracts;
 25              validatorsLeft = numberOfValidators;
 26          }
 27  
 28          public CodexNodeStartResult? Start(int i)
 29          {
 30              var name = GetCodexContainerName(i);
 31              Console.Write($" - {i} ({name})\t");
 32              Console.CursorLeft = 30;
 33  
 34              ICodexNode? codexNode = null;
 35              try
 36              {
 37                  codexNode = ci.StartCodexNode(s =>
 38                  {
 39                      s.WithName(name);
 40                      s.WithLogLevel(config.CodexLogLevel, new CodexLogCustomTopics(config.Discv5LogLevel, config.Libp2pLogLevel));
 41                      s.WithStorageQuota(config.StorageQuota!.Value.MB());
 42  
 43                      if (config.ShouldMakeStorageAvailable)
 44                      {
 45                          s.EnableMarketplace(gethNode, contracts, m =>
 46                          {
 47                              m.WithInitial(100.Eth(), config.InitialTestTokens.TstWei());
 48                              if (validatorsLeft > 0) m.AsValidator();
 49                              if (config.ShouldMakeStorageAvailable) m.AsStorageNode();
 50                          });
 51                      }
 52  
 53                      if (bootstrapNode != null) s.WithBootstrapNode(bootstrapNode);
 54                      if (config.MetricsEndpoints) s.EnableMetrics();
 55                      if (config.BlockTTL != Configuration.SecondsIn1Day) s.WithBlockTTL(TimeSpan.FromSeconds(config.BlockTTL));
 56                      if (config.BlockMI != Configuration.TenMinutes) s.WithBlockMaintenanceInterval(TimeSpan.FromSeconds(config.BlockMI));
 57                      if (config.BlockMN != 1000) s.WithBlockMaintenanceNumber(config.BlockMN);
 58  
 59                      if (config.IsPublicTestNet)
 60                      {
 61                          s.AsPublicTestNet(CreatePublicTestNetConfig(i));
 62                      }
 63                  });
 64              
 65                  var debugInfo = codexNode.GetDebugInfo();
 66                  if (!string.IsNullOrWhiteSpace(debugInfo.Spr))
 67                  {
 68                      Console.Write("Online\t");
 69  
 70                      if (config.ShouldMakeStorageAvailable)
 71                      {
 72                          var availability = new CreateStorageAvailability(
 73                              totalSpace: config.StorageSell!.Value.MB(),
 74                              maxDuration: TimeSpan.FromSeconds(config.MaxDuration),
 75                              minPricePerBytePerSecond: config.MinPricePerBytePerSecond.TstWei(),
 76                              totalCollateral: config.MaxCollateral.TstWei()
 77                          );
 78  
 79                          var response = codexNode.Marketplace.MakeStorageAvailable(availability);
 80  
 81                          if (!string.IsNullOrEmpty(response))
 82                          {
 83                              Console.Write("Storage available\t");
 84                          }
 85                          else throw new Exception("Failed to make storage available.");
 86                      }
 87                      
 88                      Console.Write("OK" + Environment.NewLine);
 89  
 90                      validatorsLeft--;
 91                      if (bootstrapNode == null) bootstrapNode = codexNode;
 92                      return new CodexNodeStartResult(codexNode);
 93                  }
 94              }
 95              catch (Exception ex)
 96              {
 97                  Console.WriteLine("Exception:" + ex.ToString());
 98              }
 99  
100              Console.WriteLine("Unknown failure.");
101              if (codexNode != null)
102              {
103                  Console.WriteLine("Downloading container log.");
104                  codexNode.DownloadLog();
105              }
106  
107              return null;
108          }
109  
110          private CodexTestNetConfig CreatePublicTestNetConfig(int i)
111          {
112              var discPort = config.PublicDiscPorts.Split(",")[i];
113              var listenPort = config.PublicListenPorts.Split(",")[i];
114  
115              return new CodexTestNetConfig
116              {
117                  PublicDiscoveryPort = Convert.ToInt32(discPort),
118                  PublicListenPort = Convert.ToInt32(listenPort)
119              };
120          }
121  
122          private string GetCodexContainerName(int i)
123          {
124              if (i == 0) return "BOOTSTRAP";
125              return "CODEX" + i;
126          }
127      }
128  
129      public class CodexNodeStartResult
130      {
131          public CodexNodeStartResult(ICodexNode codexNode)
132          {
133              CodexNode = codexNode;
134          }
135  
136          public ICodexNode CodexNode { get; }
137      }
138  }