public async Task <IEnumerable <T> > GetItemsAsync <T>( IConnectionSettings connectionSettings, Expression <Func <T, bool> > predicate, Expression <Func <T, dynamic> > select) where T : class { var client = GetClient(connectionSettings); var query = client.CreateDocumentQuery <T>( UriFactory.CreateDocumentCollectionUri( connectionSettings.DatabaseId, connectionSettings.Collection), new FeedOptions { MaxItemCount = -1 }) .Where(predicate) .Select(select) .AsDocumentQuery(); var results = new List <T>(); while (query.HasMoreResults) { var response = await query.ExecuteNextAsync <T>(); // Unable to get RequestCharge during testing since we've casted the return type // to match our select. Appears to work fine on the real cosmos; something missing on the CosmosMocker. results.AddRange(response); } return(results); }
public ILogSource GetSource(IConnectionSettings connectionSettings) { AzureConnectionSettings azureConnectionSettings = connectionSettings as AzureConnectionSettings; azureConnectionSettings = new AzureConnectionSettings(azureConnectionSettings.StorageName, azureConnectionSettings.StorageKey, true, azureConnectionSettings.QueryFilter, azureConnectionSettings.StartTimeFilter, azureConnectionSettings.EndTimeFilter, azureConnectionSettings.RoleFilter, azureConnectionSettings.RoleInstanceFilter); return(new AzureLogSource(azureConnectionSettings)); }
internal virtual ElasticsearchPathInfo <K> ToPathInfo <K>(IConnectionSettings settings, K queryString) where K : FluentQueryString <K>, new() { var inferrer = new ElasticInferrer(settings); if (this._Index == null) { this._Index = inferrer.IndexName <T>(); } if (this._Type == null) { this._Type = inferrer.TypeName <T>(); } var index = new ElasticInferrer(settings).IndexName(this._Index); var type = new ElasticInferrer(settings).TypeName(this._Type); var pathInfo = new ElasticsearchPathInfo <K>() { Index = index, Type = type }; pathInfo.QueryString = queryString ?? new K(); return(pathInfo); }
public BaseJsonTests() { this._settings = new ConnectionSettings(Test.Default.Uri) .SetDefaultIndex(Test.Default.DefaultIndex); this._connection = new InMemoryConnection(this._settings); this._client = new ElasticClient(this._settings, this._connection); }
public string Resolve(IConnectionSettings connectionSettings) { connectionSettings.ThrowIfNull("connectionSettings"); string typeName = this.Name; if (this.Type == null) { return(this.Name); } if (connectionSettings.DefaultTypeNames.TryGetValue(this.Type, out typeName)) { return(typeName); } if (this.Type != null) { var att = new PropertyNameResolver().GetElasticPropertyFor(this.Type); if (att != null && !att.TypeNameMarker.IsNullOrEmpty()) { typeName = att.TypeNameMarker.Name; } else if (att != null && !string.IsNullOrEmpty(att.Name)) { typeName = att.Name; } else { typeName = connectionSettings.DefaultTypeNameInferrer(this.Type); } return(typeName); } return(this.Name); }
public void SetConnectionSettings(IConnectionSettings contractObject) { var connectionSettings = ConnectionSettings.Create(contractObject); lock (Anchor) { bool changed = false; if (!connectionSettings.Equals(_authenticationSettings.ConnectionSettings)) { _authenticationSettings.ConnectionSettings = (IConnectionSettings)connectionSettings.Clone(); changed = true; } if (changed) { Save(); } } if (HasConnectionSettings) { IdentifierService.RegisterMasterIdentifierIfNeeded(this); } }
internal virtual ElasticsearchPathInfo <K> ToPathInfo <K>(IConnectionSettings settings, K queryString) where K : FluentQueryString <K>, new() { var inferrer = new ElasticInferrer(settings); if (!this._AllIndices.HasValue && this._Indices == null) { this._Indices = new[] { (IndexNameMarker)inferrer.DefaultIndex } } ; string index = "_all"; if (!this._AllIndices.GetValueOrDefault(false)) { index = string.Join(",", this._Indices.Select(inferrer.IndexName)); } var pathInfo = new ElasticsearchPathInfo <K>() { Index = index, }; pathInfo.QueryString = queryString ?? new K(); return(pathInfo); } }
public static IConnectionSettings ToAuditSettings(this IConnectionSettings connectionSetting) { return(new AuditConnectionSetting(connectionSetting.EndPointUri, connectionSetting.PrimaryKey, connectionSetting.DatabaseId, connectionSetting.Collection)); }
public ElasticClient(IConnectionSettings settings,bool useThrift) { if (settings == null) throw new ArgumentNullException("settings"); this.Settings = settings; if (useThrift) this.Connection = new ThriftConnection(settings); else this.Connection = new Connection(settings); this.SerializationSettings = new JsonSerializerSettings() { ContractResolver = new ElasticResolver(), NullValueHandling = NullValueHandling.Ignore, Converters = new List<JsonConverter> { new DateHistogramConverter(), new IsoDateTimeConverter(), new QueryJsonConverter(), new FacetsMetaDataConverter() } }; this.PropertyNameResolver = new PropertyNameResolver(this.SerializationSettings); }
/// <inheritdoc/> public async Task <T> GetItemByIdAsync <T>(IConnectionSettings connectionSettings, string id) { try { var client = GetClient(connectionSettings); var documentUri = UriFactory.CreateDocumentUri( connectionSettings.DatabaseId, connectionSettings.Collection, id); var response = await client.ReadDocumentAsync(documentUri); _requestChargeService.RequestCharges.Add(new RequestChargeService.RequestCharge() { Request = $"GetItemByIdAsync<{typeof(T).Name}>(id={id})", Charge = response.RequestCharge }); return((T)(dynamic)response.Resource); } catch (DocumentClientException documentClientException) { if (documentClientException.StatusCode == HttpStatusCode.NotFound) { return(default(T)); } throw; } }
public DatabaseFactory(IConnectionSettings connectionSettings) { Contract.Requires(Check.Argument.IsNotNull(connectionSettings)); _connectionString = connectionSettings.ConnectionString; _defaultContainerName = connectionSettings.DefaultContainerName; }
public static void RegisterDatabase(this IServiceCollection services, IConnectionSettings connectionSettings) { services.AddDbContext <CreditHubDbContext>(options => { options.UseNpgsql(connectionSettings.PostgreSql); }); }
public ConnectionStatus(IConnectionSettings settings, Exception e) : this(settings) { this._settings = settings; this.Success = false; this.Error = new ConnectionError(e); this.Result = this.Error.Response; }
public PathResolver(IConnectionSettings connectionSettings) { connectionSettings.ThrowIfNull("hasDefaultIndices"); this._connectionSettings = connectionSettings; this._indexNameResolver = new IndexNameResolver(connectionSettings); this._typeNameResolver = new TypeNameResolver(); this._idResolver = new IdResolver(); }
override public void Start(Script script, IConnectionSettings cs, AuditProcedure auditProcedure, Dictionary <string, string> variables) { _script = script; _script.Success = true; _script.ExecutionStatus = ExecutionStatus.Executed; base.Start(script, cs, auditProcedure, variables); }
public PutMappingDescriptor(IConnectionSettings connectionSettings) { this._connectionSettings = connectionSettings; this._Mapping = new RootObjectMapping() { }; this.Infer = new ElasticInferrer(this._connectionSettings); }
public AsyncRequestOperation(HttpWebRequest request, string requestData, IConnectionSettings connectionSettings, ConnectionStatusTracer tracer) { m_request = request; m_requestData = requestData; m_connectionSettings = connectionSettings; m_tracer = tracer; Start(); }
protected override void ConfigureSettings(ITransceiverConnectionSettings connectionSettings) { _subscriberSettings = connectionSettings.RpcServerReceiver; var transmitterSettings = connectionSettings.RpcServerTransmitter; _transmitterConnectionString = $"Endpoint=sb://{transmitterSettings.AccountId}.servicebus.windows.net/;SharedAccessKeyName={transmitterSettings.UserName};SharedAccessKey={transmitterSettings.AccessKey};"; }
private CloudBlobClient CreateBlobClient(IConnectionSettings settings) { var baseuri = $"https://{settings.AccountId}.blob.core.windows.net"; var uri = new Uri(baseuri); return(new CloudBlobClient(uri, new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(settings.AccountId, settings.AccessKey))); }
public static void RegisterRedis(this IServiceCollection services, IConnectionSettings connectionSettings) { services.AddDistributedRedisCache(options => { options.Configuration = connectionSettings.Redis; options.InstanceName = "CreditHub:"; }); }
public NestedObjectMappingDescriptor(IConnectionSettings connectionSettings) { this._connectionSettings = connectionSettings; this._TypeName = TypeNameMarker.Create <TChild>(); this._Mapping = new NestedObjectMapping() { }; }
public DecaTecWebDavClient(IConnectionSettings connectionSettings) { _connectionSettings = connectionSettings; var credentials = new NetworkCredential(_connectionSettings.UserName, _connectionSettings.GetPassword()); _session = new WebDavSession(credentials); }
/// <summary> /// CTOR /// </summary> /// <param name="url">The URL.</param> /// <param name="credentials">The credentials.</param> private FtpConnection(IConnectionSettings connectionSettings) { this.connectionSettings = connectionSettings; TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException; this.PropertyChanged += FtpConnection_PropertyChanged; }
public NotificationServiceClient( INotificationFactory factory, IConnectionSettings settings) { _cancellation = new CancellationTokenSource(); _factory = factory; _settings = settings; }
public static string ConnectionStringCreate(IConnectionSettings settings, string databaseName) { if (settings.AuthMode == SqlAuthMode.SqlServer) { return string.Format(CONN_SQL, settings.ServerName, databaseName, settings.UserName, settings.Password); } return string.Format(CONN_WIN, settings.ServerName, databaseName); }
public ObjectMappingDescriptor(IConnectionSettings connectionSettings) { this._TypeName = new TypeNameResolver().GetTypeNameFor <TChild>(); this._Mapping = new ObjectMapping() { }; this._connectionSettings = connectionSettings; }
public static string ConnectionStringCreate(IConnectionSettings settings, string databaseName) { if (settings.AuthMode == SqlAuthMode.SqlServer) { return(string.Format(CONN_SQL, settings.ServerName, databaseName, settings.UserName, settings.Password)); } return(string.Format(CONN_WIN, settings.ServerName, databaseName)); }
public TelegramServiceTest() { // Prepare Database // _connectionSettings = TestHelper.GetConnectionSettings(); _migrationRunner = new MigrationRunner(_connectionSettings.BuildConnectionString()); _migrationRunner.RunMigrationsUp(); }
public static void RegisterInfraServices(this IServiceCollection services, IConnectionSettings connectionSettings, IConfiguration configuration) { services.RegisterDatabase(connectionSettings); services.RegisterRepositories(); services.RegisterRedis(connectionSettings); }
public ElasticInferrer(IConnectionSettings connectionSettings) { this._connectionSettings = connectionSettings; this.IdResolver = new IdResolver(); this.IndexNameResolver = new IndexNameResolver(this._connectionSettings); this.TypeNameResolver = new TypeNameResolver(this._connectionSettings); this.PropertyNameResolver = new PropertyNameResolver(this._connectionSettings); }
protected BaseApprendaApiClient(IConnectionSettings connectionSettings, IRestSession restSession) : this(connectionSettings) { if (restSession == null) { throw new ArgumentNullException(nameof(restSession)); } SessionToken = restSession.ApprendaSessionToken; }
/// <summary> /// /// </summary> public ThriftConnection(IConnectionSettings connectionSettings) { Created = DateTime.Now; var tsocket = new TSocket(connectionSettings.Host, connectionSettings.Port); _transport = new TBufferedTransport(tsocket, 1024); _protocol = new TBinaryProtocol(_transport); _client = new Rest.Client(_protocol); }
public Connection(IConnectionSettings settings) { if (settings == null) throw new ArgumentNullException("settings"); this._ConnectionSettings = settings; this._ResourceLock = new Semaphore(settings.MaximumAsyncConnections, settings.MaximumAsyncConnections); }
private TfsTeamProjectCollection InitializeTFSCollection(IConnectionSettings connectionSettings) { ReportProgress($"Connecting to {connectionSettings.Uri} ..."); var tfsCollection = new TfsTeamProjectCollection(connectionSettings.Uri); tfsCollection.EnsureAuthenticated(); return(tfsCollection); }
internal TypeMappingWriter(Type t, string typeName, IConnectionSettings connectionSettings, int maxRecursion, ConcurrentDictionary<Type, int> seenTypes) { this._type = GetUnderlyingType(t); this._connectionSettings = connectionSettings; this.TypeName = typeName; this.MaxRecursion = maxRecursion; this.SeenTypes = seenTypes; }
public CloseCaseService( IDatabaseAccess databaseAccess, IExaminationConnectionSettings connectionSettings, IOptions <UrgencySettings> urgencySettings) { _connectionSettings = connectionSettings; _databaseAccess = databaseAccess; _urgencySettings = urgencySettings.Value; }
public RawElasticClient(IConnectionSettings settings, IConnection connection) { if (settings == null) throw new ArgumentNullException("settings"); this.Settings = settings; this.Connection = connection; this.Serializer = new ElasticSerializer(this.Settings); }
public static string Resolve(this IndexNameMarker marker, IConnectionSettings connectionSettings) { if (marker == null) return null; connectionSettings.ThrowIfNull("connectionSettings"); if (marker.Type == null) return marker.Name; return new IndexNameResolver(connectionSettings).GetIndexForType(marker.Type); }
/// <summary> /// Copies information between objects inheriting the IConnectionSettings interface /// </summary> /// <param name="source"></param> /// <param name="destination"></param> public static void CopyConnectionSettings(IConnectionSettings source, IConnectionSettings destination) { destination.BufferedInput = source.BufferedInput; destination.ConnectionAddress = source.ConnectionAddress; destination.ConnectionName = source.ConnectionName; destination.LocalEcho = source.LocalEcho; destination.NewLineSequence = source.NewLineSequence; destination.Port = source.Port; destination.TerminalType = source.TerminalType; }
public Connection(IConnectionSettings settings) { if (settings == null) throw new ArgumentNullException("settings"); this._ConnectionSettings = settings; var semaphore = Math.Max(1, settings.MaximumAsyncConnections); this._ResourceLock = new Semaphore(semaphore, semaphore); this._enableTrace = settings.TraceEnabled; }
public Connection(IConnectionSettings settings) : base(Connection.addressFamily) { base.Encoding = settings.Encoding; base.Address = settings.Host; base.Connected += connection_Connected; base.Disconnected += connection_Disconnected; base.Sent += connection_Sent; base.Recieved += connection_Recieved; }
public TypeMappingWriter(Type t, TypeNameMarker typeName, IConnectionSettings connectionSettings, int maxRecursion) { this._type = t; this._connectionSettings = connectionSettings; this.TypeName = typeName; this.MaxRecursion = maxRecursion; this.SeenTypes = new ConcurrentDictionary<Type, int>(); this.SeenTypes.TryAdd(t, 0); }
public ElasticClient(IConnectionSettings settings,bool useThrift) { this.Settings = settings; this.Connection = new ThriftConnection(settings); this.SerializationSettings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore, Converters = new List<JsonConverter> { new IsoDateTimeConverter(), new QueryJsonConverter(), new FacetsMetaDataConverter() } }; this.PropertyNameResolver = new PropertyNameResolver(this.SerializationSettings); }
public ThriftConnection(IConnectionSettings connectionSettings) { this._timeout = connectionSettings.Timeout; this._poolSize = connectionSettings.MaximumAsyncConnections; this._resourceLock = new Semaphore(_poolSize, _poolSize); for (var i = 0; i <= connectionSettings.MaximumAsyncConnections; i++) { var tsocket = new TSocket(connectionSettings.Host, connectionSettings.Port); var transport = new TBufferedTransport(tsocket, 1024); var protocol = new TBinaryProtocol(transport); var client = new Rest.Client(protocol); _clients.Enqueue(client); } }
public ElasticClient(IConnectionSettings settings, IConnection connection) { if (settings == null) throw new ArgumentNullException("settings"); this._connectionSettings = settings; this.Connection = connection; this.PathResolver = new PathResolver(settings); this.PropertyNameResolver = new PropertyNameResolver(); this.Serializer = new ElasticSerializer(this._connectionSettings); this.Raw = new RawElasticClient(this._connectionSettings, connection); this.Infer = new ElasticInferrer(this._connectionSettings); }
public ConnectionListener( IConnectionSettings connectionSettings, IConnectionFactory connectionFactory, IPlayerRepository playerRepository, IAdminCredentials adminCredentials) { _connectionSettings = connectionSettings; _connectionFactory = connectionFactory; _playerRepository = playerRepository; _adminCredentials = adminCredentials; _connections = new List<IConnection>(); var taskScheduler = new ThreadPerTaskScheduler(); _taskFactory = new TaskFactory(taskScheduler); }
public Directory(IConnectionSettings connectionSettings, IDirectorySearcherOptions directorySearcherOptions) { if(connectionSettings == null) throw new ArgumentNullException("connectionSettings"); this._connectionSettings = connectionSettings; this._directorySearcherOptions = directorySearcherOptions; string hostUrl = connectionSettings.Scheme.ToString() + "://" + connectionSettings.Host; if(connectionSettings.Port != null) hostUrl += ":" + connectionSettings.Port.Value.ToString(CultureInfo.InvariantCulture); if(!hostUrl.EndsWith("/", StringComparison.Ordinal)) hostUrl += "/"; this._hostUrl = hostUrl; this._rootPath = hostUrl + connectionSettings.DistinguishedName; }
AzureServiceBusEndpointAddress(AddressType addressType, string ns, string queueOrTopicName, IConnectionSettings settings, int prefetchCount) { _addressType = addressType; _namespace = ns; _queueOrTopicName = queueOrTopicName; _settings = settings; _prefetchCount = prefetchCount; string suffix = ""; if (addressType == AddressType.Topic) suffix = "?topic=true"; _friendlyUri = new Uri(string.Format("azure-sb://{0}/{1}{2}", ns, queueOrTopicName, suffix)); }
public MySqlStorage(IConnectionSettings connectionSettings) { string connection = string.Format("server={0};port={1};username={2};password={3};database={4}", connectionSettings.getHost(), connectionSettings.getPort(), connectionSettings.getLogin(), connectionSettings.getPassword(), connectionSettings.getDatabaseName()); //This is my insert query in which i am taking input from the user through windows forms //This is MySqlConnection here i have created the object and pass my connection string. _mySqlConnection = new MySqlConnection(connection); try { _mySqlConnection.Open(); } catch (MySql.Data.MySqlClient.MySqlException) { if (connectionFailed != null) { connectionFailed("Не удалось подключиться к базе данных, проверьте файл настроек"); } } }
public void Connect(IConnectionSettings connectionSettings) { Log.Debug(string.Format("Connecting to device {0}", this.DeviceName)); try { this.Protocol.ConnectionSettings = connectionSettings; this.Protocol.Connect(); this.IsConnected = true; this.Protocol.DataReceived += Protocol_DataReceived; if (this.ConnectionSuccess != null) this.ConnectionSuccess(); } catch (Exception e) { Log.ErrorFormat("Cannot establish connection with the device {0}", this.DeviceName); Log.Error(e); if (this.ConnectionFailed != null) this.ConnectionFailed(); } }
public Connection(IConnectionSettings settings) { this._ConnectionSettings = settings; this._ResourceLock = new Semaphore(settings.MaximumAsyncConnections, settings.MaximumAsyncConnections); }
public InMemoryConnection(IConnectionSettings settings, ConnectionStatus fixedResult) : base(settings) { this._fixedResult = fixedResult; }
public ILogSource GetSource(IConnectionSettings connectionSettings) { AzureConnectionSettings azureConnectionSettings = connectionSettings as AzureConnectionSettings; azureConnectionSettings = new AzureConnectionSettings(azureConnectionSettings.StorageName, azureConnectionSettings.StorageKey, true, azureConnectionSettings.QueryFilter, azureConnectionSettings.StartTimeFilter, azureConnectionSettings.EndTimeFilter, azureConnectionSettings.RoleFilter, azureConnectionSettings.RoleInstanceFilter); return new AzureLogSource(azureConnectionSettings); }
public IEnumerable<ILogSource> GetSources(IConnectionSettings settings) { return new List<ILogSource> { GetSource(settings) }; }
public Directory(IConnectionSettings connectionSettings) : this(connectionSettings, null) { }
public TestConnection(IConnectionSettings settings) : base(settings) { }
public ElasticCamelCaseResolver(IConnectionSettings connectionSettings) : base(connectionSettings) { }
public ElasticResolver(IConnectionSettings connectionSettings) : base(true) { this.ConnectionSettings = connectionSettings; }
public InMemoryConnection(IConnectionSettings settings) : base(settings) { }
public RawElasticClient(IConnectionSettings settings) : this(settings, new Connection(settings)) { }