/// <summary>
/// Initializes a new instance of the <see cref="ConversationsController"/> class.
/// </summary>
/// <param name="soulseekClient"></param>
/// <param name="applicationStateMonotor"></param>
/// <param name="tracker"></param>
public ConversationsController(
ISoulseekClient soulseekClient,
IStateMonitor <State> applicationStateMonotor,
IConversationTracker tracker)
{
Client = soulseekClient;
ApplicationStateMonitor = applicationStateMonotor;
Tracker = tracker;
}
public void Configure(
IApplicationBuilder app,
IWebHostEnvironment env,
IApiVersionDescriptionProvider provider,
ITransferTracker tracker,
IBrowseTracker browseTracker,
IConversationTracker conversationTracker,
IRoomTracker roomTracker)
{
if (!env.IsDevelopment())
{
app.UseHsts();
}
app.UseCors("AllowAll");
BasePath = BasePath ?? "/";
BasePath = BasePath.StartsWith("/") ? BasePath : $"/{BasePath}";
app.UsePathBase(BasePath);
// remove any errant double forward slashes which may have been introduced
// by a reverse proxy or having the base path removed
app.Use(async(context, next) =>
{
var path = context.Request.Path.ToString();
if (path.StartsWith("//"))
{
context.Request.Path = new string(path.Skip(1).ToArray());
}
await next();
});
WebRoot = WebRoot ?? Path.Combine(Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().GetName().CodeBase).AbsolutePath), "wwwroot");
Console.WriteLine($"Serving static content from {WebRoot}");
var fileServerOptions = new FileServerOptions
{
FileProvider = new PhysicalFileProvider(WebRoot),
RequestPath = "",
EnableDirectoryBrowsing = false,
EnableDefaultFiles = true
};
app.UseFileServer(fileServerOptions);
app.UseAuthentication();
app.UseMvc();
app.UseSwagger();
app.UseSwaggerUI(options => provider.ApiVersionDescriptions.ToList()
.ForEach(description => options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName)));
// if we made it this far and the route still wasn't matched, return the index
// this is required so that SPA routing (React Router, etc) can work properly
app.Use(async(context, next) =>
{
// exclude API routes which are not matched or return a 404
if (!context.Request.Path.StartsWithSegments("/api"))
{
context.Request.Path = "/";
}
await next();
});
app.UseFileServer(fileServerOptions);
// ---------------------------------------------------------------------------------------------------------------------------------------------
// begin SoulseekClient implementation
// ---------------------------------------------------------------------------------------------------------------------------------------------
var connectionOptions = new ConnectionOptions(
readBufferSize: ReadBufferSize,
writeBufferSize: WriteBufferSize,
connectTimeout: ConnectTimeout,
inactivityTimeout: InactivityTimeout);
// create options for the client.
// see the implementation of Func<> and Action<> options for detailed info.
var clientOptions = new SoulseekClientOptions(
listenPort: ListenPort,
userEndPointCache: new UserEndPointCache(),
distributedChildLimit: DistributedChildLimit,
enableDistributedNetwork: EnableDistributedNetwork,
minimumDiagnosticLevel: DiagnosticLevel,
autoAcknowledgePrivateMessages: false,
serverConnectionOptions: connectionOptions,
peerConnectionOptions: connectionOptions,
transferConnectionOptions: connectionOptions,
userInfoResponseResolver: UserInfoResponseResolver,
browseResponseResolver: BrowseResponseResolver,
directoryContentsResponseResolver: DirectoryContentsResponseResolver,
enqueueDownloadAction: (username, endpoint, filename) => EnqueueDownloadAction(username, endpoint, filename, tracker),
searchResponseResolver: SearchResponseResolver);
Client = new SoulseekClient(options: clientOptions);
// bind the DiagnosticGenerated event so we can trap and display diagnostic messages. this is optional, and if the event
// isn't bound the minimumDiagnosticLevel should be set to None.
Client.DiagnosticGenerated += (e, args) =>
{
lock (ConsoleSyncRoot)
{
if (args.Level == DiagnosticLevel.Debug)
{
Console.ForegroundColor = ConsoleColor.DarkGray;
}
if (args.Level == DiagnosticLevel.Warning)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] [DIAGNOSTIC:{e.GetType().Name}] [{args.Level}] {args.Message}");
Console.ResetColor();
}
};
// bind transfer events. see TransferStateChangedEventArgs and TransferProgressEventArgs.
Client.TransferStateChanged += (e, args) =>
{
var direction = args.Transfer.Direction.ToString().ToUpper();
var user = args.Transfer.Username;
var file = Path.GetFileName(args.Transfer.Filename);
var oldState = args.PreviousState;
var state = args.Transfer.State;
var completed = args.Transfer.State.HasFlag(TransferStates.Completed);
Console.WriteLine($"[{direction}] [{user}/{file}] {oldState} => {state}{(completed ? $" ({args.Transfer.BytesTransferred}/{args.Transfer.Size} = {args.Transfer.PercentComplete}%) @ {args.Transfer.AverageSpeed.SizeSuffix()}/s" : string.Empty)}");
};
Client.TransferProgressUpdated += (e, args) =>
{
// this is really verbose.
// Console.WriteLine($"[{args.Transfer.Direction.ToString().ToUpper()}] [{args.Transfer.Username}/{Path.GetFileName(args.Transfer.Filename)}] {args.Transfer.BytesTransferred}/{args.Transfer.Size} {args.Transfer.PercentComplete}% {args.Transfer.AverageSpeed}kb/s");
};
// bind BrowseProgressUpdated to track progress of browse response payload transfers.
// these can take a while depending on number of files shared.
Client.BrowseProgressUpdated += (e, args) =>
{
browseTracker.AddOrUpdate(args.Username, args);
};
// bind UserStatusChanged to monitor the status of users added via AddUserAsync().
Client.UserStatusChanged += (e, args) =>
{
// Console.WriteLine($"[USER] {args.Username}: {args.Status}");
};
Client.PrivateMessageReceived += (e, args) =>
{
conversationTracker.AddOrUpdate(args.Username, PrivateMessage.FromEventArgs(args));
};
Client.RoomMessageReceived += (e, args) =>
{
var message = RoomMessage.FromEventArgs(args, DateTime.UtcNow);
roomTracker.AddOrUpdateMessage(args.RoomName, message);
};
Client.RoomJoined += (e, args) =>
{
if (args.Username != Username) // this will fire when we join a room; track that through the join operation.
{
roomTracker.TryAddUser(args.RoomName, args.UserData);
}
};
Client.RoomLeft += (e, args) =>
{
roomTracker.TryRemoveUser(args.RoomName, args.Username);
};
Client.Disconnected += async(e, args) =>
{
Console.WriteLine($"Disconnected from Soulseek server: {args.Message}");
// don't reconnect if the disconnecting Exception is either of these types.
// if KickedFromServerException, another client was most likely signed in, and retrying will cause a connect loop.
// if ObjectDisposedException, the client is shutting down.
if (!(args.Exception is KickedFromServerException || args.Exception is ObjectDisposedException))
{
Console.WriteLine($"Attepting to reconnect...");
await Client.ConnectAsync(Username, Password);
}
};
Task.Run(async() =>
{
await Client.ConnectAsync(Username, Password);
}).GetAwaiter().GetResult();
Console.WriteLine($"Connected and logged in.");
}
/// <summary>
/// Initializes a new instance of the <see cref="ConversationsController"/> class.
/// </summary>
/// <param name="client"></param>
/// <param name="tracker"></param>
public ConversationsController(ISoulseekClient client, IConversationTracker tracker)
{
Client = client;
Tracker = tracker;
}
public Application(
OptionsAtStartup optionsAtStartup,
IOptionsMonitor <Options> optionsMonitor,
IManagedState <State> state,
ISoulseekClient soulseekClient,
IConnectionWatchdog connectionWatchdog,
ITransferService transferService,
IBrowseTracker browseTracker,
IConversationTracker conversationTracker,
IRoomTracker roomTracker,
IRoomService roomService,
IUserService userService,
IShareService shareService,
IPushbulletService pushbulletService,
IHubContext <ApplicationHub> applicationHub,
IHubContext <LogsHub> logHub)
{
Console.CancelKeyPress += (_, args) =>
{
ShuttingDown = true;
Log.Warning("Received SIGINT");
};
foreach (var signal in new[] { PosixSignal.SIGINT, PosixSignal.SIGQUIT, PosixSignal.SIGTERM })
{
PosixSignalRegistration.Create(signal, context =>
{
ShuttingDown = true;
Log.Fatal("Received {Signal}", signal);
});
}
OptionsAtStartup = optionsAtStartup;
OptionsMonitor = optionsMonitor;
OptionsMonitor.OnChange(async options => await OptionsMonitor_OnChange(options));
PreviousOptions = OptionsMonitor.CurrentValue;
CompiledSearchResponseFilters = OptionsAtStartup.Filters.Search.Request.Select(f => new Regex(f, RegexOptions.Compiled));
State = state;
State.OnChange(state => State_OnChange(state));
Shares = shareService;
Shares.StateMonitor.OnChange(state => ShareState_OnChange(state));
Transfers = transferService;
BrowseTracker = browseTracker;
ConversationTracker = conversationTracker;
Pushbullet = pushbulletService;
RoomService = roomService;
Users = userService;
ApplicationHub = applicationHub;
LogHub = logHub;
Program.LogEmitted += (_, log) => LogHub.EmitLogAsync(log);
Client = soulseekClient;
Client.DiagnosticGenerated += Client_DiagnosticGenerated;
Client.TransferStateChanged += Client_TransferStateChanged;
Client.TransferProgressUpdated += Client_TransferProgressUpdated;
Client.BrowseProgressUpdated += Client_BrowseProgressUpdated;
Client.UserStatusChanged += Client_UserStatusChanged;
Client.PrivateMessageReceived += Client_PrivateMessageRecieved;
Client.PrivateRoomMembershipAdded += (e, room) => Log.Information("Added to private room {Room}", room);
Client.PrivateRoomMembershipRemoved += (e, room) => Log.Information("Removed from private room {Room}", room);
Client.PrivateRoomModerationAdded += (e, room) => Log.Information("Promoted to moderator in private room {Room}", room);
Client.PrivateRoomModerationRemoved += (e, room) => Log.Information("Demoted from moderator in private room {Room}", room);
Client.PublicChatMessageReceived += Client_PublicChatMessageReceived;
Client.RoomMessageReceived += Client_RoomMessageReceived;
Client.Disconnected += Client_Disconnected;
Client.Connected += Client_Connected;
Client.LoggedIn += Client_LoggedIn;
Client.StateChanged += Client_StateChanged;
Client.DistributedNetworkStateChanged += Client_DistributedNetworkStateChanged;
Client.DownloadDenied += (e, args) => Log.Information("Download of {Filename} from {Username} was denied: {Message}", args.Filename, args.Username, args.Message);
Client.DownloadFailed += (e, args) => Log.Information("Download of {Filename} from {Username} failed", args.Filename, args.Username);
ConnectionWatchdog = connectionWatchdog;
}
