private AzureTableBasedGossipChannel gossipTable; // This type is internal
public AzureGossipTableTests()
{
logger = TraceLogger.GetLogger("AzureGossipTableTests", TraceLogger.LoggerType.Application);
globalServiceId = Guid.NewGuid();
deploymentId = "test-" + globalServiceId;
IPAddress ip;
if (!IPAddress.TryParse("127.0.0.1", out ip))
{
logger.Error(-1, "Could not parse ip address");
return;
}
IPEndPoint ep1 = new IPEndPoint(ip, 21111);
siloAddress1 = SiloAddress.New(ep1, 0);
IPEndPoint ep2 = new IPEndPoint(ip, 21112);
siloAddress2 = SiloAddress.New(ep2, 0);
logger.Info("DeploymentId={0}", deploymentId);
GlobalConfiguration config = new GlobalConfiguration
{
ServiceId = globalServiceId,
ClusterId = "0",
DeploymentId = deploymentId,
DataConnectionString = StorageTestConstants.DataConnectionString
};
gossipTable = new AzureTableBasedGossipChannel();
var done = gossipTable.Initialize(config.ServiceId, config.DataConnectionString);
if (!done.Wait(timeout))
{
throw new TimeoutException("Could not create/read table.");
}
}
public GatewayManager(ClientConfiguration cfg, IGatewayListProvider gatewayListProvider)
{
config = cfg;
knownDead = new Dictionary<Uri, DateTime>();
rand = new SafeRandom();
logger = TraceLogger.GetLogger("Messaging.GatewayManager", TraceLogger.LoggerType.Runtime);
lockable = new object();
gatewayRefreshCallInitiated = false;
ListProvider = gatewayListProvider;
var knownGateways = ListProvider.GetGateways().GetResult();
if (knownGateways.Count == 0)
{
string gatewayProviderType = gatewayListProvider.GetType().FullName;
string err = String.Format("Could not find any gateway in {0}. Orleans client cannot initialize.", gatewayProviderType);
logger.Error(ErrorCode.GatewayManager_NoGateways, err);
throw new OrleansException(err);
}
logger.Info(ErrorCode.GatewayManager_FoundKnownGateways, "Found {0} knownGateways from Gateway listProvider {1}", knownGateways.Count, Utils.EnumerableToString(knownGateways));
if (ListProvider is IGatewayListObservable)
{
((IGatewayListObservable)ListProvider).SubscribeToGatewayNotificationEvents(this);
}
roundRobinCounter = cfg.PreferedGatewayIndex >= 0 ? cfg.PreferedGatewayIndex : rand.Next(knownGateways.Count);
cachedLiveGateways = knownGateways;
lastRefreshTime = DateTime.UtcNow;
if (ListProvider.IsUpdatable)
{
gatewayRefreshTimer = new SafeTimer(RefreshSnapshotLiveGateways_TimerCallback, null, config.GatewayListRefreshPeriod, config.GatewayListRefreshPeriod);
}
}
public Formula(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.val = new byte[8];
this.rw = reader.ReadUInt16();
this.col = reader.ReadUInt16();
this.ixfe = reader.ReadUInt16();
this.boolValueSet = false;
long oldStreamPosition = this.Reader.BaseStream.Position;
this.val = reader.ReadBytes(8); // read 8 bytes for the value of the formula
ProcessFormulaValue();
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
// check always calc mode
this.fAlwaysCalc = Utils.BitmaskToBool((int)this.grbit, 0x01);
// check if shared formula
this.fShrFmla = Utils.BitmaskToBool((int)this.grbit, 0x08);
// check if this should ignore error checking
this.fClearErrors = Utils.BitmaskToBool(this.grbit, 0x20);
oldStreamPosition = this.Reader.BaseStream.Position;
if (!this.fShrFmla)
{
try
{
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in Row {0} Column {1}", this.rw, this.col);
TraceLogger.Debug(ex.StackTrace);
TraceLogger.Debug("Inner exception: {0}", ex.InnerException.StackTrace);
}
}
else
{
//If the next expression isn't 5 bytes long, it's not a PtgExp shared formula reference...just ignore for now
if (this.cce != 5)
{
reader.ReadBytes(this.cce);
}
//First 8 bits are reserved, must be 1 but we'll ignore them for now
byte ptg = reader.ReadByte();
//Next two bytes are the row containing the shared formula
sharedRow = reader.ReadUInt16();
//then the col containing the shared formula
sharedCol = reader.ReadUInt16();
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
// Execute one or more turns for this activation.
// This method is always called in a single-threaded environment -- that is, no more than one
// thread will be in this method at once -- but other asynch threads may still be queueing tasks, etc.
public void Execute()
{
lock (lockable)
{
if (state == WorkGroupStatus.Shutdown)
{
if (!IsActive)
{
return; // Don't mind if no work has been queued to this work group yet.
}
ReportWorkGroupProblemWithBacktrace(
"Cannot execute work items in a work item group that is in a shutdown state.",
ErrorCode.SchedulerNotExecuteWhenShutdown); // Throws InvalidOperationException
return;
}
state = WorkGroupStatus.Running;
}
var thread = WorkerPoolThread.CurrentWorkerThread;
try
{
// Process multiple items -- drain the applicationMessageQueue (up to max items) for this physical activation
int count = 0;
var stopwatch = new Stopwatch();
stopwatch.Start();
do
{
lock (lockable)
{
if (state == WorkGroupStatus.Shutdown)
{
if (WorkItemCount > 0)
{
log.Warn(ErrorCode.SchedulerSkipWorkStopping, "Thread {0} is exiting work loop due to Shutdown state {1} while still having {2} work items in the queue.",
thread.ToString(), this.ToString(), WorkItemCount);
}
else
if (log.IsVerbose)
{
log.Verbose("Thread {0} is exiting work loop due to Shutdown state {1}. Has {2} work items in the queue.",
thread.ToString(), this.ToString(), WorkItemCount);
}
break;
}
// Check the cancellation token (means that the silo is stopping)
if (thread.CancelToken.IsCancellationRequested)
{
log.Warn(ErrorCode.SchedulerSkipWorkCancelled, "Thread {0} is exiting work loop due to cancellation token. WorkItemGroup: {1}, Have {2} work items in the queue.",
thread.ToString(), this.ToString(), WorkItemCount);
break;
}
}
// Get the first Work Item on the list
Task task;
lock (lockable)
{
if (workItems.Count > 0)
{
task = workItems.Dequeue();
}
else // If the list is empty, then we're done
{
break;
}
}
#if TRACK_DETAILED_STATS
if (StatisticsCollector.CollectGlobalShedulerStats)
{
SchedulerStatisticsGroup.OnWorkItemDequeue();
}
#endif
#if DEBUG
if (log.IsVerbose2)
{
log.Verbose2("About to execute task {0} in SchedulingContext={1}", task, SchedulingContext);
}
#endif
var taskStart = stopwatch.Elapsed;
try
{
thread.CurrentTask = task;
#if TRACK_DETAILED_STATS
if (StatisticsCollector.CollectTurnsStats)
{
SchedulerStatisticsGroup.OnTurnExecutionStartsByWorkGroup(workItemGroupStatisticsNumber, thread.WorkerThreadStatisticsNumber, SchedulingContext);
}
#endif
TaskRunner.RunTask(task);
}
catch (Exception ex)
{
log.Error(ErrorCode.SchedulerExceptionFromExecute, String.Format("Worker thread caught an exception thrown from Execute by task {0}", task), ex);
throw;
}
finally
{
#if TRACK_DETAILED_STATS
if (StatisticsCollector.CollectTurnsStats)
{
SchedulerStatisticsGroup.OnTurnExecutionEnd(Utils.Since(thread.CurrentStateStarted));
}
if (StatisticsCollector.CollectThreadTimeTrackingStats)
{
thread.threadTracking.IncrementNumberOfProcessed();
}
#endif
totalItemsProcessed++;
var taskLength = stopwatch.Elapsed - taskStart;
if (taskLength > OrleansTaskScheduler.TurnWarningLengthThreshold)
{
SchedulerStatisticsGroup.NumLongRunningTurns.Increment();
log.Warn(ErrorCode.SchedulerTurnTooLong3, "Task {0} in WorkGroup {1} took elapsed time {2:g} for execution, which is longer than {3}. Running on thread {4}",
OrleansTaskExtentions.ToString(task), SchedulingContext.ToString(), taskLength, OrleansTaskScheduler.TurnWarningLengthThreshold, thread.ToString());
}
thread.CurrentTask = null;
}
count++;
}while (((MaxWorkItemsPerTurn <= 0) || (count <= MaxWorkItemsPerTurn)) &&
((ActivationSchedulingQuantum <= TimeSpan.Zero) || (stopwatch.Elapsed < ActivationSchedulingQuantum)));
stopwatch.Stop();
}
catch (Exception ex)
{
log.Error(ErrorCode.Runtime_Error_100032, String.Format("Worker thread {0} caught an exception thrown from IWorkItem.Execute", thread), ex);
}
finally
{
// Now we're not Running anymore.
// If we left work items on our run list, we're Runnable, and need to go back on the silo run queue;
// If our run list is empty, then we're waiting.
lock (lockable)
{
if (state != WorkGroupStatus.Shutdown)
{
if (WorkItemCount > 0)
{
state = WorkGroupStatus.Runnable;
masterScheduler.RunQueue.Add(this);
}
else
{
state = WorkGroupStatus.Waiting;
}
}
}
}
}
public void SendMessage(Message msg)
{
if (msg == null)
{
throw new ArgumentNullException("msg", "Can't send a null message.");
}
if (stopped)
{
logger.Info(ErrorCode.Runtime_Error_100112, "Message was queued for sending after outbound queue was stopped: {0}", msg);
return;
}
// Don't process messages that have already timed out
if (msg.IsExpired)
{
msg.DropExpiredMessage(MessagingStatisticsGroup.Phase.Send);
return;
}
if (!msg.ContainsMetadata(QUEUED_TIME_METADATA))
{
msg.SetMetadata(QUEUED_TIME_METADATA, DateTime.UtcNow);
}
// First check to see if it's really destined for a proxied client, instead of a local grain.
if (messageCenter.IsProxying && messageCenter.TryDeliverToProxy(msg))
{
return;
}
if (!msg.ContainsHeader(Message.Header.TARGET_SILO))
{
logger.Error(ErrorCode.Runtime_Error_100113, "Message does not have a target silo: " + msg + " -- Call stack is: " + (new System.Diagnostics.StackTrace()));
messageCenter.SendRejection(msg, Message.RejectionTypes.Unrecoverable, "Message to be sent does not have a target silo");
return;
}
if (Message.WriteMessagingTraces)
{
msg.AddTimestamp(Message.LifecycleTag.EnqueueOutgoing);
}
// Shortcut messages to this silo
if (msg.TargetSilo.Equals(messageCenter.MyAddress))
{
if (logger.IsVerbose3)
{
logger.Verbose3("Message has been looped back to this silo: {0}", msg);
}
MessagingStatisticsGroup.LocalMessagesSent.Increment();
messageCenter.InboundQueue.PostMessage(msg);
}
else
{
if (stopped)
{
logger.Info(ErrorCode.Runtime_Error_100115, "Message was queued for sending after outbound queue was stopped: {0}", msg);
return;
}
// check for simulation of lost messages
if (Silo.CurrentSilo.TestHookup.ShouldDrop(msg))
{
logger.Info(ErrorCode.Messaging_SimulatedMessageLoss, "Message blocked by test");
messageCenter.SendRejection(msg, Message.RejectionTypes.Unrecoverable, "Message blocked by test");
}
// Prioritize system messages
switch (msg.Category)
{
case Message.Categories.Ping:
pingSender.QueueRequest(msg);
break;
case Message.Categories.System:
systemSender.QueueRequest(msg);
break;
default:
{
int index = Math.Abs(msg.TargetSilo.GetConsistentHashCode()) % senders.Length;
senders[index].Value.QueueRequest(msg);
break;
}
}
}
}
/// <summary>
/// Parses the arguments of the tool
/// </summary>
/// <param name="args">The args array</param>
public static void ParseArgs(string[] args, string toolName)
{
try
{
if (args[0] == "-?")
{
PrintUsage(toolName);
Environment.Exit(0);
}
else if (args[0].ToLower() == "-c")
{
CreateContextMenuEntry = true;
}
else
{
InputFile = args[0];
}
for (int i = 1; i < args.Length; i++)
{
if (args[i].ToLower() == "-v")
{
//parse verbose level
string verbose = args[i + 1].ToLower();
int vLvl;
if (Int32.TryParse(verbose, out vLvl))
{
TraceLogger.LogLevel = (TraceLogger.LoggingLevel)vLvl;
}
else if (verbose == "error")
{
TraceLogger.LogLevel = TraceLogger.LoggingLevel.Error;
}
else if (verbose == "warning")
{
TraceLogger.LogLevel = TraceLogger.LoggingLevel.Warning;
}
else if (verbose == "info")
{
TraceLogger.LogLevel = TraceLogger.LoggingLevel.Info;
}
else if (verbose == "debug")
{
TraceLogger.LogLevel = TraceLogger.LoggingLevel.Debug;
}
else if (verbose == "none")
{
TraceLogger.LogLevel = TraceLogger.LoggingLevel.None;
}
}
else if (args[i].ToLower() == "-o")
{
//parse output file name
ChoosenOutputFile = args[i + 1];
}
}
}
catch (Exception)
{
TraceLogger.Error("At least one of the required arguments was not correctly set.\n");
PrintUsage(toolName);
Environment.Exit(1);
}
}
public Formula(IStreamReader reader, RecordType id, UInt16 length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.val = new byte[8];
this.rw = reader.ReadUInt16();
this.col = reader.ReadUInt16();
this.ixfe = reader.ReadUInt16();
this.boolValueSet = false;
long oldStreamPosition = this.Reader.BaseStream.Position;
this.val = reader.ReadBytes(8); // read 8 bytes for the value of the formular
if (this.val[6] == 0xFF && this.val[7] == 0xFF)
{
// this value is a string, an error or a boolean value
byte firstOffset = this.val[0];
if (firstOffset == 1)
{
// this is a boolean value
this.boolValue = val[2];
this.boolValueSet = true;
}
if (firstOffset == 2)
{
// this is a error value
this.errorValue = (int)val[2];
}
}
else
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.calculatedValue = reader.ReadDouble();
}
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
// check always calc mode
this.fAlwaysCalc = Utils.BitmaskToBool((int)grbit, 0x01);
// check if shared formula
this.fShrFmla = Utils.BitmaskToBool((int)grbit, 0x08);
oldStreamPosition = this.Reader.BaseStream.Position;
if (!fShrFmla)
{
try
{
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in Row {0} Column {1}", this.rw, this.col);
TraceLogger.Debug(ex.StackTrace);
TraceLogger.Debug("Inner exception: {0}", ex.InnerException.StackTrace);
}
}
else
{
reader.ReadBytes(this.cce);
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
internal static bool AnalyzeReadException(Exception exc, int iteration, string tableName, TraceLogger logger)
{
bool isLastErrorRetriable;
var we = exc as WebException;
if (we != null)
{
isLastErrorRetriable = true;
var statusCode = we.Status;
logger.Warn(ErrorCode.AzureTable_10, String.Format("Intermediate issue reading Azure storage table {0}: HTTP status code={1} Exception Type={2} Message='{3}'",
tableName,
statusCode,
exc.GetType().FullName,
exc.Message),
exc);
}
else
{
HttpStatusCode httpStatusCode;
string restStatus;
if (EvaluateException(exc, out httpStatusCode, out restStatus, true))
{
if (StorageErrorCodeStrings.ResourceNotFound.Equals(restStatus))
{
if (logger.IsVerbose) logger.Verbose(ErrorCode.AzureTable_DataNotFound,
"DataNotFound reading Azure storage table {0}:{1} HTTP status code={2} REST status code={3} Exception={4}",
tableName,
iteration == 0 ? "" : (" Repeat=" + iteration),
httpStatusCode,
restStatus,
exc);
isLastErrorRetriable = false;
}
else
{
isLastErrorRetriable = IsRetriableHttpError(httpStatusCode, restStatus);
logger.Warn(ErrorCode.AzureTable_11, String.Format("Intermediate issue reading Azure storage table {0}:{1} IsRetriable={2} HTTP status code={3} REST status code={4} Exception Type={5} Message='{6}'",
tableName,
iteration == 0 ? "" : (" Repeat=" + iteration),
isLastErrorRetriable,
httpStatusCode,
restStatus,
exc.GetType().FullName,
exc.Message),
exc);
}
}
else
{
logger.Error(ErrorCode.AzureTable_12, string.Format("Unexpected issue reading Azure storage table {0}: Exception Type={1} Message='{2}'",
tableName,
exc.GetType().FullName,
exc.Message),
exc);
isLastErrorRetriable = false;
}
}
return isLastErrorRetriable;
}
public static void Main(string[] args)
{
ParseArgs(args, ToolName);
InitializeLogger();
PrintWelcome(ToolName);
if (CreateContextMenuEntry)
{
// create context menu entry
try
{
TraceLogger.Info("Creating context menu entry for doc2x ...");
RegisterForContextMenu(GetContextMenuKey(ContextMenuInputExtension, ContextMenuText));
TraceLogger.Info("Succeeded.");
}
catch (Exception)
{
TraceLogger.Info("Failed. Sorry :(");
}
}
else
{
// convert
try
{
//copy processing file
ProcessingFile procFile = new ProcessingFile(InputFile);
//make output file name
if (ChoosenOutputFile == null)
{
if (InputFile.Contains("."))
{
ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".docx";
}
else
{
ChoosenOutputFile = InputFile + ".docx";
}
}
//open the reader
using (StructuredStorageReader reader = new StructuredStorageReader(procFile.File.FullName))
{
//parse the input document
WordDocument doc = new WordDocument(reader);
//prepare the output document
OpenXmlPackage.DocumentType outType = Converter.DetectOutputType(doc);
string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType);
WordprocessingDocument docx = WordprocessingDocument.Create(conformOutputFile, outType);
//start time
DateTime start = DateTime.Now;
TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile);
//convert the document
Converter.Convert(doc, docx);
DateTime end = DateTime.Now;
TimeSpan diff = end.Subtract(start);
TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture));
}
}
catch (DirectoryNotFoundException ex)
{
TraceLogger.Error(ex.Message);
TraceLogger.Debug(ex.ToString());
}
catch (FileNotFoundException ex)
{
TraceLogger.Error(ex.Message);
TraceLogger.Debug(ex.ToString());
}
catch (ReadBytesAmountMismatchException ex)
{
TraceLogger.Error("Input file {0} is not a valid Microsoft Word 97-2003 file.", InputFile);
TraceLogger.Debug(ex.ToString());
}
catch (MagicNumberException ex)
{
TraceLogger.Error("Input file {0} is not a valid Microsoft Word 97-2003 file.", InputFile);
TraceLogger.Debug(ex.ToString());
}
catch (UnspportedFileVersionException ex)
{
TraceLogger.Error("File {0} has been created with a Word version older than Word 97.", InputFile);
TraceLogger.Debug(ex.ToString());
}
catch (ByteParseException ex)
{
TraceLogger.Error("Input file {0} is not a valid Microsoft Word 97-2003 file.", InputFile);
TraceLogger.Debug(ex.ToString());
}
catch (MappingException ex)
{
TraceLogger.Error("There was an error while converting file {0}: {1}", InputFile, ex.Message);
TraceLogger.Debug(ex.ToString());
}
catch (ZipCreationException ex)
{
TraceLogger.Error("Could not create output file {0}.", ChoosenOutputFile);
//TraceLogger.Error("Perhaps the specified outputfile was a directory or contained invalid characters.");
TraceLogger.Debug(ex.ToString());
}
catch (Exception ex)
{
TraceLogger.Error("Conversion of file {0} failed.", InputFile);
TraceLogger.Debug(ex.ToString());
}
}
}
public static void Main(string[] args)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
ParseArgs(args, ToolName);
InitializeLogger();
PrintWelcome(ToolName, RevisionResource);
if (CreateContextMenuEntry)
{
// create context menu entry
try
{
TraceLogger.Info("Creating context menu entry for ppt2x ...");
RegisterForContextMenu(GetContextMenuKey(ContextMenuInputExtension, ContextMenuText));
TraceLogger.Info("Succeeded.");
}
catch (Exception)
{
TraceLogger.Info("Failed. Sorry :(");
}
}
else
{
try
{
if (InputFile.Contains("*.ppt"))
{
string[] files = Directory.GetFiles(InputFile.Replace("*.ppt", ""), "*.ppt");
foreach (String file in files)
{
if (new FileInfo(file).Extension.ToLower().EndsWith("ppt"))
{
ChoosenOutputFile = null;
processFile(file);
}
}
}
else
{
processFile(InputFile);
}
}
catch (ZipCreationException ex)
{
TraceLogger.Error("Could not create output file {0}.", ChoosenOutputFile);
//TraceLogger.Error("Perhaps the specified outputfile was a directory or contained invalid characters.");
TraceLogger.Debug(ex.ToString());
}
catch (FileNotFoundException ex)
{
TraceLogger.Error("Could not read input file {0}.", InputFile);
TraceLogger.Debug(ex.ToString());
}
catch (MagicNumberException)
{
TraceLogger.Error("Input file {0} is not a valid PowerPoint 97-2007 file.", InputFile);
}
catch (InvalidStreamException e)
{
TraceLogger.Error("Input file {0} is not a valid PowerPoint 97-2007 file.", InputFile);
}
catch (InvalidRecordException)
{
TraceLogger.Error("Input file {0} is not a valid PowerPoint 97-2007 file.", InputFile);
}
catch (StreamNotFoundException e)
{
TraceLogger.Error("Input file {0} is not a valid PowerPoint 97-2007 file.", InputFile);
}
catch (Exception ex)
{
TraceLogger.Error("Conversion of file {0} failed.", InputFile);
TraceLogger.Debug(ex.ToString());
}
}
TraceLogger.Info("End of program");
}
/// <summary>
/// Extracting the data from the stream
/// </summary>
public override void extractData()
{
BiffHeader bh, latestbiff;
BOF firstBOF = null;
//try
//{
while (this.StreamReader.BaseStream.Position < this.StreamReader.BaseStream.Length)
{
bh.id = (RecordType)this.StreamReader.ReadUInt16();
bh.length = this.StreamReader.ReadUInt16();
TraceLogger.DebugInternal("BIFF {0}\t{1}\t", bh.id, bh.length);
switch (bh.id)
{
case RecordType.EOF:
{
this.StreamReader.BaseStream.Seek(0, SeekOrigin.End);
}
break;
case RecordType.BOF:
{
BOF bof = new BOF(this.StreamReader, bh.id, bh.length);
switch (bof.docType)
{
case BOF.DocumentType.WorkbookGlobals:
case BOF.DocumentType.Worksheet:
firstBOF = bof;
break;
case BOF.DocumentType.Chart:
// parse chart
break;
default:
this.readUnkownFile();
break;
}
}
break;
case RecordType.LabelSst:
{
LabelSst labelsst = new LabelSst(this.StreamReader, bh.id, bh.length);
this.bsd.addLabelSST(labelsst);
}
break;
case RecordType.MulRk:
{
MulRk mulrk = new MulRk(this.StreamReader, bh.id, bh.length);
this.bsd.addMULRK(mulrk);
}
break;
case RecordType.Number:
{
Number number = new Number(this.StreamReader, bh.id, bh.length);
this.bsd.addNUMBER(number);
}
break;
case RecordType.RK:
{
RK rk = new RK(this.StreamReader, bh.id, bh.length);
this.bsd.addRK(rk);
}
break;
case RecordType.MergeCells:
{
MergeCells mergecells = new MergeCells(this.StreamReader, bh.id, bh.length);
this.bsd.MERGECELLSData = mergecells;
}
break;
case RecordType.Blank:
{
Blank blankcell = new Blank(this.StreamReader, bh.id, bh.length);
this.bsd.addBLANK(blankcell);
} break;
case RecordType.MulBlank:
{
MulBlank mulblank = new MulBlank(this.StreamReader, bh.id, bh.length);
this.bsd.addMULBLANK(mulblank);
}
break;
case RecordType.Formula:
{
Formula formula = new Formula(this.StreamReader, bh.id, bh.length);
this.bsd.addFORMULA(formula);
TraceLogger.DebugInternal(formula.ToString());
}
break;
case RecordType.Array:
{
ARRAY array = new ARRAY(this.StreamReader, bh.id, bh.length);
this.bsd.addARRAY(array);
}
break;
case RecordType.ShrFmla:
{
ShrFmla shrfmla = new ShrFmla(this.StreamReader, bh.id, bh.length);
this.bsd.addSharedFormula(shrfmla);
}
break;
case RecordType.String:
{
STRING formulaString = new STRING(this.StreamReader, bh.id, bh.length);
this.bsd.addFormulaString(formulaString.value);
}
break;
case RecordType.Row:
{
Row row = new Row(this.StreamReader, bh.id, bh.length);
this.bsd.addRowData(row);
}
break;
case RecordType.ColInfo:
{
ColInfo colinfo = new ColInfo(this.StreamReader, bh.id, bh.length);
this.bsd.addColData(colinfo);
}
break;
case RecordType.DefColWidth:
{
DefColWidth defcolwidth = new DefColWidth(this.StreamReader, bh.id, bh.length);
this.bsd.addDefaultColWidth(defcolwidth.cchdefColWidth);
}
break;
case RecordType.DefaultRowHeight:
{
DefaultRowHeight defrowheigth = new DefaultRowHeight(this.StreamReader, bh.id, bh.length);
this.bsd.addDefaultRowData(defrowheigth);
}
break;
case RecordType.LeftMargin:
{
LeftMargin leftm = new LeftMargin(this.StreamReader, bh.id, bh.length);
this.bsd.leftMargin = leftm.value;
}
break;
case RecordType.RightMargin:
{
RightMargin rightm = new RightMargin(this.StreamReader, bh.id, bh.length);
this.bsd.rightMargin = rightm.value;
}
break;
case RecordType.TopMargin:
{
TopMargin topm = new TopMargin(this.StreamReader, bh.id, bh.length);
this.bsd.topMargin = topm.value;
}
break;
case RecordType.BottomMargin:
{
BottomMargin bottomm = new BottomMargin(this.StreamReader, bh.id, bh.length);
this.bsd.bottomMargin = bottomm.value;
}
break;
case RecordType.Setup:
{
Setup setup = new Setup(this.StreamReader, bh.id, bh.length);
this.bsd.addSetupData(setup);
}
break;
case RecordType.HLink:
{
long oldStreamPos = this.StreamReader.BaseStream.Position;
try
{
HLink hlink = new HLink(this.StreamReader, bh.id, bh.length);
bsd.addHyperLinkData(hlink);
}
catch (Exception ex)
{
this.StreamReader.BaseStream.Seek(oldStreamPos, System.IO.SeekOrigin.Begin);
this.StreamReader.BaseStream.Seek(bh.length, System.IO.SeekOrigin.Current);
TraceLogger.Debug("Link parse error");
TraceLogger.Error(ex.StackTrace);
}
}
break;
case RecordType.MsoDrawing:
{
// Record header has already been read. Reset position to record beginning.
this.StreamReader.BaseStream.Position -= 2 * sizeof(UInt16);
this.bsd.ObjectsSequence = new ObjectsSequence(this.StreamReader);
}
break;
default:
{
// this else statement is used to read BiffRecords which aren't implemented
byte[] buffer = new byte[bh.length];
buffer = this.StreamReader.ReadBytes(bh.length);
}
break;
}
latestbiff = bh;
}
//}
//catch (Exception ex)
//{
// TraceLogger.Error(ex.Message);
// TraceLogger.Error(ex.StackTrace);
// TraceLogger.Debug(ex.ToString());
//}
}
internal static bool AnalyzeReadException(Exception exc, int iteration, string tableName, TraceLogger logger)
{
bool isLastErrorRetriable;
var we = exc as WebException;
if (we != null)
{
isLastErrorRetriable = true;
var statusCode = we.Status;
logger.Warn(ErrorCode.AzureTable_10, String.Format("Intermediate issue reading Azure storage table {0}: HTTP status code={1} Exception Type={2} Message='{3}'",
tableName,
statusCode,
exc.GetType().FullName,
exc.Message),
exc);
}
else
{
HttpStatusCode httpStatusCode;
string restStatus;
if (EvaluateException(exc, out httpStatusCode, out restStatus, true))
{
if (StorageErrorCodeStrings.ResourceNotFound.Equals(restStatus))
{
if (logger.IsVerbose)
{
logger.Verbose(ErrorCode.AzureTable_DataNotFound,
"DataNotFound reading Azure storage table {0}:{1} HTTP status code={2} REST status code={3} Exception={4}",
tableName,
iteration == 0 ? "" : (" Repeat=" + iteration),
httpStatusCode,
restStatus,
exc);
}
isLastErrorRetriable = false;
}
else
{
isLastErrorRetriable = IsRetriableHttpError(httpStatusCode, restStatus);
logger.Warn(ErrorCode.AzureTable_11, String.Format("Intermediate issue reading Azure storage table {0}:{1} IsRetriable={2} HTTP status code={3} REST status code={4} Exception Type={5} Message='{6}'",
tableName,
iteration == 0 ? "" : (" Repeat=" + iteration),
isLastErrorRetriable,
httpStatusCode,
restStatus,
exc.GetType().FullName,
exc.Message),
exc);
}
}
else
{
logger.Error(ErrorCode.AzureTable_12, string.Format("Unexpected issue reading Azure storage table {0}: Exception Type={1} Message='{2}'",
tableName,
exc.GetType().FullName,
exc.Message),
exc);
isLastErrorRetriable = false;
}
}
return(isLastErrorRetriable);
}
private async Task <List <string> > UploadAsync(string sourceParentDirectory, string containerPath, CancellationToken cancellationToken)
{
List <string> failedFiles = new List <string>();
string fileToUpload;
Stopwatch uploadTimer = new Stopwatch();
var containerId = _context.ContainerId;
var projectId = _context.ProjectId;
while (_fileUploadQueue.TryDequeue(out fileToUpload))
{
cancellationToken.ThrowIfCancellationRequested();
try
{
using (FileStream fs = File.Open(fileToUpload, FileMode.Open, FileAccess.Read, FileShare.Read))
{
string itemPath = (containerPath.TrimEnd('/') + "/" + fileToUpload.Remove(0, sourceParentDirectory.Length + 1)).Replace('\\', '/');
uploadTimer.Restart();
bool coughtExceptionDuringUpload = false;
HttpResponseMessage response = null;
try
{
response = await _fileContainerHelper.UploadFileAsync(containerId, itemPath, fs, projectId, cancellationToken, chunkSize : 4 * 1024 * 1024);
}
catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested)
{
TraceLogger.Error(string.Format(Resources.FileUploadCancelled, fileToUpload));
if (response != null)
{
response.Dispose();
response = null;
}
throw;
}
catch (Exception ex)
{
coughtExceptionDuringUpload = true;
TraceLogger.Error(string.Format(Resources.FileUploadFailed, fileToUpload, ex));
}
uploadTimer.Stop();
if (coughtExceptionDuringUpload || (response != null && response.StatusCode != HttpStatusCode.Created))
{
if (response != null)
{
TraceLogger.Info(string.Format(Resources.FileContainerUploadFailed, response.StatusCode, response.ReasonPhrase, fileToUpload, itemPath));
}
// output detail upload trace for the file.
ConcurrentQueue <string> logQueue;
if (_fileUploadTraceLog.TryGetValue(itemPath, out logQueue))
{
TraceLogger.Info(string.Format(Resources.FileUploadDetailTrace, itemPath));
string message;
while (logQueue.TryDequeue(out message))
{
TraceLogger.Info(message);
}
}
// tracking file that failed to upload.
failedFiles.Add(fileToUpload);
}
else
{
TraceLogger.Debug(string.Format(Resources.FileUploadFinish, fileToUpload, uploadTimer.ElapsedMilliseconds));
// debug detail upload trace for the file.
ConcurrentQueue <string> logQueue;
if (_fileUploadTraceLog.TryGetValue(itemPath, out logQueue))
{
TraceLogger.Debug($"Detail upload trace for file: {itemPath}");
string message;
while (logQueue.TryDequeue(out message))
{
TraceLogger.Debug(message);
}
}
}
if (response != null)
{
response.Dispose();
response = null;
}
}
Interlocked.Increment(ref filesProcessed);
}
catch (Exception ex)
{
TraceLogger.Error(string.Format(Resources.FileUploadFileOpenFailed, ex.Message, fileToUpload));
throw ex;
}
}
return(failedFiles);
}
internal void ValidateConfiguration(TraceLogger logger)
{
if (AreDefaults) return;
Type type = null;
try
{
type = TypeUtils.ResolveType(FullTypeName);
}
catch (Exception exception)
{
string errStr = String.Format("Unable to find grain class type {0} specified in configuration; Failing silo startup.", FullTypeName);
logger.Error(ErrorCode.Loader_TypeLoadError, errStr, exception);
throw new OrleansException(errStr, exception);
}
if (type == null)
{
string errStr = String.Format("Unable to find grain class type {0} specified in configuration; Failing silo startup.", FullTypeName);
logger.Error(ErrorCode.Loader_TypeLoadError_2, errStr);
throw new OrleansException(errStr);
}
var typeInfo = type.GetTypeInfo();
// postcondition: returned type must implement IGrain.
if (!typeof(IGrain).GetTypeInfo().IsAssignableFrom(type))
{
string errStr = String.Format("Type {0} must implement IGrain to be used Application configuration context.",type.FullName);
logger.Error(ErrorCode.Loader_TypeLoadError_3, errStr);
throw new OrleansException(errStr);
}
// postcondition: returned type must either be an interface or a class.
if (!typeInfo.IsInterface && !typeInfo.IsClass)
{
string errStr = String.Format("Type {0} must either be an interface or class used Application configuration context.",type.FullName);
logger.Error(ErrorCode.Loader_TypeLoadError_4, errStr);
throw new OrleansException(errStr);
}
}
public OutsideRuntimeClient(ClientConfiguration cfg, GrainFactory grainFactory, bool secondary = false)
{
this.grainFactory = grainFactory;
this.clientId = GrainId.NewClientId();
if (cfg == null)
{
Console.WriteLine("An attempt to create an OutsideRuntimeClient with null ClientConfiguration object.");
throw new ArgumentException("OutsideRuntimeClient was attempted to be created with null ClientConfiguration object.", "cfg");
}
this.config = cfg;
if (!TraceLogger.IsInitialized)
{
TraceLogger.Initialize(config);
}
StatisticsCollector.Initialize(config);
SerializationManager.Initialize(config.UseStandardSerializer);
logger = TraceLogger.GetLogger("OutsideRuntimeClient", TraceLogger.LoggerType.Runtime);
appLogger = TraceLogger.GetLogger("Application", TraceLogger.LoggerType.Application);
try
{
LoadAdditionalAssemblies();
PlacementStrategy.Initialize();
callbacks = new ConcurrentDictionary <CorrelationId, CallbackData>();
localObjects = new ConcurrentDictionary <GuidId, LocalObjectData>();
CallbackData.Config = config;
if (!secondary)
{
UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnhandledException);
}
// Ensure SerializationManager static constructor is called before AssemblyLoad event is invoked
SerializationManager.GetDeserializer(typeof(String));
// Ensure that any assemblies that get loaded in the future get recorded
AppDomain.CurrentDomain.AssemblyLoad += NewAssemblyHandler;
// Load serialization info for currently-loaded assemblies
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (!assembly.ReflectionOnly)
{
SerializationManager.FindSerializationInfo(assembly);
}
}
clientProviderRuntime = new ClientProviderRuntime(grainFactory);
statisticsProviderManager = new StatisticsProviderManager("Statistics", clientProviderRuntime);
var statsProviderName = statisticsProviderManager.LoadProvider(config.ProviderConfigurations)
.WaitForResultWithThrow(initTimeout);
if (statsProviderName != null)
{
config.StatisticsProviderName = statsProviderName;
}
responseTimeout = Debugger.IsAttached ? Constants.DEFAULT_RESPONSE_TIMEOUT : config.ResponseTimeout;
BufferPool.InitGlobalBufferPool(config);
var localAddress = ClusterConfiguration.GetLocalIPAddress(config.PreferredFamily, config.NetInterface);
// Client init / sign-on message
logger.Info(ErrorCode.ClientInitializing, string.Format(
"{0} Initializing OutsideRuntimeClient on {1} at {2} Client Id = {3} {0}",
BARS, config.DNSHostName, localAddress, clientId));
string startMsg = string.Format("{0} Starting OutsideRuntimeClient with runtime Version='{1}'", BARS, RuntimeVersion.Current);
startMsg = string.Format("{0} Config= " + Environment.NewLine + " {1}", startMsg, config);
logger.Info(ErrorCode.ClientStarting, startMsg);
if (TestOnlyThrowExceptionDuringInit)
{
throw new ApplicationException("TestOnlyThrowExceptionDuringInit");
}
config.CheckGatewayProviderSettings();
var generation = -SiloAddress.AllocateNewGeneration(); // Client generations are negative
var gatewayListProvider = GatewayProviderFactory.CreateGatewayListProvider(config)
.WithTimeout(initTimeout).Result;
transport = new ProxiedMessageCenter(config, localAddress, generation, clientId, gatewayListProvider);
if (StatisticsCollector.CollectThreadTimeTrackingStats)
{
incomingMessagesThreadTimeTracking = new ThreadTrackingStatistic("ClientReceiver");
}
}
catch (Exception exc)
{
if (logger != null)
{
logger.Error(ErrorCode.Runtime_Error_100319, "OutsideRuntimeClient constructor failed.", exc);
}
ConstructorReset();
throw;
}
}
public static bool CheckTimerDelay(DateTime previousTickTime, int totalNumTicks,
TimeSpan dueTime, TimeSpan timerFrequency, TraceLogger logger, Func<string> getName, ErrorCode errorCode, bool freezeCheck)
{
TimeSpan timeSinceLastTick = DateTime.UtcNow - previousTickTime;
TimeSpan exceptedTimeToNexTick = totalNumTicks == 0 ? dueTime : timerFrequency;
TimeSpan exceptedTimeWithSlack;
if (exceptedTimeToNexTick >= TimeSpan.FromSeconds(6))
{
exceptedTimeWithSlack = exceptedTimeToNexTick + TimeSpan.FromSeconds(3);
}
else
{
exceptedTimeWithSlack = exceptedTimeToNexTick.Multiply(1.5);
}
if (timeSinceLastTick <= exceptedTimeWithSlack) return true;
// did not tick in the last period.
var errMsg = String.Format("{0}{1} did not fire on time. Last fired at {2}, {3} since previous fire, should have fired after {4}.",
freezeCheck ? "Watchdog Freeze Alert: " : "-", // 0
getName == null ? "" : getName(), // 1
TraceLogger.PrintDate(previousTickTime), // 2
timeSinceLastTick, // 3
exceptedTimeToNexTick); // 4
if(freezeCheck)
{
logger.Error(errorCode, errMsg);
}else
{
logger.Warn(errorCode, errMsg);
}
return false;
}
private void UnhandledException(ISchedulingContext context, Exception exception)
{
logger.Error(ErrorCode.Runtime_Error_100007, String.Format("OutsideRuntimeClient caught an UnobservedException."), exception);
logger.Assert(ErrorCode.Runtime_Error_100008, context == null, "context should be not null only inside OrleansRuntime and not on the client.");
}
internal static CloudQueueClient GetCloudQueueClient(
string storageConnectionString,
IRetryPolicy retryPolicy,
TimeSpan timeout,
TraceLogger logger)
{
try
{
var storageAccount = GetCloudStorageAccount(storageConnectionString);
CloudQueueClient operationsClient = storageAccount.CreateCloudQueueClient();
operationsClient.DefaultRequestOptions.RetryPolicy = retryPolicy;
operationsClient.DefaultRequestOptions.ServerTimeout = timeout;
return operationsClient;
}
catch (Exception exc)
{
logger.Error(ErrorCode.AzureQueue_14, String.Format("Error creating GetCloudQueueOperationsClient."), exc);
throw;
}
}
/// <summary>
/// Initialize this Orleans silo for execution with the specified Azure deploymentId
/// </summary>
/// <param name="config">If null, Config data will be read from silo config file as normal, otherwise use the specified config data.</param>
/// <param name="deploymentId">Azure DeploymentId this silo is running under</param>
/// <param name="connectionString">Azure DataConnectionString. If null, defaults to the DataConnectionString setting from the Azure configuration for this role.</param>
/// <returns><c>true</c> is the silo startup was successful</returns>
public bool Start(ClusterConfiguration config, string deploymentId = null, string connectionString = null)
{
// Program ident
Trace.TraceInformation("Starting {0} v{1}", this.GetType().FullName, RuntimeVersion.Current);
// Check if deployment id was specified
if (deploymentId == null)
{
deploymentId = serviceRuntimeWrapper.DeploymentId;
}
// Read endpoint info for this instance from Azure config
string instanceName = serviceRuntimeWrapper.InstanceName;
// Configure this Orleans silo instance
if (config == null)
{
host = new SiloHost(instanceName);
host.LoadOrleansConfig(); // Load config from file + Initializes logger configurations
}
else
{
host = new SiloHost(instanceName, config); // Use supplied config data + Initializes logger configurations
}
IPEndPoint myEndpoint = serviceRuntimeWrapper.GetIPEndpoint(SiloEndpointConfigurationKeyName);
IPEndPoint proxyEndpoint = serviceRuntimeWrapper.GetIPEndpoint(ProxyEndpointConfigurationKeyName);
host.SetSiloType(Silo.SiloType.Secondary);
int generation = SiloAddress.AllocateNewGeneration();
// Bootstrap this Orleans silo instance
myEntry = new SiloInstanceTableEntry
{
DeploymentId = deploymentId,
Address = myEndpoint.Address.ToString(),
Port = myEndpoint.Port.ToString(CultureInfo.InvariantCulture),
Generation = generation.ToString(CultureInfo.InvariantCulture),
HostName = host.Config.GetConfigurationForNode(host.Name).DNSHostName,
ProxyPort = (proxyEndpoint != null ? proxyEndpoint.Port : 0).ToString(CultureInfo.InvariantCulture),
RoleName = serviceRuntimeWrapper.RoleName,
InstanceName = instanceName,
UpdateZone = serviceRuntimeWrapper.UpdateDomain.ToString(CultureInfo.InvariantCulture),
FaultZone = serviceRuntimeWrapper.FaultDomain.ToString(CultureInfo.InvariantCulture),
StartTime = TraceLogger.PrintDate(DateTime.UtcNow),
PartitionKey = deploymentId,
RowKey = myEndpoint.Address + "-" + myEndpoint.Port + "-" + generation
};
if (connectionString == null)
{
connectionString = serviceRuntimeWrapper.GetConfigurationSettingValue(DataConnectionConfigurationSettingName);
}
try
{
siloInstanceManager = OrleansSiloInstanceManager.GetManager(
deploymentId, connectionString).WithTimeout(AzureTableDefaultPolicies.TableCreationTimeout).Result;
}
catch (Exception exc)
{
var error = String.Format("Failed to create OrleansSiloInstanceManager. This means CreateTableIfNotExist for silo instance table has failed with {0}",
TraceLogger.PrintException(exc));
Trace.TraceError(error);
logger.Error(ErrorCode.AzureTable_34, error, exc);
throw new OrleansException(error, exc);
}
// Always use Azure table for membership when running silo in Azure
host.SetSiloLivenessType(GlobalConfiguration.LivenessProviderType.AzureTable);
if (config.Globals.ReminderServiceType == GlobalConfiguration.ReminderServiceProviderType.NotSpecified ||
config.Globals.ReminderServiceType == GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain)
{
host.SetReminderServiceType(GlobalConfiguration.ReminderServiceProviderType.AzureTable);
}
host.SetExpectedClusterSize(serviceRuntimeWrapper.RoleInstanceCount);
siloInstanceManager.RegisterSiloInstance(myEntry);
// Initialise this Orleans silo instance
host.SetDeploymentId(deploymentId, connectionString);
host.SetSiloEndpoint(myEndpoint, generation);
host.SetProxyEndpoint(proxyEndpoint);
host.InitializeOrleansSilo();
logger.Info(ErrorCode.Runtime_Error_100288, "Successfully initialized Orleans silo '{0}' as a {1} node.", host.Name, host.Type);
return(StartSilo());
}
public OutsideRuntimeClient(ClientConfiguration cfg, GrainFactory grainFactory, bool secondary = false)
{
this.grainFactory = grainFactory;
this.clientId = GrainId.NewClientId();
if (cfg == null)
{
Console.WriteLine("An attempt to create an OutsideRuntimeClient with null ClientConfiguration object.");
throw new ArgumentException("OutsideRuntimeClient was attempted to be created with null ClientConfiguration object.", "cfg");
}
this.config = cfg;
if (!TraceLogger.IsInitialized) TraceLogger.Initialize(config);
StatisticsCollector.Initialize(config);
SerializationManager.Initialize(config.UseStandardSerializer, cfg.SerializationProviders, config.UseJsonFallbackSerializer);
logger = TraceLogger.GetLogger("OutsideRuntimeClient", TraceLogger.LoggerType.Runtime);
appLogger = TraceLogger.GetLogger("Application", TraceLogger.LoggerType.Application);
try
{
LoadAdditionalAssemblies();
PlacementStrategy.Initialize();
callbacks = new ConcurrentDictionary<CorrelationId, CallbackData>();
localObjects = new ConcurrentDictionary<GuidId, LocalObjectData>();
if (!secondary)
{
UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnhandledException);
}
// Ensure SerializationManager static constructor is called before AssemblyLoad event is invoked
SerializationManager.GetDeserializer(typeof(String));
clientProviderRuntime = new ClientProviderRuntime(grainFactory, new DefaultServiceProvider());
statisticsProviderManager = new StatisticsProviderManager("Statistics", clientProviderRuntime);
var statsProviderName = statisticsProviderManager.LoadProvider(config.ProviderConfigurations)
.WaitForResultWithThrow(initTimeout);
if (statsProviderName != null)
{
config.StatisticsProviderName = statsProviderName;
}
responseTimeout = Debugger.IsAttached ? Constants.DEFAULT_RESPONSE_TIMEOUT : config.ResponseTimeout;
BufferPool.InitGlobalBufferPool(config);
var localAddress = ClusterConfiguration.GetLocalIPAddress(config.PreferredFamily, config.NetInterface);
// Client init / sign-on message
logger.Info(ErrorCode.ClientInitializing, string.Format(
"{0} Initializing OutsideRuntimeClient on {1} at {2} Client Id = {3} {0}",
BARS, config.DNSHostName, localAddress, clientId));
string startMsg = string.Format("{0} Starting OutsideRuntimeClient with runtime Version='{1}'", BARS, RuntimeVersion.Current);
startMsg = string.Format("{0} Config= " + Environment.NewLine + " {1}", startMsg, config);
logger.Info(ErrorCode.ClientStarting, startMsg);
if (TestOnlyThrowExceptionDuringInit)
{
throw new Exception("TestOnlyThrowExceptionDuringInit");
}
config.CheckGatewayProviderSettings();
var generation = -SiloAddress.AllocateNewGeneration(); // Client generations are negative
var gatewayListProvider = GatewayProviderFactory.CreateGatewayListProvider(config)
.WithTimeout(initTimeout).Result;
transport = new ProxiedMessageCenter(config, localAddress, generation, clientId, gatewayListProvider);
if (StatisticsCollector.CollectThreadTimeTrackingStats)
{
incomingMessagesThreadTimeTracking = new ThreadTrackingStatistic("ClientReceiver");
}
}
catch (Exception exc)
{
if (logger != null) logger.Error(ErrorCode.Runtime_Error_100319, "OutsideRuntimeClient constructor failed.", exc);
ConstructorReset();
throw;
}
}
public void FinishStep(StepExecutionEndingRequest request)
{
var key = GetStepKey(request.CurrentExecutionInfo, request.CurrentExecutionInfo.CurrentSpec, request.CurrentExecutionInfo.CurrentScenario, request.CurrentExecutionInfo.CurrentStep);
TraceLogger.Verbose($"Finishing step with key: {key}");
var stepReporter = _steps[key];
var stepStatus = Status.Passed;
// process gauge log messages
var logMessages = request.StepResult.ProtoItem.Step.StepExecutionResult.ExecutionResult.Message;
if (logMessages != null)
{
foreach (var logMessage in logMessages)
{
stepReporter.Log(new CreateLogItemRequest
{
Text = logMessage,
Level = LogLevel.Debug,
Time = DateTime.UtcNow
});
}
}
// todo it's never skipped
if (request.StepResult.ProtoItem.Step.StepExecutionResult.Skipped)
{
stepStatus = Status.Skipped;
stepReporter.Log(new CreateLogItemRequest
{
Time = DateTime.UtcNow,
Level = LogLevel.Info,
Text = $"Skip reason: {request.StepResult.ProtoItem.Step.StepExecutionResult.SkippedReason}"
});
}
;
if (request.StepResult.ProtoItem.Step.StepExecutionResult.ExecutionResult.Failed)
{
stepStatus = Status.Failed;
stepReporter.Log(new CreateLogItemRequest
{
Time = DateTime.UtcNow,
Level = LogLevel.Error,
Text = $"{request.StepResult.ProtoItem.Step.StepExecutionResult.ExecutionResult.ErrorMessage}{Environment.NewLine}{Environment.NewLine}{request.StepResult.ProtoItem.Step.StepExecutionResult.ExecutionResult.StackTrace}"
});
}
try
{
var failureScreenshotFile = request.StepResult.ProtoItem.Step.StepExecutionResult.ExecutionResult.FailureScreenshotFile;
if (!string.IsNullOrEmpty(failureScreenshotFile))
{
stepReporter.Log(new CreateLogItemRequest
{
Time = DateTime.UtcNow,
Level = LogLevel.Error,
Text = "Screenshot",
Attach = new Attach
{
Name = "screenshot",
MimeType = Shared.MimeTypes.MimeTypeMap.GetMimeType(Path.GetExtension(failureScreenshotFile)),
Data = File.ReadAllBytes(Path.Combine(_gaugeScreenshotsDir, failureScreenshotFile))
}
});
}
}
catch (Exception exp)
{
TraceLogger.Error($"Couldn't parse failure step screenshot. {exp}");
}
// post hook messages
if (request.StepResult.ProtoItem.Step.PostHookMessages.Count != 0)
{
foreach (var postHookMessage in request.StepResult.ProtoItem.Step.PostHookMessages)
{
stepReporter.Log(new CreateLogItemRequest
{
Level = LogLevel.Debug,
Text = postHookMessage,
Time = DateTime.UtcNow
});
}
}
stepReporter.Finish(new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Status = stepStatus
});
_steps.TryRemove(key, out _);
}
