/// <summary>
/// Initializes a new instance of the <see cref="HealthController"/>
/// class.
/// </summary>
/// <param name="logger">An injected instance of the logger.</param>
/// <param name="client">
/// An injected instance of the database client.
/// </param>
public HealthController(
ILogger <HealthController> logger,
IDatabaseClient client)
{
this._logger = logger;
this._client = client;
}
internal void FreeConnection(IDatabaseClient dbClient)
{
lock (this.connections.SyncRoot)
{
this.connections.Enqueue(dbClient);
}
}
public void GetScalar0Test()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
Assert.IsInstanceOfType(typeof(int), client.ExecuteScalar <int>("0"));
}
}
public IQueryAdapter getQueryreactor()
{
ActiveConnections++;
IDatabaseClient dbClient = null;
lock (connections.SyncRoot)
{
if (connections.Count > 0)
{
dbClient = (IDatabaseClient)connections.Dequeue();
}
}
if (dbClient != null)
{
dbClient.connect();
dbClient.prepare();
return(dbClient.getQueryReactor());
}
else
{
IDatabaseClient connection = new MySqlClient(this, 0);
connection.connect();
connection.prepare();
return(connection.getQueryReactor());
}
}
public AppInitializer(
IDatabaseClient db,
IUserManager users)
{
_db = db;
_users = users;
}
private static void RunSimplifiedConnectionPoolingExample()
{
try
{
for (int i = 0; i < 10; i++)
{
//Connections are pooled since pooling is not disabled explicitly.
using (IDatabaseClient client = KdbPlusDatabaseClient.Factory.CreateNewClient("server=localhost;port=1001;"))
{
// get current time
TimeSpan time = client.ExecuteScalar <TimeSpan>(".z.T");
Console.WriteLine("Current time {0}", time);
}
// Connections are recreated since pooling is disabled explicitly.
using (IDatabaseClient client = KdbPlusDatabaseClient.Factory.CreateNewClient("server=localhost;port=1001;Pooling=false;"))
{
// get current time
TimeSpan time = client.ExecuteScalar <TimeSpan>(".z.T");
Console.WriteLine("Current time {0}", time);
}
}
}
catch (KdbPlusException ex)
{
Console.WriteLine(ex);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void ExceptionAtQueryTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
client.ExecuteQuery("exception");
}
}
public void ExceptionAtMultipleResultTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
client.ExecuteQueryWithMultipleResult("exception");
}
}
public DocumentModelService(IDatabaseClient databaseClient)
{
DatabaseClient = (DatabaseClient)databaseClient;
DocumentModels =
DatabaseClient.Database.GetCollection <DocumentModel>(DatabaseClient.DatabaseSettings
.DocumentModelCollection);
}
public void FreeConnection(IDatabaseClient dbClient)
{
lock (_connections.SyncRoot)
{
_connections.Enqueue(dbClient);
}
}
public void GetCurrentTypedTimeTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
Assert.IsInstanceOfType(typeof(TimeSpan), client.ExecuteScalar <TimeSpan>(".z.T"));
}
}
public TagChannelDatabaseClient(IDatabaseClient archive, string id, int samplingInterval)
{
Archive = archive;
Id = id;
archive.AddMonitoredItem(this, id, samplingInterval, OnNewValueFromChannel);
}
public void ExceptionAtScalarTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
client.ExecuteScalar("exception");
}
}
/// <summary>
/// Restarts this instance.
/// </summary>
public override bool Restart(out IDatabaseClient client)
{
List <IDatabaseClient> connections = new List <IDatabaseClient>();
Parallel.ForEach(_processes, (process) =>
{
IDatabaseClient dbClient;
if (process.Restart(out dbClient))
{
lock (_locker)
{
connections.Add(dbClient);
}
}
});
if (connections.Count > 0)
{
client = new CompositeDatabaseClient(connections);
return(true);
}
client = null;
return(false);
}
private Client(IDatabaseClient entity)
: this(entity as IClient, entity.SyncStatus, entity.LastSyncErrorMessage, entity.IsDeleted)
{
Workspace = entity.Workspace == null ? null : Models.Workspace.From(entity.Workspace);
SyncStatus = entity.SyncStatus;
LastSyncErrorMessage = entity.LastSyncErrorMessage;
IsDeleted = entity.IsDeleted;
}
public UserManager(IDatabaseClient db)
{
_lock = new object();
_db = db;
_emailRegistrationInProgress = new HashSet <string>();
_nickRegistrationInProgress = new HashSet <string>();
}
public UnitOfWork(IEventBus eventBus,
IDatabaseClient client)
{
_eventBus = eventBus;
_client = client;
Users = new AppUserRepositoryAsync(_client);
}
public WcfCrmServer()
{
_clients = new ConcurrentDictionary<ICrmClient, CrmClient>();
_databaseClient = SimpleIoc.Default.GetInstance<IDatabaseClient<CrmEntry>>();
_client = SimpleIoc.Default.GetInstance<IClient>();
_client.SessionCompleted += ClientOnSessionCompleted;
_client.SessionCreated += ClientOnSessionCreated;
}
internal void FreeConnection(IDatabaseClient dbClient)
{
lock (connections.SyncRoot)
{
connections.Enqueue(dbClient);
}
ActiveConnections--;
}
/// <summary>
/// Creates a new instance of the <see cref="SqlCigarRepository"/> class.
/// </summary>
/// <param name="client">
/// Required client used to connect to the SQL Server database.
/// </param>
/// <param name="serializer"></param>
public SqlCigarRepository(IDatabaseClient client, IEntitySerializer serializer)
{
_client = client
?? throw new ArgumentNullException(nameof(client));
_serializer = serializer
?? throw new ArgumentNullException(nameof(serializer));
}
public WcfCrmServer()
{
_clients = new ConcurrentDictionary <ICrmClient, CrmClient>();
_databaseClient = SimpleIoc.Default.GetInstance <IDatabaseClient <CrmEntry> >();
_client = SimpleIoc.Default.GetInstance <IClient>();
_client.SessionCompleted += ClientOnSessionCompleted;
_client.SessionCreated += ClientOnSessionCreated;
}
public BaseServiceClient(IDatabaseClient databaseServiceClient)
{
if (databaseServiceClient == null)
{
throw new ArgumentNullException("databaseServiceClient");
}
DatabaseServiceClient = databaseServiceClient;
}
public MoviesRepository(IDatabaseClient client, IDynamoDBContext context)
{
_client = client;
_context = context;
_operationConfig = new DynamoDBOperationConfig
{
OverrideTableName = TableName
};
}
private void Load(string path)
{
using (IDatabaseClient client = GetConnection())
{
string command = string.Format(@"\l {0}", path);
client.ExecuteScalar(command);
}
}
public void ExecuteNonQueryTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
CreateTradeAndInsertRow(client);
Assert.IsTrue(client.ExecuteQuery("select from trade").HasRows);
}
}
public void GetScalar0AsyncTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
IAsyncResult result = client.BeginExecuteScalar("0", null, null, null);
object received = client.EndExecuteScalar(result);
Assert.IsInstanceOfType(typeof(int), received);
}
}
public void ExecuteQueryAsDataTableTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
CreateTradeAndInsertRow(client);
DataTable table = client.ExecuteQueryAsDataTable("select from trade");
CheckTrade(table);
}
}
public UserService(IOptions <CosmosDbOptions> options, IDatabaseClient databaseClient)
{
_databaseName = options?.Value?.Databases?.CosmosDbDemo;
if (string.IsNullOrWhiteSpace(_databaseName))
{
throw new ArgumentException($"You must supply a CosmosDbDemo database in your CosmosDB options");
}
_databaseClient = databaseClient;
}
public void ExecuteOneWayNonQueryTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
CreateTradeAndInsertRowOneWay(client);
Thread.Sleep(1000);
Assert.IsTrue(client.ExecuteQuery("select from trade").HasRows);
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="CoreDatabaseContext"/> class.
/// </summary>
/// <param name="databaseClient">
/// An injected instance of the database client.
/// </param>
/// <param name="logger">An injected instance of the logger.</param>
public CoreDatabaseContext(
IDatabaseClient databaseClient,
ILogger <CoreDatabaseContext> logger)
{
this._databaseClient = databaseClient;
this._databaseClient.Session.ChangeKeyspace(
Environment.GetEnvironmentVariable("HOWLER_KEYSPACE_CORE") ??
throw new ArgumentNullException(
"HOWLER_KEYSPACE_CORE is null. Please define it in" +
" your environment variables."));
this._logger = logger;
}
public void ExecuteQueryTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
CreateTradeAndInsertRow(client);
using (IDataReader reader = client.ExecuteQuery("select from trade"))
{
CheckTrade(reader);
}
}
}
public void ExecuteNonQueryWithParamTest()
{
using (IDatabaseClient client = CreateDatabaseClient())
{
CreateTrade(client);
object[] x = { "AIG", 10.75, 200 };
client.ExecuteNonQuery("insert", "trade", x);
Assert.IsTrue(client.ExecuteQuery("select from trade").HasRows);
}
}
public NormalQueryReactor(IDatabaseClient client)
: base(client)
{
switch (DatabaseManager.DatabaseConnectionType.ToLower())
{
case "firebird":
CommandFireBird = client.CreateNewCommandFireBird();
break;
case "ingres":
case "ingress":
CommandIngress = client.CreateNewCommandIngress();
break;
case "pgsql":
CommandPgSql = client.CreateNewCommandPgSql();
break;
default: // mySql
CommandMySql = client.CreateNewCommandMySql();
break;
}
}
// Dependency Injection is managed by Nancy with TinyIoC
public Hub(IDatabaseClient database)
{
_database = database;
Get["/user/{name}"] = parameters =>
{
//TODO : see LoginAndRedirect in Nancy.Authentication.Forms
try
{
dynamic createdUser = _database.GetUser(parameters.name);
_logger.InfoFormat("User get : {0}", createdUser.Name);
return string.Format("user asked is {0} and password {1}", createdUser.Name,
createdUser.Password);
}
catch (Exception e)
{
return string.Format("Error caught : {0}", e.Message);
}
};
Post["/newuser/"] = ctx =>
{
dynamic name = Request.Form.Name.Value;
dynamic password = Request.Form.Password.Value;
_database.InsertUser(name, password);
dynamic message = string.Format("User added : {0}", name);
_logger.InfoFormat(message);
return message;
};
Post["/user/stream/subscription/"] = parameters =>
{
string name = Request.Form.Name.Value;
string stream = Request.Form.Stream.Value;
_logger.InfoFormat("Try to add stream : {0} for user : {1}", stream, name);
string message;
try
{
string source = parameters.stream;
User user = _database.GetUser(parameters.name);
// TODO : does the user have rights to do that operation ?
if (user == null)
{
return Response.AsRedirect("/error/unknownuser/");
}
_logger.DebugFormat("Data fetched for user : {0}", user.Name);
var fetcher = new RssFetcher.Fetcher();
// fetch all articles from source
Dictionary<string, Article> fetchedArticles = fetcher.Fetch(source);
_logger.DebugFormat("Fetched articles : {0}", fetchedArticles.Count);
// get all articles already inserted into database
IEnumerable<Article> articles = database.GetArticles(source);
var articlesArray = articles as Article[] ?? articles.ToArray();
_logger.DebugFormat("Fetched articles from database : {0}", articlesArray.Count());
string[] articleIds = articlesArray.Select(a => a.Id).ToArray();
// compare source articles ids and fetched ids values
foreach (var article in fetchedArticles)
{
if (articles != null && !articleIds.Contains(article.Value.Id))
{
_logger.DebugFormat("Inserting article {0}", article.Value);
// insert new article
_database.InsertArticle(article.Value);
}
}
message = string.Format("Stream added : {0} for user : {1}", parameters.stream, parameters.name);
_logger.InfoFormat(message);
}
catch (Exception e)
{
return string.Format("Error caught : {0}", e.Message);
}
return message;
};
}
public TransactionQueryReactor(IDatabaseClient client)
: base(client)
{
InitTransaction();
}
public void Init()
{
_database = new DatabaseClient("mongodb://localhost");
}
internal void FreeConnection(IDatabaseClient dbClient)
{
lock (connections.SyncRoot)
{
connections.Enqueue(dbClient);
}
}
public void Initialize(OAuth2Parameters authParams)
{
_oapAuthParams = authParams;
logger.Debug("Initializing: Connecting to Google spreadsheet services");
_dbcClient = new DatabaseClient(_oapAuthParams);
}
public NormalQueryReactor(IDatabaseClient Client) : base(Client)
{
this.command = Client.createNewCommand();
}
public AuthenticationController(IDatabaseClient databaseClient, ITokenProvider tokenProvider)
{
this.databaseClient = databaseClient;
this.tokenProvider = tokenProvider;
}
public BasicQueryAdapter(IDatabaseClient client)
{
Client = client;
Command = client.CreateCommand();
}
public NormalQueryReactor(IDatabaseClient client) : base(client)
{
CommandMySql = client.CreateNewCommandMySql();
}
public BooksController(IDatabaseClient databaseClient, ISearchClient searchClient)
{
this.databaseClient = databaseClient;
this.searchClient = searchClient;
}
public QueryAdapter(IDatabaseClient client)
{
Client = client;
}
public NormalQueryAdapter(IDatabaseClient client)
{
Client = client;
Command = Client?.CreateCommand();
}
public NormalQueryAdapter(IDatabaseClient client)
{
CommandMySql = client.CreateNewCommandMySql();
Client = client;
}
public QueryAdapter(IDatabaseClient Client)
{
client = Client;
}
