public async Task <int> Open(Action <string> info)
{
using (MyDbContext _context = new MyDbContext(_settings.ConnectionString))
{
_context.Database.EnsureDeleted();
_context.Database.EnsureCreated();
}
IExtract extract = null;
switch (_settings.ExtractMethod)
{
case DataMethods.File:
{
var extract_C = new FileExtract(_dataBacklinkRowService, _dataListedInfoService, _settings)
{
ContainsExtraInfo = false
};
break;
}
case DataMethods.GoogleDocs:
{
extract = new SpreadSheetExtract(_dataBacklinkRowService, _dataListedInfoService, _settings);
break;
}
}
int i = await extract.Extract();
_settings.Positions = i;
_dbQueue = new DbQueue(_settings.ConnectionString, _settings.PlainHttpThreads, i);
DbQueue.Info = info;
return(i);
}
void ExecCover(QueueItemStream message)
{
var dt = DbQueue.MessageToDataTable(message);
using (DbBulkCopy bulk = new DbBulkCopy(CoverPath))
{
bulk.BulkInsert(dt, CoverTableName, ConnectTimeout, null);
}
}
public bool ExecuteQueue(DbQueue queue)
{
if (!File.Exists(queue.SourceFile))
{
return(true);
}
Utils.CreateFolder(queue.ActionParam);
File.Copy(queue.SourceFile, queue.ActionParam, true);
Utils.WaitForFile(queue.SourceFile);
File.Delete(queue.SourceFile);
return(true);
}
public async Task Perform()
{
List <BacklinkRow> list = new List <BacklinkRow>();
for (int i = 0; i < _settings.PlainHttpThreads; i++)
{
DataBacklinkRow datarow = await _dataBacklinkRowService.GetFirstDataBacklinkRowByStatus(CurrentTaskStatus);
datarow.Status = Status.PlainHttp;
await _dataBacklinkRowService.UpdateDataBacklinkRow(datarow);
list.Add(new BacklinkRow()
{
DataBacklinkRow = datarow
});
}
_plainHttp = new PlainHttp(_settings.PlainHttpThreads, FreeThread);
await _plainHttp.Perform(list);
list.Clear();
CurrentTaskStatus = Status.PlainHttpNotFound;
_dbQueue = new DbQueue(_settings.ConnectionString, _settings.PlainHttpThreads, _settings.Positions);
for (int i = 0; i < _settings.WebDriverThreads; i++)
{
DataBacklinkRow datarow = await _dataBacklinkRowService.GetFirstDataBacklinkRowByStatus(CurrentTaskStatus);
if (datarow == null)
{
_settings.WebDriverThreads = i;
break;
}
datarow.Status = Status.WebDriver;
await _dataBacklinkRowService.UpdateDataBacklinkRow(datarow);
list.Add(new BacklinkRow()
{
DataBacklinkRow = datarow
});
}
_webDriver = new WebDriver(_settings.WebDriverThreads, FreeThread);
await _webDriver.Perform(list);
_webDriver.Quit();
}
static void Main(string[] args)
{
DbQueue queue = new DbQueue();
bool continueRunning = true;
while (continueRunning)
{
System.Console.WriteLine("Items to create (if not parseable int will exit)");
string value = System.Console.ReadLine();
int itemsToCreate = 0;
continueRunning = int.TryParse(value, out itemsToCreate);
if (continueRunning)
{
queue.Enqueue(CreateFile(itemsToCreate).ToArray());
System.Console.WriteLine("Created: {0}", itemsToCreate);
}
}
}
static void Main(string[] args)
{
ConsoleTraceListener listener = new ConsoleTraceListener();
ITaskQueue <IAssemblyData, FinishResult> provider = new DbQueue();
var c = new CancellationTokenSource();
var task = new AssemblyTask();
var data = new Agent.InitData <IAssemblyData, FinishResult>(task, c.Token, provider, AppSettings.MillisecondsToBeIdle, AppSettings.BatchSize, Guid.NewGuid(), Environment.MachineName, listener);
var service = new Agent.Service <IAssemblyData, FinishResult>(data);
service.Start();
System.Console.WriteLine("{0} instance {1} Listenning...", data.InstanceName, data.InstanceId);
System.Console.ReadKey();
service.Stop();
System.Console.ReadKey();
service.Start();
System.Console.ReadKey();
c.Cancel();
System.Console.ReadKey();
}
public void Add(DbQueue item)
{
Items.Add(item);
}
/// <summary>
/// Execute remote command from client to queue managment using <see cref="QueueMessage"/>.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
internal static NetStream ExecManager(QueueMessage message)
{
QueueState state = QueueState.Ok;
try
{
NetStream stream = null;
switch (message.Command)
{
case QueueManagerCmd.Reply:
return(QueueEntry.GetAckStream(QueueState.Ok, QueueManagerCmd.Reply, message.Key));
case QueueManagerCmd.QueueProperties:
if (_Queue == null)
{
return(null);
}
return(message.AsyncTask(() => Queue.PerformanceCounter.GetPerformanceProperties(), message.Command));
case QueueManagerCmd.CloneItems:
if (_Queue == null)
{
return(null);
}
var args = message.GetArgs();
CloneType ct = EnumExtension.Parse <CloneType>(args.Get <string>("value"), CloneType.All);
return(message.AsyncTask(() => Queue.CloneItems(ct), message.Command));
case QueueManagerCmd.GetAllKeys:
if (_Queue == null)
{
return(null);
}
return(message.AsyncTask(() => Queue.GetAllKeys(), message.Command));
case QueueManagerCmd.GetAllKeysIcons:
if (_Queue == null)
{
return(null);
}
return(message.AsyncTask(() => Queue.GetAllKeysIcons(), message.Command));
case QueueManagerCmd.StateCounterQueue:
return(message.AsyncTask(() => QueueStateCounter(QueueAgentType.Queue), message.Command));
case QueueManagerCmd.StateCounterSync:
return(message.AsyncTask(() => QueueStateCounter(QueueAgentType.SyncQueue), message.Command));
case QueueManagerCmd.StateCounterSession:
return(message.AsyncTask(() => QueueStateCounter(QueueAgentType.SessionQueue), message.Command));
case QueueManagerCmd.StateCounterDataQueue:
return(message.AsyncTask(() => QueueStateCounter(QueueAgentType.DataQueue), message.Command));
case QueueManagerCmd.GetStateCounterReport:
return(message.AsyncTask(() => QueueStateCounter(), message.Command));
case QueueManagerCmd.GetPerformanceReport:
return(message.AsyncTask(() => PerformanceReport(), message.Command));
case QueueManagerCmd.GetAgentPerformanceReport:
QueueAgentType agentType = QueuePerformanceCounter.GetAgent(message.Key);
return(message.AsyncTask(() => PerformanceReport(agentType), message.Command));
case QueueManagerCmd.ResetPerformanceCounter:
message.AsyncTask(() => ResetPerformanceCounter());
return(null);
case QueueManagerCmd.GetAllDataKeys:
if (_DbQueue == null)
{
return(null);
}
return(message.AsyncTask(() => DbQueue.GetAllDataKeys(), message.Command));
case QueueManagerCmd.GetAllSyncQueueKeys:
if (_SyncQueue == null)
{
return(null);
}
return(message.AsyncTask(() => SyncQueue.QueueKeys().ToArray(), message.Command));
case QueueManagerCmd.QueueLog:
return(message.AsyncTask(() => QueueLogger.Logger.QueueLog(), message.Command));
case QueueManagerCmd.GetAllSessionsKeys:
if (_Session == null)
{
return(null);
}
return(message.AsyncTask(() => Session.GetAllSessionsKeys(), message.Command));
case QueueManagerCmd.GetAllSessionsStateKeys:
if (_Session == null)
{
return(null);
}
stream = new NetStream();
SessionState st = (SessionState)message.GetArgs().Get <int>("state");
return(message.AsyncTask(() => Session.GetAllSessionsStateKeys(st), message.Command));
case QueueManagerCmd.GetSessionItemsKeys:
if (_Session == null)
{
return(null);
}
return(message.AsyncTask(() => Session.GetSessionsItemsKeys(message.Id), message.Command));
//=== Queue api===================================================
case QueueCmd.ViewItem:
case QueueCmd.RemoveItem:
return(Queue.ExecRemote(message));
//=== Data Queue api===================================================
case DataQueueCmd.GetItemProperties:
case DataQueueCmd.RemoveTable:
//case DataQueueCmd.GetDataStatistic:
case DataQueueCmd.GetDataTable:
return(DbQueue.ExecRemote(message));
//=== Sync Queue api===================================================
case SyncQueueCmd.RemoveSyncItem:
case SyncQueueCmd.GetSyncItem:
//case SyncQueueCmd.GetSyncStatistic:
case SyncQueueCmd.GetItemsReport:
return(SyncQueue.ExecRemote(message));
//=== Session Queue api===================================================
case SessionCmd.RemoveSession:
case SessionCmd.GetExistingSession:
return(Session.ExecRemote(message));
}
}
catch (System.Runtime.Serialization.SerializationException se)
{
state = QueueState.SerializationError;
QueueLogger.Logger.LogAction(QueueAction.QueueException, QueueActionState.Error, "ExecManager error: " + se.Message);
}
catch (Exception ex)
{
state = QueueState.UnexpectedError;
QueueLogger.Logger.LogAction(QueueAction.QueueException, QueueActionState.Error, "ExecManager error: " + ex.Message);
}
return(QueueEntry.GetAckStream(state, message.Command)); //null;
}
