public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
ErrorTypes eResult = ErrorTypes.TaskQueue;
try
{
oTask.VisibilityTimeout = m_oVisibilityTimeout;
string strId = (string)oTask.m_sKey;
string strInsertRow = GetInsertString(oTask, oPriority);
using (System.Data.IDbConnection dbConnection = GetDbConnection())
{
dbConnection.Open();
using (System.Data.IDbCommand oInsertCommand = dbConnection.CreateCommand())
{
oInsertCommand.CommandText = strInsertRow;
oInsertCommand.ExecuteNonQuery();
eResult = ErrorTypes.NoError;
}
}
}
catch
{
eResult = ErrorTypes.TaskQueue;
}
return(eResult);
}
public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
ErrorTypes eResult = ErrorTypes.Unknown;
string strUrlQueue = GetQueueUrl(oPriority);
try
{
oTask.VisibilityTimeout = m_oVisibilityTimeout;
string strData = TaskQueueData.SerializeToXml(oTask);
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
SendMessageRequest oSendMessageRequest = new SendMessageRequest();
oSendMessageRequest.QueueUrl = strUrlQueue;
oSendMessageRequest.MessageBody = strData;
oSQSClient.SendMessage(oSendMessageRequest);
eResult = ErrorTypes.NoError;
}
}
catch (AmazonSQSException)
{
eResult = ErrorTypes.TaskQueue;
}
catch
{
eResult = ErrorTypes.TaskQueue;
}
return(eResult);
}
private TaskQueueData GetTaskFromLongPoolingQueue()
{
TaskQueueData oData = null;
if (0 == Interlocked.CompareExchange(ref m_nIsHPRead, 1, 0))
{
_log.Debug("Try to get high priority task...");
oData = GetTask(Priority.High);
Interlocked.Exchange(ref m_nIsHPRead, 0);
}
else if (0 == Interlocked.CompareExchange(ref m_nIsNPRead, 1, 0))
{
_log.Debug("Try to get normal priority task...");
oData = GetTask(Priority.Normal);
Interlocked.Exchange(ref m_nIsNPRead, 0);
}
else if (0 == Interlocked.CompareExchange(ref m_nIsLPRead, 1, 0))
{
_log.Debug("Try to get low priority task...");
oData = GetTask(Priority.Low);
Interlocked.Exchange(ref m_nIsLPRead, 0);
}
else
{
_log.Debug("All task queue listening!");
}
return(oData);
}
public TaskQueueData GetTask()
{
TaskQueueData oData = null;
bool bResult = false;
uint ncq_id = 0;
string strSelectSQL = GetSelectString();
string strUpdateSQL = GetUpdateString();
try
{
using (System.Data.IDbConnection dbConnection = GetDbConnection())
{
dbConnection.Open();
bool bIsExist = false;
using (IDbCommand oSelectCommand = dbConnection.CreateCommand())
{
oSelectCommand.CommandText = strSelectSQL;
using (System.Data.IDataReader oDataReader = oSelectCommand.ExecuteReader())
{
if (true == oDataReader.Read())
{
ncq_id = Convert.ToUInt32(oDataReader["cq_id"]);
oData = TaskQueueData.DeserializeFromXml(Convert.ToString(oDataReader["cq_data"]));
oData.m_oDataKey = ncq_id;
bIsExist = true;
}
}
}
if (bIsExist)
{
using (System.Data.IDbCommand oUpdateCommand = dbConnection.CreateCommand())
{
oUpdateCommand.CommandText = strUpdateSQL + ncq_id + "';";
if (oUpdateCommand.ExecuteNonQuery() > 0)
{
bResult = true;
}
else
{
bResult = false;
}
}
}
}
}
catch
{
}
return((bResult) ? oData : null);
}
private string GetInsertString(TaskQueueData oTask, Priority ePriority)
{
string sData = TaskQueueData.SerializeToXml(oTask);
return(string.Format("INSERT INTO {0} " +
"(cq_data, cq_priority, cq_update_time, cq_create_time, cq_isbusy) " +
"VALUES ('{1}', '{2}', '{3}', '{3}', '{4}');",
m_cstrTableName,
Utils.MySqlEscape(sData, m_sConnectionString),
ePriority.ToString("d"),
DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat),
BusyType.not_busy.ToString("d")));
}
public static string SerializeToXml(TaskQueueData oData)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings ws = new XmlWriterSettings();
ws.NewLineHandling = NewLineHandling.None;
ws.Indent = false;
XmlWriter xw = System.Xml.XmlWriter.Create(sb, ws);
System.Xml.Serialization.XmlSerializer formatter = new System.Xml.Serialization.XmlSerializer(typeof(TaskQueueData));
formatter.Serialize(xw, oData);
return(sb.ToString());
}
public void AddTaskBegin(TaskQueueData oTask, Priority oPriority, AsyncCallback fCallback, object oParam)
{
m_oAddTask = new TransportClass(fCallback, oParam);
try
{
m_oAddTask.m_delegateAdder = AddTask;
m_oAddTask.m_delegateAdder.BeginInvoke(oTask, oPriority, m_oAddTask.m_fCallback, m_oAddTask.m_oParam);
}
catch
{
m_oAddTask.DisposeAndCallback();
}
return;
}
public TaskQueueData GetTask()
{
TaskQueueData oData = null;
if (m_LongPoolingEnable)
{
oData = GetTaskFromLongPoolingQueue();
}
else
{
oData = GetTaskFromQueue();
}
return(oData);
}
private void GetTaskCallback(IAsyncResult ar)
{
try
{
uint ncq_id = 0;
DateTime oTaskUpdateTime = DateTime.UtcNow;
bool bIsExist = false;
using (IDataReader oReader = m_GetTask.m_delegateReader.EndInvoke(ar))
{
if (true == oReader.Read())
{
ncq_id = Convert.ToUInt32(oReader["cq_id"]);
oTaskUpdateTime = Convert.ToDateTime(oReader["cq_update_time"]);
m_GetTask.m_oTaskQueueData = TaskQueueData.DeserializeFromXml(Convert.ToString(oReader["cq_data"]));
m_GetTask.m_oTaskQueueData.m_oDataKey = ncq_id;
bIsExist = true;
}
}
if (null != m_GetTask.m_oCommand)
{
m_GetTask.m_oCommand.Dispose();
m_GetTask.m_oCommand = null;
}
m_GetTask.Close();
if (bIsExist)
{
IDbCommand oUpdateCommand = m_GetTask.m_oSqlCon.CreateCommand();
oUpdateCommand.CommandText = GetUpdateString(ncq_id, oTaskUpdateTime);
m_GetTask.m_oCommand = oUpdateCommand;
m_GetTask.m_delegateNonQuery = new ExecuteNonQuery(oUpdateCommand.ExecuteNonQuery);
m_GetTask.m_delegateNonQuery.BeginInvoke(m_GetTask.m_fCallback, m_GetTask.m_oParam);
}
else
{
m_GetTask.m_delegateNonQuery = null;
m_GetTask.FireCallback();
}
}
catch (Exception e)
{
_log.Error("Exception cathed in GetTaskCallback:", e);
m_GetTask.DisposeAndCallback();
}
}
public TaskQueueData GetTask()
{
TaskQueueData oData = null;
try
{
using (System.Data.IDbConnection dbConnection = GetDbConnection())
{
dbConnection.Open();
using (IDbCommand oSelectCommand = dbConnection.CreateCommand())
{
oSelectCommand.CommandText = GetSelectString();
using (System.Data.IDataReader oDataReader = oSelectCommand.ExecuteReader())
{
while (true == oDataReader.Read())
{
uint ncq_id = Convert.ToUInt32(oDataReader["cq_id"]);
DateTime oTaskCreateTime = Convert.ToDateTime(oDataReader["cq_create_time"]);
if (DateTime.UtcNow < (oTaskCreateTime + m_oRetentionPeriod))
{
DateTime oTaskUpdateTime = Convert.ToDateTime(oDataReader["cq_update_time"]);
if (TryUpdateTask(ncq_id, oTaskUpdateTime))
{
oData = TaskQueueData.DeserializeFromXml(Convert.ToString(oDataReader["cq_data"]));
oData.m_oDataKey = ncq_id;
break;
}
}
else
{
RemoveTask(ncq_id);
}
}
}
}
}
}
catch
{
}
return(oData);
}
private TaskQueueData GetTaskFromQueue()
{
TaskQueueData oData = null;
oData = GetTask(Priority.High);
if (null != oData)
{
return(oData);
}
oData = GetTask(Priority.Normal);
if (null != oData)
{
return(oData);
}
oData = GetTask(Priority.Low);
return(oData);
}
public TaskQueueData GetTaskEnd(IAsyncResult ar)
{
TaskQueueData oTaskQueueDate = null;
if (ErrorTypes.NoError == m_oGetTask.m_eError)
{
try
{
if (null != m_oGetTask.m_delegateGetter)
{
oTaskQueueDate = m_oGetTask.m_delegateGetter.EndInvoke(ar);
}
m_oGetTask.Close();
}
catch
{
m_oGetTask.Dispose();
}
}
return(oTaskQueueDate);
}
private TaskQueueData GetTask(Priority oPriority)
{
string strUrlQueue = GetQueueUrl(oPriority);
TaskQueueData oData = null;
try
{
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
ReceiveMessageRequest oReceiveMessageRequest = new ReceiveMessageRequest();
oReceiveMessageRequest.QueueUrl = strUrlQueue;
oReceiveMessageRequest.MaxNumberOfMessages = 1;
ReceiveMessageResponse oReceiveMessageResponse = oSQSClient.ReceiveMessage(oReceiveMessageRequest);
if (oReceiveMessageResponse.IsSetReceiveMessageResult())
{
ReceiveMessageResult oReceiveMessageResult = oReceiveMessageResponse.ReceiveMessageResult;
foreach (Message oMessage in oReceiveMessageResult.Message)
{
oData = TaskQueueData.DeserializeFromXml(oMessage.Body);
SQSDataKey oSQSDataKey = new SQSDataKey();
oSQSDataKey.m_oPriority = oPriority;
oSQSDataKey.m_strReceiptHandle = oMessage.ReceiptHandle;
oData.m_oDataKey = oSQSDataKey;
break;
}
}
}
}
catch (AmazonSQSException)
{
}
catch
{
}
return(oData);
}
private void AddTask(InputCommand cmd, TransportClassMainAshx oTransportClassMainAshx)
{
try
{
int nToFormat = FileFormats.AVS_OFFICESTUDIO_FILE_CANVAS;
TaskQueueData oTaskQueueData = new TaskQueueData(cmd.id, nToFormat, "Editor.bin");
oTaskQueueData.m_sFromUrl = cmd.url;
oTaskQueueData.m_sFromFormat = cmd.format;
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
oTaskQueueData.m_bEmbeddedFonts = false;
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassMainAshx, oTaskQueue, null);
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.High, TaskQueueAddCallback, oTransportClassTaskQueue);
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand("waitopen", "0"));
}
catch
{
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand(ErrorTypes.Unknown));
}
}
private void StorageWriteFileAsyncCallback(IAsyncResult ar)
{
TransportClassStorage oTransportClassStorage = ar.AsyncState as TransportClassStorage;
try
{
int nReadWriteBytes;
ErrorTypes eError = oTransportClassStorage.m_oStorage.WriteFileEnd(ar, out nReadWriteBytes);
if (null != oTransportClassStorage.m_oStream)
oTransportClassStorage.m_oStream.Dispose();
if (ErrorTypes.NoError == eError)
{
InputCommand cmd = oTransportClassStorage.m_oInputCommand;
if (c_sSaveTypeCompleteAll == cmd.savetype || c_sSaveTypeComplete == cmd.savetype)
{
int nOutputFormat = cmd.outputformat.Value;
TaskQueueData oTaskQueueData = new TaskQueueData(oTransportClassStorage.m_sKey, nOutputFormat, "output." + FileFormats.ToString(nOutputFormat));
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_sFromFormat = "bin";
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
if (null != cmd.vkey)
{
bool bPaid;
Signature.getVKeyParams(cmd.vkey, out bPaid);
oTaskQueueData.m_bPaid = bPaid;
}
Priority oPriority = Priority.Low;
if (cmd.innersave)
oPriority = Priority.Normal;
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassStorage, oTaskQueue, oTaskQueueData);
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
}
else
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
OutputSavePartData oOutputSavePartData = new OutputSavePartData(oTransportClassStorage.m_sKey, cmd.outputformat.Value);
WriteOutputCommand(oTransportClassStorage, new OutputCommand("savepart", serializer.Serialize(oOutputSavePartData)));
}
}
else
WriteOutputCommand(oTransportClassStorage, new OutputCommand(eError));
}
catch
{
WriteOutputCommand(oTransportClassStorage, new OutputCommand(ErrorTypes.Unknown));
}
}
private void TaskResultAddRandomKeyAsyncCallback2(IAsyncResult ar)
{
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
try
{
TaskResultData oTaskResultData;
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
if (ErrorTypes.NoError == eError)
{
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
TaskQueueData oTaskQueueData = new TaskQueueData(oTaskResultData.sKey, FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF, "output.pdf");
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_sFromFormat = "pdf";
oTaskQueueData.m_bFromOrigin = true;
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
if (null != cmd.vkey)
{
bool bPaid;
Signature.getVKeyParams(cmd.vkey, out bPaid);
oTaskQueueData.m_bPaid = bPaid;
}
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassTaskResult, oTaskQueue, oTaskQueueData);
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.Low, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
}
else
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
}
catch
{
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
}
}
private void ChangesWriteCallback(IAsyncResult ar)
{
TransportClassStorage2 oTransportClassStorage = ar.AsyncState as TransportClassStorage2;
try
{
int nReadWriteBytes;
oTransportClassStorage.m_oStorage.WriteFileEnd(ar, out nReadWriteBytes);
if (null != oTransportClassStorage.m_oStream)
oTransportClassStorage.m_oStream.Dispose();
InputCommand cmd = oTransportClassStorage.m_oInputCommand;
if (c_sSaveTypeComplete == cmd.savetype || c_sSaveTypeCompleteAll == cmd.savetype)
{
int nOutputFormat = cmd.outputformat.HasValue ? cmd.outputformat.Value : FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_TEAMLAB_INNER;
TaskQueueData oTaskQueueData = new TaskQueueData(oTransportClassStorage.m_sKey, nOutputFormat, "output." + FileFormats.ToString(nOutputFormat));
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_sFromFormat = "bin";
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
if (null != cmd.vkey)
{
bool bPaid;
Signature.getVKeyParams(cmd.vkey, out bPaid);
oTaskQueueData.m_bPaid = bPaid;
}
Priority oPriority = Priority.Low;
if (cmd.innersave)
oPriority = Priority.Normal;
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassStorage, oTaskQueue, oTaskQueueData);
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
}
else
WriteOutputCommand(oTransportClassStorage, oTransportClassStorage.m_oOutputCommand);
}
catch(Exception e)
{
_log.Error("Exception catched in ChangesWriteCallback:", e);
WriteOutputCommand(oTransportClassStorage, new OutputCommand(ErrorTypes.Unknown));
}
}
private void GetOrCreateCallback(IAsyncResult ar)
{
TransportClass1 oTransportClass1 = ar.AsyncState as TransportClass1;
try
{
TaskResultData oTaskResultData;
bool bCreate;
ErrorTypes eError = oTransportClass1.m_oTaskResult.GetOrCreateEnd(ar, out oTaskResultData, out bCreate);
if (ErrorTypes.NoError == eError)
{
if(bCreate)
{
InputParams oInputParams = oTransportClass1.m_oInputParams;
TaskQueueData oTaskQueueData = new TaskQueueData(oInputParams.m_sKey, oInputParams.m_nOutputtype, "output." + FileFormats.ToString(oInputParams.m_nOutputtype));
oTaskQueueData.m_sFromUrl = oInputParams.m_sUrl;
oTaskQueueData.m_sFromFormat = oInputParams.m_sFiletype;
if (null != oInputParams.m_sDelimiter && string.Empty != oInputParams.m_sDelimiter)
oTaskQueueData.m_nCsvDelimiter = int.Parse(oInputParams.m_sDelimiter);
else
oTaskQueueData.m_nCsvDelimiter = (int)CsvDelimiter.Comma;
if (null != oInputParams.m_sCodepage && string.Empty != oInputParams.m_sCodepage)
oTaskQueueData.m_nCsvTxtEncoding = int.Parse(oInputParams.m_sCodepage);
else
oTaskQueueData.m_nCsvTxtEncoding = Encoding.UTF8.CodePage;
if ("true" == oInputParams.m_sEmbeddedfonts)
oTaskQueueData.m_bEmbeddedFonts = true;
oTransportClass1.m_oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.Low, AddTaskCallback, oTransportClass1);
}
else
CheckStatus(oTransportClass1, oTaskResultData);
}
else
WriteOutputCommand(oTransportClass1, new OutputCommand(null, null, null, eError));
}
catch
{
WriteOutputCommand(oTransportClass1, new OutputCommand(null, null, null, ErrorTypes.Unknown));
}
}
private string GetInsertString(TaskQueueData oTask, Priority ePriority)
{
string sData = TaskQueueData.SerializeToXml(oTask);
return string.Format("INSERT INTO {0} " +
"(cq_data, cq_priority, cq_update_time, cq_create_time, cq_isbusy) " +
"VALUES ('{1}', '{2}', '{3}', '{3}', '{4}');",
m_cstrTableName,
Utils.MySqlEscape(sData, m_sConnectionString),
ePriority.ToString("d"),
DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat),
BusyType.not_busy.ToString("d"));
}
public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
return(m_oTaskQueue.AddTask(oTask, oPriority));
}
public void AddTaskBegin(TaskQueueData oTask, Priority oPriority, AsyncCallback fCallback, object oParam)
{
m_AddTask = AddTask;
m_AddTask.BeginInvoke(oTask, oPriority, fCallback, oParam);
}
public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
ErrorTypes eResult = ErrorTypes.TaskQueue;
try
{
string strId = (string)oTask.m_sKey;
string strInsertRow = GetInsertString(oTask, oPriority);
using (System.Data.IDbConnection dbConnection = GetDbConnection())
{
dbConnection.Open();
using (System.Data.IDbCommand oInsertCommand = dbConnection.CreateCommand())
{
oInsertCommand.CommandText = strInsertRow;
oInsertCommand.ExecuteNonQuery();
eResult = ErrorTypes.NoError;
}
}
}
catch
{
eResult = ErrorTypes.TaskQueue;
}
return eResult;
}
public static string SerializeToXml(TaskQueueData oData)
{
return Utils.SerializeToXml(typeof(TaskQueueData), oData);
}
private string GetInsertString(TaskQueueData oTask, Priority ePriority)
{
string sData = TaskQueueData.SerializeToXml(oTask);
return("INSERT INTO " + m_cstrTableName + " ( cq_data, cq_priority, cq_time, cq_isbusy ) VALUES ( '" + sData + "', '" + ePriority.ToString("d") + "', '" + DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat) + "', '" + BusyType.not_busy.ToString("d") + "' );");
}
public static string SerializeToXml(TaskQueueData oData)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings ws = new XmlWriterSettings();
ws.NewLineHandling = NewLineHandling.None;
ws.Indent = false;
XmlWriter xw = System.Xml.XmlWriter.Create(sb, ws);
System.Xml.Serialization.XmlSerializer formatter = new System.Xml.Serialization.XmlSerializer(typeof(TaskQueueData));
formatter.Serialize(xw, oData);
return sb.ToString();
}
public void AddTaskBegin(TaskQueueData oTask, Priority oPriority, AsyncCallback fCallback, object oParam)
{
m_oTaskQueue.AddTaskBegin(oTask, oPriority, fCallback, oParam);
}
public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
return m_oTaskQueue.AddTask(oTask, oPriority);
}
private void TaskResultUpdateCallback(IAsyncResult ar)
{
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
try
{
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.UpdateEnd(ar);
if (ErrorTypes.NoError == eError)
{
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
int nToFormat = FileFormats.AVS_OFFICESTUDIO_FILE_CANVAS;
TaskQueueData oTaskQueueData = new TaskQueueData(cmd.id, nToFormat, "Editor.bin");
if ("reopen" == cmd.c)
{
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_bFromSettings = true;
}
else
oTaskQueueData.m_sFromUrl = cmd.url;
oTaskQueueData.m_sFromFormat = cmd.format;
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
oTaskQueueData.m_bEmbeddedFonts = false;
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassTaskResult, oTaskQueue, null);
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.High, TaskQueueAddCallback, oTransportClassTaskQueue);
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand("waitopen", "0"));
}
else
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
}
catch
{
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
}
}
public void AddTaskBegin(TaskQueueData oTask, Priority oPriority, AsyncCallback fCallback, object oParam)
{
m_oTaskQueue.AddTaskBegin(oTask, oPriority, fCallback, oParam);
}
private string GetInsertString(TaskQueueData oTask, Priority ePriority)
{
string sData = TaskQueueData.SerializeToXml(oTask);
return "INSERT INTO " + m_cstrTableName + " ( cq_data, cq_priority, cq_time, cq_isbusy ) VALUES ( '" + sData + "', '" + ePriority.ToString("d") + "', '" + DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat) + "', '" + BusyType.not_busy.ToString("d") + "' );";
}
private void TaskResultAddRandomKeyAsyncCallback4(IAsyncResult ar)
{
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
try
{
TaskResultData oTaskResultData;
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
if (ErrorTypes.NoError == eError)
{
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
TaskQueueData oTaskQueueData = new TaskQueueData(oTaskResultData.sKey, cmd.outputformat.Value, "output." + FileFormats.ToString(cmd.outputformat.Value));
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_sFromFormat = "doct";
oTaskQueueData.m_bFromChanges = true;
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassTaskResult, oTaskQueue, oTaskQueueData);
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.Low, TaskQueueAddCallbackSave3, oTransportClassTaskQueue);
}
else
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
}
catch
{
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
}
}
private void TaskResultAddRandomKeyAsyncCallback3(IAsyncResult ar)
{
TransportClassSaveChanges1 oTransportClassSaveChanges = ar.AsyncState as TransportClassSaveChanges1;
try
{
InputCommand cmd = oTransportClassSaveChanges.m_oInputCommand;
_log.DebugFormat("Enter TaskResultAddRandomKeyAsyncCallback3(id={0})", cmd.id);
TaskResultData oTaskResultData;
ErrorTypes eError = oTransportClassSaveChanges.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
if (ErrorTypes.NoError == eError)
{
string sFilename = "output.zip";
int nOutputFormat = FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_TEAMLAB_INNER;
if(cmd.outputformat.HasValue)
{
nOutputFormat = cmd.outputformat.Value;
sFilename = "output." + FileFormats.ToString(nOutputFormat);
}
TaskQueueData oTaskQueueData = new TaskQueueData(oTaskResultData.sKey, nOutputFormat, sFilename);
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_sFromFormat = "bin";
oTaskQueueData.m_bFromChanges = true;
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
if (null != cmd.vkey)
{
bool bPaid;
Signature.getVKeyParams(cmd.vkey, out bPaid);
oTaskQueueData.m_bPaid = bPaid;
}
Priority oPriority = Priority.Low;
if (cmd.innersave)
oPriority = Priority.Normal;
oTaskQueueData.m_sResultCallbackUrl = UrlBuilder.FullUrl(oTransportClassSaveChanges.m_oHttpContext.Request);
InputCommand oSaveCommand = new InputCommand();
oSaveCommand.c = "sfcc";
oSaveCommand.id = cmd.id;
oSaveCommand.task_queue_data = oTaskQueueData;
oSaveCommand.url = cmd.url;
oSaveCommand.status = (int)oTransportClassSaveChanges.m_oTaskResultDataToUpdate.eStatus.Value;
oSaveCommand.status_info = oTransportClassSaveChanges.m_oTaskResultDataToUpdate.nStatusInfo.Value;
oTaskQueueData.m_sResultCallbackData = InputCommand.SerializeToJson(oSaveCommand);
_log.DebugFormat("oTaskQueueData.m_sResultCallbackData = {0}(id={1})", oTaskQueueData.m_sResultCallbackData, cmd.id);
CTaskQueue oTaskQueue = new CTaskQueue();
oTransportClassSaveChanges.m_oTaskQueue = oTaskQueue;
oTransportClassSaveChanges.m_oTaskQueueData = oTaskQueueData;
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave2, oTransportClassSaveChanges);
}
else
{
_log.ErrorFormat("Error in TaskResultAddRandomKeyAsyncCallback3(code={0})", (int)eError);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(eError));
}
}
catch(Exception e)
{
_log.Error("Exception catched in TaskResultAddRandomKeyAsyncCallback3:", e);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(ErrorTypes.Unknown));
}
}
public ErrorTypes AddTask(TaskQueueData oTask, Priority oPriority)
{
ErrorTypes eResult = ErrorTypes.Unknown;
string strUrlQueue = GetQueueUrl(oPriority);
try
{
string strData = TaskQueueData.SerializeToXml(oTask);
using (Amazon.SQS.AmazonSQS oSQSClient = Amazon.AWSClientFactory.CreateAmazonSQSClient())
{
Amazon.SQS.Model.SendMessageRequest oSendMessageRequest = new Amazon.SQS.Model.SendMessageRequest();
oSendMessageRequest.QueueUrl = strUrlQueue;
oSendMessageRequest.MessageBody = strData;
oSQSClient.SendMessage(oSendMessageRequest);
eResult = ErrorTypes.NoError;
}
}
catch (Amazon.SQS.AmazonSQSException)
{
eResult = ErrorTypes.TaskQueue;
}
catch
{
eResult = ErrorTypes.TaskQueue;
}
return eResult;
}
public void AddTaskBegin(TaskQueueData oTask, Priority oPriority, AsyncCallback fCallback, object oParam)
{
m_AddTask = AddTask;
m_AddTask.BeginInvoke(oTask, oPriority, fCallback, oParam);
}
public void AddTaskBegin(TaskQueueData oTask, Priority oPriority, AsyncCallback fCallback, object oParam)
{
m_oAddTask = new TransportClass(fCallback, oParam);
try
{
m_oAddTask.m_delegateAdder = AddTask;
m_oAddTask.m_delegateAdder.BeginInvoke(oTask, oPriority, m_oAddTask.m_fCallback, m_oAddTask.m_oParam);
}
catch
{
m_oAddTask.DisposeAndCallback();
}
return;
}
public static string SerializeToXml(TaskQueueData oData)
{
return(Utils.SerializeToXml(typeof(TaskQueueData), oData));
}
