private HashSet <PhotoModel> TryLoadQueue()
{
if (!QueueFile.Exists)
{
return(null);
}
lock (_queueFileLock)
{
using (var stream = QueueFile.OpenRead())
{
Console.WriteLine("*** Loading Queue...");
var list = stream.Load <HashSet <PhotoModel> >(null);
var knownSets = new Dictionary <string, PhotosetModel>();
foreach (var i in list)
{
switch (i.State)
{
case ProcessingStateType.Failed:
//TODO: check, if we should retry failed
//i.State = ProcessingStateType.Pending;
break;
case ProcessingStateType.Uploading:
//not sure if uploaded! restart
i.State = ProcessingStateType.Pending;
break;
//case ProcessingStateType.Pending:
//case ProcessingStateType.Duplicate:
//case ProcessingStateType.ReadyToUpload:
//case ProcessingStateType.Uploaded:
//case ProcessingStateType.Retry:
//case ProcessingStateType.Completed:
//default:
// break;
}
var sets = i.Sets.ToArray();
foreach (var s in sets)
{
if (!knownSets.ContainsKey(s.Key))
{
knownSets.Add(s.Key, s);
}
else
{
i.Sets.Remove(s);
i.Sets.Add(knownSets[s.Key]);
}
}
}
Console.WriteLine($"*** Loaded {list.Count} items into Queue ***");
foreach (var g in list.GroupBy(i => i.State))
{
var spaces = 15 - g.Key.ToString().Length;
Console.WriteLine($" {g.Key}:{new string(' ', spaces)}{g.Count()}");
}
stream.Close();
return(list);
}
}
}
private void SaveQueue(HashSet <PhotoModel> list)
{
if (QueueFile == null)
{
return;
}
lock (_queueFileLock)
{
var tmpFile = new FileInfo(QueueFile.FullName + ".tmp");
using (var stream = tmpFile.OpenWrite())
{
Console.WriteLine("*** Saving Queue...");
list.ToXml(stream, Encoding.Default, null);
_qLastSaved = DateTime.Now;
}
QueueFile.Refresh();
if (QueueFile.Exists)
{
QueueFile.Delete();
}
tmpFile.MoveTo(QueueFile.FullName);
QueueFile.Refresh();
Console.WriteLine("*** Queue saved ***");
}
}
private void FileWrite(QueueFile queue_data)
{
FileStream _fs = null;
try
{
if (System.IO.Directory.Exists(queue_data.Directory) == false)
{
System.IO.Directory.CreateDirectory(queue_data.Directory);
}
var _path = Path.Combine(queue_data.Directory, queue_data.FileName);
File.WriteAllBytes(_path, queue_data.Buffer);
}
catch (Exception ex)
{
OEventLog.SNG.WriteEntry(ex.ToString(), EventLogEntryType.Error);
}
finally
{
if (_fs != null)
{
_fs.Close();
}
}
}
/// <summary>
/// 별도 thread에서 QueueFile을 이용해 file에 write 합니다.
/// </summary>
/// <param name="directory_name"></param>
/// <param name="file_name"></param>
/// <param name="out_buffer"></param>
public void QueueWrite(string directory_name, string file_name, byte[] out_buffer)
{
lock (FileWriteQ.SyncRoot)
{
QueueFile _qdata = new QueueFile()
{
Directory = directory_name,
FileName = file_name,
Buffer = out_buffer
};
FileWriteQ.Enqueue(_qdata);
if (QueueThread == null || QueueThread.IsAlive == false)
{
if (QueueThread != null)
{
QueueThread.Abort();
}
QueueThread = new Thread(Parser)
{
IsBackground = true
};
QueueThread.Start();
}
}
}
private static async Task Main()
{
var queue = new QueueFile(@"C:\Temp\Queues", "Mine");
await queue.Open();
await queue.Enqueue(new MyMessage("go go 2"));
var tasks = new[]
{
Application1(),
Application2()
};
await Task.WhenAll(tasks);
//var message = await queue.Dequeue();
Console.WriteLine("Hello World!");
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
private void Parser()
{
while (true)
{
lock (FileWriteQ.SyncRoot)
{
if (FileWriteQ.Count > 0)
{
object _dequeue = FileWriteQ.Dequeue();
if (_dequeue != null)
{
QueueFile _qdata = (QueueFile)_dequeue;
this.FileWrite(_qdata);
}
}
else
{
Thread.Sleep(1000);
}
}
Thread.Sleep(100);
}
}
public QueueFileTests()
{
_directory = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetTempFileName()));
Directory.CreateDirectory(_directory);
_sut = new QueueFile(_directory, "Test");
}
