public MessageTO sendDraft(string pwd, Int32 messageId, Int32 messageOplock)
{
MessageTO result = new MessageTO();
if (String.IsNullOrEmpty(pwd))
{
result.fault = new FaultTO("Missing pwd");
}
else if (messageId <= 0)
{
result.fault = new FaultTO("Must supply a valid message ID");
}
try
{
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
SecureMessageDao dao = new SecureMessageDao(cxn);
gov.va.medora.mdo.domain.sm.Message msg = new Message()
{
Id = messageId, Oplock = messageOplock
};
result = new MessageTO(dao.sendDraft(msg));
}
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
public MessageTO sendReplyMessage(string pwd, Int32 replyingToMessageId, Int32 senderId, Int32 recipientId, string messageBody)
{
MessageTO result = new MessageTO();
if (replyingToMessageId <= 0)
{
result.fault = new FaultTO("Missing reply message ID");
}
else if (senderId <= 0)
{
result.fault = new FaultTO("Missing sender ID");
}
//else if (recipientId <= 0)
//{
// result.fault = new FaultTO("Missing recipient ID");
//}
else if (String.IsNullOrEmpty(messageBody))
{
result.fault = new FaultTO("Must supply a message body");
}
if (result.fault != null)
{
return(result);
}
try
{
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
SecureMessageDao dao = new SecureMessageDao(cxn);
Message replyingTo = dao.getMessage(replyingToMessageId);
if (replyingTo == null || replyingTo.Id <= 0)
{
throw new Exception("No message found for that ID");
}
Message newReply = new Message()
{
SentDate = DateTime.Now,
SenderId = senderId,
RecipientId = recipientId,
Body = messageBody,
Checksum = StringUtils.getMD5Hash(messageBody),
MessageThread = replyingTo.MessageThread
};
result = new MessageTO(dao.sendReply(replyingTo, newReply));
}
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
public MessageTO getTablesUploadResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.TablesUploadResponse;
if (request == null || request.CompressedDataTables == null || request.CompressedDataTables.Count == 0 ||
request.Configuration == null)
{
response.MessageType = MessageTypeTO.Error;
response.Message = _errorMsg;
return(response);
}
try
{
// some times this takes a while - we don't want to wait so we'll do it in a seperate thread
Thread extractThread = new Thread(new ParameterizedThreadStart(extractAndVerify));
extractThread.IsBackground = true;
// passing this ParamterizedThreadStart an ugly object but seems to be most efficient way to handle
extractThread.Start(new KeyValuePair <ExtractorConfiguration, Dictionary <string, byte[]> >
(request.Configuration, request.CompressedDataTables));
}
catch (Exception exc)
{
//LOG.Error(exc);
}
return(response);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("***** Start DownstreamException String *****");
if (!String.IsNullOrEmpty(Message))
{
sb.AppendLine("Message: " + Message);
}
if (InnerException != null)
{
sb.AppendLine("Inner Exception: " + InnerException.ToString());
}
if (Extractor != null)
{
sb.AppendLine("Extractor: " + Extractor.ToString());
}
if (VistaQuery != null)
{
sb.AppendLine("Vista Query: " + VistaQuery.ToString());
}
if (ExtractorConfiguration != null)
{
sb.AppendLine("Extractor Config: " + ExtractorConfiguration.ToString());
}
if (MessageTO != null)
{
sb.AppendLine("MessageTO Object: " + MessageTO.ToString());
}
sb.AppendLine("***** End DownstreamException String *****");
return(sb.ToString());
}
public MessageTO getZipFileUploadResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.ZipFileUploadResponse;
if (request == null || request.ZippedFile == null || request.ZippedFile.Length == 0)
{
response.MessageType = MessageTypeTO.Error;
response.Message = _errorMsg;
return(response);
}
try
{
// some times this takes a while - we don't want to wait so we'll do it in a seperate thread
FileDao fileDao = new FileDao();
Thread extractThread = new Thread(new ParameterizedThreadStart(fileDao.extractFiles));
extractThread.IsBackground = true;
extractThread.Start(new KeyValuePair <string, byte[]>(request.Message, request.ZippedFile));
}
catch (Exception exc)
{
//LOG.Error(exc);
}
return(response);
}
public MessageTO getTableUploadResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.TableUploadResponse;
if (request == null || request.VistaData == null || String.IsNullOrEmpty(request.VistaData.TableName) ||
request.VistaData.Rows == null || request.VistaData.Rows.Count <= 0 || request.Configuration == null)
{
//LOG.Debug("Received an invalid table upload request - notifying client");
response.MessageType = MessageTypeTO.Error;
response.Error = "Invalid table upload request!";
return(response);
}
try
{
FileDao fileDao = new FileDao();
response.Message = fileDao.saveToFile(request.VistaData, request.Configuration.ExtractMode);
}
catch (Exception exc)
{
response.MessageType = MessageTypeTO.Error;
response.Error = exc.ToString();
}
return(response);
}
/// <summary>
/// Get all the extractors currently running.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MessageTO getExtractorsResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.ExtractorsResponse;
response.Extractors = Extractors.GetExtractors();
return(response);
}
internal MessageTO getResumeResponse(MessageTO request, Server server)
{
server.SocketContainer.Locked = false;
return(new MessageTO()
{
MessageType = MessageTypeTO.ResumeResponse, Message = "Server Unlocked"
});
}
/// <summary>
/// Downstream extractor constructor. Any of the domain specific arguments can be null
/// </summary>
/// <param name="extractor"></param>
/// <param name="extractorConfig"></param>
/// <param name="vistaQuery"></param>
/// <param name="messageTO"></param>
/// <param name="message"></param>
/// <param name="inner"></param>
public DownstreamException(Extractor extractor, ExtractorConfiguration extractorConfig, VistaQuery vistaQuery,
MessageTO messageTO, string message, Exception inner)
: base(message, inner)
{
Extractor = extractor;
ExtractorConfiguration = extractorConfig;
VistaQuery = vistaQuery;
MessageTO = messageTO;
}
public String getNextRunTime()
{
Client c = new Client(_orchestratorHostName, _orchestratorPort);
MessageTO response = c.submitRequest(new MessageTO()
{
MessageType = MessageTypeTO.TimeToNextRunRequest
});
return(response.Message);
}
public MessageTO getTimeToNextRunResonse()
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.TimeToNextRunResponse;
response.Message = this.ServiceState.NextRun.ToString();
return(response);
}
public MessageTO moveMessage(string pwd, Int32 userId, Int32 messageId, Int32 newFolderId)
{
MessageTO result = new MessageTO();
pwd = getConnectionString(pwd);
if (String.IsNullOrEmpty(pwd))
{
result.fault = new FaultTO("No connection string specified or configured");
}
if (result.fault != null)
{
return(result);
}
try
{
Message message = new Message();
message.Id = messageId;
message.Addressees = new List <Addressee>()
{
new Addressee()
{
FolderId = newFolderId, Owner = new User()
{
Id = userId
}
}
};
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
AddresseeDao dao = new AddresseeDao(cxn);
message.Addressees[0] = dao.moveMessage(new Message()
{
Id = messageId
}, new User()
{
Id = userId
}, new Folder()
{
Id = newFolderId
});
result = new MessageTO(message);
}
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
internal String getLastRunCompletedTime()
{
Client c = new Client(_orchestratorHostName, _orchestratorPort);
MessageTO response = c.submitRequest(new MessageTO()
{
MessageType = MessageTypeTO.LastRunInfoRequest
});
//return gov.va.medora.utils.JsonUtils.Deserialize<KeyValuePair<String, DateTime>>(response.Message);
return(response.Message); // will be JSON serialized KeyValuePair<String, DateTime>
}
/// <summary>
/// Check to see if any post processing needs to happen for this file. If so, do it.
/// </summary>
/// <param name="request">The last request we serviced</param>
private void postProcess(object obj)
{
MessageTO request = (MessageTO)obj;
// Set up
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.JobCompletedResponse;
// Protect
if (request == null || String.IsNullOrEmpty(request.Configuration.SiteCode) ||
String.IsNullOrEmpty(request.Configuration.QueryConfigurations.RootNode.Value.File))
{
return;
}
// Do our work
try
{
String sqlProvider = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlProvider];
String connectionString = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlConnectionString];
ISqlDao sqlDao = new SqlDaoFactory().getSqlDao(new SqlConnectionFactory().getConnection(sqlProvider, connectionString));
//if (request.Configuration.ON_COMPLETE != null)
//{
if (ActiveExtractions.ExistsByFile(request.Configuration.QueryConfigurations.RootNode.Value.File)
||
WorkStack.ExistsByFile(request.Configuration.QueryConfigurations.RootNode.Value.File)
)
{
}
else
{
//sqlDao.executeDelimited(request.Configuration.ON_COMPLETE, 5 * 60 * 1000);
//// for each query configuration, disable indexes on the file
//IList<string> distinctFiles = new List<string>();
//parseDistinctFiles(request.Configuration.QueryConfigurations.RootNode, distinctFiles);
//foreach (string file in distinctFiles)
//{
// sqlDao.enableIndexes(file);
//}
// TODO: Add support for the SQL server version of this
//sqlDao.executeStoredProcedureNoArguments(request.Configuration.QueryConfigurations.RootNode.Value.File + "_END", 10 * 60 * 1000);
sqlDao.postProcess(request.Configuration.QueryConfigurations.RootNode);
}
//}
}
catch
{
// TODO: REQ HANDLER NEEDS A LOGGING MECHANISM THAT IS THREAD-SAFE
}
}
public void logMessage(MessageTO request)
{
//LOG.Error("An extraction job uploaded the following error: " + request.Error);
try
{
System.Net.Mail.SmtpClient mail = new System.Net.Mail.SmtpClient("smtp.va.gov", 25);
mail.SendAsync("*****@*****.**", "*****@*****.**", "Log Error Request From Client", request.Error, new object());
}
catch (Exception exc)
{
//LOG.Error("Unable to send email about error log request!", exc);
}
}
public WebFleetMessage Map(MessageTO msg)
{
var result = new WebFleetMessage()
{
MessageId = msg.messageId,
MessageTime = msg.messageTime,
MessageText = msg.messageText,
PositionText = msg.positionText,
ObjectNumber = [email protected],
};
SetMessageStatusFromText(result);
return(result);
}
/// <summary>
/// Check if the orchestrator has jobs on it's work stack. Returns the number of jobs in the message property.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MessageTO getServerHasWorkResponse(MessageTO request)
{
MessageTO response = new MessageTO()
{
MessageType = MessageTypeTO.ServerHasWorkResponse,
Message = "0"
};
//LOG.Debug("Telling client we have " + WorkStack.Count() + " jobs on the stack");
if (!_locked && WorkStack != null && WorkStack.Count() > 0)
{
response.Message = WorkStack.Count().ToString();
}
return(response);
}
public MessageTO deleteDraft(string pwd, Int32 messageId)
{
MessageTO result = new MessageTO();
pwd = getConnectionString(pwd);
if (String.IsNullOrEmpty(pwd))
{
result.fault = new FaultTO("No connection string specified or configured");
}
else if (messageId <= 0)
{
result.fault = new FaultTO("Missing message ID");
}
if (result.fault != null)
{
return(result);
}
try
{
Message message = new Message()
{
Id = messageId
};
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
SecureMessageDao dao = new SecureMessageDao(cxn);
dao.deleteDraft(message);
}
message.Addressees = null;
message.MessageThread = null;
message.Body = "OK";
message.Id = -1;
result = new MessageTO(message);
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
public dto.sm.MessageTO readMessage(string pwd, Int32 addresseeId, Int32 addresseeOplock)
{
MessageTO result = new MessageTO();
pwd = getConnectionString(pwd);
if (String.IsNullOrEmpty(pwd))
{
result.fault = new FaultTO("No connection string specified or configured");
}
else if (addresseeId <= 0)
{
result.fault = new FaultTO("Must supply addressee ID");
}
if (result.fault != null)
{
return(result);
}
try
{
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
AddresseeDao dao = new AddresseeDao(cxn);
gov.va.medora.mdo.domain.sm.Addressee addressee = dao.readMessage(new Addressee()
{
Id = addresseeId, Oplock = addresseeOplock
});
MessageTO message = new MessageTO(addressee.Message);
message.addressees = new AddresseeTO[1] {
new AddresseeTO(addressee)
};
result = message;
}
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
/// <summary>
/// This method sets the internal shutdown flag of the RequestHandler. Subsequent calls to RequestHandler.getInstance().getShutdownSignal()
/// should return true. Note no asynchronous events occur on the parent thread or process
/// </summary>
/// <param name="request">MessageTO</param>
/// <returns>MessageTO</returns>
public MessageTO getStopJobResponse(MessageTO request)
{
// some notes... this is not thread safe because RequestHandler is a singleton. instead, it appears the best
// way to enable this sort of coordination is to share local service state for a thread with it's Server
// and just put a hook in to check for changing job status
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.StopServerResponse;
_shutdownSignal = true;
response.Message = "OK";
if (this.ServiceState != null)
{
this.ServiceState.Status = ServiceStatus.STOPPED;
this.ServiceState.StatusSetBy = request.HostName;
}
//LOG.Info("Stopping extraction job at request of orchestrator. Reason: " + request.Message);
return(response);
}
internal MessageTO getPauseResponse(MessageTO request, Server server)
{
if (server.SocketContainer.Locked)
{
return(new MessageTO()
{
MessageType = MessageTypeTO.PauseResponse, Message = "Server already locked"
});
}
else
{
server.SocketContainer.Locked = true;
return(new MessageTO()
{
MessageType = MessageTypeTO.PauseResponse, Message = "Server Locked"
});
}
}
public void UserInterfaceTest()
{
// UserInterfaceRole AssistanteRole = new UserInterfaceRole();
AdminInterfaceRole AssistanteRole = new AdminInterfaceRole();
AdminInterfaceRole Garbage = new AdminInterfaceRole();
StructMessage structure = new StructMessage()
{
MessageType = MessageType.chat,
IdSender = 1,
IdReceiver = 2,
Title = "subject",
Email = "*****@*****.**",
Content = "",
IsSent = false,
Date = new DateTime(),
Id = 0
};
MessageTO message0 = new MessageTO(new StructMessage());
Assert.False(AssistanteRole.SendMessage(message0));
MessageTO message = new MessageTO(structure);
Assert.True(AssistanteRole.SendMessage(message));
structure.IdReceiver = 3;
structure.MessageType = MessageType.email;
MessageTO message1 = new MessageTO(structure);
Assert.True(AssistanteRole.SendMessage(message1));
structure.MessageType = MessageType.notification;
MessageTO message2 = new MessageTO(structure);
Assert.False(AssistanteRole.SendMessage(message2));
Garbage.Erase();
Assert.Equal(new List <int>()
{
}, AssistanteRole.GetHistory(1));
}
/// <summary>
/// Return all the work stacks
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MessageTO getWorkStacksResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.WorkStacksResponse;
//LOG.Debug(WorkStack.Count() + " jobs on the workstack");
//LOG.Debug(ActiveExtractions.Count() + " active jobs");
//LOG.Debug(ErroredExtractions.Count() + " errored jobs");
//LOG.Debug(CompletedExtractions.Count() + " completed jobs");
response.Configurations = new Dictionary <string, IList <ExtractorConfiguration> >();
response.Configurations.Add("Queued", new List <ExtractorConfiguration>());
response.Configurations.Add("Active", new List <ExtractorConfiguration>());
response.Configurations.Add("Errored", new List <ExtractorConfiguration>());
response.Configurations.Add("Completed", new List <ExtractorConfiguration>());
if (WorkStack != null && WorkStack.Count() > 0)
{
WorkStack.CopyTo(response.Configurations["Queued"]);
}
if (ActiveExtractions != null && ActiveExtractions.Count() > 0)
{
response.Configurations["Active"] = ActiveExtractions.CopyTo(response.Configurations["Active"]);
}
if (ErroredExtractions != null && ErroredExtractions.Count() > 0)
{
response.Configurations["Errored"] = ErroredExtractions.CopyTo(response.Configurations["Errored"]);
}
if (CompletedExtractions != null && CompletedExtractions.Count() > 0)
{
response.Configurations["Completed"] = CompletedExtractions.CopyTo(response.Configurations["Completed"]);
}
response.Message = gov.va.medora.utils.JsonUtils.Serialize <TaggedExtractorConfigArrays>
(new TaggedExtractorConfigArrays(response.Configurations));
response.Configurations = null; // null this since we serialized the results to a JSON string
return(response);
}
public MessageTO moveMessage(string pwd, Int32 userId, Int32 messageId, Int32 newFolderId)
{
MessageTO result = new MessageTO();
try
{
Message message = new Message();
message.Id = messageId;
message.Addressees = new List <Addressee>()
{
new Addressee()
{
FolderId = newFolderId, Owner = new User()
{
Id = userId
}
}
};
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
AddresseeDao dao = new AddresseeDao(cxn);
message.Addressees[0] = dao.moveMessage(new Message()
{
Id = messageId
}, new User()
{
Id = userId
}, new Folder()
{
Id = newFolderId
});
result = new MessageTO(message);
}
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
/// <summary>
/// Handle a request specifying from which server the request originated
/// </summary>
/// <param name="request"></param>
/// <param name="server"></param>
/// <returns></returns>
public MessageTO handleRequest(MessageTO request, Server server)
{
switch (request.MessageType)
{
case MessageTypeTO.PauseRequest:
return(getPauseResponse(request, server));
case MessageTypeTO.ResumeRequest:
return(getResumeResponse(request, server));
case MessageTypeTO.JobStatusRequest:
return(getJobStatusResponse(request, server));
default:
return(handleRequest(request));
}
// if we somehow get down here
return(handleRequest(request));
}
internal MessageTO getJobStatusResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.JobStatusResponse;
if (this.ServiceState != null)
{
// a bit kludgy but better than before... if the percentage complete is set (typically by the extractorservice) then return that.
// otherwise return the ToString value of the current servicestate
if (!String.IsNullOrEmpty(this.ServiceState.PercentageComplete))
{
response.Message = this.ServiceState.PercentageComplete;
}
else
{
response.Message = this.ServiceState.ToString();
}
}
return(response);
}
public dto.sm.MessageTO deleteAttachment(string pwd, Int32 messageId)
{
MessageTO result = new MessageTO();
pwd = getConnectionString(pwd);
if (String.IsNullOrEmpty(pwd))
{
result.fault = new FaultTO("No connection string specified or configured");
}
else if (messageId <= 0)
{
result.fault = new FaultTO("Invalid message ID");
}
if (result.fault != null)
{
return(result);
}
try
{
using (MdoOracleConnection cxn = new MdoOracleConnection(new mdo.DataSource()
{
ConnectionString = pwd
}))
{
AttachmentDao dao = new AttachmentDao(cxn);
Message dbMsg = dao.deleteAttachmentFromMessage(messageId);
result = new MessageTO(dbMsg);
}
}
catch (Exception exc)
{
result.fault = new FaultTO(exc);
}
return(result);
}
/// <summary>
/// For new job requests, do the following:
/// 1. Make sure we can call client back on specified hostname
/// 2. Pop a job off the work stack
/// 3. Try locking the site/file from the popped job (put job back on stack if fail)
/// 4. Send response back to client
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public MessageTO getNewJobResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.NewJobResponse;
if (String.Equals(request.HostName, "SansCallback") && request.ListeningPort == 0)
{
// this is from a test - don't require a callback
}
else
{
try
{
//LOG.Debug("Received a new job response - first checking to make sure we can communicate with the client");
Client c = new Client();
c.connect(request.HostName, request.ListeningPort);
c.disconnect();
//LOG.Debug("Successfully connected to the client! Going to try sending the client a job now...");
}
catch (Exception exc)
{
response.MessageType = MessageTypeTO.Error;
response.Error = exc.ToString();
//LOG.Debug("Couldn't call back client who requested new job!", exc);
return(response);
}
}
if (this.WorkStack == null)
{
//LOG.Debug("The work stack is null! Has the application been initialized properly?");
response.MessageType = MessageTypeTO.Error;
response.Error = "The WorkStack has not been initialized!";
return(response);
}
// I think we were opening up a race condition here - now we just try and pop a job and see if we got one
// instead of making a call for the count and then another to pop a job
//if (WorkStack.Count() == 0)
//{
// LOG.Debug("Looks like there are no more jobs on the work stack! Tell the client thanks but nothing to do");
// response.Message = "No more jobs on the stack!";
// return response;
//}
//LOG.Debug("Found a job for the client - popping it off the stack");
// Don't process new jobs if we are currently locked
if (_locked)
{
response.Message = "No more jobs on the stack!";
return(response);
}
//ExtractorConfiguration responseConfig = WorkStack.PopSiteUnique(ActiveExtractions);
ExtractorConfiguration responseConfig = WorkStack.Pop();
if (responseConfig == null)
{
//LOG.Debug("Looks like there are no more jobs on the work stack! Tell the client thanks but nothing to do");
response.Message = "No more jobs on the stack!";
return(response);
}
String sqlProvider = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlProvider];
String connectionString = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlConnectionString];
ISqlDao sqlDao = new SqlDaoFactory().getSqlDao(new SqlConnectionFactory().getConnection(sqlProvider, connectionString));
try
{
if (!sqlDao.lockSite(responseConfig.SiteCode, responseConfig.QueryConfigurations.RootNode.Value.File,
request.HostName, Convert.ToInt16(request.ListeningPort)))
{
//LOG.Debug("Unable to lock the new job for the client! Tell them we couldn't assign a new job");
response.MessageType = MessageTypeTO.Error;
response.Error = "Unable to lock site!";
return(response);
}
}
catch (Exception exc)
{
WorkStack.Push(responseConfig); // put it back on stack if error occured
response.MessageType = MessageTypeTO.Error;
response.Error = exc.ToString();
//LOG.Error(exc);
return(response);
}
ActiveExtractions.Push(responseConfig);
response.Configuration = responseConfig;
response.Extractor = new Extractor(request.HostName, request.ListeningPort,
response.Configuration.SiteCode, response.Configuration.QueryConfigurations.RootNode.Value.File, DateTime.Now);
Extractors.Add(response.Extractor);
//LOG.Debug("Successfully obtained a new job for our client and locked it in the database! Sending...");
response.Extractor.Configuration = responseConfig;
// now passing the extractor a directory name in which to dump all extractions
response.Message = this.BatchDirectory;
// end passing dir name
/// TBD - maybe provide a start value in the event a vista extraction stopped in the middle of a file and
/// the extractor
//try
//{
// FileDao fileDao = new FileDao();
// string lastFileIen = fileDao.getLastIen(response.Configuration.SiteCode, response.Configuration.VistaFile);
// int lastIen = Convert.ToInt32(lastFileIen);
// if (lastIen > 0)
// {
// response.Extractor.
// }
//}
// catch (Exception exc)
// {
// }
return(response);
}
public MessageTO getJobCompletedResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.JobCompletedResponse;
if (request == null || String.IsNullOrEmpty(request.Configuration.SiteCode) ||
String.IsNullOrEmpty(request.Configuration.QueryConfigurations.RootNode.Value.File))
{
//LOG.Debug("Received an invalid job completed request from the client - unable to process: " + request.Configuration.ToString());
logging.Log.LOG("Problem with job complete request!");
response.MessageType = MessageTypeTO.Error;
response.Error = "Invalid request!";
return(response);
}
try
{
String sqlProvider = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlProvider];
String connectionString = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlConnectionString];
ISqlDao sqlDao = new SqlDaoFactory().getSqlDao(new SqlConnectionFactory().getConnection(sqlProvider, connectionString));
if (request.ExtractorReport != null)
{
try
{
logging.Log.LOG("Saving successful job report...");
sqlDao.saveReport(request.ExtractorReport);
}
catch (Exception exc)
{
logging.Log.LOG("Unable to save extractors report: " + request.Configuration.SiteCode + " - " + request.Configuration.QueryConfigurations.RootNode.Value.File + ", " + exc.Message);
}
}
// get last IEN from message and save to tracking table
sqlDao.saveLastIen(request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File, request.ExtractorReport.StartIen, request.ExtractorReport.LastIen, request.ExtractorReport.BatchId);
// unlock site from locks table
sqlDao.unlockSite(request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File);
// the remove function keys off the site code and vista file - those are the only params we need
Extractors.Remove(new Extractor("", 0, request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File, DateTime.Now));
CompletedExtractions.Push(request.Configuration);
ActiveExtractions.Remove(request.Configuration);
// all done with site?
try
{
checkSiteCompleteAndTrigger(request.ExtractorReport.BatchId, request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File);
}
catch (Exception triggerExc) // shouldn't fail job complete request if there is a problem with this - we just won't create the trigger
{
logging.Log.LOG("An unexpected error occured when checking if it was ok to create the trigger for site " + request.Configuration.SiteCode + "\r\n\r\n" + triggerExc.ToString());
}
response.Message = "Nice Work!";
}
catch (Exception exc)
{
logging.Log.LOG(exc.Message);
response.MessageType = MessageTypeTO.Error;
response.Error = exc.ToString();
}
// handle post process in separate thread
Thread postProcessThread = new Thread(new ParameterizedThreadStart(RequestHandler.getInstance().postProcess));
postProcessThread.Start(request);
return(response);
}
public MessageTO getJobErrorResponse(MessageTO request)
{
MessageTO response = new MessageTO();
response.MessageType = MessageTypeTO.JobErrorResponse;
if (request == null || request.Configuration == null || !request.Configuration.isCompleteConfiguration())
{
response.MessageType = MessageTypeTO.Error;
response.Error = "Incomplete ExtractorConfiguration parameter on request";
logging.Log.LOG("The ExtractorConfiguration object sent to the job error request handler is incomplete! Unable to process request");
//LOG.Error("The ExtractorConfiguration object sent to the job error request handler is incomplete! Unable to process request: " + request.Configuration.ToString());
return(response);
}
if (WorkStack == null)
{
logging.Log.LOG("The work stack is null for the job error request. Was everything setup correctly?");
//LOG.Debug("The work stack is null - was everything set up correctly?");
response.MessageType = MessageTypeTO.Error;
response.Error = "WorkStack has not been initialized";
return(response);
}
// the remove function keys off the site code and vista file - those are the only params we need
Extractors.Remove(new Extractor("", 0, request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File, DateTime.Now));
ActiveExtractions.Remove(request.Configuration);
ErroredExtractions.Push(request.Configuration);
// bug fix: some edge cases will allow duplicate configs to be added to stack - need to check not already there
//bool alreadyOnStack = false;
//if (WorkStack.Contains(request.Configuration))
//{
// //LOG.Debug("It looks like this job was already on the stack - no need to add it again");
// alreadyOnStack = true;
//}
// decided to temporarily stop adding errored jobs back to the stack to check for patterns in error site codes
//if (!alreadyOnStack)
//{
// LOG.Debug("Adding a job back to the work stack since the client reported an error while processing");
// ErroredExtractions.Push(request.Configuration);
// ActiveExtractions.Remove(request.Configuration);
// WorkStack.Push(request.Configuration);
//}
// end bug fix
try
{
String sqlProvider = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlProvider];
String connectionString = ConfigurationManager.AppSettings[config.AppConfigSettingsConstants.SqlConnectionString];
ISqlDao sqlDao = new SqlDaoFactory().getSqlDao(new SqlConnectionFactory().getConnection(sqlProvider, connectionString));
if (request.ExtractorReport != null)
{
try
{
logging.Log.LOG("Saving error report...");
sqlDao.saveReport(request.ExtractorReport);
}
catch (Exception exc)
{
//LOG.Error("Unable to save an extractor's report!", exc);
}
}
sqlDao.unlockSite(request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File);
//LOG.Debug("Successfully unlocked job so another client can process");
// should check site completion on job error reports too
try
{
checkSiteCompleteAndTrigger(request.ExtractorReport.BatchId, request.Configuration.SiteCode, request.Configuration.QueryConfigurations.RootNode.Value.File);
}
catch (Exception te)
{ /* problems with trigger file shouldn't effect extractor */
logging.Log.LOG("An error occured when checking trigger file creation criteria: " + te.ToString());
}
}
catch (Exception exc)
{
logging.Log.LOG("The call to unlock the extraction job for site " + request.Configuration.SiteCode +
", file " + request.Configuration.QueryConfigurations.RootNode.Value.File + " has failed unexpectedly");
logging.Log.LOG(exc.Message);
response.MessageType = MessageTypeTO.Error;
response.Error = exc.ToString();
return(response);
}
return(response);
}
