private static bool ExecuteSqlScript(ConnectionProvider provider, string scriptFile)
{
if (!File.Exists(scriptFile))
{
stdio.ErrorFormat("no input file found : {0}", scriptFile);
return false;
}
stdio.WriteLine("Execute {0}", scriptFile);
var script = new SqlScript(provider, scriptFile);
script.Reported += (sender, e) =>
{
// stdio.WriteLine("processed: {0}>{1}", e.Value1, e.Value2);
};
bool hasError = false;
script.Error += (sender, e) =>
{
hasError = true;
stdio.ErrorFormat("line:{0}, {1}, SQL:{2}", e.Line, e.Exception.Message, e.Command);
};
Func<bool> stopOnError = () =>
{
return !stdio.YesOrNo("are you sure to contune (yes/no)?:");
};
script.Execute(stopOnError);
stdio.WriteLine("completed to run {0}", scriptFile);
return !hasError;
}
public RiaDbConnection(ConnectionProvider provider)
{
this.Provider = provider;
this.ConnectionString = Provider.ConnectionString;
this.DataSource = Provider.DataSource;
this.database = Provider.InitialCatalog;
}
public static RemoveTextPacket Create(ConnectionProvider connection, string TextName)
{
PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.RemoveText);
p.AddString(TextName);
return new RemoveTextPacket(connection, p.GetPacket());
}
public static InjectDisplayPacket Create(ConnectionProvider connection, bool Injected)
{
PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.InjectDisplayText);
p.AddByte(Convert.ToByte(Injected));
return new InjectDisplayPacket(connection, p.GetPacket());
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageProvider"/> class.
/// </summary>
/// <param name="connection">The connection.</param>
public MessageProvider(ConnectionProvider connection)
{
Connection = connection;
Server = new Actions.Messages.Server(connection);
System = new Actions.Messages.System(connection);
Screen = new Actions.Messages.Screen(connection);
}
/// <summary>
/// Initializes a new instance of the <see cref="Slot"/> class.
/// </summary>
/// <param name="address">The address.</param>
/// <param name="connection">The connection.</param>
/// <param name="id">The id.</param>
public Slot(uint address, ConnectionProvider connection, InventoryID id)
{
this.address = address;
this.id = id;
this.memory = connection.Memory;
this.connection = connection;
}
public SqlEditor(Configuration cfg, ConnectionProvider provider, FileLink link)
{
InitializeComponent(cfg);
this.cfg = cfg;
this.provider = provider;
textBox.Document.Blocks.Clear();
if (link != null)
{
this.link = link;
string text = link.ReadAllText();
textBox.Document.Blocks.Add(new Paragraph(new Run(text)));
}
else
{
this.link = FileLink.CreateLink(untitled);
}
UpdateTitle();
tabControl.SelectionChanged += TabControl_SelectionChanged;
textBox.SelectionChanged += TextBox_SelectionChanged;
textBox.TextChanged += TextBox_TextChanged;
textBox.Focus();
}
public static RemoveCreatureTextPacket Create(ConnectionProvider connection, int CreatureID, string CreatureName)
{
PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.RemoveCreatureText);
p.AddLong(CreatureID);
p.AddString(CreatureName);
return new RemoveCreatureTextPacket(connection, p.GetPacket());
}
public Item(Slot slot)
{
Slot = slot;
connection = slot.Connection;
if (slot.Item.Id > 0) {
base.Id = slot.Item.Id;
}
}
/// <summary>
/// Binds the packet.
/// </summary>
/// <param name="encryptedData">The encrypted data.</param>
/// <param name="connection">The connection.</param>
/// <param name="cripto">The cripto.</param>
/// <returns></returns>
public static Packet BindPacket(byte[] data, ConnectionProvider connection)
{
return new Packet {
Data = data,
ConnectionSource = connection,
InterceptedDate = DateTime.Now,
};
}
public SqlScript(ConnectionProvider provider, string scriptFile)
{
this.provider = provider;
this.scriptFile = scriptFile;
if (!File.Exists(scriptFile))
throw new FileNotFoundException("cannot find file", scriptFile);
}
/// <summary>
/// Initializes a new instance of the <see cref="Slot"/> class.
/// </summary>
/// <param name="address">The address.</param>
/// <param name="ownerContainer">The owner container.</param>
/// <param name="position">The position.</param>
public Slot(uint address, IContainer ownerContainer, int position)
{
this.address = address;
this.container = ownerContainer;
this.position = position;
id = InventoryID.Container;
memory = Container.Memory;
connection = Container.Connection;
}
public XmlDbConnection(ConnectionProvider provider)
{
this.Provider = provider;
this.ConnectionString = Provider.ConnectionString;
this.DataSource = Provider.DataSource;
this.database = Provider.InitialCatalog;
this.FileLink = FileLink.CreateLink(provider.DataSource, provider.UserId, provider.Password);
}
/// <summary>
/// Binds the packet.
/// </summary>
/// <param name="encryptedData">The encrypted data.</param>
/// <param name="interceptedDate">The intercepted date.</param>
/// <param name="connection">The connection.</param>
/// <param name="source">The source.</param>
/// <param name="cripto">The cripto.</param>
/// <returns></returns>
public static Packet BindPacket(byte[] encryptedData, DateTime interceptedDate, ConnectionProvider connection, PacketSource source)
{
return new Packet {
EncryptedData = encryptedData,
ConnectionSource = connection,
InterceptedDate = interceptedDate,
PacketSource = source,
};
}
public override int Fill(DataSet dataSet)
{
command = (XmlDbCommand)this.SelectCommand;
connection = (XmlDbConnection)command.Connection;
provider = connection.Provider;
string sql = command.CommandText;
TableName tname = getTableName(sql);
return FillDataTable(tname, dataSet);
}
public static UpdateCreatureTextPacket Create(ConnectionProvider connection, int CreatureID, string CreatureName, Location TextLoc, string NewText)
{
PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.UpdateCreatureText);
p.AddLong(CreatureID);
p.AddString(CreatureName);
p.AddShort(TextLoc.X);
p.AddShort(TextLoc.Y);
p.AddString(NewText);
return new UpdateCreatureTextPacket(connection, p.GetPacket());
}
protected virtual bool IsSupported (ConnectionProvider provider)
{
if (HasFlag (InstrumentationConnectionFlags.RequireMonoClient) && !SupportsMonoExtensions (provider))
return false;
if (HasFlag (InstrumentationConnectionFlags.RequireEcDhe) && !SupportsEcDhe (provider))
return false;
if ((provider.Flags & ConnectionProviderFlags.SupportsTls12) == 0)
return false;
return true;
}
public void Update(string name, string value, int id)
{
using (var client = new HttpClient(_messageHandler))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var connectionProvider = new ConnectionProvider(id, name, value);
var response = client.PutAsync(UrlBase, connectionProvider, new JsonMediaTypeFormatter()).Result;
response.EnsureSuccessStatusCode();
}
}
public ActionResult Edit(int id, ConnectionProvider connectionProvider)
{
try
{
_dbConnectionProviderRepository.Update(connectionProvider);
return RedirectToAction("Index");
}
catch
{
return View(connectionProvider);
}
}
public ActionResult Create(ConnectionProvider connectionProvider)
{
try
{
_dbConnectionProviderRepository.Insert(connectionProvider);
return RedirectToAction("Index");
}
catch
{
return View(connectionProvider);
}
}
public DbProvider(string script, ConnectionProvider provider)
{
this.script = script;
this.provider = provider;
this.DbConnection = this.provider.NewDbConnection;
this.DbCommand = NewDbCommand();
if (this.script.Contains(" ")) //Stored Procedure Name does not contain a space letter
this.DbCommand.CommandType = CommandType.Text;
else
this.DbCommand.CommandType = CommandType.StoredProcedure;
}
public void DeleteRedemption(int nTransactionID, int qtyOfItemToRestoreAfterDelete)
{
TblRewardsTransaction rewardTrans = new TblRewardsTransaction();
rewardTrans.NTransactionID = nTransactionID;
rewardTrans.SelectOne();
if (rewardTrans.NTypeID != 2 || (Convert.ToDateTime(rewardTrans.DtDate.Value).Date != DateTime.Now.Date && ACMSLogic.User.RightsLevelID != 9000))
throw new Exception("You have no right to delete this record. It is not a redemption or the redemption date is before today. ");
string itemCode = rewardTrans.StrReferenceNo.IsNull ? "" : rewardTrans.StrReferenceNo.Value;
//TblProductInventory productInvent = new TblProductInventory();
//productInvent.StrProductCode = itemCode;
//productInvent.SelectOne();
//productInvent.NQuantity = ACMS.Convert.ToInt32(productInvent.NQuantity) + qtyOfItemToRestoreAfterDelete;
ACMSDAL.ConnectionProvider connProvider = new ConnectionProvider();
try
{
rewardTrans.MainConnectionProvider = connProvider;
//productInvent.MainConnectionProvider = connProvider;
connProvider.OpenConnection();
connProvider.BeginTransaction("DeleteRedemption");
rewardTrans.Delete();
//productInvent.Update();
connProvider.CommitTransaction();
}
catch (Exception)
{
connProvider.RollbackTransaction("DeleteRedemption");
throw;
}
finally
{
if (connProvider.CurrentTransaction != null)
connProvider.CurrentTransaction.Dispose();
if (connProvider.DBConnection != null)
{
if (connProvider.DBConnection.State == ConnectionState.Open)
connProvider.DBConnection.Close();
}
rewardTrans.MainConnactionIsCreatedLocal = true;
//productInvent.MainConnactionIsCreatedLocal = true;
}
}
public void FirstThrowsSocketUsesSecondAndWorksTwice()
{
var d1 = new DummyConnectionFactoryWrapper(new SocketException(123));
var d2 = new DummyConnectionFactoryWrapper(true);
var cp = new ConnectionProvider(d2, d1);
var connection = cp.GetConnection();
Assert.NotNull(connection);
var connection2 = cp.GetConnection();
Assert.NotNull(connection2);
}
public static DisplayTextPacket Create(ConnectionProvider connection, string textId, Location loc, Color color, ClientFont font, string text)
{
PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.DisplayText);
p.AddString(textId);
p.AddInt(loc.X.ToInt32());
p.AddInt(loc.Y.ToInt32());
p.AddInt(color.R);
p.AddInt(color.G);
p.AddInt(color.B);
p.AddInt((int)font);
p.AddString(text);
return new DisplayTextPacket(connection, p.GetPacket());
}
public void FirstConnectionNoyOpenUsesSecondAndWorksTwice()
{
var d1 = new DummyConnectionFactoryWrapper(false);
var d2 = new DummyConnectionFactoryWrapper(true);
var cp = new ConnectionProvider(d2, d1);
var connection = cp.GetConnection();
Assert.NotNull(connection);
var connection2 = cp.GetConnection();
Assert.NotNull(connection2);
Assert.Equal(1, d1.NumberOfTimesCalled);
}
public static DisplayCreatureTextPacket Create(ConnectionProvider connection, int creatureID, string creatureName, Location loc, Color color, ClientFont font, string text)
{
PipePacketBuilder p = new PipePacketBuilder(connection, PipePacketType.DisplayCreatureText);
p.AddLong(creatureID);
p.AddString(creatureName);
p.AddShort(loc.X);
p.AddShort(loc.Y);
p.AddInt(color.R);
p.AddInt(color.G);
p.AddInt(color.B);
p.AddInt((int)font);
p.AddString(text);
return new DisplayCreatureTextPacket(connection, p.GetPacket());
}
public bool Delete(int creditPackageID)
{
myCreditPkg.NCreditPackageID = creditPackageID;
myCreditPkg.SelectOne();
myCreditPkg.NStatusID = 2;
TblAudit audit = new TblAudit();
audit.NAuditTypeID = AuditTypeID.DeleteMemberCreditPackage;
audit.NEmployeeID = User.EmployeeID;
audit.StrAuditEntry = " Delete member credit Package " + creditPackageID.ToString();
audit.StrReference = creditPackageID.ToString();
ACMSDAL.ConnectionProvider connProvider = new ConnectionProvider();
try
{
myCreditPkg.MainConnectionProvider = connProvider;
audit.MainConnectionProvider = connProvider;
connProvider.OpenConnection();
connProvider.BeginTransaction("DeleteMemberCreditPackage");
myCreditPkg.Update();
audit.Insert();
connProvider.CommitTransaction();
return true;
}
catch (Exception)
{
connProvider.RollbackTransaction("DeleteMemberCreditPackage");
throw;
}
finally
{
if (connProvider.CurrentTransaction != null)
connProvider.CurrentTransaction.Dispose();
if (connProvider.DBConnection != null)
{
if (connProvider.DBConnection.State == ConnectionState.Open)
connProvider.DBConnection.Close();
}
myCreditPkg.MainConnactionIsCreatedLocal = true;
audit.MainConnactionIsCreatedLocal = true;
}
}
public XmlDbSchemaProvider(ConnectionProvider provider)
: base(provider)
{
var link = FileLink.CreateLink(provider.DataSource, provider.UserId, provider.Password);
dbSchema = new DataSet();
try
{
link.ReadXml(dbSchema);
if (dbSchema.Tables.Count == 0)
throw new Exception(string.Format("error in xml schema file: {0}", provider));
}
catch (Exception)
{
throw new Exception($"bad data source defined {provider.DataSource}");
}
}
public bool Delete(int nCaseID)
{
ACMSDAL.ConnectionProvider connProvider = new ConnectionProvider();
try
{
myCase.MainConnectionProvider = connProvider;
myCaseAction.MainConnectionProvider = connProvider;
connProvider.OpenConnection();
connProvider.BeginTransaction("CancelMemberPackage");
myCase.NCaseID = nCaseID;
myCaseAction.NCaseID = nCaseID;
myCaseAction.DeleteAllWnCaseIDLogic();
myCase.Delete();
connProvider.CommitTransaction();
return true;
}
catch (Exception)
{
connProvider.RollbackTransaction("DeleteCase");
throw;
}
finally
{
if (connProvider.CurrentTransaction != null)
connProvider.CurrentTransaction.Dispose();
if (connProvider.DBConnection != null)
{
if (connProvider.DBConnection.State == ConnectionState.Open)
connProvider.DBConnection.Close();
//connProvider.DBConnection.Dispose();
}
myCase.MainConnactionIsCreatedLocal = true;
myCaseAction.MainConnactionIsCreatedLocal = true;
}
}
public override int Fill(DataSet dataSet)
{
command = (RiaDbCommand)this.SelectCommand;
connection = (RiaDbConnection)command.Connection;
provider = connection.Provider;
var parameters = this.GetFillParameters();
RemoteInvoke agent = new RemoteInvoke(new Uri(provider.DataSource));
string sql = command.CommandText;
string code = $"var cmd=new tw.Common.SqlCmdDirect('{sql}');ds=cmd.FillDataSet();";
agent.Execute(code);
var ds = agent.GetValue<DataSet>("ds");
if (ds != null)
{
foreach (DataTable dt in ds.Tables)
{
dataSet.Tables.Add(dt.Copy());
}
}
return 0;
}
public HandShake(ILogger <HandShake> logger, ConnectionProvider connectionProvider, IConfiguration configuration)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_connection = connectionProvider?.Connection;
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
}
public InsertBookQuery(ConnectionProvider provider)
: base(provider)
{
}
protected override ClientAndServerProvider Create(ConnectionProvider client, ConnectionProvider server)
{
return(new InstrumentationConnectionProvider(client, server, Category, Flags));
}
/*const string Query = @"select
* r.rubric_id, r.rubric_name, r.rubric_description,
* r.rubric_parent_id, p.rubric_name as parent_name, p.rubric_description as parent_description
* from rubric r
* left join rubric p on r.rubric_parent_id = p.rubric_id
* start with r.rubric_parent_id is null
* connect by prior r.rubric_id = r.rubric_parent_id
* order siblings by r.rubric_name";*/
public GetRubricsQuery(ConnectionProvider provider)
: base(provider)
{
}
private static void FindNameOnSqlServer(ConnectionProvider provider, string match)
{
bool found = false;
string sql = "SELECT name AS TableName FROM sys.tables";
var dt = new SqlCmd(provider, sql).FillDataTable();
Search(match, dt, "TableName");
if (dt.Rows.Count != 0)
{
found = true;
cout.WriteLine(ConsoleColor.Cyan, "Table Names");
dt.ToConsole();
}
;
sql = @"
SELECT
s.name as SchemaName,
t.name as TableName,
c.name AS ColumnName,
ty.name AS DataType,
c.max_length AS Length,
CASE c.is_nullable WHEN 0 THEN 'NOT NULL' WHEN 1 THEN 'NULL' END AS Nullable
FROM sys.tables t
INNER JOIN sys.columns c ON t.object_id = c.object_id
INNER JOIN sys.types ty ON ty.system_type_id =c.system_type_id AND ty.name<>'sysname'
LEFT JOIN sys.Computed_columns d ON t.object_id = d.object_id AND c.name = d.name
INNER JOIN sys.schemas s ON s.schema_id=t.schema_id
ORDER BY c.name, c.column_id
";
dt = new SqlCmd(provider, sql).FillDataTable();
Search(match, dt, "ColumnName");
if (dt.Rows.Count != 0)
{
found = true;
cout.WriteLine(ConsoleColor.Cyan, "Table Columns");
dt.ToConsole();
}
;
sql = @"SELECT SCHEMA_NAME(schema_id) SchemaName, name AS ViewName FROM sys.views ORDER BY name";
dt = new SqlCmd(provider, sql).FillDataTable();
Search(match, dt, "ViewName");
if (dt.Rows.Count != 0)
{
found = true;
cout.WriteLine(ConsoleColor.Cyan, "View Names");
dt.ToConsole();
}
sql = @"
SELECT
VCU.TABLE_NAME AS ViewName,
COL.COLUMN_NAME AS ColumnName,
COL.DATA_TYPE,
COL.IS_NULLABLE
FROM INFORMATION_SCHEMA.VIEW_COLUMN_USAGE AS VCU
JOIN INFORMATION_SCHEMA.COLUMNS AS COL
ON COL.TABLE_SCHEMA = VCU.TABLE_SCHEMA
AND COL.TABLE_CATALOG = VCU.TABLE_CATALOG
AND COL.TABLE_NAME = VCU.TABLE_NAME
AND COL.COLUMN_NAME = VCU.COLUMN_NAME" ;
dt = new SqlCmd(provider, sql).FillDataTable();
Search(match, dt, "ColumnName");
if (dt.Rows.Count != 0)
{
found = true;
cout.WriteLine(ConsoleColor.Cyan, "View Columns");
dt.ToConsole();
}
if (!found)
{
cout.WriteLine("nothing is found");
}
}
public List <T> FindPath(T start, T goal)
{
if (start == null)
{
return(null);
}
if (goal == null)
{
return(null);
}
this.Goal = goal;
gScore = new Dictionary <T, float>();
fScore = new Dictionary <T, float>();
//var openset = new HashSet<T>();
var openset = new FibonacciQueue <T, float>(d => fScore[d]);
var closedset = new HashSet <T>();
cameFrom = new Dictionary <T, T>();
//came_from := the empty map // The map of navigated nodes.
gScore[start] = 0; // Cost from start along best known path.
// Estimated total cost from start to goal through y.
fScore[start] = gScore[start] + ConnectionProvider.GetHeuristicCostEstimate(start, goal);
openset.Enqueue(start);
onBegin();
while (openset.Count > 0)
{
var current = openset.Dequeue();
onSelectNode(current);
if (StopCondition(current))
{
return(reconstruct_reverse_path(cameFrom, current).Reverse().ToList());
}
if (current.Equals(goal))
{
return(reconstruct_reverse_path(cameFrom, goal).Reverse().ToList());
}
closedset.Add(current); //add current to closedset
foreach (var neighbor in ConnectionProvider.GetConnectedNodes(this, current))
{
if (closedset.Contains(neighbor))
{
continue;
}
var tentative_g_score = gScore[current] + ConnectionProvider.GetCost(current, neighbor);
if (openset.Contains(neighbor) && !(tentative_g_score <= gScore[neighbor]))
{
continue;
}
cameFrom[neighbor] = current;
gScore[neighbor] = tentative_g_score;
fScore[neighbor] = gScore[neighbor] + ConnectionProvider.GetHeuristicCostEstimate(neighbor, goal);
if (openset.Contains(neighbor))
{
continue;
}
openset.Enqueue(neighbor);
onEnqueueNode(neighbor);
}
}
return(null);
}
/// <summary>
/// Register database connection provider
/// </summary>
public static void RegisterConnectionProvider()
{
ConnectionProvider.Register(ProviderName, CreateSqlCeProvider);
}
public InstrumentationConnectionProvider(ConnectionProvider client, ConnectionProvider server, InstrumentationCategory category, InstrumentationConnectionFlags flags)
: base(client, server, string.Format("{0}:{1}:{2}{3}", client.Name, server.Name, category, GetFlagsName(flags)))
{
Category = category;
Flags = flags;
}
static void Main(string[] args)
{
Console.WriteLine("Server starting...");
var connectionOpitions = new ConnectionOpitions(true, new TimeSpan(0, 0, 10), new TimeSpan(0, 0, 15));
provider = new ConnectionProvider(IPAddress.Any, 8888, 10, connectionOpitions);
provider.OnConnectionsCountChanged += ReDrawUI;
provider.OnIncomingConnection += OnIncomingConnection;
database = new Database("CardCollectiveUsersDatabase", Directory.GetCurrentDirectory());
//init
var spells = new List <Pair <Container, Info> >()
{
new Pair <Container, Info>(new SpellCard(10, new List <Modifier>()
{
new Modifier(typeof(Destroyable), "DeltaHealth", new object[] { 5 })
}), new Info("Healing potion", "restores 5 units of health")),
new Pair <Container, Info>(new SpellCard(10, new List <Modifier>()
{
new Modifier(typeof(Attacker), "DeltaPower", new object[] { 5 })
}), new Info("Warming up potion", "restores 5 units of attack power")),
new Pair <Container, Info>(new SpellCard(10, new List <Modifier>()
{
new Modifier(typeof(Destroyable), "DeltaHealth", new object[] { -5 })
}), new Info("Destructive potion", "damages 5 units of health")),
};
var soliders = new List <Pair <Container, Info> >()
{
new Pair <Container, Info>(new SoliderCard(5, 10, 10, 5, 1), new Info("Peasant", "a peasant from a nearby village, a weak but cheap unit")),
new Pair <Container, Info>(new SoliderCard(10, 5, 5, 15, 1), new Info("Militiaman", "a peasant from a nearby village, not so weak but cheap unit")),
new Pair <Container, Info>(new SoliderCard(15, 10, 10, 25, 1), new Info("Old man", "in a long-standing war he killed people")),
new Pair <Container, Info>(new SoliderCard(15, 30, 30, 10, 1), new Info("Strong peasant", "young, strong, able to hold back the pressure for a long time")),
new Pair <Container, Info>(new SoliderCard(20, 40, 40, 10, 1), new Info("Warrior", "at least he has a real sword")),
new Pair <Container, Info>(new SoliderCard(25, 30, 30, 40, 1), new Info("Trained warrior", "knows where to hit to kill")),
new Pair <Container, Info>(new SoliderCard(30, 40, 40, 50, 1), new Info("Veteran", "he saw blood liters")),
new Pair <Container, Info>(new SoliderCard(35, 60, 60, 60, 1), new Info("Mercenary", "on your side while you have money")),
new Pair <Container, Info>(new SoliderCard(40, 75, 75, 75, 1), new Info("Knight", "elite, heavily armored, very expensive")),
new Pair <Container, Info>(new SoliderCard(50, 100, 100, 100, 1), new Info("Paladin", "best of the best, capable of almost everything")),
new Pair <Container, Info>(new CasterSoliderCard(40, 20, 20, 5, 1, 25, 25, new List <SpellCard>()
{
new SpellCard(10, new List <Modifier>()
{
new Modifier(typeof(Destroyable), "DeltaHealth", new object[] { 5 })
}),
new SpellCard(10, new List <Modifier>()
{
new Modifier(typeof(Attacker), "DeltaPower", new object[] { 5 })
}),
new SpellCard(10, new List <Modifier>()
{
new Modifier(typeof(Destroyable), "DeltaHealth", new object[] { -5 })
})
}), new Info("Witch", "creates spells on the battlefield")),
};
//init
supervisor = new Supervisor(soliders, spells, database, 10, 10);
provider.AllowNewConnections = true;
Console.WriteLine("Server in work...");
while (Console.ReadLine() != "stop")
{
;
}
}
/// <inheritdoc />
public virtual async Task <MessageJournalReadResult> Read(MessageJournalPosition start, int count, MessageJournalFilter filter = null, CancellationToken cancellationToken = default(CancellationToken))
{
var myFilter = filter ?? new MessageJournalFilter();
var next = start;
var journaledMessages = new List <MessageJournalEntry>();
var endOfJournal = true;
var connection = ConnectionProvider.GetConnection();
try
{
var commandBuilder = CommandBuilders.NewSelectJournaledMessagesCommandBuilder();
commandBuilder.Categories = myFilter.Categories.Select(c => (string)c).ToList();
commandBuilder.Topics = myFilter.Topics.Select(t => (string)t).ToList();
commandBuilder.From = myFilter.From;
commandBuilder.To = myFilter.To;
commandBuilder.Origination = myFilter.Origination;
commandBuilder.Destination = myFilter.Destination;
commandBuilder.RelatedTo = myFilter.RelatedTo;
commandBuilder.MessageName = myFilter.MessageName;
commandBuilder.Start = ((SQLMessageJournalPosition)start).Id;
commandBuilder.Count = count + 1;
using (var scope = new TransactionScope(TransactionScopeOption.Required, TransactionScopeAsyncFlowOption.Enabled))
{
using (var command = commandBuilder.BuildDbCommand(connection))
{
using (var reader = await command.ExecuteReaderAsync(cancellationToken))
{
while (await reader.ReadAsync(cancellationToken))
{
var record = commandBuilder.BuildJournaledMessageRecord(reader);
next = new SQLMessageJournalPosition(record.Id);
if (journaledMessages.Count < count)
{
var category = record.Category;
var timestamp = record.Timestamp;
var headers = DeserializeHeaders(record.Headers);
var messageContent = record.Content;
var offset = new SQLMessageJournalPosition(record.Id);
var message = new Message(headers, messageContent);
var journaledMessage = new MessageJournalEntry(category, offset, timestamp, message);
journaledMessages.Add(journaledMessage);
next = new SQLMessageJournalPosition(record.Id + 1);
}
else
{
endOfJournal = false;
}
}
}
}
scope.Complete();
}
}
finally
{
ConnectionProvider.ReleaseConnection(connection);
}
return(new MessageJournalReadResult(start, next, endOfJournal, journaledMessages));
}
public InstrumentationConnectionProvider(ConnectionProvider client, ConnectionProvider server, InstrumentationCategory category, InstrumentationConnectionFlags flags)
: base(client, server, (MonoConnectionTestCategory)category, (MonoConnectionTestFlags)flags)
{
}
static bool SupportsTls12(ConnectionProvider provider)
{
return((provider.Flags & ConnectionProviderFlags.SupportsTls12) != 0);
}
/// <summary>
/// The base implementation of this method opens and disposes a connection internally.
/// </summary>
/// <param name="query">The query.</param>
/// <returns></returns>
public override DataSet ExecuteQueryDataSet(string query)
{
return(ExecuteQueryDataSet(query, ConnectionProvider.GetConnection()));
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <Core.IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2));
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// ICloudConnectionProvider
builder.Register(c => new CloudConnectionProvider(c.Resolve <Core.IMessageConverterProvider>(), this.connectionPoolSize, c.Resolve <IClientProvider>(), this.upstreamProtocol))
.As <ICloudConnectionProvider>()
.SingleInstance();
if (this.isStoreAndForwardEnabled || this.cacheTokens)
{
// Detect system environment
builder.Register(c => new SystemEnvironment())
.As <ISystemEnvironment>()
.SingleInstance();
// DataBase options
builder.Register(c => new Storage.RocksDb.RocksDbOptionsProvider(c.Resolve <ISystemEnvironment>(), this.optimizeForPerformance))
.As <Storage.RocksDb.IRocksDbOptionsProvider>()
.SingleInstance();
// IDbStore
builder.Register(
c =>
{
var loggerFactory = c.Resolve <ILoggerFactory>();
ILogger logger = loggerFactory.CreateLogger(typeof(RoutingModule));
if (this.usePersistentStorage)
{
// Create partitions for messages and twins
var partitionsList = new List <string> {
Core.Constants.MessageStorePartitionKey, Core.Constants.TwinStorePartitionKey, Core.Constants.CheckpointStorePartitionKey
};
try
{
IDbStoreProvider dbStoreprovider = Storage.RocksDb.DbStoreProvider.Create(c.Resolve <Storage.RocksDb.IRocksDbOptionsProvider>(),
this.storagePath, partitionsList);
logger.LogInformation($"Created persistent store at {this.storagePath}");
return(dbStoreprovider);
}
catch (Exception ex) when(!ExceptionEx.IsFatal(ex))
{
logger.LogError(ex, "Error creating RocksDB store. Falling back to in-memory store.");
return(new InMemoryDbStoreProvider());
}
}
else
{
logger.LogInformation($"Using in-memory store");
return(new InMemoryDbStoreProvider());
}
})
.As <IDbStoreProvider>()
.SingleInstance();
}
// Task<ICredentialsStore>
builder.Register(async c =>
{
if (this.cacheTokens)
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IEncryptionProvider encryptionProvider = await this.workloadUri.Map(
async uri => await EncryptionProvider.CreateAsync(
this.storagePath,
new Uri(uri),
Service.Constants.WorkloadApiVersion,
this.edgeModuleId,
this.edgeModuleGenerationId.Expect(() => new InvalidOperationException("Missing generation ID")),
Service.Constants.InitializationVectorFileName) as IEncryptionProvider)
.GetOrElse(() => Task.FromResult <IEncryptionProvider>(NullEncryptionProvider.Instance));
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IEntityStore <string, string> tokenCredentialsEntityStore = storeProvider.GetEntityStore <string, string>("tokenCredentials");
return(new TokenCredentialsStore(tokenCredentialsEntityStore, encryptionProvider));
}
else
{
return(new NullCredentialsStore() as ICredentialsStore);
}
})
.As <Task <ICredentialsStore> >()
.SingleInstance();
// IConnectionManager
builder.Register(c => new ConnectionManager(c.Resolve <ICloudConnectionProvider>(), this.maxConnectedClients))
.As <IConnectionManager>()
.SingleInstance();
// IEndpointFactory
builder.Register(c => new EndpointFactory(c.Resolve <IConnectionManager>(), c.Resolve <Core.IMessageConverter <IRoutingMessage> >(), this.edgeDeviceId))
.As <IEndpointFactory>()
.SingleInstance();
// RouteFactory
builder.Register(c => new EdgeRouteFactory(c.Resolve <IEndpointFactory>()))
.As <RouteFactory>()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// ITwinManager
builder.Register(c => TwinManager.CreateTwinManager(c.Resolve <IConnectionManager>(), c.Resolve <IMessageConverterProvider>(), Option.None <IStoreProvider>()))
.As <ITwinManager>()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// ICheckpointStore
builder.Register(c => CheckpointStore.Create(c.Resolve <IDbStoreProvider>()))
.As <ICheckpointStore>()
.SingleInstance();
// IMessageStore
builder.Register(
c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue);
return(messageStore);
})
.As <IMessageStore>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(
c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = c.Resolve <IMessageStore>();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// ITwinManager
builder.Register(c => TwinManager.CreateTwinManager(c.Resolve <IConnectionManager>(), c.Resolve <IMessageConverterProvider>(), Option.Some <IStoreProvider>(new StoreProvider(c.Resolve <IDbStoreProvider>()))))
.As <ITwinManager>()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<ICloudProxy> "EdgeHubCloudProxy"
builder.Register(
async c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var connectionManager = c.Resolve <IConnectionManager>();
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(edgeHubCredentials);
if (!cloudProxyTry.Success)
{
throw new EdgeHubConnectionException("Edge hub is unable to connect to IoT Hub", cloudProxyTry.Exception);
}
ICloudProxy cloudProxy = cloudProxyTry.Value;
return(cloudProxy);
})
.Named <Task <ICloudProxy> >("EdgeHubCloudProxy")
.SingleInstance();
// IInvokeMethodHandler
builder.Register(c => new InvokeMethodHandler(c.Resolve <IConnectionManager>()))
.As <IInvokeMethodHandler>()
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
Router router = await c.Resolve <Task <Router> >();
IEdgeHub hub = new RoutingEdgeHub(router, c.Resolve <Core.IMessageConverter <IRoutingMessage> >(), c.Resolve <IConnectionManager>(),
c.Resolve <ITwinManager>(), this.edgeDeviceId, c.Resolve <IInvokeMethodHandler>());
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null;
Router router = await c.Resolve <Task <Router> >();
var configUpdater = new ConfigUpdater(router, messageStore);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
var routeFactory = c.Resolve <RouteFactory>();
if (this.useTwinConfig)
{
var connectionManager = c.Resolve <IConnectionManager>();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManager = c.Resolve <ITwinManager>();
ICloudProxy cloudProxy = await c.ResolveNamed <Task <ICloudProxy> >("EdgeHubCloudProxy");
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConfigSource edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials,
edgeHub,
twinManager,
connectionManager,
cloudProxy,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
this.versionInfo
);
return(edgeHubConnection);
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConnectionProvider connectionProvider = new ConnectionProvider(c.Resolve <IConnectionManager>(), edgeHub);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
/// <summary>
/// Drop and re-create statunit search view
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
public static void CreateViewsProceduresAndFunctions(NSCRegDbContext context, ConnectionProvider provider, ReportingSettings reportingSettings = null)
{
IDbInitializer initializer;
switch (provider)
{
case ConnectionProvider.InMemory: initializer = new InMemoryDbInitializer();
break;
case ConnectionProvider.SqlServer: initializer = new MsSqlDbInitializer();
break;
case ConnectionProvider.PostgreSql: initializer = new PostgreSqlDbInitializer();
break;
case ConnectionProvider.MySql: initializer = new MySqlDbInitializer();
break;
default: throw new Exception(Resources.Languages.Resource.ProviderIsNotSet);
}
initializer.Initialize(context, reportingSettings);
}
static void ReDrawUI(ConnectionProvider provider, int count)
{
Console.WriteLine(DateTime.Now + " connections count: [" + count + "]/[" + provider.MaxConnections + "]");
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2), edgeHubCredentials.Identity);
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(
c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// Task<ICloudConnectionProvider>
builder.Register(
async c =>
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var clientProvider = c.Resolve <IClientProvider>();
var tokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubClientAuthTokenProvider");
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var deviceScopeIdentitiesCacheTask = c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
var proxy = c.Resolve <Option <IWebProxy> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await deviceScopeIdentitiesCacheTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
this.connectionPoolSize,
clientProvider,
this.upstreamProtocol,
tokenProvider,
deviceScopeIdentitiesCache,
credentialsCache,
edgeHubCredentials.Identity,
this.cloudConnectionIdleTimeout,
this.closeCloudConnectionOnIdleTimeout,
this.operationTimeout,
proxy);
return(cloudConnectionProvider);
})
.As <Task <ICloudConnectionProvider> >()
.SingleInstance();
// IIdentityProvider
builder.Register(_ => new IdentityProvider(this.iotHubName))
.As <IIdentityProvider>()
.SingleInstance();
// Task<IConnectionManager>
builder.Register(
async c =>
{
var cloudConnectionProviderTask = c.Resolve <Task <ICloudConnectionProvider> >();
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var identityProvider = c.Resolve <IIdentityProvider>();
ICloudConnectionProvider cloudConnectionProvider = await cloudConnectionProviderTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
IConnectionManager connectionManager = new ConnectionManager(
cloudConnectionProvider,
credentialsCache,
identityProvider,
this.maxConnectedClients);
return(connectionManager);
})
.As <Task <IConnectionManager> >()
.SingleInstance();
// Task<IEndpointFactory>
builder.Register(
async c =>
{
var messageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new EndpointFactory(connectionManager, messageConverter, this.edgeDeviceId, this.maxUpstreamBatchSize, this.upstreamFanOutFactor) as IEndpointFactory);
})
.As <Task <IEndpointFactory> >()
.SingleInstance();
// Task<RouteFactory>
builder.Register(async c => new EdgeRouteFactory(await c.Resolve <Task <IEndpointFactory> >()) as RouteFactory)
.As <Task <RouteFactory> >()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(
async c =>
{
if (this.useV1TwinManager)
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
ITwinManager twinManager = new PassThroughTwinManager(connectionManager, messageConverterProvider);
return(twinManager);
}
else
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>()));
}
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// ICheckpointStore
builder.Register(
c =>
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
return(CheckpointStore.Create(storeProvider));
})
.As <ICheckpointStore>()
.SingleInstance();
// IMessageStore
builder.Register(
c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue);
return(messageStore);
})
.As <IMessageStore>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(
c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = c.Resolve <IMessageStore>();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(
async c =>
{
if (this.useV1TwinManager)
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.Some <IStoreProvider>(new StoreProvider(dbStoreProvider))));
}
else
{
var storeProvider = c.Resolve <IStoreProvider>();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
IEntityStore <string, TwinStoreEntity> entityStore = storeProvider.GetEntityStore <string, TwinStoreEntity>("EdgeTwin");
ITwinManager twinManager = StoringTwinManager.Create(
connectionManager,
messageConverterProvider,
entityStore,
deviceConnectivityManager,
new ReportedPropertiesValidator(),
this.minTwinSyncPeriod,
this.reportedPropertiesSyncFrequency);
return(twinManager);
}
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<IInvokeMethodHandler>
builder.Register(
async c =>
{
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new InvokeMethodHandler(connectionManager) as IInvokeMethodHandler);
})
.As <Task <IInvokeMethodHandler> >()
.SingleInstance();
// Task<ISubscriptionProcessor>
builder.Register(
async c =>
{
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
return(new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager) as ISubscriptionProcessor);
})
.As <Task <ISubscriptionProcessor> >()
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
var routingMessageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
var routerTask = c.Resolve <Task <Router> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var subscriptionProcessorTask = c.Resolve <Task <ISubscriptionProcessor> >();
Router router = await routerTask;
ITwinManager twinManager = await twinManagerTask;
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
ISubscriptionProcessor subscriptionProcessor = await subscriptionProcessorTask;
IEdgeHub hub = new RoutingEdgeHub(
router,
routingMessageConverter,
connectionManager,
twinManager,
this.edgeDeviceId,
invokeMethodHandler,
subscriptionProcessor);
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null;
Router router = await c.Resolve <Task <Router> >();
var configUpdater = new ConfigUpdater(router, messageStore);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >();
if (this.useTwinConfig)
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var edgeHubTask = c.Resolve <Task <IEdgeHub> >();
ITwinManager twinManager = await twinManagerTask;
IEdgeHub edgeHub = await edgeHubTask;
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
IConfigSource edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
this.versionInfo,
deviceScopeIdentitiesCache);
return(edgeHubConnection);
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var edgeHubTask = c.Resolve <Task <IEdgeHub> >();
IConnectionManager connectionManager = await connectionManagerTask;
IEdgeHub edgeHub = await edgeHubTask;
IConnectionProvider connectionProvider = new ConnectionProvider(connectionManager, edgeHub);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
public DataContext(ConnectionProvider provider)
{
this.sqlCommand = query => new SqlCmd(provider, query);
this.Description = provider.ConnectionString;
}
public UserService()
{
_cp = new ConnectionProvider();
_dbConnection = _cp.GetConnection();
_userAccountDapper = new UserAccountDapper();
}
/// <summary>
/// Handle retrieving a message from the queue, decoding it, and performing any transaction maintenance.
/// </summary>
/// <param name="context">Tranasction context the receive is operating on</param>
/// <param name="cancellationToken">Token to abort processing</param>
/// <returns>A <seealso cref="TransportMessage"/> or <c>null</c> if no message can be dequeued</returns>
protected override async Task <TransportMessage> ReceiveInternal(ITransactionContext context, CancellationToken cancellationToken)
{
TransportMessage transportMessage = null;
using (var connection = await ConnectionProvider.GetConnection())
{
using (var selectCommand = connection.CreateCommand())
{
selectCommand.CommandType = CommandType.Text;
selectCommand.CommandText = $@"
;WITH TopCTE AS (
SELECT TOP 1
[id],
[headers],
[body],
[leasedat],
[leaseduntil],
[leasedby]
FROM {ReceiveTableName.QualifiedName} M WITH (ROWLOCK, READPAST, READCOMMITTEDLOCK)
WHERE M.[visible] < sysdatetimeoffset()
AND M.[expiration] > sysdatetimeoffset()
AND 1 = CASE
WHEN M.[leaseduntil] is null then 1
WHEN DATEADD(ms, @leasetolerancemilliseconds, DATEADD(ss, @leasetolerancetotalseconds, M.[leaseduntil])) < sysdatetimeoffset() THEN 1
ELSE 0
END
ORDER
BY [priority] DESC,
[visible] ASC,
[id] ASC
)
UPDATE TopCTE WITH (ROWLOCK, READCOMMITTEDLOCK)
SET [leaseduntil] = DATEADD(ms, @leasemilliseconds, DATEADD(ss, @leasetotalseconds, sysdatetimeoffset())),
[leasedat] = sysdatetimeoffset(),
[leasedby] = @leasedby
OUTPUT inserted.*";
selectCommand.Parameters.Add("@leasetotalseconds", SqlDbType.Int).Value = (int)_leaseInterval.TotalSeconds;
selectCommand.Parameters.Add("@leasemilliseconds", SqlDbType.Int).Value = _leaseInterval.Milliseconds;
selectCommand.Parameters.Add("@leasetolerancetotalseconds", SqlDbType.Int).Value = (int)_leaseTolerance.TotalSeconds;
selectCommand.Parameters.Add("@leasetolerancemilliseconds", SqlDbType.Int).Value = _leaseTolerance.Milliseconds;
selectCommand.Parameters.Add("@leasedby", SqlDbType.VarChar, LeasedByColumnSize).Value = _leasedByFactory();
try
{
using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
{
transportMessage = await ExtractTransportMessageFromReader(reader, cancellationToken).ConfigureAwait(false);
if (transportMessage == null)
{
return(null);
}
var messageId = (long)reader["id"];
ApplyTransactionSemantics(context, messageId, cancellationToken);
}
}
catch (Exception exception) when(cancellationToken.IsCancellationRequested)
{
// ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this:
throw new TaskCanceledException("Receive operation was cancelled", exception);
}
}
await connection.Complete();
}
return(transportMessage);
}
public bool ValidateConnection(string site)
{
return(ConnectionProvider.IsValidConnection(site));
}
/// <summary>
/// The base implementation of this method opens and disposes a connection internally.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public override int ExecuteNonQuery(string query)
{
return(ExecuteNonQuery(query, ConnectionProvider.GetConnection()));
}
public void UpdateDatabase(ConnectionProvider provider)
{
this.DatabaseName = new DatabaseName(provider, Provider.InitialCatalog);
}
private static void FindNameOnDbFile(ConnectionProvider provider, DatabaseName[] dnames, string match)
{
const string NAME_SPACE = "NameSpace";
const string DATABASE_NAME = "Database";
const string SCHEMA_NAME = "Schema";
const string TABLE_NAME = "Table";
const string COLUMN_NAME = "Column";
var schema = provider.Schema;
Regex regex = match.WildcardRegex();
DataTable dt = new DataTable();
dt.Columns.Add(DATABASE_NAME, typeof(string));
dt.Columns.Add(NAME_SPACE, typeof(string));
dt.Columns.Add(SCHEMA_NAME, typeof(string));
dt.Columns.Add(TABLE_NAME, typeof(string));
dt.Columns.Add(COLUMN_NAME, typeof(string));
dt.Columns.Add("DataType", typeof(string));
dt.Columns.Add("Length", typeof(int));
dt.Columns.Add("Nullable", typeof(string));
foreach (DatabaseName dname in dnames)
{
TableName[] tnames = schema.GetTableNames(dname);
if (regex.IsMatch(dname.Name))
{
var newRow = dt.NewRow();
newRow[DATABASE_NAME] = dname.Name;
newRow[NAME_SPACE] = dname.NameSpace;
dt.Rows.Add(newRow);
}
foreach (var tname in tnames)
{
bool found = false;
var newRow = dt.NewRow();
newRow[DATABASE_NAME] = dname.Name;
newRow[NAME_SPACE] = dname.NameSpace;
if (regex.IsMatch(tname.SchemaName))
{
found = true;
newRow[SCHEMA_NAME] = tname.ShortName;
}
if (regex.IsMatch(tname.ShortName))
{
found = true;
newRow[TABLE_NAME] = tname.ShortName;
}
if (found)
{
dt.Rows.Add(newRow);
}
TableSchema tschema = new TableSchema(tname);
foreach (var column in tschema.Columns)
{
if (regex.IsMatch(column.ColumnName))
{
newRow = dt.NewRow();
newRow[DATABASE_NAME] = dname.Name;
newRow[SCHEMA_NAME] = tname.SchemaName;
newRow[TABLE_NAME] = tname.Name;
newRow[COLUMN_NAME] = column.ColumnName;
newRow["DataType"] = column.DataType.ToString();
if (column.Length != -1)
{
newRow["Length"] = column.Length;
}
newRow["Nullable"] = column.Nullable ? "NULL" : "NOT NULL";
newRow[NAME_SPACE] = dname.NameSpace;
dt.Rows.Add(newRow);
}
}
}
}
if (dt.Rows.Count != 0)
{
//cout.WriteLine(ConsoleColor.Cyan, "Table Columns");
dt.ToConsole(vertical: false, more: false, outputDbNull: false);
}
else
{
cout.WriteLine("nothing is found");
}
}
public Side(ConnectionProvider provider)
{
this.DatabaseName = new DatabaseName(provider, provider.InitialCatalog);
}
static bool SupportsMonoExtensions(ConnectionProvider provider)
{
var monoProvider = provider as IMonoConnectionProvider;
return(monoProvider != null && monoProvider.SupportsMonoExtensions);
}
public UpdateBookQuery(ConnectionProvider provider)
: base(provider)
{
}
static bool SupportsInstrumentation(ConnectionProvider provider)
{
var monoProvider = provider as IMonoConnectionProvider;
return(monoProvider != null && monoProvider.SupportsInstrumentation);
}
/// <summary>
/// The base implementation of this method opens and disposes a connection internally.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public override IDataReader ExecuteQueryReader(string query)
{
return(ExecuteQueryReader(query, ConnectionProvider.GetConnection()));
}
static bool SupportsEcDhe(ConnectionProvider provider)
{
return((provider.Flags & ConnectionProviderFlags.SupportsEcDheCiphers) != 0);
}
