Skip to content

Commit 8c17d3c

Browse files
Squidman95Squidman95
committed
Removed http and while thread
1 parent dd87819 commit 8c17d3c

File tree

5 files changed

+113
-84
lines changed

5 files changed

+113
-84
lines changed

‎App/API/Endpoints.cs

+2
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,8 @@ public Endpoints(WebApplication app)
3535
// To maintain connection
3636
app.MapGet("ping", (HttpContext httpContext) =>
3737
{
38+
//var appUrl = app.Urls.FirstOrDefault();
39+
//Console.WriteLine("Repo URL: " + appUrl);
3840
return "pong";
3941
});
4042

‎App/Database/FileDatabase.cs

+47-39
Original file line numberDiff line numberDiff line change
@@ -15,60 +15,63 @@ public class FileDatabase : IFileDatabase
1515
{
1616
static readonly string pathToResources = Path.Combine(Directory.GetCurrentDirectory(), "Resources");
1717
static readonly string pathToMetadata = Path.Combine(pathToResources, "resourceMetadata.json");
18-
static ConcurrentQueue<MetadataObject> metadataQueue = new ConcurrentQueue<MetadataObject>();
19-
18+
//static ConcurrentQueue<MetadataObject> metadataQueue = new ConcurrentQueue<MetadataObject>();
2019
static ConcurrentDictionary<string, long> dynamicFiles = new();
2120
// 1.000ms = 1s. 30.000ms = 30s. 300.000ms = 5min
2221
static readonly long millisecondsToWait = 30000; // 30 seconds before dynamic resources are changed
2322

24-
static Thread? MetadataThread;
25-
static Thread? FileThread;
26-
27-
//static Thread? FileThread;
23+
//static Thread? MetadataThread;
24+
static Thread? DynamicThread;
2825
public FileDatabase()
2926
{
30-
if (MetadataThread == null)
31-
{
32-
Console.WriteLine("Creating MetadataThread");
33-
MetadataThread = new Thread(() =>
34-
{
35-
while (true)
36-
{
37-
if (!metadataQueue.IsEmpty)
38-
{
39-
metadataQueue.TryDequeue(out MetadataObject? metadataObject);
40-
UpdateMetadataFile(metadataObject);
41-
}
42-
}
43-
});
44-
MetadataThread.Name = Guid.NewGuid().ToString();
45-
MetadataThread.Start();
46-
}
47-
if (FileThread == null)
27+
#region metadatathread
28+
//if (MetadataThread == null)
29+
//{
30+
// Console.WriteLine("Creating MetadataThread");
31+
// MetadataThread = new Thread(() =>
32+
// {
33+
// while (true)
34+
// {
35+
// if (!metadataQueue.IsEmpty)
36+
// {
37+
// metadataQueue.TryDequeue(out MetadataObject? metadataObject);
38+
// UpdateMetadataFile(metadataObject);
39+
// }
40+
// }
41+
// });
42+
// MetadataThread.Name = Guid.NewGuid().ToString();
43+
// MetadataThread.Start();
44+
//}
45+
#endregion
46+
47+
#region dynamicthread
48+
if (DynamicThread == null)
4849
{
49-
Console.WriteLine("Creating FileThread");
50-
FileThread = new Thread(() =>
50+
Console.WriteLine("Creating DynamicThread");
51+
DynamicThread = new Thread(() =>
5152
{
5253
while (true)
5354
{
5455
foreach (var dynamicFile in dynamicFiles)
5556
{
56-
var newTime = (long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalMilliseconds - millisecondsToWait;
57+
var currentTime = (long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalMilliseconds;
58+
var newTime = currentTime - millisecondsToWait;
5759
//Console.WriteLine($"Dynamicfile key: {dynamicFile.Key} and Dynamicfile value: {dynamicFile.Value} and New time: {newTime}");
5860
if (dynamicFile.Value < newTime)
5961
{
60-
Console.WriteLine($"No update to dynamic in {millisecondsToWait * 1000} seconds. Setting Dynamic to false and removing from dynamicFiles.");
62+
Console.WriteLine($"No update to dynamic in {(dynamicFile.Value - currentTime) * 1000} seconds. Setting Dynamic to false and removing from dynamicFiles.");
6163
// TODO: Consider that we can technically queue the update to Dynamic in metadata, remove it from "dynamicFiles" and then receive an update in the meantime. Very unlikely, but possible. And does it matter?
62-
SetDynamicToFalse(dynamicFile.Key);
64+
SetDynamicToFalse(dynamicFile.Key);
6365
dynamicFiles.TryRemove(dynamicFile);
6466
}
6567
}
66-
Thread.Sleep(2000); // TODO: We don't really have to sleep here, it's just to make prints more managable.
68+
Thread.Sleep((int)millisecondsToWait); // Sleep here to reduce processing requirements
6769
}
6870
});
69-
FileThread.Name = Guid.NewGuid().ToString();
70-
FileThread.Start();
71+
DynamicThread.Name = Guid.NewGuid().ToString();
72+
DynamicThread.Start();
7173
}
74+
#endregion
7275
}
7376
public bool ContainsKey(string key)
7477
{
@@ -86,8 +89,9 @@ public bool ContainsKey(string key)
8689

8790
public void UpdateMetadataObject(MetadataObject metadataObject)
8891
{
89-
metadataQueue.Enqueue(metadataObject);
90-
Console.WriteLine($"Adding metadata object to queue with length {metadataQueue.Count()} on Thread: {MetadataThread.Name}");
92+
UpdateMetadataFile(metadataObject);
93+
//metadataQueue.Enqueue(metadataObject);
94+
//Console.WriteLine($"Adding metadata object to queue with length {metadataQueue.Count()} on Thread: {MetadataThread.Name}");
9195
}
9296

9397
public void UpdateDynamicResourceTime(string resourceId)
@@ -146,11 +150,15 @@ private void UpdateMetadataFile(MetadataObject? metadataObject)
146150

147151
// TODO: (Lock might have fixed this) Following error can still occur despite queue: The process cannot access the file because it is being used by another process
148152
//File.WriteAllText(pathToMetadata, updatedMetadataJsonString);
149-
lock (Globals.FileAccessLock)
150-
{
151-
File.WriteAllText(pathToMetadata, updatedMetadataJsonString);
152-
}
153-
153+
154+
//lock (Globals.FileAccessLock)
155+
//{
156+
// File.WriteAllText(pathToMetadata, updatedMetadataJsonString);
157+
//}
158+
159+
updatedMetadataJsonString.Write(pathToMetadata);
160+
161+
154162
}
155163
catch (IOException ioe)
156164
{

‎App/Database/MultiThreadFileWriter.cs

+57-39
Original file line numberDiff line numberDiff line change
@@ -3,49 +3,67 @@
33
namespace Repository.App.Database
44
{
55
// TODO: This class may be another way of writing to files from multiple threads in a safe way.
6-
public class MultiThreadFileWriter
6+
public static class MultiThreadFileWriter
77
{
8-
private static ConcurrentQueue<string> _textToWrite = new ConcurrentQueue<string>();
9-
private CancellationTokenSource _source = new CancellationTokenSource();
10-
private CancellationToken _token;
11-
private static string path;
12-
13-
public MultiThreadFileWriter()
14-
{
15-
_token = _source.Token;
16-
// This is the task that will run
17-
// in the background and do the actual file writing
18-
Task.Run(WriteToFile, _token);
19-
}
20-
21-
/// The public method where a thread can ask for a line
22-
/// to be written.
23-
public void WriteLine(string line, string path)
24-
{
25-
path = path;
26-
_textToWrite.Enqueue(line);
27-
}
28-
29-
/// The actual file writer, running
30-
/// in the background.
31-
private async void WriteToFile()
8+
static ReaderWriterLock locker = new ReaderWriterLock();
9+
static readonly int milliSecTimeout = 60000; // Timeout after 60 sec
10+
public static void Write(this string text, string path)
3211
{
33-
while (true)
12+
try
13+
{
14+
locker.AcquireWriterLock(milliSecTimeout); // You might wanna change timeout value. Set to int.MaxValue or some val
15+
Console.WriteLine("Lock set");
16+
//var x = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase).Replace("file:\\", ""), "debug.txt");
17+
//File.AppendAllLines(path, new[] { text });
18+
File.WriteAllText(path, text);
19+
}
20+
finally
3421
{
35-
if (_token.IsCancellationRequested)
36-
{
37-
return;
38-
}
39-
using (StreamWriter w = File.AppendText(path))
40-
{
41-
while (_textToWrite.TryDequeue(out string textLine))
42-
{
43-
await w.WriteLineAsync(textLine);
44-
}
45-
w.Flush();
46-
Thread.Sleep(100);
47-
}
22+
locker.ReleaseWriterLock();
23+
Console.WriteLine("Lock released");
4824
}
4925
}
26+
//private static ConcurrentQueue<string> _textToWrite = new ConcurrentQueue<string>();
27+
//private CancellationTokenSource _source = new CancellationTokenSource();
28+
//private CancellationToken _token;
29+
//private static string path;
30+
31+
//public MultiThreadFileWriter()
32+
//{
33+
// _token = _source.Token;
34+
// // This is the task that will run
35+
// // in the background and do the actual file writing
36+
// Task.Run(WriteToFile, _token);
37+
//}
38+
39+
///// The public method where a thread can ask for a line
40+
///// to be written.
41+
//public void WriteLine(string line, string path)
42+
//{
43+
// path = path;
44+
// _textToWrite.Enqueue(line);
45+
//}
46+
47+
///// The actual file writer, running
48+
///// in the background.
49+
//private async void WriteToFile()
50+
//{
51+
// while (true)
52+
// {
53+
// if (_token.IsCancellationRequested)
54+
// {
55+
// return;
56+
// }
57+
// using (StreamWriter w = File.AppendText(path))
58+
// {
59+
// while (_textToWrite.TryDequeue(out string textLine))
60+
// {
61+
// await w.WriteLineAsync(textLine);
62+
// }
63+
// w.Flush();
64+
// Thread.Sleep(100);
65+
// }
66+
// }
67+
//}
5068
}
5169
}

‎Program.cs

+4-3
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,8 @@ public static void Main(string[] args)
1717
if (builder.Environment.IsDevelopment())
1818
{
1919
Console.WriteLine("Environment.IsDevelopment");
20-
builder.WebHost.UseUrls("https://localhost:4000");
20+
builder.WebHost.UseUrls("http://localhost:4001");
21+
//builder.WebHost.UseUrls("http://localhost:4001", "https://localhost:4000");
2122
}
2223

2324
// Add services to the container.
@@ -65,9 +66,9 @@ public static void Main(string[] args)
6566
app.UseSwaggerUI();
6667
}
6768

68-
app.UseHttpsRedirection();
69+
//app.UseHttpsRedirection();
6970

70-
app.UseAuthorization();
71+
//app.UseAuthorization();
7172
//ResourceConnector.GetGraphForResource("08ac06ea-4005-4e31-ae69-7ffc0447b332");
7273
//HistogramGenerator.GetHistogram("21514961-4208-41ab-8c7a-3b549e22e3e3");
7374

‎appsettings.json

+3-3
Original file line numberDiff line numberDiff line change
@@ -14,12 +14,12 @@
1414
// }
1515
//},
1616
"EndPoints": {
17+
//"Https": {
18+
// "Url": "https://+:4000"
19+
//},
1720
"Http": {
1821
"Url": "http://+:4001"
1922
}
20-
//"Https": {
21-
// "Url": "https://+:4000"
22-
//}
2323
}
2424
}
2525
}

0 commit comments

Comments
 (0)