private static ClassDeclarationSyntax LinkNode(ServerInstance instance, out StatementSyntax appStatement)
{
appStatement = Templates.CallStartNode.Get <StatementSyntax>(instance.Id); //td:
var statements = new List <StatementSyntax>();
var only = Templates
.StringArray
.Get <ArrayCreationExpressionSyntax>()
.WithInitializer(StringArrayInitializer(instance.HostedClasses));
statements.Add(Templates
.StartNetMQServer
.Get <StatementSyntax>(
Roslyn.Quoted(instance.Host.Address),
Roslyn.Quoted(instance.Parent.Identity),
Roslyn.Constant(instance.Threads),
only,
instance.Id));
var result = Templates
.ServerInstance
.Get <ClassDeclarationSyntax>(instance.Id, Roslyn.Quoted(instance.Id));
var start = result
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(method => method.Identifier.ToString() == "Run" &&
method.ParameterList.Parameters.Count == 3)
.Single();
return(result
.ReplaceNode(start, start
.AddBodyStatements(statements.ToArray())));
}
private static SyntaxNode LinkServerInstance(ServerInstance app, Func <ServerModel, Scope, SyntaxNode> transform, Scope scope)
{
//a list of statements and types to be added
var statements = new List <StatementSyntax>();
foreach (var node in app.Nodes)
{
var appStatement = default(StatementSyntax);
scope.AddType(LinkNode(node, out appStatement));
if (appStatement != null)
{
statements.Add(appStatement);
}
}
//create the http start
//
var except = Templates
.StringArray
.Get <ArrayCreationExpressionSyntax>()
.WithInitializer(StringArrayInitializer(app
.Nodes
.SelectMany(node => node.HostedClasses)));
//find functional filters
var filters = new List <ExpressionSyntax>();
if (app.SQL != null)
{
var connectionString = default(ExpressionSyntax);
if (app.SQL.ConnectionString != null)
{
Debug.Assert(app.SQL.ConnectionId == null);
connectionString = Roslyn.Quoted(app.SQL.ConnectionString);
}
else
{
Debug.Assert(app.SQL.ConnectionId != null);
connectionString = Templates
.SqlConnectionStringFromConfig
.Get <ExpressionSyntax>(
Roslyn.Quoted(app.SQL.ConnectionId));
}
var connectionClass = app.SQL.ConnectionInstantiator ?? "SqlConnection";
filters.Add(Templates
.SqlFilter
.Get <ExpressionSyntax>(
connectionString,
CSharp.IdentifierName(connectionClass)));
}
filters.Add(Templates.UserFilter);
//start the server
statements.Add(Templates
.StartHttpServer
.Get <StatementSyntax>(
Roslyn.Quoted(app.Host.Address),
Roslyn.Quoted(app.Identity),
Roslyn.Quoted(app.StaticFiles, escaped: true),
Roslyn.Constant(app.Threads),
except,
Roslyn.Constant(app.Nodes.Count),
app.Id,
Templates
.EmptyArray
.WithInitializer(CSharp.InitializerExpression(
SyntaxKind.ArrayInitializerExpression, CSharp.SeparatedList(
filters)))));
//generate configuration class
var result = Templates
.ServerInstance
.Get <ClassDeclarationSyntax>(app.Id, Roslyn.Quoted(app.Id));
var runMethods = result
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(method => method.Identifier.ToString() == "Run");
return(result.ReplaceNodes(runMethods,
(on, nn) => nn.AddBodyStatements(statements.ToArray())));
}
private static Func <SyntaxNode, Scope, SyntaxNode> CompileApp(Options options)
{
var compileObject = CompileObject(options);
return((node, scope) =>
{
var result = (node as ClassDeclarationSyntax)
.WithModifiers(CSharp.TokenList(
CSharp.Token(SyntaxKind.PublicKeyword)));
var main = result
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(method => method.Identifier.ToString() == "main")
.SingleOrDefault();
if (main != null)
{
result = result.ReplaceNode(main, CompileAppMain(main, options));
}
else
{
Debug.Assert(false, "concurrent app must have main"); //td: error
}
if (options.GenerateAppProgram)
{
scope.AddType(Templates.AppProgram.Get <ClassDeclarationSyntax>());
}
//convert to concurrent object
result = (ClassDeclarationSyntax)compileObject(result, scope);
//add a way for this app to run, stop and await completion
var runner = null as Func <BlockSyntax, MemberDeclarationSyntax>;
if (options.GenerateAppConstructor)
{
runner = body => CSharp.ConstructorDeclaration("__app")
.WithModifiers(CSharp.TokenList(
CSharp.Token(SyntaxKind.StaticKeyword)))
.WithBody(body);
}
else
{
runner = body => Templates.AppRun.WithBody(options.GenerateAppProgram
? CSharp.Block(new StatementSyntax[] { Templates.AppAssignArguments }
.Union(body.Statements))
: body);
}
return result.AddMembers(
runner(Templates.AppThreaded
.Get <BlockSyntax>(
Roslyn.Constant(options.ThreadCount),
Roslyn.Constant(options.BlockUntilNextEvent),
options.AsFastAsPossible
? Templates.HighPriority
: Templates.NormalPriority)),
Templates.AppArguments,
Templates.AppStop,
Templates.AppAwait);
});
}
