public SyncthingDebugFacilitiesManager(SynchronizedTransientWrapper<ISyncthingApiClient> apiClient, ISyncthingCapabilities capabilities)
{
this.apiClient = apiClient;
this.capabilities = capabilities;
this.SupportsRestartlessUpdate = false;
this.DebugFacilities = new List<DebugFacility>();
}
public SyncthingDebugFacilitiesManager(SynchronizedTransientWrapper <ISyncthingApiClient> apiClient, ISyncthingCapabilities capabilities)
{
this.apiClient = apiClient;
this.capabilities = capabilities;
this.SupportsRestartlessUpdate = false;
this.DebugFacilities = new List <DebugFacility>();
}
public SyncthingDeviceManager(SynchronizedTransientWrapper <ISyncthingApiClient> apiClient, ISyncthingEventWatcher eventWatcher, ISyncthingCapabilities capabilities)
{
this.eventDispatcher = new SynchronizedEventDispatcher(this);
this.apiClient = apiClient ?? throw new ArgumentNullException(nameof(apiClient));
this.eventWatcher = eventWatcher ?? throw new ArgumentNullException(nameof(eventWatcher));
this.capabilities = capabilities ?? throw new ArgumentNullException(nameof(capabilities));
this.eventWatcher.DeviceConnected += this.EventDeviceConnected;
this.eventWatcher.DeviceDisconnected += this.EventDeviceDisconnected;
this.eventWatcher.DevicePaused += this.EventDevicePaused;
this.eventWatcher.DeviceResumed += this.EventDeviceResumed;
}
public SyncthingDeviceManager(SynchronizedTransientWrapper <ISyncthingApiClient> apiClient, ISyncthingEventWatcher eventWatcher, ISyncthingCapabilities capabilities)
{
this.eventDispatcher = new SynchronizedEventDispatcher(this);
this.apiClient = apiClient;
this.eventWatcher = eventWatcher;
this.capabilities = capabilities;
this.eventWatcher.DeviceConnected += this.EventDeviceConnected;
this.eventWatcher.DeviceDisconnected += this.EventDeviceDisconnected;
this.eventWatcher.DevicePaused += this.EventDevicePaused;
this.eventWatcher.DeviceResumed += this.EventDeviceResumed;
}
public SyncthingDeviceManager(SynchronizedTransientWrapper<ISyncthingApiClient> apiClient, ISyncthingEventWatcher eventWatcher, ISyncthingCapabilities capabilities)
{
this.eventDispatcher = new SynchronizedEventDispatcher(this);
this.apiClient = apiClient;
this.eventWatcher = eventWatcher;
this.capabilities = capabilities;
this.eventWatcher.DeviceConnected += this.EventDeviceConnected;
this.eventWatcher.DeviceDisconnected += this.EventDeviceDisconnected;
this.eventWatcher.DevicePaused += this.EventDevicePaused;
this.eventWatcher.DeviceResumed += this.EventDeviceResumed;
}
public SyncThingFolderManager(
SynchronizedTransientWrapper<ISyncThingApiClient> apiClient,
ISyncThingEventWatcher eventWatcher,
TimeSpan ignoresFetchTimeout)
{
this.eventDispatcher = new SynchronizedEventDispatcher(this);
this.apiClient = apiClient;
this.ignoresFetchTimeout = ignoresFetchTimeout;
this.eventWatcher = eventWatcher;
this.eventWatcher.SyncStateChanged += (o, e) => this.FolderSyncStateChanged(e);
this.eventWatcher.ItemStarted += (o, e) => this.ItemStarted(e.Folder, e.Item);
this.eventWatcher.ItemFinished += (o, e) => this.ItemFinished(e.Folder, e.Item);
}
public SyncthingFolderManager(
SynchronizedTransientWrapper <ISyncthingApiClient> apiClient,
ISyncthingEventWatcher eventWatcher)
{
this.eventDispatcher = new SynchronizedEventDispatcher(this);
this.apiClient = apiClient;
this.eventWatcher = eventWatcher;
this.eventWatcher.SyncStateChanged += (o, e) => this.FolderSyncStateChanged(e);
this.eventWatcher.FolderStatusChanged += (o, e) => this.FolderStatusChanged(e.FolderId, e.FolderStatus);
this.eventWatcher.ItemStarted += (o, e) => this.ItemStarted(e.Folder, e.Item);
this.eventWatcher.ItemFinished += (o, e) => this.ItemFinished(e.Folder, e.Item);
this.eventWatcher.FolderErrorsChanged += (o, e) => this.FolderErrorsChangedEvt(e.FolderId, e.Errors);
}
public ISyncThingEventWatcher CreateEventWatcher(SynchronizedTransientWrapper<ISyncThingApiClient> apiClient)
{
return new SyncThingEventWatcher(apiClient);
}
public SyncthingManager(
ISyncthingProcessRunner processRunner,
ISyncthingApiClientFactory apiClientFactory,
ISyncthingEventWatcherFactory eventWatcherFactory,
ISyncthingConnectionsWatcherFactory connectionsWatcherFactory,
IFreePortFinder freePortFinder)
{
this.StartedTime = DateTime.MinValue;
this.LastConnectivityEventTime = DateTime.MinValue;
this.eventDispatcher = new SynchronizedEventDispatcher(this);
this.processRunner = processRunner;
this.apiClientFactory = apiClientFactory;
this.freePortFinder = freePortFinder;
this.apiClient = new SynchronizedTransientWrapper<ISyncthingApiClient>(this.apiClientsLock);
this.eventWatcher = eventWatcherFactory.CreateEventWatcher(this.apiClient);
this.eventWatcher.DeviceConnected += (o, e) => this.LastConnectivityEventTime = DateTime.UtcNow;
this.eventWatcher.DeviceDisconnected += (o, e) => this.LastConnectivityEventTime = DateTime.UtcNow;
this.eventWatcher.ConfigSaved += (o, e) => this.ReloadConfigDataAsync();
this.eventWatcher.EventsSkipped += (o, e) => this.ReloadConfigDataAsync();
this.connectionsWatcher = connectionsWatcherFactory.CreateConnectionsWatcher(this.apiClient);
this.connectionsWatcher.TotalConnectionStatsChanged += (o, e) => this.OnTotalConnectionStatsChanged(e.TotalConnectionStats);
this._folders = new SyncthingFolderManager(this.apiClient, this.eventWatcher, TimeSpan.FromMinutes(10));
this._devices = new SyncthingDeviceManager(this.apiClient, this.eventWatcher, this.Capabilities);
this._transferHistory = new SyncthingTransferHistory(this.eventWatcher, this._folders);
this._debugFacilities = new SyncthingDebugFacilitiesManager(this.apiClient, this.Capabilities);
this.processRunner.ProcessStopped += (o, e) => this.ProcessStopped(e.ExitStatus);
this.processRunner.MessageLogged += (o, e) => this.OnMessageLogged(e.LogMessage);
this.processRunner.ProcessRestarted += (o, e) => this.ProcessRestarted();
this.processRunner.Starting += (o, e) => this.ProcessStarting();
}
public ISyncThingConnectionsWatcher CreateConnectionsWatcher(SynchronizedTransientWrapper<ISyncThingApiClient> apiClient)
{
return new SyncThingConnectionsWatcher(apiClient);
}
private async Task<Ignores> FetchFolderIgnoresAsync(string folderId, CancellationToken cancellationToken)
{
// Until startup is complete, these can return a 500.
// There's no sensible way to determine when startup *is* complete, so we just have to keep trying...
// Again, there's the possibility that we've just abort the API...
ISyncThingApiClient apiClient;
lock (this.apiClient.LockObject)
{
cancellationToken.ThrowIfCancellationRequested();
apiClient = this.apiClient.UnsynchronizedValue;
if (apiClient == null)
throw new InvalidOperationException("ApiClient must not be null");
}
Ignores ignores = null;
// We used to time out after an absolute time here. However, there's the possiblity of going to sleep
// halfway through polling, which throws things off. Therefore use a number of iterations
var numRetries = this.ignoresFetchTimeout.TotalSeconds; // Each iteration is a second
for (var retriesCount = 0; retriesCount < numRetries; retriesCount++)
{
try
{
ignores = await apiClient.FetchIgnoresAsync(folderId);
// No need to log: ApiClient did that for us
break;
}
catch (ApiException e)
{
logger.Debug("Attempting to fetch folder {0}, but received status {1}", folderId, e.StatusCode);
if (e.StatusCode != HttpStatusCode.InternalServerError)
throw;
}
await Task.Delay(1000, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
}
if (ignores == null)
throw new SyncThingDidNotStartCorrectlyException($"Unable to fetch ignores for folder {folderId}. Syncthing returned 500 after {this.ignoresFetchTimeout}");
return ignores;
}
public SyncThingConnectionsWatcher(SynchronizedTransientWrapper<ISyncThingApiClient> apiClient)
: base(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10))
{
this.apiClientWrapper = apiClient;
}
public ISyncthingEventWatcher CreateEventWatcher(SynchronizedTransientWrapper <ISyncthingApiClient> apiClient)
{
return(new SyncthingEventWatcher(apiClient));
}
public SyncThingEventWatcher(SynchronizedTransientWrapper<ISyncThingApiClient> apiClient)
: base(TimeSpan.Zero, TimeSpan.FromSeconds(10))
{
this.apiClientWrapper = apiClient;
}
public SyncthingEventWatcher(SynchronizedTransientWrapper <ISyncthingApiClient> apiClient)
: base(TimeSpan.Zero, TimeSpan.FromSeconds(10))
{
this.apiClientWrapper = apiClient;
}
private async Task LoadStartupDataAsync(CancellationToken cancellationToken)
{
logger.Debug("Startup Complete! Loading startup data");
// There's a race where Syncthing died, and so we kill the API clients and set it to null,
// but we still end up here, because threading.
ISyncThingApiClient apiClient;
lock (this.apiClientsLock)
{
cancellationToken.ThrowIfCancellationRequested();
apiClient = this.apiClient.UnsynchronizedValue;
if (apiClient == null)
throw new InvalidOperationException("ApiClient must not be null");
}
var configTask = apiClient.FetchConfigAsync();
var systemTask = apiClient.FetchSystemInfoAsync();
var versionTask = apiClient.FetchVersionAsync();
var connectionsTask = apiClient.FetchConnectionsAsync();
cancellationToken.ThrowIfCancellationRequested();
await Task.WhenAll(configTask, systemTask, versionTask, connectionsTask);
// We can potentially see duplicate devices (if the user set their config file that way). Ignore them.
var devices = configTask.Result.Devices.DistinctBy(x => x.DeviceID).Select(device =>
{
var deviceObj = new Device(device.DeviceID, device.Name);
ItemConnectionData connectionData;
if (connectionsTask.Result.DeviceConnections.TryGetValue(device.DeviceID, out connectionData))
deviceObj.SetConnected(connectionData.Address);
return deviceObj;
});
this.devices = new ConcurrentDictionary<string, Device>(devices.Select(x => new KeyValuePair<string, Device>(x.DeviceId, x)));
await this._folders.LoadFoldersAsync(configTask.Result, systemTask.Result, cancellationToken);
this.Version = versionTask.Result;
cancellationToken.ThrowIfCancellationRequested();
this.StartedTime = DateTime.UtcNow;
this.IsDataLoaded = true;
this.OnDataLoaded();
}
