public void MessageSent_EventIsRaised()
{
using (var sender = SetupSender())
{
sender.MessageSent += RecordMessageEvent;
using (var receiver = new QueueManager("localhost", "test2.esent"))
{
receiver.CreateQueues("h");
receiver.Start();
using (var tx = new TransactionScope())
{
sender.Send(
new Uri("file://localhost/h"),
new MessagePayload
{
Data = new byte[] { 1, 2, 4, 5 }
});
tx.Complete();
}
sender.WaitForAllMessagesToBeSent();
}
sender.MessageSent -= RecordMessageEvent;
}
Assert.NotNull(_messageEventArgs);
Assert.Equal("localhost", _messageEventArgs.Endpoint);
Assert.Equal("h", _messageEventArgs.Message.Queue);
}
public AutoSelectPort()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
queueManager = new QueueManager(endPoint, "test.esent");
}
protected void EnsureStorage( string connectionString )
{
bool runInstall = CreateDatabaseIfNotExists( connectionString );
if( runInstall )
{
SchemaManager.Install( connectionString );
}
var storage = new QueueStorage( connectionString );
try
{
storage.Initialize();
}
catch(Exception ex)
{
if ( !( ex is InvalidOperationException ) && !( ex is SqlException ) )
{
throw;
}
SchemaManager.Install( connectionString );
storage.Initialize();
}
using ( var qManager = new QueueManager( connectionString, port: 2204 ) )
{
qManager.ConfigureEndPoint();
}
StorageUtil.PurgeAll( connectionString );
}
public StartingRhinoQueues()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
}
public QueueIsAsync()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
queueManager.CreateQueues("h");
}
public QueueIsAsync()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
_queueManager = new QueueManager("localhost", "test.esent");
_queueManager.CreateQueues("h");
_queueManager.Start();
}
public WhenPeekingMessages()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
_queueManager = new QueueManager("localhost", "test.esent");
_queueManager.CreateQueues("h");
_queueManager.Start();
}
public Errors()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
_sender = new QueueManager(null, "test.esent");
_sender.Start();
}
public ReceivingFromRhinoQueue()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
_queueManager = new QueueManager("localhost", "test.esent");
_queueManager.CreateQueues("h");
_queueManager.Start();
}
public Errors()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
sender = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
sender.Start();
}
public bool Start(HostControl hostControl)
{
_logger.Info("Producer service starting");
_queueManager = new QueueManager(_queueName, _svcBusConnection);
_queueManager.Start().Wait();
_task = StartProducing();
return true;
}
public void Enabling_performance_counters_after_queue_has_started_should_throw()
{
Setup();
using (var queueManager = new QueueManager("localhost", TEST_QUEUE_1))
{
queueManager.Start();
Assert.Throws<InvalidOperationException>(() => queueManager.EnablePerformanceCounters());
}
}
public ReceivingFromRhinoQueue()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
queueManager.CreateQueues("h");
queueManager.Start();
}
public WhenPeekingMessages()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
queueManager.CreateQueues("h");
queueManager.Start();
}
public void Enabling_performance_counters_without_existing_categories_throws_meaningful_error()
{
PerformanceCounterCategoryCreation.DeletePerformanceCounters();
using (var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), TEST_QUEUE_1))
{
Assert.Throws<ApplicationException>(() => queueManager.EnablePerformanceCounters());
}
}
// Use this for initialization
void Start()
{
if (singleton == null) singleton = this;
player = GameObject.FindGameObjectWithTag("Player").GetComponent<Player>();
counter = GameObject.FindGameObjectWithTag("Counter");
SpawnPeople();
//people[numberOfPeople - 1].StartMoving();
//spawn = GameObject.FindGameObjectWithTag("Spawner").GetComponent<PersonSpawner>();
}
public static QueueManager GetInstance()
{
if (queueManager == null)
{
queueManager = new QueueManager();
}
return queueManager;
}
public static QueueManager QueueManager(string name = "test", string queue = "h")
{
var directory = string.Format("{0}.esent", name);
if (Directory.Exists(directory))
Directory.Delete(directory, true);
var queueManager = new QueueManager("localhost", directory);
queueManager.CreateQueues(queue);
return queueManager;
}
public void Enabling_performance_counters_should_syncronize_counters_with_current_queue_state()
{
Setup();
using (var queueManager = new QueueManager("localhost", TEST_QUEUE_1))
{
EnqueueMessages(queueManager);
queueManager.EnablePerformanceCounters();
}
AssertAllCountersHaveCorrectValues();
}
public void After_enabling_performance_counters_changes_to_queue_state_should_be_reflected_in_counters()
{
Setup();
using (var queueManager = new QueueManager("localhost", TEST_QUEUE_1))
{
queueManager.EnablePerformanceCounters();
EnqueueMessages(queueManager);
}
AssertAllCountersHaveCorrectValues();
}
public void Setup()
{
using (var tx = new TransactionScope())
{
receiver = ObjectMother.QueueManager("receiver", 4545, "uno");
receiver.Start();
tx.Complete();
}
}
public void Enabling_performance_counters_after_queue_has_started_should_throw()
{
Setup();
using (var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), TEST_QUEUE_1))
{
queueManager.Start();
Assert.Throws<InvalidOperationException>(() => queueManager.EnablePerformanceCounters());
}
}
public static QueueManager QueueManager(string name = "test", int port = 23456, string queue = "h")
{
var directory = string.Format("{0}.esent", name);
if (Directory.Exists(directory))
Directory.Delete(directory, true);
var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, port), directory);
queueManager.CreateQueues(queue);
return queueManager;
}
public static QueueManager QueueManager(string name = "test", int port = 23456, string queue = "h", bool delete = true, ILogger logger = null)
{
var directory = string.Format("{0}.esent", name);
if (delete && Directory.Exists(directory))
Directory.Delete(directory, true);
var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, port), directory, new QueueManagerConfiguration(), logger);
queueManager.CreateQueues(queue);
return queueManager;
}
public bool Execute(QueueManager manager)
{
try
{
if (FileItem.ItemType != FileItemType.File)
return true;
switch (Generate)
{
case QueueType.Thumb:
if (File.Exists(FileItem.SmallThumb))
{
var thumb = BitmapLoader.Instance.LoadSmallImage(FileItem);
thumb.Freeze();
FileItem.Thumbnail = thumb;
thumb = thumb.Clone();
BitmapLoader.Highlight(thumb, true, true);
BitmapLoader.Instance.DrawFocusPoints(FileItem, thumb);
thumb.Freeze();
FileItem.ThumbnailMarks = thumb;
}
else
{
FileItem.GetExtendedThumb();
if (ServiceProvider.Settings.SelectedBitmap.FileItem != FileItem)
ServiceProvider.QueueManager.Add(new QueueItemFileItem
{
FileItem = FileItem,
Generate = QueueType.Cache
});
}
break;
case QueueType.Cache:
BitmapLoader.Instance.GenerateCache(FileItem);
if (!FileItem.HaveHistogramReady())
ServiceProvider.QueueManager.AddWithLowPriority(new QueueItemFileItem
{
FileItem = FileItem,
Generate = QueueType.Histogram
});
break;
case QueueType.Histogram:
BitmapLoader.Instance.LoadHistogram(FileItem);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception)
{
//Log.Error(e);
}
return true;
}
public bool Start(HostControl hostControl)
{
_logger.Info("Subscriber service starting");
_queueManager = new QueueManager(_queueName, _svcBusConnection);
_queueManager.Start().Wait();
var cloudTableClient = _storageAccount.CreateCloudTableClient();
_tableRef = cloudTableClient.GetTableReference("MessageData");
_tableRef.CreateIfNotExists();
_task = StartConsuming();
return true;
}
public void SetUp()
{
cars = new List<Car>()
{
new Car()
};
queueManager = new QueueManager(new MessageProcessorFactory());
queueManager.Init(cars, 20);
queueManager.Start();
}
public void QueueManager_EnqueTest()
{
//Init
var qn = "q1";
var q = new QueueManager<string>(qn);
q.Flush();
// Push items into queue
data.ForEach(x => q.Push(x));
// Test
Assert.AreEqual(q.GetElements().Length, data.Count);
}
public UsingSubQueues()
{
if (Directory.Exists("test.esent"))
Directory.Delete("test.esent", true);
if (Directory.Exists("test2.esent"))
Directory.Delete("test2.esent", true);
sender = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
receiver = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23457), "test2.esent");
receiver.CreateQueues("h", "a");
}
public void Enabling_performance_counters_should_syncronize_counters_with_current_queue_state()
{
Setup();
using (var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), TEST_QUEUE_1))
{
EnqueueMessages(queueManager);
queueManager.EnablePerformanceCounters();
}
AssertAllCountersHaveCorrectValues();
}
public static async Task Main(string [] args)
{
Console.WriteLine($"DotNet Core Console - Containerized - Update Azure Storeage - v{RuntimeHelper.GetAppVersion()} - IsRunningContainerMode:{RuntimeHelper.IsRunningContainerMode()}");
Console.WriteLine($"Env Fred={Environment.GetEnvironmentVariable("Fred")}");
Console.WriteLine(RuntimeHelper.GetContextInformation());
var aListOfStrings = new List <string>()
{
"a", "b"
};
Console.WriteLine($"DynamicSugarCore: List<string>.Format {aListOfStrings.Format()}");
var alphabetDic = DS.Resources.GetTextResource(new Regex("embed.text.txt", RegexOptions.IgnoreCase), Assembly.GetExecutingAssembly());
foreach (var e in alphabetDic)
{
Console.WriteLine($"DynamicSugarCore Embed Resource: key:{e.Key} value:{e.Value} ");
}
var dataTxtFile = RuntimeHelper.GetAppFilePath("data.txt");
Console.WriteLine($"dataTxtFile:${dataTxtFile}, exists:{File.Exists(dataTxtFile)}");
var tutuFolder = RuntimeHelper.GetAppFolderPath("tutu");
Console.WriteLine($"tutuFolder:${tutuFolder}, exists:{Directory.Exists(tutuFolder)}");
// Initialize Azure storage and queue
var storageAccount = RuntimeHelper.GetAppSettings("storage:accountName");
var storageKey = RuntimeHelper.GetAppSettings("storage:key");
const string containerName = "public";
const string queueName = "myQueue2";
var qm = new QueueManager(storageAccount, storageKey, queueName);
var bm = new BlobManager(storageAccount, storageKey, containerName);
var tm = new TableManager(storageAccount, storageKey, "FileHistory");
//var fileLogHistoryAzureTableRecord = new FileLogHistoryAzureTableRecord {
// FileName = "zizi.txt", ComputerOrigin = Environment.MachineName, CreationTime = DateTime.UtcNow
//};
//fileLogHistoryAzureTableRecord.SetIdentification();
//await tm.Insert(fileLogHistoryAzureTableRecord);
var allRecords = await tm.GetRecords <FileLogHistoryAzureTableRecord>(Environment.MachineName);
var ziziRecords = await tm.GetRecords <FileLogHistoryAzureTableRecord>(Environment.MachineName, "zizi.txt",
new TableManager.WhereClauseExpression {
Name = "ComputerOrigin", Value = Environment.MachineName
});
if (args.Length > 0)
{
switch (args[0].ToLowerInvariant())
{
case "help":
Console.WriteLine(@"fCoreConsoleAzureStorage
clearQueue | clearStorage | dirStorage | dirQueue | getQueue | sendMessage ""text""
");
break;
case "clearqueue":
var deleteMessages = await qm.ClearAsync();
Console.WriteLine($"{deleteMessages.Count} deleted message");
break;
case "dirqueue":
{
var messageCount = await qm.ApproximateMessageCountAsync();
Console.WriteLine($"{messageCount} messages");
}
break;
case "getqueue":
{
while (true)
{
var m = await qm.DequeueAsync();
if (m == null)
{
break;
}
await qm.DeleteAsync(m.Id);
Console.WriteLine($"Message id:{m.Id}, body:{m.AsString}");
}
}
break;
case "clearstorage":
{
var blobs = await bm.DirAsync();
Console.WriteLine($"About to delete {blobs.Count} cloud file from storage container:{bm.ContainerName}");
await bm.DeleteFileAsync(blobs);
}
break;
case "dirstorage":
{
var blobs = await bm.DirAsync();
Console.WriteLine($"{blobs.Count} file(s) found in container:{bm.ContainerName}");
foreach (var b in blobs)
{
Console.WriteLine($" {b}");
}
}
break;
case "sendmessage":
Console.WriteLine($"Sending Message:{args[1]}");
var messageId = await qm.EnqueueAsync(args[1]);
Console.WriteLine($"MessageId:${messageId}");
break;
default:
Console.WriteLine($"Command not supported:{args[0]}");
break;
}
Environment.Exit(0);
}
Console.WriteLine($"Storage:{storageAccount}, container:{containerName}");
for (var i = 0; i < 100; i++)
{
Console.WriteLine($"");
Console.WriteLine($"{i} execution(s).");
CreateTextFileInStorage(bm, qm).GetAwaiter().GetResult();
Console.WriteLine($"Waiting {WaitTime} seconds");
System.Threading.Tasks.Task.Delay(1000 * WaitTime).Wait();
}
Console.WriteLine("Done");
}
