/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo and client config options.
/// </summary>
protected TestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
siloInitOptions = siloOptions;
clientInitOptions = clientOptions;
AppDomain.CurrentDomain.UnhandledException += ReportUnobservedException;
try
{
Initialize(siloOptions, clientOptions);
string startMsg = "----------------------------- STARTING NEW UNIT TEST SILO HOST: " + GetType().FullName + " -------------------------------------";
WriteLog(startMsg);
}
catch (TimeoutException te)
{
throw new TimeoutException("Timeout during test initialization", te);
}
catch (Exception ex)
{
Exception baseExc = ex.GetBaseException();
if (baseExc is TimeoutException)
{
throw new TimeoutException("Timeout during test initialization", ex);
}
throw new AggregateException(
string.Format("Exception during test initialization: {0}",
TraceLogger.PrintException(ex)), ex);
}
}
/// <summary>
/// Start the default Primary and Secondary test silos, plus client in-process,
/// using the specified silo and client config options.
/// </summary>
public UnitTestSiloHost(UnitTestSiloOptions siloOptions, UnitTestClientOptions clientOptions)
{
this.siloInitOptions = siloOptions;
this.clientInitOptions = clientOptions;
AppDomain.CurrentDomain.UnhandledException += _ReportUnobservedException;
try
{
_Initialize(siloOptions, clientOptions);
string startMsg = "----------------------------- STARTING NEW UNIT TEST BASE: " + this.GetType().FullName + " -------------------------------------";
Console.WriteLine(startMsg);
}
catch (TimeoutException te)
{
throw new TimeoutException("Timeout during test initialization", te);
}
catch (Exception ex)
{
Exception baseExc = ex.GetBaseException();
if (baseExc is TimeoutException)
{
throw new TimeoutException("Timeout during test initialization", ex);
}
throw new AggregateException(
string.Format("Exception during test initialization: {0}",
TraceLogger.PrintException(ex)), ex);
}
}
private static void InternalUnobservedTaskExceptionHandler(object sender, UnobservedTaskExceptionEventArgs e)
{
var aggrException = e.Exception;
var baseException = aggrException.GetBaseException();
var tplTask = (Task)sender;
var contextObj = tplTask.AsyncState;
var context = contextObj as ISchedulingContext;
try
{
if (unobservedExceptionHandler != null)
{
unobservedExceptionHandler(context, baseException);
}
}
finally
{
if (e.Observed)
{
logger.Info(ErrorCode.Runtime_Error_100311, "UnobservedExceptionsHandlerClass caught an UnobservedTaskException which was successfully observed and recovered from. BaseException = {0}. Exception = {1}",
baseException.Message, TraceLogger.PrintException(aggrException));
}
else
{
var errorStr = String.Format("UnobservedExceptionsHandlerClass Caught an UnobservedTaskException event sent by {0}. Exception = {1}",
OrleansTaskExtentions.ToString((Task)sender), TraceLogger.PrintException(aggrException));
logger.Error(ErrorCode.Runtime_Error_100005, errorStr);
logger.Error(ErrorCode.Runtime_Error_100006, "Exception remained UnObserved!!! The subsequent behaivour depends on the ThrowUnobservedTaskExceptions setting in app config and .NET version.");
}
}
}
/// <summary>
/// Ensures that code generation has been run for the provided assembly.
/// </summary>
/// <param name="input">
/// The assembly to generate code for.
/// </param>
public void GenerateAndLoadForAssembly(Assembly input)
{
try
{
RegisterGeneratedCodeTargets(input);
if (!ShouldGenerateCodeForAssembly(input))
{
TryLoadGeneratedAssemblyFromCache(input);
return;
}
var timer = Stopwatch.StartNew();
var generated = GenerateForAssemblies(new List <Assembly> {
input
}, true);
var compiled = default(byte[]);
if (generated.Syntax != null)
{
compiled = CompileAndLoad(generated);
}
foreach (var assembly in generated.SourceAssemblies)
{
var generatedAssembly = new GeneratedAssembly {
Loaded = true, RawBytes = compiled
};
CompiledAssemblies.AddOrUpdate(
assembly.GetName().FullName,
generatedAssembly,
(_, __) => generatedAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
(int)ErrorCode.CodeGenCompilationSucceeded,
"Generated code for 1 assembly in {0}ms",
timer.ElapsedMilliseconds);
}
}
catch (Exception exception)
{
var message = string.Format(
"Exception generating code for input assembly {0}\nException: {1}",
input.GetName().FullName,
TraceLogger.PrintException(exception));
Logger.Warn((int)ErrorCode.CodeGenCompilationFailed, message, exception);
throw;
}
}
private void DeployTestingSiloHost(TestingSiloOptions siloOptions, TestingClientOptions clientOptions)
{
siloInitOptions = siloOptions;
clientInitOptions = clientOptions;
AppDomain.CurrentDomain.UnhandledException += ReportUnobservedException;
InitializeLogWriter();
try
{
string startMsg = "----------------------------- STARTING NEW UNIT TEST SILO HOST: " + GetType().FullName + " -------------------------------------";
WriteLog(startMsg);
InitializeAsync(siloOptions, clientOptions).Wait();
UninitializeLogWriter();
Instance = this;
}
catch (TimeoutException te)
{
FlushLogToConsole();
throw new TimeoutException("Timeout during test initialization", te);
}
catch (Exception ex)
{
StopAllSilos();
Exception baseExc = ex.GetBaseException();
FlushLogToConsole();
if (baseExc is TimeoutException)
{
throw new TimeoutException("Timeout during test initialization", ex);
}
// IMPORTANT:
// Do NOT re-throw the original exception here, also not as an internal exception inside AggregateException
// Due to the way MS tests works, if the original exception is an Orleans exception,
// it's assembly might not be loaded yet in this phase of the test.
// As a result, we will get "MSTest: Unit Test Adapter threw exception: Type is not resolved for member XXX"
// and will loose the original exception. This makes debugging tests super hard!
// The root cause has to do with us initializing our tests from Test constructor and not from TestInitialize method.
// More details: http://dobrzanski.net/2010/09/20/mstest-unit-test-adapter-threw-exception-type-is-not-resolved-for-member/
throw new Exception(
string.Format("Exception during test initialization: {0}",
TraceLogger.PrintException(baseExc)));
}
}
/// <summary>
/// Report an error during silo startup.
/// </summary>
/// <remarks>
/// Information on the silo startup issue will be logged to any attached Loggers,
/// then a timestamped StartupError text file will be written to
/// the current working directory (if possible).
/// </remarks>
/// <param name="exc">Exception which caused the silo startup issue.</param>
public void ReportStartupError(Exception exc)
{
if (string.IsNullOrWhiteSpace(Name))
{
Name = "Silo";
}
var errMsg = "ERROR starting Orleans silo name=" + Name + " Exception=" + TraceLogger.PrintException(exc);
if (logger != null)
{
logger.Error(ErrorCode.Runtime_Error_100105, errMsg, exc);
}
// Dump Startup error to a log file
var now = DateTime.UtcNow;
const string dateFormat = "yyyy-MM-dd-HH.mm.ss.fffZ";
var dateString = now.ToString(dateFormat, CultureInfo.InvariantCulture);
var startupLog = Name + "-StartupError-" + dateString + ".txt";
try
{
File.AppendAllText(startupLog, dateString + "Z" + Environment.NewLine + errMsg);
}
catch (Exception exc2)
{
if (logger != null)
{
logger.Error(ErrorCode.Runtime_Error_100106, "Error writing log file " + startupLog, exc2);
}
}
TraceLogger.Flush();
}
internal void ReportError(string msg, Exception exc)
{
msg = "*****\t" + msg + "\n --->" + TraceLogger.PrintException(exc);
ReportError(msg);
}
/// <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 (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 async Task <GrainStateRecord> Read(string partitionKey, string rowKey)
{
if (logger.IsVerbose3)
{
logger.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_Storage_Reading, "Reading: PartitionKey={0} RowKey={1} from Table={2}", partitionKey, rowKey, TableName);
}
try
{
Tuple <GrainStateEntity, string> data = await tableManager.ReadSingleTableEntryAsync(partitionKey, rowKey);
if (data == null || data.Item1 == null)
{
if (logger.IsVerbose2)
{
logger.Verbose2((int)AzureProviderErrorCode.AzureTableProvider_DataNotFound, "DataNotFound reading: PartitionKey={0} RowKey={1} from Table={2}", partitionKey, rowKey, TableName);
}
return(null);
}
GrainStateEntity stateEntity = data.Item1;
var record = new GrainStateRecord {
Entity = stateEntity, ETag = data.Item2
};
if (logger.IsVerbose3)
{
logger.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_Storage_DataRead, "Read: PartitionKey={0} RowKey={1} from Table={2} with ETag={3}", stateEntity.PartitionKey, stateEntity.RowKey, TableName, record.ETag);
}
return(record);
}
catch (Exception exc)
{
if (AzureStorageUtils.TableStorageDataNotFound(exc))
{
if (logger.IsVerbose2)
{
logger.Verbose2((int)AzureProviderErrorCode.AzureTableProvider_DataNotFound, "DataNotFound reading (exception): PartitionKey={0} RowKey={1} from Table={2} Exception={3}", partitionKey, rowKey, TableName, TraceLogger.PrintException(exc));
}
return(null); // No data
}
throw;
}
}
public int RunMain(string[] args)
{
ConsoleText.WriteStatus("Orleans-CodeGen - command-line = {0}", Environment.CommandLine);
if (args.Length < 1)
{
Console.WriteLine(
"Usage: ClientGenerator.exe <grain interface dll path> [<client dll path>] [<key file>] [<referenced assemblies>]");
Console.WriteLine(
" ClientGenerator.exe /server <grain dll path> [<factory dll path>] [<key file>] [<referenced assemblies>]");
return(1);
}
try
{
var options = new CodeGenOptions();
// STEP 1 : Parse parameters
if (args.Length == 1 && args[0].StartsWith("@"))
{
// Read command line args from file
string arg = args[0];
string argsFile = arg.Trim('"').Substring(1).Trim('"');
Console.WriteLine("Orleans-CodeGen - Reading code-gen params from file={0}", argsFile);
AssertWellFormed(argsFile, true);
args = File.ReadAllLines(argsFile);
}
int i = 1;
foreach (string a in args)
{
string arg = a.Trim('"').Trim().Trim('"');
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine("Orleans-CodeGen - arg #{0}={1}", i++, arg);
}
if (string.IsNullOrEmpty(arg) || string.IsNullOrWhiteSpace(arg))
{
continue;
}
if (arg.StartsWith("/"))
{
if (arg.StartsWith("/reference:") || arg.StartsWith("/r:"))
{
// list of references passed from from project file. separator =';'
string refstr = arg.Substring(arg.IndexOf(':') + 1);
string[] references = refstr.Split(';');
foreach (string rp in references)
{
AssertWellFormed(rp, true);
options.ReferencedAssemblies.Add(rp);
}
}
else if (arg.StartsWith("/in:"))
{
var infile = arg.Substring(arg.IndexOf(':') + 1);
AssertWellFormed(infile);
options.InputLib = new FileInfo(infile);
}
else if (arg.StartsWith("/bootstrap") || arg.StartsWith("/boot"))
{
// special case for building circular dependecy in preprocessing:
// Do not build the input assembly, assume that some other build step
options.CodeGenFile = Path.GetFullPath(CodeGenFileRelativePathCSharp);
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine(
"Orleans-CodeGen - Set CodeGenFile={0} from bootstrap",
options.CodeGenFile);
}
}
else if (arg.StartsWith("/sources:") || arg.StartsWith("/src:"))
{
var sourcesStr = arg.Substring(arg.IndexOf(':') + 1);
string[] sources = sourcesStr.Split(';');
foreach (var source in sources)
{
HandleSourceFile(source, options);
}
}
}
else
{
HandleSourceFile(arg, options);
}
}
if (options.TargetLanguage != Language.CSharp)
{
ConsoleText.WriteLine(
"ERROR: Compile-time code generation is supported for C# only. "
+ "Remove code generation from your project in order to use run-time code generation.");
return(2);
}
// STEP 2 : Validate and calculate unspecified parameters
if (options.InputLib == null)
{
Console.WriteLine("ERROR: Orleans-CodeGen - no input file specified.");
return(2);
}
if (string.IsNullOrEmpty(options.CodeGenFile))
{
Console.WriteLine(
"ERROR: No codegen file. Add a file '{0}' to your project",
Path.Combine("Properties", "orleans.codegen.cs"));
return(2);
}
options.SourcesDir = Path.Combine(options.InputLib.DirectoryName, "Generated");
// STEP 3 : Dump useful info for debugging
Console.WriteLine(
"Orleans-CodeGen - Options " + Environment.NewLine + "\tInputLib={0} " + Environment.NewLine
+ "\tCodeGenFile={1}",
options.InputLib.FullName,
options.CodeGenFile);
if (options.ReferencedAssemblies != null)
{
Console.WriteLine("Orleans-CodeGen - Using referenced libraries:");
foreach (string assembly in options.ReferencedAssemblies)
{
Console.WriteLine("\t{0} => {1}", Path.GetFileName(assembly), assembly);
}
}
// STEP 5 : Finally call code generation
if (!CreateGrainClientAssembly(options))
{
return(-1);
}
// DONE!
return(0);
}
catch (Exception ex)
{
File.WriteAllText("error.txt", ex.Message + Environment.NewLine + ex.StackTrace);
Console.WriteLine("-- Code-gen FAILED -- \n{0}", TraceLogger.PrintException(ex));
return(3);
}
}
private static void InitializeImpl_FromFile(FileInfo configFile)
{
if (GrainClient.IsInitialized)
{
Trace.TraceInformation("Connection to Orleans gateway silo already initialized.");
return;
}
ClientConfiguration config;
try
{
if (configFile == null)
{
Trace.TraceInformation("Looking for standard Orleans client config file");
config = ClientConfiguration.StandardLoad();
}
else
{
var configFileLocation = configFile.FullName;
Trace.TraceInformation("Loading Orleans client config file {0}", configFileLocation);
config = ClientConfiguration.LoadFromFile(configFileLocation);
}
}
catch (Exception ex)
{
var msg = String.Format("Error loading Orleans client configuration file {0} {1} -- unable to continue. {2}", configFile, ex.Message, TraceLogger.PrintException(ex));
Trace.TraceError(msg);
throw new AggregateException(msg, ex);
}
Trace.TraceInformation("Overriding Orleans client config from Azure runtime environment.");
try
{
config.DeploymentId = GetDeploymentId();
config.DataConnectionString = GetDataConnectionString();
config.GatewayProvider = ClientConfiguration.GatewayProviderType.AzureTable;
}
catch (RoleEnvironmentException ex)
{
var msg = string.Format("ERROR: No AzureClient role setting value '{0}' specified for this role -- unable to continue", AzureConstants.DataConnectionConfigurationSettingName);
Trace.TraceError(msg);
throw new AggregateException(msg, ex);
}
InitializeImpl_FromConfig(config);
}
/// <summary>
/// Generates and loads code for the specified inputs.
/// </summary>
/// <param name="inputs">The assemblies to generate code for.</param>
public void GenerateAndLoadForAssemblies(params Assembly[] inputs)
{
if (inputs == null)
{
throw new ArgumentNullException("inputs");
}
var timer = Stopwatch.StartNew();
foreach (var input in inputs)
{
RegisterGeneratedCodeTargets(input);
TryLoadGeneratedAssemblyFromCache(input);
}
var grainAssemblies = inputs.Where(ShouldGenerateCodeForAssembly).ToList();
if (grainAssemblies.Count == 0)
{
// Already up to date.
return;
}
try
{
// Generate code for newly loaded assemblies.
var generatedSyntax = GenerateForAssemblies(grainAssemblies, true);
var compiled = default(byte[]);
if (generatedSyntax.Syntax != null)
{
compiled = CompileAndLoad(generatedSyntax);
}
foreach (var assembly in generatedSyntax.SourceAssemblies)
{
var generatedAssembly = new GeneratedAssembly {
Loaded = true, RawBytes = compiled
};
CompiledAssemblies.AddOrUpdate(
assembly.GetName().FullName,
generatedAssembly,
(_, __) => generatedAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
(int)ErrorCode.CodeGenCompilationSucceeded,
"Generated code for {0} assemblies in {1}ms",
generatedSyntax.SourceAssemblies.Count,
timer.ElapsedMilliseconds);
}
}
catch (Exception exception)
{
var message = string.Format(
"Exception generating code for input assemblies:\n{0}\nException: {1}",
string.Join("\n", grainAssemblies.Select(_ => _.GetName().FullName)),
TraceLogger.PrintException(exception));
Logger.Warn((int)ErrorCode.CodeGenCompilationFailed, message, exception);
throw;
}
}
public int RunMain(string[] args)
{
ConsoleText.WriteStatus("Orleans-CodeGen - command-line = {0}", Environment.CommandLine);
if (args.Length < 1)
{
Console.WriteLine(
"Usage: ClientGenerator.exe <grain interface dll path> [<client dll path>] [<key file>] [<referenced assemblies>]");
Console.WriteLine(
" ClientGenerator.exe /server <grain dll path> [<factory dll path>] [<key file>] [<referenced assemblies>]");
return(1);
}
try
{
var options = new CodeGenOptions();
// STEP 1 : Parse parameters
if (args.Length == 1 && args[0].StartsWith("@"))
{
// Read command line args from file
string arg = args[0];
string argsFile = arg.Trim('"').Substring(1).Trim('"');
Console.WriteLine("Orleans-CodeGen - Reading code-gen params from file={0}", argsFile);
AssertWellFormed(argsFile, true);
args = File.ReadAllLines(argsFile);
}
int i = 1;
foreach (string a in args)
{
string arg = a.Trim('"').Trim().Trim('"');
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine("Orleans-CodeGen - arg #{0}={1}", i++, arg);
}
if (string.IsNullOrEmpty(arg) || string.IsNullOrWhiteSpace(arg))
{
continue;
}
if (arg.StartsWith("/"))
{
if (arg.StartsWith("/reference:") || arg.StartsWith("/r:"))
{
// list of references passed from from project file. separator =';'
string refstr = arg.Substring(arg.IndexOf(':') + 1);
string[] references = refstr.Split(';');
foreach (string rp in references)
{
AssertWellFormed(rp, true);
options.ReferencedAssemblies.Add(rp);
}
}
else if (arg.StartsWith("/cwd:"))
{
options.WorkingDirectory = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/in:"))
{
var infile = arg.Substring(arg.IndexOf(':') + 1);
AssertWellFormed(infile);
options.InputLib = new FileInfo(infile);
}
else if (arg.StartsWith("/keyfile:") || arg.StartsWith("/key:"))
{
string keyFile = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrWhiteSpace(keyFile))
{
AssertWellFormed(keyFile, true);
options.SigningKey = new FileInfo(keyFile);
}
}
else if (arg.StartsWith("/config:"))
{
options.Config = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/fsharp:"))
{
var path = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrEmpty(path))
{
Console.WriteLine("F# compiler path = '{0}' ", path);
options.FSharpCompilerPath = path;
}
else
{
Console.WriteLine("F# compiler path not set.");
}
}
else if (arg.StartsWith("/rootns:") || arg.StartsWith("/rns:"))
{
options.RootNamespace = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/bootstrap") || arg.StartsWith("/boot"))
{
// special case for building circular dependecy in preprocessing:
// Do not build the input assembly, assume that some other build step
options.CodeGenFile = Path.GetFullPath(CodeGenFileRelativePathCSharp);
if (GrainClientGeneratorFlags.Verbose)
{
Console.WriteLine(
"Orleans-CodeGen - Set CodeGenFile={0} from bootstrap",
options.CodeGenFile);
}
}
else if (arg.StartsWith("/define:") || arg.StartsWith("/d:"))
{
// #define constants passed from project file. separator =';'
var definsStr = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrWhiteSpace(definsStr))
{
string[] defines = definsStr.Split(';');
foreach (var define in defines)
{
options.Defines.Add(define);
}
}
}
else if (arg.StartsWith("/imports:") || arg.StartsWith("/i:"))
{
// Standard VB imports passed from project file. separator =';'
string importsStr = arg.Substring(arg.IndexOf(':') + 1);
if (!string.IsNullOrWhiteSpace(importsStr))
{
string[] imports = importsStr.Split(';');
foreach (var import in imports)
{
options.Imports.Add(import);
}
}
}
else if (arg.StartsWith("/Option")) // VB-specific options
{
if (arg.StartsWith("/OptionExplicit:"))
{
options.OptionExplicit = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/OptionStrict:"))
{
options.OptionStrict = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/OptionInfer:"))
{
options.OptionInfer = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/OptionCompare:"))
{
options.OptionCompare = arg.Substring(arg.IndexOf(':') + 1);
}
}
else if (arg.StartsWith("/MyType:")) // VB-specific option
{
options.MyType = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("/sources:") || arg.StartsWith("/src:"))
{
// C# sources passed from from project file. separator = ';'
//if (GrainClientGeneratorFlags.Verbose)
// Console.WriteLine("Orleans-CodeGen - Unpacking source file list arg={0}", arg);
var sourcesStr = arg.Substring(arg.IndexOf(':') + 1);
//if (GrainClientGeneratorFlags.Verbose)
// Console.WriteLine("Orleans-CodeGen - Splitting source file list={0}", sourcesStr);
string[] sources = sourcesStr.Split(';');
foreach (var source in sources)
{
AddSourceFile(
options.SourceFiles,
ref options.LanguageConflict,
ref options.TargetLanguage,
ref options.CodeGenFile,
source);
}
}
}
else
{
// files passed in without associated flags , we'll make the best guess.
if (arg.ToLowerInvariant().EndsWith(".snk", StringComparison.InvariantCultureIgnoreCase))
{
options.SigningKey = new FileInfo(arg);
}
else
{
AddSourceFile(
options.SourceFiles,
ref options.LanguageConflict,
ref options.TargetLanguage,
ref options.CodeGenFile,
arg);
}
}
}
if (!options.TargetLanguage.HasValue)
{
Console.WriteLine("ERROR: Unable to determine source code language to use for code generation.");
return(2);
}
// STEP 2 : Validate and calculate unspecified parameters
if (options.InputLib == null)
{
Console.WriteLine("ERROR: Orleans-CodeGen - no input file specified.");
return(2);
}
if (string.IsNullOrEmpty(options.CodeGenFile))
{
Console.WriteLine(
"ERROR: No codegen file. Add a file '{0}' to your project",
Path.Combine("Properties", "orleans.codegen.cs"));
return(2);
}
// STEP 3 : Check timestamps and skip if output is up-to-date wrt to all inputs
/* if (!bootstrap && IsProjectUpToDate(options.InputLib, options.SourceFiles, options.ReferencedAssemblies)
* && !Debugger.IsAttached)
* {
* Console.WriteLine(
* "Orleans-CodeGen - Skipping because all output files are up-to-date with respect to the input files.");
* return 0;
* }*/
options.SourcesDir = Path.Combine(options.InputLib.DirectoryName, "Generated");
// STEP 4 : Dump useful info for debugging
Console.WriteLine(
"Orleans-CodeGen - Options " + Environment.NewLine + "\tInputLib={0} " + Environment.NewLine
+ "\tSigningKey={1} " + Environment.NewLine
+ "\tCodeGenFile={2}",
options.InputLib.FullName,
options.SigningKey != null ? options.SigningKey.FullName : "",
options.CodeGenFile);
if (options.ReferencedAssemblies != null)
{
Console.WriteLine("Orleans-CodeGen - Using referenced libraries:");
foreach (string assembly in options.ReferencedAssemblies)
{
Console.WriteLine("\t{0} => {1}", Path.GetFileName(assembly), assembly);
}
}
// STEP 5 :
// if (!bootstrap) BuildInputAssembly(options);
// STEP 6 : Finally call code generation
if (!CreateGrainClientAssembly(options))
{
return(-1);
}
// DONE!
return(0);
}
catch (Exception ex)
{
Console.WriteLine("-- Code-gen FAILED -- \n{0}", TraceLogger.PrintException(ex));
return(3);
}
}
protected override void ProcessBatch(List <Message> msgs)
{
if (Log.IsVerbose2)
{
Log.Verbose2("Got {0} messages to send.", msgs.Count);
}
for (int i = 0; i < msgs.Count;)
{
bool sendThisMessage = PrepareMessageForSend(msgs[i]);
if (sendThisMessage)
{
i++;
}
else
{
msgs.RemoveAt(i); // don't advance i
}
}
if (msgs.Count <= 0)
{
return;
}
Socket sock;
string error;
SiloAddress targetSilo;
bool continueSend = GetSendingSocket(msgs[0], out sock, out targetSilo, out error);
if (!continueSend)
{
foreach (Message msg in msgs)
{
OnGetSendingSocketFailure(msg, error);
}
return;
}
List <ArraySegment <byte> > data;
int headerLength = 0;
continueSend = SerializeMessages(msgs, out data, out headerLength, OnMessageSerializationFailure);
if (!continueSend)
{
return;
}
int length = data.Sum(x => x.Count);
int bytesSent = 0;
bool exceptionSending = false;
bool countMismatchSending = false;
string sendErrorStr = null;
try
{
bytesSent = sock.Send(data);
if (bytesSent != length)
{
// The complete message wasn't sent, even though no error was reported; treat this as an error
countMismatchSending = true;
sendErrorStr = String.Format("Byte count mismatch on sending to {0}: sent {1}, expected {2}", targetSilo, bytesSent, length);
Log.Warn(ErrorCode.Messaging_CountMismatchSending, sendErrorStr);
}
}
catch (Exception exc)
{
exceptionSending = true;
if (!(exc is ObjectDisposedException))
{
sendErrorStr = String.Format("Exception sending message to {0}. {1}", targetSilo, TraceLogger.PrintException(exc));
Log.Warn(ErrorCode.Messaging_ExceptionSending, sendErrorStr, exc);
}
}
MessagingStatisticsGroup.OnMessageBatchSend(targetSilo, msgs[0].Direction, bytesSent, headerLength, GetSocketDirection(), msgs.Count);
bool sendError = exceptionSending || countMismatchSending;
if (sendError)
{
OnSendFailure(sock, targetSilo);
}
foreach (Message msg in msgs)
{
ProcessMessageAfterSend(msg, sendError, sendErrorStr);
}
}
private string MakeErrorMsg(string what, GrainReference grainReference, Exception exc)
{
string errorCode = AzureStorageUtils.ExtractRestErrorCode(exc);
return(string.Format("Error from storage provider during {0} for grain Type={1} Pk={2} Id={3} Error={4}\n {5}",
what, grainTypeName, grainReference.GrainId.ToDetailedString(), grainReference, errorCode, TraceLogger.PrintException(exc)));
}
private static void InitializeImpl_FromConfig(ClientConfiguration config)
{
if (GrainClient.IsInitialized)
{
Trace.TraceInformation("Connection to Orleans gateway silo already initialized.");
return;
}
//// Find endpoint info for the gateway to this Orleans silo cluster
//Trace.WriteLine("Searching for Orleans gateway silo via Orleans instance table...");
var deploymentId = config.DeploymentId;
var connectionString = config.DataConnectionString;
if (String.IsNullOrEmpty(deploymentId))
{
throw new ArgumentException("Cannot connect to Azure silos with null deploymentId", "config.DeploymentId");
}
if (String.IsNullOrEmpty(connectionString))
{
throw new ArgumentException("Cannot connect to Azure silos with null connectionString", "config.DataConnectionString");
}
bool initSucceeded = false;
Exception lastException = null;
for (int i = 0; i < MaxRetries; i++)
{
try
{
// Initialize will throw if cannot find Gateways
GrainClient.Initialize(config);
initSucceeded = true;
break;
}
catch (Exception exc)
{
lastException = exc;
Trace.TraceError("Client.Initialize failed with exc -- {0}. Will try again", exc.Message);
}
// Pause to let Primary silo start up and register
Trace.TraceInformation("Pausing {0} awaiting silo and gateways registration for Deployment={1}", StartupRetryPause, deploymentId);
Thread.Sleep(StartupRetryPause);
}
if (initSucceeded)
{
return;
}
OrleansException err;
err = lastException != null ? new OrleansException(String.Format("Could not Initialize Client for DeploymentId={0}. Last exception={1}",
deploymentId, lastException.Message), lastException) : new OrleansException(String.Format("Could not Initialize Client for DeploymentId={0}.", deploymentId));
Trace.TraceError("Error starting Orleans Azure client application -- {0} -- bailing. {1}", err.Message, TraceLogger.PrintException(err));
throw err;
}
private string MakeErrorMsg(string what, Exception exc)
{
var httpStatusCode = HttpStatusCode.Unused;
string errorCode = String.Empty;
var decoder = store as IRestExceptionDecoder;
if (decoder != null)
{
decoder.DecodeException(exc, out httpStatusCode, out errorCode, true);
}
GrainReference grainReference = baseGrain.GrainReference;
return(string.Format("Error from storage provider during {0} for grain Type={1} Pk={2} Id={3} Error={4}" + Environment.NewLine + " {5}",
what, grainTypeName, grainReference.GrainId.ToDetailedString(), grainReference, errorCode, TraceLogger.PrintException(exc)));
}
private string MakeErrorMsg(string what, GrainReference grainReference, Exception exc)
{
HttpStatusCode httpStatusCode;
string errorCode;
AzureStorageUtils.EvaluateException(exc, out httpStatusCode, out errorCode, true);
return string.Format("Error from storage provider during {0} for grain Type={1} Pk={2} Id={3} Error={4}" + Environment.NewLine + " {5}",
what, grainTypeName, grainReference.GrainId.ToDetailedString(), grainReference, errorCode, TraceLogger.PrintException(exc));
}
