private async Task HandleAsync(byte[] bytes, Stream stream, DecisionEngine engine)
{
Gatekeeper.LdapPacketParserLibrary.Parser parser = new Gatekeeper.LdapPacketParserLibrary.Parser();
LdapPacketParserLibrary.Models.LdapMessage message = parser.TryParsePacket(bytes);
List <LdapMessage> replies = await engine.GenerateReply(message);
foreach (LdapMessage outMsg in replies)
{
if (outMsg.ProtocolOp.GetType() == typeof(Gatekeeper.LdapServerLibrary.Models.Operations.Response.UnbindDummyResponse))
{
_clientIsConnected = false;
break;
}
byte[] msg = (new Parser.PacketParser()).TryEncodePacket(outMsg);
stream.Write(msg, 0, msg.Length);
if (outMsg.ProtocolOp.GetType() == typeof(Gatekeeper.LdapServerLibrary.Models.Operations.Response.ExtendedOperationResponse))
{
var response = ((Gatekeeper.LdapServerLibrary.Models.Operations.Response.ExtendedOperationResponse)outMsg.ProtocolOp);
if (response.ResponseName == ExtendedRequestHandler.StartTLS)
{
_useStartTls = true;
}
}
}
}
/// <summary>
/// Determines whether a merge join is possible for the specified edge.
/// </summary>
/// <param name="edge">The join edge.</param>
/// <returns>
/// <c>true</c> if a merge join is possible for the specified edge; otherwise, <c>false</c>.
/// </returns>
private bool CanDoMergeJoin(Edge edge)
{
//
// first, determine the output sort order for the left and right inputs of the join
// edge, if any exists to begin with.
long[] orderLeft;
long[] orderRight;
if (edge.Left.HasOperator)
{
orderLeft = edge.Left.Operator.GetOutputSortOrder();
}
else
{
orderLeft = edge.Left.SAP.GetScanOrdering();
}
if (edge.Right.HasOperator)
{
orderRight = edge.Right.Operator.GetOutputSortOrder();
}
else
{
orderRight = edge.Right.SAP.GetScanOrdering();
}
//
// if this ordering allows us to do a merge join, return true. otherwise, return false.
return(DecisionEngine.CanDoMergeJoin(orderLeft, orderRight));
}
/// <summary>
/// Instantiates the decision engine used during query plan generation for decision point
/// resolving.
/// </summary>
/// <param name="context">The database context.</param>
/// <returns>
/// An instantiated decision engine.
/// </returns>
private static DecisionEngine GetDecisionEngine(Database context)
{
//
// any rules that are used are hardcoded here
var de = new DecisionEngine(context);
//
// load seed rules
de.SeedRules.Add(new rs::PositionalPrioritizer()); // Rule 1
//de.SeedRules.Add(new rs::StatisticalPrioritizer()); // Rule 2
de.SeedRules.Add(new rs::RandomPicker());
//
// load join rules
de.JoinRules.Add(new rj::PatternPrioritizer()); // Rule 2
de.JoinRules.Add(new rj::MergeJoinPrioritizer()); // Rule 1
de.JoinRules.Add(new rj::LiteralPrioritizer()); // Rule 4
de.JoinRules.Add(new rj::PositionalPrioritizer()); // Rule 3
//de.JoinRules.Add(new rj::StatisticalPrioritizer()); // Rule 5
de.JoinRules.Add(new rj::RandomPicker());
return(de);
}
internal void StartReceiving()
{
Task networkTask = new Task(async() =>
{
NetworkStream unencryptedStream = Client.GetStream();
SslStream sslStream = new SslStream(unencryptedStream);
IPEndPoint?endpoint = (IPEndPoint?)Client.Client.RemoteEndPoint;
if (endpoint == null)
{
throw new Exception("IP address is null");
}
ClientContext clientContext = new ClientContext(endpoint.Address);
DecisionEngine engine = new DecisionEngine(clientContext);
bool _initializedTls = false;
while (_clientIsConnected)
{
Stream rawOrSslStream = (_useStartTls) ? sslStream : unencryptedStream;
try
{
if (_useStartTls && !_initializedTls)
{
await sslStream.AuthenticateAsServerAsync(new SslServerAuthenticationOptions
{
ServerCertificate = SingletonContainer.GetCertificate(),
});
_initializedTls = true;
}
Byte[] data = await ReadFullyAsync(rawOrSslStream);
await HandleAsync(data, rawOrSslStream, engine);
}
catch (Exception e)
{
ILogger?logger = SingletonContainer.GetLogger();
if (logger != null)
{
logger.LogException(e);
}
break;
}
}
Client.Close();
});
networkTask.Start();
}
public void DecideLoanForCorp()
{
IDecisionEngine decisionEngine = new DecisionEngine();
decisionEngine.CreditScoreSubsystem = new CreditScoreSubsystem();
decisionEngine.PartyWebService = new PartyWebService();
bool approved = decisionEngine.IsApproved(TaxidCcorpExcellent, 40000M);
Assert.IsTrue(approved, "Expected a 40k loan to be approved for this C-Corp");
}
static void Main(string[] args)
{
IDecisionEngine decisionEngine = new DecisionEngine();
decisionEngine.CreditScoreSubsystem = new CreditScoreSubsystem();
decisionEngine.PartyWebService = new PartyWebService();
bool approved = decisionEngine.IsApproved(111223333, 40000M);
Console.WriteLine("Party [111223333]" + ((approved)?" was":" was not") + " approved.");
var name = Console.ReadLine();
}
public BotPlayer(string name, int startingStack, DecisionEngine decisionEngine) : base(name, startingStack)
{
this.decisionEngine = decisionEngine;
}
