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); }