//-------------------------------------------------------------------------------------------------//
public override ExperimentInfo RunExperiment(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "RunExperiment";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
// Create a result report ready to fill in
experimentInfo.resultReport = new ResultReport();
try
{
//
// Parse the XML specification string to generate a validation report (should be accepted!)
//
Specification specification = new Specification(this.configuration, this.equipmentServiceProxy);
ValidationReport validationReport = specification.Parse(experimentInfo.xmlSpecification);
if (validationReport.accepted == false)
{
throw new ArgumentException(validationReport.errorMessage);
}
experimentInfo.setupId = specification.SetupId;
//
// Create an instance of the driver for the specified setup and then
// execute the experiment and return the result information
//
ResultInfo resultInfo = null;
//
// All setups use the equipment driver
//
DriverEquipment driver = new DriverEquipment(this.equipmentServiceProxy, this.configuration, this.labExperimentInfo.cancelExperiment);
resultInfo = (ResultInfo)driver.Execute(specification);
//
// Create an instance of LabExperimentResult to convert the experiment results to an XML string
//
ExperimentResult experimentResult = new ExperimentResult(
experimentInfo.experimentId, experimentInfo.sbName, DateTime.Now,
this.unitId, (Configuration)this.labConfiguration, specification, resultInfo);
//
// Fill in the result report
//
experimentInfo.resultReport.experimentResults = experimentResult.ToString();
experimentInfo.resultReport.statusCode = (int)resultInfo.statusCode;
experimentInfo.resultReport.errorMessage = resultInfo.errorMessage;
}
catch (Exception ex)
{
experimentInfo.resultReport.statusCode = (int)StatusCodes.Failed;
experimentInfo.resultReport.errorMessage = ex.Message;
Logfile.WriteError(ex.Message);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return experimentInfo;
}
//-------------------------------------------------------------------------------------------------//
private bool ConcludeExperiment(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "ConcludeExperiment";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
try
{
//
// Update experiment status both here and the queue table
//
experimentInfo.status = (StatusCodes)experimentInfo.resultReport.statusCode;
if (this.experimentQueue.UpdateStatus(experimentInfo.experimentId, experimentInfo.sbName, experimentInfo.status) == false)
{
throw new ArgumentException(STRERR_FailedToUpdateQueueStatus);
}
//
// Save the experiment results
//
if (this.experimentResults.Save(experimentInfo) == false)
{
throw new ArgumentException(STRERR_FailedToSaveExperimentResults);
}
//
// Check experiment completion status for updating the statistics
//
DateTime now = DateTime.Now;
if (experimentInfo.status == StatusCodes.Cancelled)
{
// Update statistics for cancelled experiment
if (this.experimentStatistics.Cancelled(experimentInfo.experimentId, experimentInfo.sbName, now) == false)
{
throw new ArgumentException(STRERR_FailedToUpdateStatisticsCancelled);
}
}
else
{
// Update statistics for completed experiment
if (this.experimentStatistics.Completed(experimentInfo.experimentId, experimentInfo.sbName, now) == false)
{
throw new ArgumentException(STRERR_FailedToUpdateStatisticsCompleted);
}
//
// Determine actual execution time of the experiment
//
TimeSpan timeSpan = now - this.labExperimentInfo.startDateTime;
int executionTime = (int)timeSpan.TotalSeconds;
Logfile.Write(STRLOG_ActualExecutionTime + executionTime.ToString() + STRLOG_seconds);
}
success = true;
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
//
// Experiment is finished
//
lock (this.statusLock)
{
if (this.labExperimentInfo != null)
{
this.labExperimentInfo.cancelExperiment = null;
this.labExperimentInfo = null;
}
}
string logMessage = STRLOG_success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
public LabExperimentInfo(ExperimentInfo experimentInfo, DateTime startDateTime)
{
this.experimentInfo = experimentInfo;
this.cancelExperiment = new CancelExperiment();
this.startDateTime = startDateTime;
this.minTimeToLive = 0.0;
this.errorMessage = null;
}
//-------------------------------------------------------------------------------------------------//
private bool PrepareExperiment(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "PrepareExperiment";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
//
// Check if the experiment has been cancelled
//
if (experimentInfo.cancelled == true)
{
//
// Experiment was cancelled while waiting on the queue
//
experimentInfo.resultReport = new ResultReport((int)StatusCodes.Cancelled, STRLOG_QueuedExperimentCancelled);
Logfile.Write(STRLOG_QueuedExperimentCancelled);
}
else
{
//
// Update the statistics for starting the experiment
//
DateTime now = DateTime.Now;
success = this.experimentStatistics.Started(experimentInfo.experimentId, experimentInfo.sbName, this.unitId, now);
//
// Create an instance of LabExperimentInfo to execute the experiment
//
lock (this.statusLock)
{
experimentInfo.unitId = this.unitId;
experimentInfo.status = StatusCodes.Running;
this.labExperimentInfo = new LabExperimentInfo(experimentInfo, now);
}
}
string logMessage = STRLOG_success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
//-------------------------------------------------------------------------------------------------//
private bool NotifyServiceBroker(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "NotifyServiceBroker";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
try
{
//
// Notify the ServiceBroker so that the results can be retrieved
//
LabServerToSbAPI labServerToSbAPI = new LabServerToSbAPI(this.allowedServiceBrokers);
if ((success = labServerToSbAPI.Notify(experimentInfo.experimentId, experimentInfo.sbName)) == true)
{
success = this.experimentResults.UpdateNotified(experimentInfo.experimentId, experimentInfo.sbName);
}
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
string logMessage = STRLOG_success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
//-------------------------------------------------------------------------------------------------//
private bool NotifyEmail(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "NotifyEmail";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
try
{
/*
* Send an email to the iLab Administrator stating that an experiment has completed.
* If the experiment failed, send an email to the email address for reporting failed experiments.
*/
MailMessage mailMessage = null;
string errorMessage = String.Empty;
StatusCodes statusCode = (StatusCodes)experimentInfo.resultReport.statusCode;
if (statusCode == StatusCodes.Failed)
{
/*
* Email goes to all those listed for when the experiment fails
*/
if (this.emailAddressesExperimentFailed != null && this.emailAddressesExperimentFailed.Length > 0)
{
if (mailMessage == null)
{
mailMessage = new MailMessage();
}
for (int i = 0; i < this.emailAddressesExperimentFailed.Length; i++)
{
mailMessage.To.Add(new MailAddress(this.emailAddressesExperimentFailed[i]));
}
errorMessage = String.Format(STRLOG_MailMessageError_arg, experimentInfo.resultReport.errorMessage);
}
}
else
{
/*
* Email goes to all those listed for when the experiment completes successfully or is cancelled
*/
if (this.emailAddressesExperimentCompleted != null && this.emailAddressesExperimentCompleted.Length > 0)
{
if (mailMessage == null)
{
mailMessage = new MailMessage();
}
for (int i = 0; i < this.emailAddressesExperimentCompleted.Length; i++)
{
mailMessage.To.Add(new MailAddress(this.emailAddressesExperimentCompleted[i]));
}
}
}
/*
* Check if recipient email addresses have been specified
*/
if (mailMessage != null)
{
mailMessage.From = new MailAddress(this.emailAddressLabServer);
mailMessage.Subject = String.Format(STRLOG_MailMessageSubject_arg2, this.labConfiguration.Title, statusCode);
mailMessage.Body = String.Format(STRLOG_MailMessageBody_arg7,
experimentInfo.sbName, experimentInfo.userGroup, experimentInfo.experimentId, this.unitId, experimentInfo.setupId, statusCode, errorMessage);
Logfile.Write(
String.Format(STRLOG_SendingEmail_arg3, mailMessage.To.ToString(), mailMessage.From.Address, mailMessage.Subject));
/*
* Send the email
*/
SmtpClient smtpClient = new SmtpClient(Consts.STR_LocalhostIP);
smtpClient.Send(mailMessage);
}
success = true;
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
string logMessage = STRLOG_success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
//---------------------------------------------------------------------------------------//
public bool Save(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "Save";
string logMessage = null;
if (experimentInfo != null)
{
logMessage = STRLOG_experimentId + experimentInfo.experimentId.ToString() +
Logfile.STRLOG_Spacer + STRLOG_sbName + Logfile.STRLOG_Quote + experimentInfo.sbName + Logfile.STRLOG_Quote;
}
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName, logMessage);
//
// Catch all exceptions thrown and return false if an error occurred.
//
bool success = false;
lock (this.resultsLock)
{
try
{
//
// Check that the experiment info exists
//
if (experimentInfo == null)
{
throw new ArgumentNullException(STRERR_ExperimentInfoIsNull);
}
//
// Check for null strings and change to empty strings if necessary
//
string errorMessage = (experimentInfo.resultReport.errorMessage == null) ? string.Empty : experimentInfo.resultReport.errorMessage;
string xmlBlobExtension = (experimentInfo.resultReport.xmlBlobExtension == null) ? string.Empty : experimentInfo.resultReport.xmlBlobExtension;
string xmlResultExtension = (experimentInfo.resultReport.xmlResultExtension == null) ? string.Empty : experimentInfo.resultReport.xmlResultExtension;
string experimentResults = (experimentInfo.resultReport.experimentResults == null) ? string.Empty : experimentInfo.resultReport.experimentResults;
string userGroup = (experimentInfo.userGroup == null) ? string.Empty : experimentInfo.userGroup;
//
// Convert warning messages to XML format
//
string xmlWarningMessages = string.Empty;
if (experimentInfo.resultReport.warningMessages != null)
{
XmlDocument xmlDocument = XmlUtilities.GetXmlDocument(STRXMLDOC_WarningMessagesTemplate);
XmlNode xmlRootNode = XmlUtilities.GetXmlRootNode(xmlDocument, STRXML_warningMessages);
XmlUtilities.SetXmlValues(xmlRootNode, STRXML_warningMessage, experimentInfo.resultReport.warningMessages, true);
xmlWarningMessages = xmlDocument.OuterXml;
}
SqlCommand sqlCommand = new SqlCommand(STRSQLCMD_StoreResults, this.sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_ExperimentId, experimentInfo.experimentId));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_SbName, experimentInfo.sbName));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_UserGroup, userGroup));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_PriorityHint, experimentInfo.priorityHint));
StatusCodes status = (StatusCodes)experimentInfo.resultReport.statusCode;
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_Status, status.ToString()));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_XmlExperimentResult, experimentResults));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_XmlResultExtension, xmlResultExtension));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_XmlBlobExtension, xmlBlobExtension));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_WarningMessages, xmlWarningMessages));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_ErrorMessage, errorMessage));
try
{
this.sqlConnection.Open();
if (sqlCommand.ExecuteNonQuery() == 0)
{
throw new Exception(STRERR_FailedToSaveResults);
}
}
catch (SqlException ex)
{
throw new Exception(STRERR_SqlException + ex.Message);
}
catch (Exception ex)
{
throw new Exception(STRERR_Exception + ex.Message);
}
finally
{
this.sqlConnection.Close();
}
// Information saved successfully
success = true;
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
}
logMessage = STRLOG_success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return success;
}
//---------------------------------------------------------------------------------------//
private string ConvertToXml(ExperimentInfo[] experimentInfoArray)
{
const string STRLOG_MethodName = "ConvertToXml";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
//
// Catch all exceptions thrown and return an empty string if an error occurred
//
XmlDocument xmlDocument = null;
string xmlExperimentQueue = string.Empty;
try
{
//
// Check that the experiment info array exists
//
if (experimentInfoArray == null)
{
throw new ArgumentNullException(STRERR_ExperimentInfoArrayIsNull);
}
//
// Take the experiment info and put into the XML document
//
for (int i = 0; i < experimentInfoArray.GetLength(0); i++)
{
ExperimentInfo experimentInfo = experimentInfoArray[i];
// Load experiment results XML template string
XmlDocument xmlTemplateDocument = XmlUtilities.GetXmlDocument(STRXMLDOC_XmlTemplate);
//
// Fill in the XML template with values from the experiment information
//
XmlNode xmlRootNode = XmlUtilities.GetXmlRootNode(xmlTemplateDocument, STRXML_experimentQueue);
XmlNode xmlNode = XmlUtilities.GetXmlNode(xmlRootNode, STRXML_experiment);
XmlUtilities.SetXmlValue(xmlNode, STRXML_experimentId, experimentInfo.experimentId);
XmlUtilities.SetXmlValue(xmlNode, STRXML_sbName, experimentInfo.sbName, false);
XmlUtilities.SetXmlValue(xmlNode, STRXML_userGroup, experimentInfo.userGroup, false);
XmlUtilities.SetXmlValue(xmlNode, STRXML_priorityHint, experimentInfo.priorityHint);
XmlUtilities.SetXmlValue(xmlNode, STRXML_specification, experimentInfo.xmlSpecification, false);
XmlUtilities.SetXmlValue(xmlNode, STRXML_estExecutionTime, experimentInfo.estExecutionTime);
XmlUtilities.SetXmlValue(xmlNode, STRXML_cancelled, experimentInfo.cancelled);
if (xmlDocument == null)
{
xmlDocument = xmlTemplateDocument;
}
else
{
//
// Create an XML fragment from the XML template and append to the document
//
XmlDocumentFragment xmlFragment = xmlDocument.CreateDocumentFragment();
xmlFragment.InnerXml = xmlNode.OuterXml;
xmlDocument.DocumentElement.AppendChild(xmlFragment);
}
}
//
// Check if there were any experiments queued
//
if (xmlDocument == null)
{
xmlDocument = XmlUtilities.GetXmlDocument(STRXMLDOC_XmlTemplate);
XmlNode xmlRootNode = XmlUtilities.GetXmlRootNode(xmlDocument, STRXML_experimentQueue);
XmlNode xmlNode = XmlUtilities.GetXmlNode(xmlRootNode, STRXML_experiment);
xmlRootNode.RemoveChild(xmlNode);
}
//
// Convert the XML document to a string
//
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Formatting = Formatting.Indented;
xmlDocument.WriteTo(xtw);
xtw.Flush();
xmlExperimentQueue = sw.ToString();
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return xmlExperimentQueue;
}
//---------------------------------------------------------------------------------------//
public ExperimentInfo[] RetrieveAllWithStatus(StatusCodes status)
{
const string STRLOG_MethodName = "RetrieveAllWithStatus";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
List<ExperimentInfo> experimentInfoList = new List<ExperimentInfo>();
lock (this.queueLock)
{
try
{
SqlCommand sqlCommand = new SqlCommand(STRSQLCMD_RetrieveQueueAllWithStatus, this.sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_Status, status.ToString()));
try
{
this.sqlConnection.Open();
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read() == true)
{
ExperimentInfo experimentInfo = new ExperimentInfo(0, null);
//
// Get the experiment information from waiting experiment
//
object sdrObject = null;
if ((sdrObject = sqlDataReader[STRSQL_ExperimentId]) != System.DBNull.Value)
experimentInfo.experimentId = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_SbName]) != System.DBNull.Value)
experimentInfo.sbName = (string)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_UserGroup]) != System.DBNull.Value)
experimentInfo.userGroup = (string)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_PriorityHint]) != System.DBNull.Value)
experimentInfo.priorityHint = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_XmlSpecification]) != System.DBNull.Value)
experimentInfo.xmlSpecification = (string)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_EstimatedExecTime]) != System.DBNull.Value)
experimentInfo.estExecutionTime = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_Cancelled]) != System.DBNull.Value)
experimentInfo.cancelled = (bool)sdrObject;
//
// Add the experiment info to the list
//
experimentInfoList.Add(experimentInfo);
}
sqlDataReader.Close();
}
catch (SqlException ex)
{
throw new Exception(STRERR_SqlException + ex.Message);
}
catch (Exception ex)
{
throw new Exception(STRERR_Exception + ex.Message);
}
finally
{
this.sqlConnection.Close();
}
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
}
string logMessage = STRLOG_count + experimentInfoList.Count.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return experimentInfoList.ToArray();
}
//---------------------------------------------------------------------------------------//
/// <summary>
/// Add an experiment to the end of the queue. Return queue information about the experiment.
/// </summary>
/// <param name="experimentInfo"></param>
/// <returns>Queue information about the experiment.</returns>
public QueuedExperimentInfo Enqueue(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "Enqueue";
string logMessage = null;
if (experimentInfo != null)
{
logMessage = STRLOG_experimentId + experimentInfo.experimentId.ToString() +
Logfile.STRLOG_Spacer + STRLOG_sbName + Logfile.STRLOG_Quote + experimentInfo.sbName + Logfile.STRLOG_Quote;
}
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName, logMessage);
QueuedExperimentInfo queuedExperimentInfo = null;
lock (this.queueLock)
{
try
{
//
// Check that the queued experiment info exists
//
if (experimentInfo == null)
{
throw new ArgumentNullException(STRERR_ExperimentInfoIsNull);
}
SqlCommand sqlCommand = new SqlCommand(STRSQLCMD_StoreQueue, this.sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_ExperimentId, experimentInfo.experimentId));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_SbName, experimentInfo.sbName));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_UserGroup, experimentInfo.userGroup));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_PriorityHint, experimentInfo.priorityHint));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_XmlSpecification, experimentInfo.xmlSpecification));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_EstimatedExecTime, experimentInfo.estExecutionTime));
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_Status, StatusCodes.Waiting.ToString()));
try
{
this.sqlConnection.Open();
if (sqlCommand.ExecuteNonQuery() == 0)
{
throw new Exception(STRERR_FailedToEnqueueExperiment);
}
}
catch (SqlException ex)
{
throw new Exception(STRERR_SqlException + ex.Message);
}
catch (Exception ex)
{
throw new Exception(STRERR_Exception + ex.Message);
}
finally
{
this.sqlConnection.Close();
}
//
// Get the queued experiment information and update with queue length
//
queuedExperimentInfo = GetQueuedExperimentInfo(experimentInfo.experimentId, experimentInfo.sbName);
queuedExperimentInfo.queueLength--;
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return queuedExperimentInfo;
}
//---------------------------------------------------------------------------------------//
/// <summary>
/// Get the experiment information for the experiment waiting at the head of the queue.
/// </summary>
/// <returns></returns>
public ExperimentInfo Dequeue(int unitId)
{
const string STRLOG_MethodName = "Dequeue";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
ExperimentInfo experimentInfo = null;
//
// Lock the queue so that two processes don't dequeue the same experiment before status is updated
//
lock (this.queueLock)
{
try
{
SqlCommand sqlCommand = new SqlCommand(STRSQLCMD_RetrieveQueueAllWithStatus, this.sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.Add(new SqlParameter(STRSQLPRM_Status, StatusCodes.Waiting.ToString()));
try
{
this.sqlConnection.Open();
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
if (sqlDataReader.Read() == true)
{
experimentInfo = new ExperimentInfo(0, null);
//
// Get the experiment information from waiting experiment
//
object sdrObject = null;
if ((sdrObject = sqlDataReader[STRSQL_QueueId]) != System.DBNull.Value)
experimentInfo.queueId = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_ExperimentId]) != System.DBNull.Value)
experimentInfo.experimentId = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_SbName]) != System.DBNull.Value)
experimentInfo.sbName = (string)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_UserGroup]) != System.DBNull.Value)
experimentInfo.userGroup = (string)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_PriorityHint]) != System.DBNull.Value)
experimentInfo.priorityHint = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_XmlSpecification]) != System.DBNull.Value)
experimentInfo.xmlSpecification = (string)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_Status]) != System.DBNull.Value)
experimentInfo.status = (StatusCodes)Enum.Parse(typeof(StatusCodes), (string)sdrObject);
if ((sdrObject = sqlDataReader[STRSQL_EstimatedExecTime]) != System.DBNull.Value)
experimentInfo.estExecutionTime = (int)sdrObject;
if ((sdrObject = sqlDataReader[STRSQL_Cancelled]) != System.DBNull.Value)
experimentInfo.cancelled = (bool)sdrObject;
}
sqlDataReader.Close();
}
catch (SqlException ex)
{
throw new Exception(STRERR_SqlException + ex.Message);
}
catch (Exception ex)
{
throw new Exception(STRERR_Exception + ex.Message);
}
finally
{
this.sqlConnection.Close();
}
if (experimentInfo != null)
{
//
// Update experiment status to 'Running' and update the unit ID
//
if (this.UpdateStatusToRunning(experimentInfo.experimentId, experimentInfo.sbName, unitId) == true)
{
experimentInfo.status = StatusCodes.Running;
experimentInfo.unitId = unitId;
}
}
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
}
string logMessage = null;
if (experimentInfo != null)
{
logMessage = STRLOG_experimentId + experimentInfo.experimentId.ToString() +
Logfile.STRLOG_Spacer + STRLOG_sbName + experimentInfo.sbName;
}
else
{
logMessage = STRLOG_NoExperimentsWaiting;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return experimentInfo;
}
//-------------------------------------------------------------------------------------------------//
public SubmissionReport Submit(int experimentID, string sbName, string experimentSpecification,
string userGroup, int priorityHint)
{
SubmissionReport submissionReport = null;
//
// Create a SubmissionReport object ready to fill in and return
//
submissionReport = new SubmissionReport(experimentID);
//
// Validate the experiment specification before submitting
//
ValidationReport validationReport = Validate(experimentSpecification, userGroup);
if (validationReport.accepted == false)
{
// Experiment specification is invalid, cannot submit
submissionReport.vReport = validationReport;
return submissionReport;
}
//
// Create an instance of the experiment
//
ExperimentInfo experimentInfo = new ExperimentInfo(experimentID, sbName,
userGroup, priorityHint, experimentSpecification, (int)validationReport.estRuntime);
//
// Add the experiment to the queue
//
QueuedExperimentInfo queuedExperimentInfo = this.experimentQueue.Enqueue(experimentInfo);
if (queuedExperimentInfo != null)
{
//
// Update submission report
//
submissionReport.vReport.accepted = true;
submissionReport.vReport.estRuntime = queuedExperimentInfo.estExecutionTime;
submissionReport.wait = new WaitEstimate(queuedExperimentInfo.queueLength, queuedExperimentInfo.waitTime);
//
// Get minimum remaining runtime of any currently running experiments and add into the wait estimate
//
int minRemainingRuntime = GetMinRemainingRuntime();
submissionReport.wait.estWait += minRemainingRuntime;
//
// Update the statistics with revised wait estimate
//
queuedExperimentInfo.waitTime = (int)submissionReport.wait.estWait;
this.experimentStatistics.Submitted(queuedExperimentInfo, DateTime.Now);
// Tell lab experiment manager thread that an experiment has been submitted
this.SignalSubmitted();
}
else
{
//
// Failed to add experiment to the queue
//
submissionReport.vReport.accepted = true;
submissionReport.vReport.errorMessage = STRERR_FailedToQueueExperiment;
}
return submissionReport;
}
//-------------------------------------------------------------------------------------------------//
public override ExperimentInfo RunExperiment(ExperimentInfo experimentInfo)
{
const string STRLOG_MethodName = "RunExperiment";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
// Create a result report ready to fill in
experimentInfo.resultReport = new ResultReport();
try
{
//
// Parse the XML specification string to generate a validation report (should be accepted!)
//
Specification specification = new Specification(this.configuration, this.equipmentServiceProxy);
ValidationReport validationReport = specification.Parse(experimentInfo.xmlSpecification);
if (validationReport.accepted == false)
{
throw new ArgumentException(validationReport.errorMessage);
}
experimentInfo.setupId = specification.SetupId;
//
// Create an instance of the driver for the specified setup and then
// execute the experiment and return the result information
//
ResultInfo resultInfo = null;
if (specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsTime) ||
specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsDistance))
{
if (this.equipmentServiceProxy != null)
{
//
// Hardware is available to this unit, run it there
//
DriverRadioactivity driver = new DriverRadioactivity(this.equipmentServiceProxy, this.configuration, this.labExperimentInfo.cancelExperiment);
resultInfo = (ResultInfo)driver.Execute(specification);
}
else
{
//
// This unit does not have hardware available, run the simulation instead
//
DriverSimActivity driver = new DriverSimActivity(this.configuration, this.labExperimentInfo.cancelExperiment);
resultInfo = (ResultInfo)driver.Execute(specification);
}
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsAbsorber))
{
DriverAbsorbers driver = new DriverAbsorbers(this.equipmentServiceProxy, this.configuration, this.labExperimentInfo.cancelExperiment);
resultInfo = (ResultInfo)driver.Execute(specification);
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsTime) ||
specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsDistance))
{
DriverSimActivity driver = new DriverSimActivity(this.configuration, this.labExperimentInfo.cancelExperiment);
resultInfo = (ResultInfo)driver.Execute(specification);
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsTimeNoDelay) ||
specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsDistanceNoDelay))
{
DriverSimActivity driver = new DriverSimActivity(this.configuration, this.labExperimentInfo.cancelExperiment, false);
resultInfo = (ResultInfo)driver.Execute(specification);
}
//
// Create an instance of LabExperimentResult to convert the experiment results to an XML string
//
ExperimentResult experimentResult = new ExperimentResult(
experimentInfo.experimentId, experimentInfo.sbName, DateTime.Now,
this.unitId, (Configuration)this.labConfiguration, specification, resultInfo);
//
// Fill in the result report
//
experimentInfo.resultReport.experimentResults = experimentResult.ToString();
experimentInfo.resultReport.statusCode = (int)resultInfo.statusCode;
experimentInfo.resultReport.errorMessage = resultInfo.errorMessage;
}
catch (Exception ex)
{
experimentInfo.resultReport.statusCode = (int)StatusCodes.Failed;
experimentInfo.resultReport.errorMessage = ex.Message;
Logfile.WriteError(ex.Message);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return experimentInfo;
}
//-------------------------------------------------------------------------------------------------//
public SubmissionReport Submit(int experimentID, string sbName, string experimentSpecification,
string userGroup, int priorityHint)
{
SubmissionReport submissionReport = null;
//
// Create a SubmissionReport object ready to fill in and return
//
submissionReport = new SubmissionReport(experimentID);
//
// Validate the experiment specification before submitting
//
ValidationReport validationReport = Validate(experimentSpecification, userGroup);
if (validationReport.accepted == false)
{
// Experiment specification is invalid, cannot submit
submissionReport.vReport = validationReport;
return(submissionReport);
}
//
// Create an instance of the experiment
//
ExperimentInfo experimentInfo = new ExperimentInfo(experimentID, sbName,
userGroup, priorityHint, experimentSpecification, (int)validationReport.estRuntime);
//
// Add the experiment to the queue
//
QueuedExperimentInfo queuedExperimentInfo = this.experimentQueue.Enqueue(experimentInfo);
if (queuedExperimentInfo != null)
{
//
// Update submission report
//
submissionReport.vReport.accepted = true;
submissionReport.vReport.estRuntime = queuedExperimentInfo.estExecutionTime;
submissionReport.wait = new WaitEstimate(queuedExperimentInfo.queueLength, queuedExperimentInfo.waitTime);
//
// Get minimum remaining runtime of any currently running experiments and add into the wait estimate
//
int minRemainingRuntime = GetMinRemainingRuntime();
submissionReport.wait.estWait += minRemainingRuntime;
//
// Update the statistics with revised wait estimate
//
queuedExperimentInfo.waitTime = (int)submissionReport.wait.estWait;
this.experimentStatistics.Submitted(queuedExperimentInfo, DateTime.Now);
// Tell lab experiment manager thread that an experiment has been submitted
this.SignalSubmitted();
}
else
{
//
// Failed to add experiment to the queue
//
submissionReport.vReport.accepted = true;
submissionReport.vReport.errorMessage = STRERR_FailedToQueueExperiment;
}
return(submissionReport);
}
