public void TestCommandDownloadBucketWithInvalidRemotePathIsBlockedBySanitizationAndThrowError(string invalidPath, string pathType = null) { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new DownloadBucketCommand(); var config = new BucketConfiguration() { RemoteRelativePathFiles = new List <string>(), RemoteRelativePathFolders = new List <string>(), LocalPathGet = "a", RemoteRelativePath = "b", DeleteFiles = true, }; switch (pathType) { case "folder": config.RemoteRelativePathFolders.Add(invalidPath); break; case "file": default: config.RemoteRelativePathFiles.Add(invalidPath); break; } var ret = Assert.ThrowsAsync <Exception>( async() => await command.ExecuteAsync(bucket, config, ct), "Invalid path should throw an error"); var expectedErrorMessage = "Download failed. Invalid remote path(s)"; Assert.AreEqual(expectedErrorMessage, ret.Message); }
public void ListBucketOptionsCheckTestParsArg() { string[] argv = null; var commandLineParser = new CommandLine.Parser(); CommandLineParser parser = new CommandLineParser(new OptionConverter(new JsonDeserializer()), commandLineParser, new ParserUsage(), new VerbFormater()); IConfiguration iConfSet = null; BucketConfiguration confset = null; argv = new string[] { "bucket", "list" }; iConfSet = parser.Parse(argv); if (!(iConfSet is BucketConfiguration)) { throw new Exception("return value is not ConfigurationBucket "); } confset = (BucketConfiguration)iConfSet; Assert.AreEqual(confset.Type, ConfigType.Bucket); Assert.AreEqual(confset.Command, CommandApi.List); argv = new string[] { "bucket", "list" }; iConfSet = parser.Parse(argv); if (!(iConfSet is BucketConfiguration)) { throw new Exception("return value is not ConfigurationBucket "); } confset = (BucketConfiguration)iConfSet; Assert.AreEqual(confset.Type, ConfigType.Bucket); Assert.AreEqual(confset.Command, CommandApi.List); commandLineParser.Dispose(); }
public async Task TestToGetFilesInfoFromABucketAndCheckTheReturnHumanReadableStringInfo() { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new ListBucketEntriesCommand(new BytesFormatter()); var config = new BucketConfiguration() { Name = "myName", LocalPathGet = "a", RemoteRelativePath = "b", RemoteRelativePathFolders = new List <string>() { "folder1", "folder2" }, DeleteFiles = true, HumanReadable = true, }; CommandValues.BucketInfoCommandValue ret = await command.ExecuteAsync(bucket, config, ct); Assert.IsTrue(ret is CommandValues.BucketInfoCommandValue); Assert.AreEqual(ret.Shortname, "Shortname1"); Assert.AreEqual(ret.BucketFilesDetail[0], "120.56 KB - test/path"); Assert.AreEqual(ret.TotalFileCount, "156"); Assert.AreEqual(ret.TotalUsedSpaceBytes, "52.94 KB"); }
public void When_NotSupportedException_Thrown_When_Proxy_Port_Is_Configured() { var configuration = new ClientConfiguration { PoolConfiguration = new PoolConfiguration { MaxSize = 10, MinSize = 10 } }; configuration.Servers.Clear(); configuration.Servers.Add(new Uri("http://127.0.0.1:8091/pools")); var bc = new BucketConfiguration(); bc.Password = "******"; bc.Username = "******"; bc.BucketName = "authenticated"; bc.Servers.Clear(); bc.Servers.Add(new Uri("http://127.0.0.1:8091/pools")); bc.Port = 11211; configuration.BucketConfigs.Clear(); configuration.BucketConfigs.Add("authenticated", bc); Assert.Throws <NotSupportedException>(() => configuration.Initialize()); }
/// <summary> /// Initializes a new instance of the <see cref="BucketCacheHandle{TCacheValue}"/> class. /// </summary> /// <param name="managerConfiguration">The manager configuration.</param> /// <param name="configuration">The cache handle configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <exception cref="System.InvalidOperationException"> /// If <c>configuration.HandleName</c> is not valid. /// </exception> public BucketCacheHandle(CacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory) : base(managerConfiguration, configuration) { NotNull(configuration, nameof(configuration)); NotNull(loggerFactory, nameof(loggerFactory)); this.Logger = loggerFactory.CreateLogger(this); // we can configure the bucket name by having "<configKey>:<bucketName>" as handle's // name value var nameParts = configuration.Key.Split(new[] { ":" }, StringSplitOptions.RemoveEmptyEntries); Ensure(nameParts.Length > 0, "Handle key is not valid {0}", configuration.Key); this.configurationName = nameParts[0]; if (nameParts.Length == 2) { this.bucketName = nameParts[1]; } this.configuration = CouchbaseConfigurationManager.GetConfiguration(this.configurationName); this.bucketConfiguration = CouchbaseConfigurationManager.GetBucketConfiguration(this.configuration, this.bucketName); this.bucket = CouchbaseConfigurationManager.GetBucket(this.configuration, this.configurationName, this.bucketName); }
public async Task TestToGetABucketListAndCheckTheReturnStringInfo() { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new BucketListResumeCommand(new BytesFormatter()); var config = new BucketConfiguration() { Name = "myName", LocalPathGet = "a", RemoteRelativePath = "b", RemoteRelativePathFolders = new List <string>() { "folder1", "folder2" }, DeleteFiles = true, }; CommandValues.BucketCommandValue ret = await command.ExecuteAsync(bucket, config, ct); Assert.IsTrue(ret is CommandValues.BucketCommandValue); Assert.AreEqual(ret.Shortname, "Shortname1"); Assert.AreEqual(ret.FileCount, "156"); Assert.AreEqual(ret.UsedSpaceBytes, "54213"); }
public async Task TestCommandDownloadBucketWithinvalidRemotePathIsBlockedBySanitization(string invalidPath, string pathType = null) { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new DownloadBucketCommand(); var config = new BucketConfiguration() { RemoteRelativePathFiles = new List <string>(), RemoteRelativePathFolders = new List <string>(), LocalPathGet = "a", RemoteRelativePath = "b", DeleteFiles = true, }; switch (pathType) { case "folder": config.RemoteRelativePathFolders.Add(invalidPath); break; case "file": default: config.RemoteRelativePathFiles.Add(invalidPath); break; } CommandValues.GenericInfoCommandValue ret = await command.ExecuteAsync(bucket, config, ct); Assert.IsTrue(ret is CommandValues.GenericInfoCommandValue); Assert.AreEqual(ret.Uuid, "Shortname1"); Assert.AreEqual("Download failed. Invalid remote path(s)", (ret as CommandValues.GenericInfoCommandValue).Message); }
protected void CreateCouchBaseDBClientConfiguration(Config config) { if (config.GetBoolean("UseClusterHelper")) { BucketName = config.GetString("BucketName"); CBClientConfiguration = ClusterHelper.GetBucket(BucketName).Cluster.Configuration; UseClusterHelper = true; } else { CBClientConfiguration = new ClientConfiguration(); // Reset the serializers and deserializers so that JSON is stored as PascalCase instead of camelCase CBClientConfiguration.Serializer = () => new DefaultSerializer(new JsonSerializerSettings(), new JsonSerializerSettings()); CBClientConfiguration.Servers.RemoveAt(0); //Get the URI's from the HOCON config try { if (config.GetStringList("ServersURI").Count > 0) { List <Uri> uris = new List <Uri>(); foreach (string s in config.GetStringList("ServersURI")) { CBClientConfiguration.Servers.Add(new Uri(s)); } } } catch (Exception ex) { throw new Exception("Invalid URI specified in HOCON configuration", ex); } // Use SSL? CBClientConfiguration.UseSsl = config.GetBoolean("UseSSL"); // This will not be needed since we are not creating a bucket on the fly. //AdminPassword = config.GetString("AdminPassword"); //AdminUserName = config.GetString("AdminUserName"); // Get the bucket(s) configuration Dictionary <string, BucketConfiguration> BucketConfigs = new Dictionary <string, BucketConfiguration>(); BucketConfiguration newBC = new BucketConfiguration(); newBC.UseSsl = config.GetBoolean("BucketUseSSL"); newBC.Password = config.GetString("Password"); newBC.DefaultOperationLifespan = (uint)config.GetInt("DefaultOperationLifespan"); BucketName = config.GetString("BucketName"); newBC.BucketName = BucketName; newBC.PoolConfiguration.MinSize = config.GetInt("PoolConfiguration.MinSize"); newBC.PoolConfiguration.MaxSize = config.GetInt("PoolConfiguration.MaxSize"); // Create the bucket config specified in the HOCON BucketConfigs.Add(newBC.BucketName, newBC); CBClientConfiguration.BucketConfigs = BucketConfigs; } }
public static string GetBaseUriAsString(INodeAdapter adapter, BucketConfiguration config) { var uriAsString = string.Format(BaseUriFormat, config.UseSsl ? Https : Http, adapter.Hostname, config.UseSsl ? adapter.MgmtApiSsl: adapter.MgmtApi); return(uriAsString); }
public static string GetAnalyticsUri(INodeAdapter adapter, BucketConfiguration config) { var uri = string.Format(AnalyticsUriFormat, config.UseSsl ? Https : Http, adapter.Hostname, config.UseSsl ? adapter.AnalyticsSsl : adapter.Analytics); return(uri); }
// ReSharper disable once InconsistentNaming public static string GetN1QLBaseUriAsString(INodeAdapter adapter, BucketConfiguration config) { var uriAsString = string.Format(N1QLUriFormat, config.UseSsl ? Https : Http, GetHostName(adapter), config.UseSsl ? adapter.N1QLSsl : adapter.N1QL); return(uriAsString); }
public Server(IIOService ioService, IViewClient viewClient, IViewClient streamingViewClient, IQueryClient queryClient, IQueryClient streamingQueryClient, ISearchClient searchClient, IAnalyticsClient analyticsClient, INodeAdapter nodeAdapter, ClientConfiguration clientConfiguration, ITypeTranscoder transcoder, IBucketConfig bucketConfig) { if (ioService != null) { _ioService = ioService; _ioService.ConnectionPool.Owner = this; } _nodeAdapter = nodeAdapter; _clientConfiguration = clientConfiguration; _bucketConfiguration = clientConfiguration.BucketConfigs[bucketConfig.Name]; _timingEnabled = _clientConfiguration.EnableOperationTiming; _typeTranscoder = transcoder; _bucketConfig = bucketConfig; //services that this node is responsible for IsMgmtNode = _nodeAdapter.MgmtApi > 0; IsDataNode = _nodeAdapter.KeyValue > 0; IsQueryNode = _nodeAdapter.N1QL > 0; IsIndexNode = _nodeAdapter.IndexAdmin > 0; IsViewNode = _nodeAdapter.Views > 0; IsSearchNode = _nodeAdapter.IsSearchNode; IsAnalyticsNode = _nodeAdapter.IsAnalyticsNode; //View and query clients ViewClient = viewClient; _streamingViewClient = streamingViewClient; QueryClient = queryClient; SearchClient = searchClient; _streamingQueryClient = streamingQueryClient; AnalyticsClient = analyticsClient; CachedViewBaseUri = UrlUtil.GetViewBaseUri(_nodeAdapter, _bucketConfiguration); CachedQueryBaseUri = UrlUtil.GetN1QLBaseUri(_nodeAdapter, _bucketConfiguration); if (IsDataNode || IsQueryNode) { _lastIOErrorCheckedTime = DateTime.Now; //On initialization, data nodes are authenticated, so they can start in a down state. //If the node is down immediately start the timer, otherwise disable it. if (IsDataNode) { _isDown = _ioService.ConnectionPool.InitializationFailed; } Log.Info("Initialization {0} for node {1}", _isDown ? "failed" : "succeeded", EndPoint); //timer and node status _heartBeatTimer = new Timer(_heartBeatTimer_Elapsed, null, Timeout.Infinite, Timeout.Infinite); if (_isDown) { StartHeartbeatTimer(); } } }
public static string GetViewBaseUriAsString(INodeAdapter adapter, BucketConfiguration config) { var uriAsString = string.Format(ViewUriFormat, config.UseSsl ? Https : Http, adapter.Hostname, config.UseSsl ? adapter.ViewsSsl : adapter.Views, config.BucketName); return(uriAsString); }
public static string GetSearchBaseUri(INodeAdapter adapter, BucketConfiguration config) { var uriAsString = string.Format(BaseUriFormat, config.UseSsl ? Https : Http, GetHostName(adapter), config.UseSsl ? adapter.FtsSsl : adapter.Fts); return(uriAsString); }
/// <summary> /// Gets an <see cref="BucketConfiguration"/> from the <see cref="ClientConfiguration"/>. If one doesn't exist /// for a given bucket, a new one will be created and added to the configuration. /// </summary> /// <param name="bucketName">The <see cref="IBucket.Name"/> to use for the lookup.</param> /// <returns>An <see cref="BucketConfiguration"/> instance.</returns> protected virtual BucketConfiguration GetOrCreateConfiguration(string bucketName) { try { ConfigLock.EnterWriteLock(); // do we already have the bucket config cached? if (ClientConfig.BucketConfigs.TryGetValue(bucketName, out var bucketConfiguration)) { SetNetworkType(bucketConfiguration.NetworkType); return(bucketConfiguration); } // need to create new config // can we copy settings from another bucket's config? if (ClientConfig.BucketConfigs.Any()) { // use settings from existing config var defaultConfig = ClientConfig.BucketConfigs.First().Value; bucketConfiguration = new BucketConfiguration { BucketName = bucketName, PoolConfiguration = defaultConfig.PoolConfiguration, Servers = defaultConfig.Servers, Port = defaultConfig.Port, Username = defaultConfig.Username, Password = string.Empty, UseSsl = defaultConfig.UseSsl }; } else { // create new config using client configuration settings bucketConfiguration = new BucketConfiguration { BucketName = bucketName, PoolConfiguration = ClientConfig.PoolConfiguration, Servers = ClientConfig.Servers, UseSsl = ClientConfig.UseSsl, Port = ClientConfig.DirectPort }; } SetNetworkType(bucketConfiguration.NetworkType); // cache bucket config ClientConfig.BucketConfigs.Add(bucketConfiguration.BucketName, bucketConfiguration); return(bucketConfiguration); } finally { ConfigLock.ExitWriteLock(); } }
public void TestBasicCommandOnBucketNotFoundReturnTheNotFoundErrorMessage(CommandApi commandType) { QBucket bucket = null; // symbolize the null return from sdk retrieve bucket method if the bucket doses not exist ICommand <QBucket, CommandValues.GenericInfoCommandValue> command; Task commandAsync = null; CancellationToken ct = default(CancellationToken); var config = new BucketConfiguration() { Name = "NonExistingBucket", LocalPathGet = "a", RemoteRelativePaths = new List <string> { "b" }, }; switch (commandType) { case CommandApi.Delete: command = new DeleteBucketCommand(); commandAsync = command.ExecuteAsync(bucket, config, ct); break; case CommandApi.SyncFrom: command = new SynchronizeLocalFolderFromBucketCommand(); commandAsync = command.ExecuteAsync(bucket, config, ct); break; case CommandApi.SyncTo: command = new SynchronizeLocalFolderToBucketCommand(); commandAsync = command.ExecuteAsync(bucket, config, ct); break; case CommandApi.Upload: command = new UploadBucketCommand(); commandAsync = command.ExecuteAsync(bucket, config, ct); break; case CommandApi.Download: command = new DownloadBucketCommand(); commandAsync = command.ExecuteAsync(bucket, config, ct); break; case CommandApi.Remove: command = new RemoveEntityBucketCommand(); commandAsync = command.ExecuteAsync(bucket, config, ct); break; } var cliException = Assert.ThrowsAsync <Exception>(async() => await commandAsync, "Bucket not found should throw an error"); string expected1 = "Bucket not found"; StringAssert.Contains(expected1, cliException.Message); }
public void When_UseSsl_True_N1QL_Uri_Contains_Https() { var serverConfigJson = File.ReadAllText("Data\\Configuration\\nodesext-with-json-and-kv.json"); var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson); var clientConfig = new BucketConfiguration { UseSsl = true }; var expected = new Uri("https://192.168.77.102:18093/query"); var actual = UrlUtil.GetN1QLBaseUri(serverConfig.GetNodes().First(x => x.Hostname.Equals("192.168.77.102")), clientConfig); Assert.AreEqual(expected, actual); }
public void When_NodeExt_And_UseSsl_Is_True_And_IPv6_IPEndpoint_Uses_Port_11207() { var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\config-with-nodes-ext.json"); var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson); var clientConfig = new BucketConfiguration { UseSsl = true }; const string expected = "192.168.56.101:11207"; var actual = IPEndPointExtensions.GetEndPoint(serverConfig.NodesExt[0].Hostname); Assert.AreEqual(expected, actual.ToString()); }
public void When_NodeAdapter_And_UseSsl_Is_True_IPEndPoint_Uses_Port_11210() { var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\config-with-nodes-ext.json"); var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson); var clientConfig = new BucketConfiguration { UseSsl = false }; const string expected = "192.168.56.102:11210"; var actual = IPEndPointExtensions.GetEndPoint(serverConfig.GetNodes()[0], clientConfig, serverConfig); Assert.AreEqual(expected, actual.ToString()); }
public void When_UseSsl_True_View_Uri_Contains_Http() { var serverConfigJson = ResourceHelper.ReadResource("Data\\Configuration\\nodesext-with-json-and-kv.json"); var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson); var clientConfig = new BucketConfiguration { UseSsl = false }; var expected = new Uri("http://192.168.77.102:8092/default/"); var actual = UrlUtil.GetViewBaseUri(serverConfig.GetNodes().First(x => x.Hostname.Equals("192.168.77.102")), clientConfig); Assert.AreEqual(expected, actual); }
public void When_Node_And_UseSsl_Is_True_IPEndPoint_Uses_Port_11207() { var serverConfigJson = File.ReadAllText("Data\\Configuration\\config-with-nodes-ext.json"); var serverConfig = JsonConvert.DeserializeObject <BucketConfig>(serverConfigJson); var clientConfig = new BucketConfiguration { UseSsl = true }; const string expected = "192.168.56.101:11207"; var actual = IPEndPointExtensions.GetEndPoint(serverConfig.Nodes[0], clientConfig, serverConfig); Assert.AreEqual(expected, actual.ToString()); }
public Server(IOStrategy ioStrategy, IViewClient viewClient, IQueryClient queryClient, INodeAdapter nodeAdapter, ClientConfiguration clientConfiguration, ITypeTranscoder transcoder, IBucketConfig bucketConfig) { if (ioStrategy != null) { _ioStrategy = ioStrategy; _ioStrategy.ConnectionPool.Owner = this; } _nodeAdapter = nodeAdapter; _clientConfiguration = clientConfiguration; _bucketConfiguration = clientConfiguration.BucketConfigs[bucketConfig.Name]; _timingEnabled = _clientConfiguration.EnableOperationTiming; _typeTranscoder = transcoder; _bucketConfig = bucketConfig; //services that this node is responsible for IsMgmtNode = _nodeAdapter.MgmtApi > 0; IsDataNode = _nodeAdapter.KeyValue > 0; IsQueryNode = _nodeAdapter.N1QL > 0; IsIndexNode = _nodeAdapter.IndexAdmin > 0; IsViewNode = _nodeAdapter.Views > 0; //View and query clients ViewClient = viewClient; QueryClient = queryClient; CachedViewBaseUri = UrlUtil.GetViewBaseUri(_nodeAdapter, _bucketConfiguration); CachedQueryBaseUri = UrlUtil.GetN1QLBaseUri(_nodeAdapter, _bucketConfiguration); if (IsDataNode || IsQueryNode) { _lastIOErrorCheckedTime = DateTime.Now; //On initialization, data nodes are authenticated, so they can start in a down state. //If the node is down immediately start the timer, otherwise disable it. if (IsDataNode) { _isDown = _ioStrategy.ConnectionPool.InitializationFailed; } Log.InfoFormat("Initialization {0} for node {1}", _isDown ? "failed" : "succeeded", EndPoint); //timer and node status _heartBeatTimer = new Timer(_clientConfiguration.NodeAvailableCheckInterval) { Enabled = _isDown }; _heartBeatTimer.Elapsed += _heartBeatTimer_Elapsed; } }
public Server(IIOService ioService, IViewClient viewClient, IViewClient streamingViewClient, IQueryClient queryClient, IQueryClient streamingQueryClient, ISearchClient searchClient, IAnalyticsClient analyticsClient, INodeAdapter nodeAdapter, ITypeTranscoder transcoder, ConfigContextBase context) { if (ioService != null) { _ioService = ioService; _ioService.ConnectionPool.Owner = this; } _clientConfiguration = context.ClientConfig; _bucketConfiguration = context.ClientConfig.BucketConfigs[context.BucketConfig.Name]; _timingEnabled = _clientConfiguration.EnableOperationTiming; _typeTranscoder = transcoder; _bucketConfig = context.BucketConfig; //set all properties based off the nodes and nodeExt adapter LoadNodeAdapter(nodeAdapter); //View and query clients ViewClient = viewClient; _streamingViewClient = streamingViewClient; QueryClient = queryClient; SearchClient = searchClient; _streamingQueryClient = streamingQueryClient; AnalyticsClient = analyticsClient; if (IsDataNode || IsQueryNode) { _lastIOErrorCheckedTime = DateTime.Now; //On initialization, data nodes are authenticated, so they can start in a down state. //If the node is down immediately start the timer, otherwise disable it. if (IsDataNode) { _isDown = _ioService.ConnectionPool.InitializationFailed; } Log.Info("Initialization {0} for node {1}", _isDown ? "failed" : "succeeded", EndPoint); //timer and node status _heartBeatTimer = new Timer(_heartBeatTimer_Elapsed, null, Timeout.Infinite, Timeout.Infinite); if (_isDown) { StartHeartbeatTimer(); } } }
/// <summary> /// Gets an <see cref="BucketConfiguration"/> from the <see cref="ClientConfiguration"/>. If one doesn't exist /// for a given bucket, a new one will be created and added to the configuration. /// </summary> /// <param name="bucketName">The <see cref="IBucket.Name"/> to use for the lookup.</param> /// <returns>An <see cref="BucketConfiguration"/> instance.</returns> protected virtual BucketConfiguration GetOrCreateConfiguration(string bucketName) { try { ConfigLock.EnterWriteLock(); BucketConfiguration bucketConfiguration = null; if (ClientConfig.BucketConfigs.ContainsKey(bucketName)) { bucketConfiguration = ClientConfig.BucketConfigs[bucketName]; } if (bucketConfiguration != null) { return(bucketConfiguration); } var defaultBucket = ClientConfig.BucketConfigs.FirstOrDefault(); if (defaultBucket.Value == null) { bucketConfiguration = new BucketConfiguration { BucketName = bucketName, PoolConfiguration = ClientConfig.PoolConfiguration, Servers = ClientConfig.Servers, UseSsl = ClientConfig.UseSsl }; } else { var defaultConfig = defaultBucket.Value; bucketConfiguration = new BucketConfiguration { BucketName = bucketName, PoolConfiguration = defaultConfig.PoolConfiguration, Servers = defaultConfig.Servers, Port = defaultConfig.Port, Username = defaultConfig.Username, Password = string.Empty, UseSsl = defaultConfig.UseSsl }; } ClientConfig.BucketConfigs.Add(bucketConfiguration.BucketName, bucketConfiguration); return(bucketConfiguration); } finally { ConfigLock.ExitWriteLock(); } }
public static IPEndPoint GetEndPoint(Node node, BucketConfiguration clientConfig, IBucketConfig serverConfig) { var address = node.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(ClientConfiguration.UseInterNetworkV6Addresses); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = clientConfig.UseSsl ? node.Ports.SslDirect : node.Ports.Direct; return(new IPEndPoint(ipAddress, port)); }
public static IPEndPoint GetEndPoint(NodeExt nodeExt, BucketConfiguration bucketConfig, IBucketConfig serverConfig) { var address = nodeExt.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = bucketConfig.UseSsl ? nodeExt.Services.KvSSL : nodeExt.Services.KV; return(new IPEndPoint(ipAddress, port)); }
public static IPEndPoint GetEndPoint(INodeAdapter adapter, BucketConfiguration clientConfig, IBucketConfig serverConfig) { var address = adapter.Hostname.Split(':').First(); IPAddress ipAddress; if (!IPAddress.TryParse(address, out ipAddress)) { var uri = new Uri(String.Format("http://{0}", address)); ipAddress = uri.GetIpAddress(); if (ipAddress == null) { throw new ArgumentException("ipAddress"); } } var port = clientConfig.UseSsl ? adapter.KeyValueSsl : adapter.KeyValue; return(new IPEndPoint(ipAddress, port)); }
public async Task TestCommandSynchronizeLocalFolderFromBucket() { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new SynchronizeLocalFolderFromBucketCommand(); var config = new BucketConfiguration() { LocalPathGet = "a", RemoteRelativePath = "b", DeleteFiles = true, }; CommandValues.GenericInfoCommandValue ret = await command.ExecuteAsync(bucket, config, ct); Assert.IsTrue(ret is CommandValues.GenericInfoCommandValue); Assert.AreEqual(ret.Uuid, "Shortname1"); }
public async Task TestCommandSynchronizeLocalFolderToBucketWithInvalidRemotePathIsBlockedBySanitization() { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new SynchronizeLocalFolderToBucketCommand(); var config = new BucketConfiguration() { LocalPathGet = "a", RemoteRelativePath = "/invalid//Path", DeleteFiles = true, }; CommandValues.GenericInfoCommandValue ret = await command.ExecuteAsync(bucket, config, ct); Assert.IsTrue(ret is CommandValues.GenericInfoCommandValue); Assert.AreEqual(ret.Uuid, "Shortname1"); Assert.AreEqual("Synchronization failed. Invalid remote path", (ret as CommandValues.GenericInfoCommandValue).Message); }
public async Task TestCommandRemoveBucketEntity() { var bucket = Builder <FakeBucket> .CreateNew().Build(); CancellationToken ct = default(CancellationToken); var command = new RemoveEntityBucketCommand(); var config = new BucketConfiguration() { LocalPathGet = "a", RemoteRelativePaths = new List <string> { "b" }, DeleteFiles = true, }; CommandValues.GenericInfoCommandValue ret = await command.ExecuteAsync(bucket, config, ct); Assert.IsTrue(ret is CommandValues.GenericInfoCommandValue); Assert.AreEqual(ret.Uuid, "Shortname1"); }