public override Task OnActivateAsync()
{
logger = TraceLogger.GetLogger("GrainBasedMembershipTable", TraceLogger.LoggerType.Runtime);
logger.Info(ErrorCode.MembershipGrainBasedTable1, "GrainBasedMembershipTable Activated.");
table = new InMemoryMembershipTable();
return TaskDone.Done;
}
internal VirtualBucketsRingProvider(SiloAddress siloAddr, int nBucketsPerSilo)
{
if (nBucketsPerSilo <= 0 )
throw new IndexOutOfRangeException("numBucketsPerSilo is out of the range. numBucketsPerSilo = " + nBucketsPerSilo);
logger = TraceLogger.GetLogger(typeof(VirtualBucketsRingProvider).Name);
statusListeners = new List<IRingRangeListener>();
bucketsMap = new SortedDictionary<uint, SiloAddress>();
sortedBucketsList = new List<Tuple<uint, SiloAddress>>();
myAddress = siloAddr;
numBucketsPerSilo = nBucketsPerSilo;
lockable = new object();
running = true;
myRange = RangeFactory.CreateFullRange();
logger.Info("Starting {0} on silo {1}.", typeof(VirtualBucketsRingProvider).Name, siloAddr.ToStringWithHashCode());
StringValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_RING, ToString);
IntValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_RINGSIZE, () => GetRingSize());
StringValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_MYRANGE_RINGDISTANCE, () => String.Format("x{0,8:X8}", ((IRingRangeInternal)myRange).RangeSize()));
FloatValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_MYRANGE_RINGPERCENTAGE, () => (float)((IRingRangeInternal)myRange).RangePercentage());
FloatValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_AVERAGERINGPERCENTAGE, () =>
{
int size = GetRingSize();
return size == 0 ? 0 : ((float)100.0/(float) size);
});
// add myself to the list of members
AddServer(myAddress);
}
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 async Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, TraceLogger traceLogger)
{
logger = traceLogger;
deploymentId = config.DeploymentId;
if (logger.IsVerbose3) logger.Verbose3("SqlMembershipTable.InitializeMembershipTable called.");
database = RelationalStorageUtilities.CreateGenericStorageInstance(config.AdoInvariant, config.DataConnectionString);
//This initializes all of Orleans operational queries from the database using a well known view
//and assumes the database with appropriate defintions exists already.
queryConstants = await database.InitializeOrleansQueriesAsync();
// even if I am not the one who created the table,
// try to insert an initial table version if it is not already there,
// so we always have a first table version row, before this silo starts working.
if(tryInitTableVersion)
{
var wasCreated = await InitTableAsync();
if(wasCreated)
{
logger.Info("Created new table version row.");
}
}
}
public override Task OnActivateAsync()
{
logger = TraceLogger.GetLogger(String.Format("GrainBasedReminderTable_{0}", Data.Address.ToString()), TraceLogger.LoggerType.Runtime);
logger.Info("GrainBasedReminderTable {0} Activated. Full identity: {1}", Identity, Data.Address.ToFullString());
remTable = new InMemoryRemindersTable();
base.DelayDeactivation(TimeSpan.FromDays(10 * 365)); // Delay Deactivation for GrainBasedReminderTable virtually indefinitely.
return TaskDone.Done;
}
public async Task Initialize(Guid serviceid, string connectionstring)
{
Name = "AzureTableBasedGossipChannel-" + ++sequenceNumber;
logger = TraceLogger.GetLogger(Name, TraceLogger.LoggerType.Runtime);
logger.Info("Initializing Gossip Channel for ServiceId={0} using connection: {1}, SeverityLevel={2}",
serviceid, ConfigUtilities.RedactConnectionStringInfo(connectionstring), logger.SeverityLevel);
tableManager = await GossipTableInstanceManager.GetManager(serviceid, connectionstring, logger);
}
public void TestInitialize()
{
logger = TraceLogger.GetLogger(GetType().Name, TraceLogger.LoggerType.Application);
deploymentId = "test-" + Guid.NewGuid();
logger.Info("DeploymentId={0}", deploymentId);
var globalConfiguration = new GlobalConfiguration
{
DeploymentId = deploymentId,
AdoInvariant = GetAdoInvariant(),
DataConnectionString = GetConnectionString()
};
var mbr = CreateMembershipTable(logger);
mbr.InitializeMembershipTable(globalConfiguration, true, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait();
membershipTable = mbr;
}
public async Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, TraceLogger traceLogger)
{
logger = traceLogger;
AzureTableDefaultPolicies.MaxBusyRetries = config.MaxStorageBusyRetries;
TraceLogger.SetExceptionDecoder(typeof(StorageException), AzureStorageUtils.PrintStorageException);
tableManager = await OrleansSiloInstanceManager.GetManager(
config.DeploymentId, config.DataConnectionString);
// even if I am not the one who created the table,
// try to insert an initial table version if it is not already there,
// so we always have a first table version row, before this silo starts working.
if (tryInitTableVersion)
{
// ignore return value, since we don't care if I inserted it or not, as long as it is in there.
bool created = await tableManager.TryCreateTableVersionEntryAsync().WithTimeout(AzureTableDefaultPolicies.TableOperationTimeout);
if(created) logger.Info("Created new table version row.");
}
}
public void TestInitialize()
{
logger = TraceLogger.GetLogger(GetType().Name, TraceLogger.LoggerType.Application);
var serviceId = Guid.NewGuid();
var deploymentId = "test-" + serviceId;
logger.Info("DeploymentId={0}", deploymentId);
var globalConfiguration = new GlobalConfiguration
{
ServiceId = serviceId,
DeploymentId = deploymentId,
AdoInvariantForReminders = GetAdoInvariant(),
DataConnectionStringForReminders = GetConnectionString()
};
var rmndr = CreateRemindersTable();
rmndr.Init(globalConfiguration, logger).WithTimeout(TimeSpan.FromMinutes(1)).Wait();
remindersTable = rmndr;
}
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);
}
}
/// <summary>
/// Initialize this silo.
/// </summary>
public void InitializeOrleansSilo()
{
#if DEBUG
AssemblyLoaderUtils.EnableAssemblyLoadTracing();
#endif
try
{
if (!ConfigLoaded)
{
LoadOrleansConfig();
}
logger.Info(ErrorCode.SiloInitializing, "Initializing Silo {0} on host={1} CPU count={2} running .NET version='{3}' Is .NET 4.5={4} OS version='{5}'",
Name, Environment.MachineName, Environment.ProcessorCount, Environment.Version, ConfigUtilities.IsNet45OrNewer(), Environment.OSVersion);
logger.Info(ErrorCode.SiloGcSetting, "Silo running with GC settings: ServerGC={0} GCLatencyMode={1}", GCSettings.IsServerGC, Enum.GetName(typeof(GCLatencyMode), GCSettings.LatencyMode));
if (!GCSettings.IsServerGC)
{
logger.Warn(ErrorCode.SiloGcWarning, "Note: Silo not running with ServerGC turned on - recommend checking app config : <configuration>-<runtime>-<gcServer enabled=\"true\"> and <configuration>-<runtime>-<gcConcurrent enabled=\"false\"/>");
}
orleans = new Silo(Name, Type, Config);
}
catch (Exception exc)
{
ReportStartupError(exc);
orleans = null;
}
}
public void TestCleanup()
{
logger.Info("Test {0} completed - Outcome = {1}", TestContext.TestName, TestContext.CurrentTestOutcome);
}
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;
}
}
/// <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.GetOrCreateNodeConfigurationForSilo(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 (host.Config.Globals.ReminderServiceType == GlobalConfiguration.ReminderServiceProviderType.NotSpecified ||
host.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 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 override Task OnDeactivateAsync()
{
logger.Info("GrainBasedMembershipTable Deactivated.");
return(TaskDone.Done);
}
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;
}
// 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.TestHook.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;
}
}
}
}
public void Explore(string path)
{
if (!_exploredPaths.Contains(path))
{
lock (_lockObj)
{
if (!_exploredPaths.Contains(path))
{
var logFormatters = new List <ILogFormatter>();
var reportEventObservers = new List <IReportEventsObserver>();
var commandsListeners = new List <ICommandsListener>();
var currentDirectory = new DirectoryInfo(path);
TraceLogger.Info($"Exploring extensions in '{currentDirectory}' directory.");
foreach (var file in currentDirectory.GetFiles("*ReportPortal*.dll"))
{
TraceLogger.Verbose($"Found '{file.Name}' and loading it into current AppDomain.");
AppDomain.CurrentDomain.Load(Path.GetFileNameWithoutExtension(file.Name));
}
var iLogFormatterExtensionInterfaceType = typeof(ILogFormatter);
var iReportEventObserseExtensionInterfaceType = typeof(IReportEventsObserver);
var iCommandsListenerInterfaceType = typeof(ICommandsListener);
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Where(a => a.GetName().Name.Contains("ReportPortal")))
{
if (!_exploredAssemblies.Contains(assembly.Location))
{
_exploredAssemblies.Add(assembly.Location);
TraceLogger.Verbose($"Exploring '{assembly.FullName}' assembly for extensions.");
try
{
foreach (var type in assembly.GetTypes().Where(t => t.IsClass))
{
if (!type.IsAbstract && type.GetConstructors().Any(ctor => ctor.GetParameters().Length == 0))
{
if (iLogFormatterExtensionInterfaceType.IsAssignableFrom(type))
{
var extension = Activator.CreateInstance(type);
logFormatters.Add((ILogFormatter)extension);
TraceLogger.Info($"Registered '{type.FullName}' type as {nameof(ILogFormatter)} extension.");
}
if (iReportEventObserseExtensionInterfaceType.IsAssignableFrom(type))
{
var extension = Activator.CreateInstance(type);
reportEventObservers.Add((IReportEventsObserver)extension);
TraceLogger.Info($"Registered '{type.FullName}' type as {nameof(IReportEventsObserver)} extension.");
}
if (iCommandsListenerInterfaceType.IsAssignableFrom(type))
{
var extension = Activator.CreateInstance(type);
commandsListeners.Add((ICommandsListener)extension);
TraceLogger.Info($"Registered '{type.FullName}' type as {nameof(ICommandsListener)} extension.");
}
}
}
}
catch (ReflectionTypeLoadException exp)
{
TraceLogger.Warn($"Couldn't load '{assembly.GetName().Name}' assembly into domain. \n {exp}");
foreach (var loaderException in exp.LoaderExceptions)
{
TraceLogger.Error(loaderException.ToString());
}
}
}
}
logFormatters.OrderBy(ext => ext.Order).ToList().ForEach(lf => LogFormatters.Add(lf));
reportEventObservers.ToList().ForEach(reo => ReportEventObservers.Add(reo));
commandsListeners.ForEach(cl => CommandsListeners.Add(cl));
_exploredPaths.Add(path);
}
}
}
}
private void RunLoggerPerfTest(string testName, int n, int logCode, TimeSpan target, TraceLogger logger)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < n; i++)
{
logger.Warn(logCode, "msg " + i);
}
var elapsed = stopwatch.Elapsed;
string msg = testName + " : Elapsed time = " + elapsed;
// Wait until the BulkMessageInterval time interval expires before wring the final log message - should cause bulk message flush
while (stopwatch.Elapsed <= TraceLogger.BulkMessageInterval)
{
Thread.Sleep(10);
}
Console.WriteLine(msg);
logger.Info(logCode, msg);
Assert.IsTrue(elapsed < target.Multiply(timingFactor), "{0}: Elapsed time {1} exceeds target time {2}", testName, elapsed, target);
}
/// <summary>
/// Copy files to container.
/// </summary>
/// <param name="directoryAndcontainerPath">Directory and container path as tuple.</param>
/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
/// <param name="retryDelay">Bool for weather to delay 1 minute before retrying.</param>
/// <returns></returns>
public virtual async Task CopyToContainerAsync(Tuple <string, string> directoryAndcontainerPath, CancellationToken cancellationToken, bool retryDelay = true)
{
int maxConcurrentUploads = Math.Max(Environment.ProcessorCount / 2, 1);
string sourceParentDirectory;
var uploadDirectory = directoryAndcontainerPath.Item1;
var containerPath = directoryAndcontainerPath.Item2;
List <string> files;
files = Directory.EnumerateFiles(uploadDirectory, "*", SearchOption.AllDirectories).ToList();
sourceParentDirectory = uploadDirectory.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
TraceLogger.Info(string.Format(Resources.TotalUploadFiles, files.Count()));
using (var uploadCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
{
// hook up reporting event from file container client.
_fileContainerHelper.UploadFileReportTrace += UploadFileTraceReportReceived;
_fileContainerHelper.UploadFileReportProgress += UploadFileProgressReportReceived;
try
{
// try upload all files for the first time.
List <string> failedFiles = await ParallelUploadAsync(files, sourceParentDirectory, containerPath, maxConcurrentUploads, uploadCancellationTokenSource.Token);
if (failedFiles.Count == 0)
{
// all files have been upload succeed.
TraceLogger.Info(Resources.FileUploadSucceed);
return;
}
else
{
TraceLogger.Info(string.Format(Resources.FileUploadFailedRetryLater, failedFiles.Count));
}
if (retryDelay)
{
// Delay 1 min then retry failed files.
for (int timer = 60; timer > 0; timer -= 5)
{
TraceLogger.Info(string.Format(Resources.FileUploadRetryInSecond, timer));
await Task.Delay(TimeSpan.FromSeconds(5), uploadCancellationTokenSource.Token);
}
}
// Retry upload all failed files.
TraceLogger.Info(string.Format(Resources.FileUploadRetry, failedFiles.Count));
failedFiles = await ParallelUploadAsync(failedFiles, sourceParentDirectory, containerPath, maxConcurrentUploads, uploadCancellationTokenSource.Token);
if (failedFiles.Count == 0)
{
// all files have been upload succeed after retry.
TraceLogger.Info(Resources.FileUploadRetrySucceed);
return;
}
else
{
throw new Exception(Resources.FileUploadFailedAfterRetry);
}
}
finally
{
_fileContainerHelper.UploadFileReportTrace -= UploadFileTraceReportReceived;
_fileContainerHelper.UploadFileReportProgress -= UploadFileProgressReportReceived;
}
}
}
internal PersistentStreamPullingManager(
GrainId id,
string strProviderName,
IStreamProviderRuntime runtime,
IStreamPubSub streamPubSub,
IQueueAdapterFactory adapterFactory,
IStreamQueueBalancer streamQueueBalancer,
PersistentStreamProviderConfig config)
: base(id, runtime.ExecutingSiloAddress)
{
if (string.IsNullOrWhiteSpace(strProviderName))
{
throw new ArgumentNullException("strProviderName");
}
if (runtime == null)
{
throw new ArgumentNullException("runtime", "IStreamProviderRuntime runtime reference should not be null");
}
if (streamPubSub == null)
{
throw new ArgumentNullException("streamPubSub", "StreamPubSub reference should not be null");
}
if (streamQueueBalancer == null)
{
throw new ArgumentNullException("streamQueueBalancer", "IStreamQueueBalancer streamQueueBalancer reference should not be null");
}
queuesToAgentsMap = new Dictionary<QueueId, PersistentStreamPullingAgent>();
streamProviderName = strProviderName;
providerRuntime = runtime;
pubSub = streamPubSub;
this.config = config;
nonReentrancyGuarantor = new AsyncSerialExecutor();
latestRingNotificationSequenceNumber = 0;
latestCommandNumber = 0;
queueBalancer = streamQueueBalancer;
this.adapterFactory = adapterFactory;
queueAdapterCache = adapterFactory.GetQueueAdapterCache();
logger = TraceLogger.GetLogger(GetType().Name + "-" + streamProviderName, TraceLogger.LoggerType.Provider);
logger.Info((int)ErrorCode.PersistentStreamPullingManager_01, "Created {0} for Stream Provider {1}.", GetType().Name, streamProviderName);
IntValueStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_NUM_PULLING_AGENTS, strProviderName), () => queuesToAgentsMap.Count);
queuePrintTimer = providerRuntime.RegisterTimer(AsyncTimerCallback, null, QUEUES_PRINT_PERIOD, QUEUES_PRINT_PERIOD);
}
public Async_TimingTests()
{
TraceLogger.Initialize(ClientConfiguration.StandardLoad());
logger = TraceLogger.GetLogger("AC_TimingTests", TraceLogger.LoggerType.Application);
logger.Info("----------------------------- STARTING AC_TimingTests -------------------------------------");
}
/// <summary>
/// Start this silo.
/// </summary>
/// <returns></returns>
public bool StartOrleansSilo()
{
try
{
if (string.IsNullOrEmpty(Thread.CurrentThread.Name))
{
Thread.CurrentThread.Name = this.GetType().Name;
}
if (orleans != null)
{
var shutdownEventName = Config.Defaults.SiloShutdownEventName ?? Name + "-Shutdown";
logger.Info(ErrorCode.SiloShutdownEventName, "Silo shutdown event name: {0}", shutdownEventName);
bool createdNew;
shutdownEvent = new EventWaitHandle(false, EventResetMode.ManualReset, shutdownEventName, out createdNew);
if (!createdNew)
{
logger.Info(ErrorCode.SiloShutdownEventOpened, "Opened existing shutdown event. Setting the event {0}", shutdownEventName);
}
else
{
logger.Info(ErrorCode.SiloShutdownEventCreated, "Created and set shutdown event {0}", shutdownEventName);
}
// Start silo
orleans.Start();
// Wait for the shutdown event, and trigger a graceful shutdown if we receive it.
var shutdownThread = new Thread(o =>
{
shutdownEvent.WaitOne();
logger.Info(ErrorCode.SiloShutdownEventReceived, "Received a shutdown event. Starting graceful shutdown.");
orleans.Shutdown();
});
shutdownThread.IsBackground = true;
shutdownThread.Start();
var startupEventName = Name;
logger.Info(ErrorCode.SiloStartupEventName, "Silo startup event name: {0}", startupEventName);
startupEvent = new EventWaitHandle(true, EventResetMode.ManualReset, startupEventName, out createdNew);
if (!createdNew)
{
logger.Info(ErrorCode.SiloStartupEventOpened, "Opened existing startup event. Setting the event {0}", startupEventName);
startupEvent.Set();
}
else
{
logger.Info(ErrorCode.SiloStartupEventCreated, "Created and set startup event {0}", startupEventName);
}
logger.Info(ErrorCode.SiloStarted, "Silo {0} started successfully", Name);
IsStarted = true;
}
else
{
throw new InvalidOperationException("Cannot start silo " + this.Name + " due to prior initialization error");
}
}
catch (Exception exc)
{
ReportStartupError(exc);
orleans = null;
IsStarted = false;
return(false);
}
return(true);
}
private void Heading(string testName)
{
logger.Info("\n\n************************ {0} {1}_{2} ********************************* \n\n", testNumber, streamProviderName, testName);
}
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");
}
protected async Task MembershipTable_ReadAll_EmptyTable()
{
var data = await membershipTable.ReadAll();
Assert.IsNotNull(data, "Membership Data not null");
logger.Info("Membership.ReadAll returned VableVersion={0} Data={1}", data.Version, data);
Assert.AreEqual(0, data.Members.Count, "Number of records returned - no table version row");
Assert.IsNotNull(data.Version.VersionEtag, "ETag should not be null");
Assert.AreEqual(0, data.Version.Version, "Initial tabel version should be zero");
}
public async Task Test_Reminders_Basic_StopByRef()
{
Console.WriteLine(TestContext.TestName + " started");
log.Info(TestContext.TestName);
IReminderTestGrain2 grain = GrainClient.GrainFactory.GetGrain <IReminderTestGrain2>(Guid.NewGuid());
IGrainReminder r1 = await grain.StartReminder(DR);
IGrainReminder r2 = await grain.StartReminder(DR);
Console.WriteLine(TestContext.TestName + " reminders started");
try
{
// First handle should now be out of date once the seconf handle to the same reminder was obtained
await grain.StopReminder(r1);
Assert.Fail("Removed reminder1, which shouldn't be possible.");
}
catch (Exception exc)
{
log.Info("Couldn't remove {0}, as expected. Exception received = {1}", r1, exc);
}
await grain.StopReminder(r2);
log.Info("Removed reminder2 successfully");
// trying to see if readreminder works
IGrainReminder o1 = await grain.StartReminder(DR);
IGrainReminder o2 = await grain.StartReminder(DR);
IGrainReminder o3 = await grain.StartReminder(DR);
IGrainReminder o4 = await grain.StartReminder(DR);
IGrainReminder r = await grain.GetReminderObject(DR);
await grain.StopReminder(r);
log.Info("Removed got reminder successfully");
}
static void Main(string[] args)
{
ParseArgs(args, ToolName);
InitializeLogger();
PrintWelcome(ToolName, RevisionResource);
if (CreateContextMenuEntry)
{
// create context menu entry
try
{
TraceLogger.Info("Creating context menu entry for xls2x ...");
RegisterForContextMenu(GetContextMenuKey(ContextMenuInputExtension, ContextMenuText));
TraceLogger.Info("Succeeded.");
}
catch (Exception)
{
TraceLogger.Info("Failed. Sorry :(");
}
}
else
{
try
{
//copy processing file
ProcessingFile procFile = new ProcessingFile(InputFile);
//make output file name
if (ChoosenOutputFile == null)
{
if (InputFile.Contains("."))
{
ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".xlsx";
}
else
{
ChoosenOutputFile = InputFile + ".xlsx";
}
}
//parse the document
using (StructuredStorageReader reader = new StructuredStorageReader(procFile.File.FullName))
{
XlsDocument xlsDoc = new XlsDocument(reader);
OpenXmlPackage.DocumentType outType = Converter.DetectOutputType(xlsDoc);
string conformOutputFile = Converter.GetConformFilename(ChoosenOutputFile, outType);
using (SpreadsheetDocument spreadx = SpreadsheetDocument.Create(conformOutputFile, outType))
{
//start time
DateTime start = DateTime.Now;
TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile);
Converter.Convert(xlsDoc, spreadx);
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 (ParseException ex)
{
TraceLogger.Error("Could not convert {0} because it was created by an unsupported application (Excel 95 or older).", InputFile);
TraceLogger.Debug(ex.ToString());
}
catch (DirectoryNotFoundException ex)
{
TraceLogger.Error(ex.Message);
TraceLogger.Debug(ex.ToString());
}
catch (FileNotFoundException ex)
{
TraceLogger.Error(ex.Message);
TraceLogger.Debug(ex.ToString());
}
catch (ZipCreationException ex)
{
TraceLogger.Error("Could not create output file {0}.", ChoosenOutputFile);
TraceLogger.Debug(ex.ToString());
}
catch (Exception ex)
{
TraceLogger.Error("Conversion of file {0} failed.", InputFile);
TraceLogger.Debug(ex.ToString());
}
}
}
/// <summary>
/// Extracts the data from the stream
/// </summary>
public override void extractData()
{
BiffHeader bh;
//try
//{
while (this.StreamReader.BaseStream.Position < this.StreamReader.BaseStream.Length)
{
bh.id = (RecordType)this.StreamReader.ReadUInt16();
bh.length = this.StreamReader.ReadUInt16();
// Debugging output
TraceLogger.DebugInternal("BIFF {0}\t{1}\t", bh.id, bh.length);
switch (bh.id)
{
case RecordType.BoundSheet8:
{
// Extracts the Boundsheet data
BoundSheet8 bs = new BoundSheet8(this.StreamReader, bh.id, bh.length);
TraceLogger.DebugInternal(bs.ToString());
SheetData sheetData = null;
switch (bs.dt)
{
case BoundSheet8.SheetType.Worksheet:
sheetData = new WorkSheetData();
this.oldOffset = this.StreamReader.BaseStream.Position;
this.StreamReader.BaseStream.Seek(bs.lbPlyPos, SeekOrigin.Begin);
WorksheetExtractor se = new WorksheetExtractor(this.StreamReader, sheetData as WorkSheetData);
this.StreamReader.BaseStream.Seek(oldOffset, SeekOrigin.Begin);
break;
case BoundSheet8.SheetType.Chartsheet:
ChartSheetData chartSheetData = new ChartSheetData();
this.oldOffset = this.StreamReader.BaseStream.Position;
this.StreamReader.BaseStream.Seek(bs.lbPlyPos, SeekOrigin.Begin);
chartSheetData.ChartSheetSequence = new ChartSheetSequence(this.StreamReader);
this.StreamReader.BaseStream.Seek(oldOffset, SeekOrigin.Begin);
sheetData = chartSheetData;
break;
default:
TraceLogger.Info("Unsupported sheet type: {0}", bs.dt);
break;
}
if (sheetData != null)
{
// add general sheet info
sheetData.boundsheetRecord = bs;
}
this.workBookData.addBoundSheetData(sheetData);
}
break;
case RecordType.Template:
{
this.workBookData.Template = true;
}
break;
case RecordType.SST:
{
/* reads the shared string table biff record and following continue records
* creates an array of bytes and then puts that into a memory stream
* this all is used to create a longer biffrecord then 8224 bytes. If theres a string
* beginning in the SST that is then longer then the 8224 bytes, it continues in the
* CONTINUE BiffRecord, so the parser has to read over the SST border.
* The problem here is, that the parser has to overread the continue biff record header
*/
SST sst;
UInt16 length = bh.length;
// save the old offset from this record begin
this.oldOffset = this.StreamReader.BaseStream.Position;
// create a list of bytearrays to store the following continue records
// List<byte[]> byteArrayList = new List<byte[]>();
byte[] buffer = new byte[length];
LinkedList <VirtualStreamReader> vsrList = new LinkedList <VirtualStreamReader>();
buffer = this.StreamReader.ReadBytes((int)length);
// byteArrayList.Add(buffer);
// create a new memory stream and a new virtualstreamreader
MemoryStream bufferstream = new MemoryStream(buffer);
VirtualStreamReader binreader = new VirtualStreamReader(bufferstream);
BiffHeader bh2;
bh2.id = (RecordType)this.StreamReader.ReadUInt16();
while (bh2.id == RecordType.Continue)
{
bh2.length = (UInt16)(this.StreamReader.ReadUInt16());
buffer = new byte[bh2.length];
// create a buffer with the bytes from the records and put that array into the
// list
buffer = this.StreamReader.ReadBytes((int)bh2.length);
// byteArrayList.Add(buffer);
// create for each continue record a new streamreader !!
MemoryStream contbufferstream = new MemoryStream(buffer);
VirtualStreamReader contreader = new VirtualStreamReader(contbufferstream);
vsrList.AddLast(contreader);
// take next Biffrecord ID
bh2.id = (RecordType)this.StreamReader.ReadUInt16();
}
// set the old position of the stream
this.StreamReader.BaseStream.Position = this.oldOffset;
sst = new SST(binreader, bh.id, length, vsrList);
this.StreamReader.BaseStream.Position = this.oldOffset + bh.length;
this.workBookData.SstData = new SSTData(sst);
}
break;
case RecordType.EOF:
{
// Reads the end of the internal file !!!
this.StreamReader.BaseStream.Seek(0, SeekOrigin.End);
}
break;
case RecordType.ExternSheet:
{
ExternSheet extsheet = new ExternSheet(this.StreamReader, bh.id, bh.length);
this.externSheets.Add(extsheet);
this.workBookData.addExternSheetData(extsheet);
}
break;
case RecordType.SupBook:
{
SupBook supbook = new SupBook(this.StreamReader, bh.id, bh.length);
this.supBooks.Add(supbook);
this.workBookData.addSupBookData(supbook);
}
break;
case RecordType.XCT:
{
XCT xct = new XCT(this.StreamReader, bh.id, bh.length);
this.XCTList.Add(xct);
this.workBookData.addXCT(xct);
}
break;
case RecordType.CRN:
{
CRN crn = new CRN(this.StreamReader, bh.id, bh.length);
this.CRNList.Add(crn);
this.workBookData.addCRN(crn);
}
break;
case RecordType.ExternName:
{
ExternName externname = new ExternName(this.StreamReader, bh.id, bh.length);
this.workBookData.addEXTERNNAME(externname);
}
break;
case RecordType.Format:
{
Format format = new Format(this.StreamReader, bh.id, bh.length);
this.workBookData.styleData.addFormatValue(format);
}
break;
case RecordType.XF:
{
XF xf = new XF(this.StreamReader, bh.id, bh.length);
this.workBookData.styleData.addXFDataValue(xf);
}
break;
case RecordType.Style:
{
Style style = new Style(this.StreamReader, bh.id, bh.length);
this.workBookData.styleData.addStyleValue(style);
}
break;
case RecordType.Font:
{
Font font = new Font(this.StreamReader, bh.id, bh.length);
this.workBookData.styleData.addFontData(font);
}
break;
case RecordType.NAME:
case RecordType.Lbl:
{
Lbl name = new Lbl(this.StreamReader, bh.id, bh.length);
this.workBookData.addDefinedName(name);
}
break;
case RecordType.BOF:
{
this.workBookData.BOF = new BOF(this.StreamReader, bh.id, bh.length);
}
break;
case RecordType.CodeName:
{
this.workBookData.CodeName = new CodeName(this.StreamReader, bh.id, bh.length);
}
break;
case RecordType.FilePass:
{
throw new ExtractorException(ExtractorException.FILEENCRYPTED);
}
break;
case RecordType.Palette:
{
Palette palette = new Palette(this.StreamReader, bh.id, bh.length);
workBookData.styleData.setColorList(palette.rgbColorList);
}
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);
TraceLogger.Debug("Unknown record found. ID {0}", bh.id);
}
break;
}
}
//}
//catch (Exception ex)
//{
// TraceLogger.Error(ex.Message);
// TraceLogger.Debug(ex.ToString());
//}
}
private static void LogStatus(TraceLogger log, string msg, params object[] args)
{
if (SystemStatus.Current.Equals(SystemStatus.Creating))
{
// Reduce log noise during silo startup
if (log.IsVerbose) log.Verbose(msg, args);
}
else
{
// Changes in agent threads during all operations aside for initial creation are usually important diag events.
log.Info(msg, args);
}
}
public override Task OnDeactivateAsync()
{
logger.Info("GrainBasedReminderTable {0} OnDeactivateAsync. Full identity: {1}", Identity, Data.Address.ToFullString());
return(TaskDone.Done);
}
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;
}
}
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);
}
