/// <summary>
/// Creates a new instance of the <see cref="IpfsEngine"/> class.
/// </summary>
public IpfsEngine(char[] passphrase)
{
this.passphrase = passphrase;
// Init the core api inteface.
Bitswap = new BitswapApi(this);
Block = new BlockApi(this);
Bootstrap = new BootstrapApi(this);
Config = new ConfigApi(this);
Dag = new DagApi(this);
Dht = new DhtApi(this);
FileSystem = new FileSystemApi(this);
Generic = new GenericApi(this);
Key = new KeyApi(this);
Name = new NameApi(this);
Object = new ObjectApi(this);
Pin = new PinApi(this);
PubSub = new PubSubApi(this);
Swarm = new SwarmApi(this);
}
void Init()
{
// Init the core api inteface.
Bitswap = new BitswapApi(this);
Block = new BlockApi(this);
BlockRepository = new BlockRepositoryApi(this);
Bootstrap = new BootstrapApi(this);
Config = new ConfigApi(this);
Dag = new DagApi(this);
Dht = new DhtApi(this);
Dns = new DnsApi(this);
FileSystem = new FileSystemApi(this);
Generic = new GenericApi(this);
Key = new KeyApi(this);
Name = new NameApi(this);
Object = new ObjectApi(this);
Pin = new PinApi(this);
PubSub = new PubSubApi(this);
Stats = new StatsApi(this);
Swarm = new SwarmApi(this);
// Async properties
LocalPeer = new AsyncLazy <Peer>(async() =>
{
log.Debug("Building local peer");
var keyChain = await KeyChain().ConfigureAwait(false);
log.Debug("Getting key info about self");
var self = await keyChain.FindKeyByNameAsync("self").ConfigureAwait(false);
var localPeer = new Peer
{
Id = self.Id,
PublicKey = await keyChain.GetPublicKeyAsync("self").ConfigureAwait(false),
ProtocolVersion = "ipfs/0.1.0"
};
var version = typeof(IpfsEngine).GetTypeInfo().Assembly.GetName().Version;
localPeer.AgentVersion = $"net-ipfs/{version.Major}.{version.Minor}.{version.Revision}";
log.Debug("Built local peer");
return(localPeer);
});
SwarmService = new AsyncLazy <Swarm>(async() =>
{
log.Debug("Building swarm service");
if (Options.Swarm.PrivateNetworkKey == null)
{
var path = Path.Combine(Options.Repository.Folder, "swarm.key");
if (File.Exists(path))
{
using (var x = File.OpenText(path))
{
Options.Swarm.PrivateNetworkKey = new PreSharedKey();
Options.Swarm.PrivateNetworkKey.Import(x);
}
}
}
var peer = await LocalPeer.ConfigureAwait(false);
var keyChain = await KeyChain().ConfigureAwait(false);
var self = await keyChain.GetPrivateKeyAsync("self").ConfigureAwait(false);
var swarm = new Swarm
{
LocalPeer = peer,
LocalPeerKey = PeerTalk.Cryptography.Key.CreatePrivateKey(self),
NetworkProtector = Options.Swarm.PrivateNetworkKey == null
? null
: new Psk1Protector {
Key = Options.Swarm.PrivateNetworkKey
}
};
if (Options.Swarm.PrivateNetworkKey != null)
{
log.Debug($"Private network {Options.Swarm.PrivateNetworkKey.Fingerprint().ToHexString()}");
}
log.Debug("Built swarm service");
return(swarm);
});
BitswapService = new AsyncLazy <BlockExchange.Bitswap>(async() =>
{
log.Debug("Building bitswap service");
var bitswap = new BlockExchange.Bitswap
{
Swarm = await SwarmService.ConfigureAwait(false),
BlockService = Block
};
log.Debug("Built bitswap service");
return(bitswap);
});
DhtService = new AsyncLazy <PeerTalk.Routing.Dht1>(async() =>
{
log.Debug("Building DHT service");
var dht = new PeerTalk.Routing.Dht1
{
Swarm = await SwarmService.ConfigureAwait(false)
};
dht.Swarm.Router = dht;
log.Debug("Built DHT service");
return(dht);
});
PubSubService = new AsyncLazy <PeerTalk.PubSub.NotificationService>(async() =>
{
log.Debug("Building PubSub service");
var pubsub = new PeerTalk.PubSub.NotificationService
{
LocalPeer = await LocalPeer.ConfigureAwait(false)
};
pubsub.Routers.Add(new PeerTalk.PubSub.FloodRouter
{
Swarm = await SwarmService.ConfigureAwait(false)
});
log.Debug("Built PubSub service");
return(pubsub);
});
}
/// <summary>
/// Starts the network services.
/// </summary>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
/// <remarks>
/// Starts the various IPFS and Lib.P2P network services. This should
/// be called after any configuration changes.
/// </remarks>
/// <exception cref="Exception">
/// When the engine is already started.
/// </exception>
public async Task StartAsync()
{
_dfsState.IsStarted = true;
if (_stopTasks.Count > 0)
{
throw new Exception("IPFS engine is already started.");
}
// Repository must be at the correct version.
await MigrationManager.MirgrateToVersionAsync(MigrationManager.LatestVersion).ConfigureAwait(false);
Log.Debug("starting " + LocalPeer.Id);
// Everybody needs the swarm.
_stopTasks.Add(async() => { await SwarmService.StopAsync().ConfigureAwait(false); });
await SwarmService.StartAsync().ConfigureAwait(false);
var peerManager = new PeerManager
{
SwarmService = SwarmService
};
await peerManager.StartAsync().ConfigureAwait(false);
_stopTasks.Add(async() => { await peerManager.StopAsync().ConfigureAwait(false); });
// Start the primary services.
var tasks = new List <Func <Task> >
{
async() =>
{
_stopTasks.Add(async() => await BitSwapService.StopAsync().ConfigureAwait(false));
await BitSwapService.StartAsync().ConfigureAwait(false);
},
async() =>
{
_stopTasks.Add(async() => await DhtService.StopAsync().ConfigureAwait(false));
await DhtService.StartAsync().ConfigureAwait(false);
},
async() =>
{
_stopTasks.Add(async() => await PingService.StopAsync().ConfigureAwait(false));
await PingService.StartAsync().ConfigureAwait(false);
},
async() =>
{
_stopTasks.Add(async() => await PubSubService.StopAsync().ConfigureAwait(false));
await PubSubService.StartAsync().ConfigureAwait(false);
}
};
Log.Debug("waiting for services to start");
await Task.WhenAll(tasks.Select(t => t())).ConfigureAwait(false);
// Starting listening to the swarm.
var json = await ConfigApi.GetAsync("Addresses.Swarm").ConfigureAwait(false);
var numberListeners = 0;
foreach (string a in json)
{
try
{
await SwarmService.StartListeningAsync(a).ConfigureAwait(false);
++numberListeners;
}
catch (Exception e)
{
Log.Warning($"Listener failure for '{a}'", e);
}
}
if (numberListeners == 0)
{
Log.Error("No listeners were created.");
}
// Now that the listener addresses are established, the discovery
// services can begin.
MulticastService multicast = null;
if (!Options.Discovery.DisableMdns)
{
multicast = new MulticastService();
#pragma warning disable CS1998
_stopTasks.Add(async() => multicast.Dispose());
#pragma warning restore CS1998
}
var autodialer = new AutoDialer(SwarmService)
{
MinConnections = Options.Swarm.MinConnections
};
#pragma warning disable CS1998
_stopTasks.Add(async() => autodialer.Dispose());
#pragma warning restore CS1998
tasks = new List <Func <Task> >
{
// Bootstrap discovery
async() =>
{
var bootstrap = new Bootstrap
{
Addresses = await BootstrapApi.ListAsync()
};
bootstrap.PeerDiscovered += OnPeerDiscovered;
_stopTasks.Add(async() => await bootstrap.StopAsync().ConfigureAwait(false));
await bootstrap.StartAsync().ConfigureAwait(false);
},
async() =>
{
if (Options.Discovery.DisableRandomWalk)
{
return;
}
var randomWalk = new RandomWalk {
Dht = DhtApi
};
_stopTasks.Add(async() => await randomWalk.StopAsync().ConfigureAwait(false));
await randomWalk.StartAsync().ConfigureAwait(false);
}
};
Log.Debug("waiting for discovery services to start");
await Task.WhenAll(tasks.Select(t => t())).ConfigureAwait(false);
multicast?.Start();
Log.Debug("started");
}
void Init()
{
// Init the core api inteface.
Bitswap = new BitswapApi(this);
Block = new BlockApi(this);
Bootstrap = new BootstrapApi(this);
Config = new ConfigApi(this);
Dag = new DagApi(this);
Dht = new DhtApi(this);
Dns = new DnsApi(this);
FileSystem = new FileSystemApi(this);
Generic = new GenericApi(this);
Key = new KeyApi(this);
Name = new NameApi(this);
Object = new ObjectApi(this);
Pin = new PinApi(this);
PubSub = new PubSubApi(this);
Stats = new StatsApi(this);
Swarm = new SwarmApi(this);
// Async properties
LocalPeer = new AsyncLazy <Peer>(async() =>
{
log.Debug("Building local peer");
var keyChain = await KeyChain();
log.Debug("Getting key info about self");
var self = await keyChain.FindKeyByNameAsync("self");
var localPeer = new Peer();
localPeer.Id = self.Id;
localPeer.PublicKey = await keyChain.GetPublicKeyAsync("self");
localPeer.ProtocolVersion = "ipfs/0.1.0";
var version = typeof(IpfsEngine).GetTypeInfo().Assembly.GetName().Version;
localPeer.AgentVersion = $"net-ipfs/{version.Major}.{version.Minor}.{version.Revision}";
log.Debug("Built local peer");
return(localPeer);
});
SwarmService = new AsyncLazy <Swarm>(async() =>
{
log.Debug("Building swarm service");
var peer = await LocalPeer;
var keyChain = await KeyChain();
var self = await keyChain.GetPrivateKeyAsync("self");
var swarm = new Swarm
{
LocalPeer = peer,
LocalPeerKey = PeerTalk.Cryptography.Key.CreatePrivateKey(self)
};
log.Debug("Built swarm service");
return(swarm);
});
BitswapService = new AsyncLazy <BlockExchange.Bitswap>(async() =>
{
log.Debug("Building bitswap service");
var bitswap = new BlockExchange.Bitswap
{
Swarm = await SwarmService,
BlockService = Block
};
log.Debug("Built bitswap service");
return(bitswap);
});
DhtService = new AsyncLazy <PeerTalk.Routing.Dht1>(async() =>
{
log.Debug("Building DHT service");
var dht = new PeerTalk.Routing.Dht1
{
Swarm = await SwarmService
};
dht.Swarm.Router = dht;
log.Debug("Built DHT service");
return(dht);
});
}
public Instance AddModuleInstance(ModuleEnum module, InstanceConfiguration instanceConfiguration)
{
var additionalProperties = instanceConfiguration.GetHashtable();
var config = new Config(
apiKey: instanceConfiguration.ApiKey,
host: instanceConfiguration.Host)
{
AutostartNotifications = instanceConfiguration.AutostartDaemon,
ForceClear = true,
LogLevel = LogLevel.ALL,
};
var instance = new Instance {
Id = Guid.NewGuid().ToString(), Module = module, CreatedAt = DateTime.Now
};
switch (module)
{
case ModuleEnum.AccountManagementApi:
var accountApi = new AccountManagementApi(config);
Instances.Add(instance, accountApi);
break;
case ModuleEnum.CertificatesApi:
var certApi = new CertificatesApi(config);
Instances.Add(instance, certApi);
break;
case ModuleEnum.ConnectApi:
var connectApi = new ConnectApi(config);
Instances.Add(instance, connectApi);
break;
case ModuleEnum.DeviceDirectoryApi:
var deviceApi = new DeviceDirectoryApi(config);
Instances.Add(instance, deviceApi);
break;
case ModuleEnum.StubAPI:
var stubApi = new StubApi(config);
Instances.Add(instance, stubApi);
break;
case ModuleEnum.UpdateApi:
var updateApi = new UpdateApi(config);
Instances.Add(instance, updateApi);
break;
case ModuleEnum.EnrollmentApi:
var enrollmentApi = new EnrollmentApi(config);
Instances.Add(instance, enrollmentApi);
break;
case ModuleEnum.BootstrapApi:
var bootstrapApi = new BootstrapApi(config);
Instances.Add(instance, bootstrapApi);
break;
case ModuleEnum.BillingApi:
var billingApi = new BillingApi(config);
Instances.Add(instance, billingApi);
break;
}
return(instance);
}
