public IObservable <TResult> PbcRepeatRead <TResult>(IRiakEndPoint endPoint, Func <TResult, bool> repeatRead) where TResult : class, new() { var pbcStreamReadIterator = Observable.Create <TResult>(async observer => { await endPoint.GetMultipleResultViaPbc(async socket => { try { TResult result; do { result = await PbcRead <TResult>(socket).ConfigureAwait(false); observer.OnNext(result); } while (repeatRead(result)); observer.OnCompleted(); } catch (Exception exception) { observer.OnError(exception); } }).ConfigureAwait(false); return(Disposable.Empty); }); return(pbcStreamReadIterator); }
//eejmplo public Form1() { InitializeComponent(); IRiakEndPoint cluster = RiakCluster.FromConfig("riakConfig"); client = cluster.CreateClient(); }
public async Task <TResult> PbcRead <TResult>(IRiakEndPoint endPoint) where TResult : class, new() { var result = await endPoint.GetSingleResultViaPbc(async socket => await PbcRead <TResult>(socket).ConfigureAwait(false)); return(result); }
static void Main(string[] args) { using (IRiakEndPoint endpoint = RiakCluster.FromConfig("riakConfig")) { IRiakClient client = endpoint.CreateClient(); UserRepository userRepo = new UserRepository(client); MsgRepository msgRepo = new MsgRepository(client); TimelineRepository timelineRepo = new TimelineRepository(client); TimelineManager timelineMgr = new TimelineManager(timelineRepo, msgRepo); // Create and save users var marleen = new User("marleenmgr", "Marleen Manager", "*****@*****.**"); var joe = new User("joeuser", "Joe User", "*****@*****.**"); userRepo.Save(marleen); userRepo.Save(joe); // Create new Msg, post to timelines Msg msg = new Msg(marleen.UserName, joe.UserName, "Welcome to the company!"); timelineMgr.PostMsg(msg); // Get Joe's inbox for today, get first message Timeline joesInboxToday = timelineMgr.GetTimeline(joe.UserName, Timeline.TimelineType.Inbox, DateTime.UtcNow); Msg joesFirstMsg = msgRepo.Get(joesInboxToday.MsgKeys.First()); Console.WriteLine("From: " + joesFirstMsg.Sender); Console.WriteLine("Msg : " + joesFirstMsg.Text); } }
public IObservable <TResult> PbcWriteStreamRead <TRequest, TResult>(IRiakEndPoint endPoint, TRequest request, Func <TResult, bool> repeatRead) where TRequest : class where TResult : class, new() { return(PbcWriteStreamReadIterator(endPoint, request, repeatRead)); }
internal RiakClient(IRiakEndPoint endPoint, string seed = null) { _endPoint = endPoint; ClientId = GetClientId(seed); Async = new RiakAsyncClient(this); }
public async Task PbcWriteRead(IRiakEndPoint endPoint, MessageCode messageCode, MessageCode expectedMessageCode) { await endPoint.GetSingleResultViaPbc(async socket => { await PbcWrite(socket, messageCode).ConfigureAwait(false); await PbcRead(socket, expectedMessageCode).ConfigureAwait(false); }).ConfigureAwait(false); }
public LiveRiakConnectionTestBase(string section = "riak1NodeConfiguration") { // TODO: do something smarter with this // switch between cluster and load balancer configuration "easily" by changing the following // two lines around //Cluster = RiakExternalLoadBalancer.FromConfig("riakHaproxyConfiguration"); Cluster = RiakCluster.FromConfig(section); }
public LiveRiakConnectionTestBase(string section = "riak1NodeConfiguration") { // TODO: do something smarter with this // switch between cluster and load balancer configuration "easily" by changing the following // two lines around //Cluster = RiakExternalLoadBalancer.FromConfig("riakHaproxyConfiguration"); Cluster = RiakCluster.FromConfig(section); }
public async Task PbcWriteRead <TRequest>(IRiakEndPoint endPoint, TRequest request, MessageCode expectedMessageCode) where TRequest : class { await endPoint.GetSingleResultViaPbc(async socket => { await PbcWrite(socket, request).ConfigureAwait(false); await PbcRead(socket, expectedMessageCode).ConfigureAwait(false); }).ConfigureAwait(false); }
public void ShortConnectTimeoutMayResultInError() { IRiakEndPoint cluster = RiakCluster.FromConfig("riakShortConnectConfiguration"); IRiakClient client = cluster.CreateClient(); RiakResult result = client.Ping(); if (!result.IsSuccess) { Assert.IsTrue(result.ErrorMessage.Contains("Connection to remote server timed out"), result.ErrorMessage); } }
public void ShortReadTimeoutMayResultInError() { IRiakEndPoint cluster = RiakCluster.FromConfig("riakShortReadConfiguration"); IRiakClient client = cluster.CreateClient(); RiakResult result = client.Ping(); if (!result.IsSuccess) { Assert.IsTrue(result.ErrorMessage.Contains("the connected party did not properly respond after a period of time"), result.ErrorMessage); } }
private static void DeleteExistingKeys(IRiakEndPoint cluster, string bucket) { // Delete all keys in bucket... maybe should just delete the bucket itself var keys = cluster.CreateClient().StreamListKeys(bucket).Value.ToList(); Console.WriteLine("Cleaning up {0} existing items", keys.Count); foreach (var key in keys) { var res = cluster.CreateClient().Delete(new RiakObjectId { Bucket = bucket, Key = key }); } }
public async Task <TResult> PbcWriteRead <TResult>(IRiakEndPoint endPoint, MessageCode messageCode) where TResult : class, new() { var result = await endPoint.GetSingleResultViaPbc(async socket => { await PbcWrite(socket, messageCode).ConfigureAwait(false); var result2 = await PbcRead <TResult>(socket).ConfigureAwait(false); return(result2); }).ConfigureAwait(false); return(result); }
static void Main(string[] args) { Console.WriteLine("Creating Data"); Customer customer = CreateCustomer(); IEnumerable <Order> orders = CreateOrders(customer); OrderSummary orderSummary = CreateOrderSummary(customer, orders); Console.WriteLine("Starting Client"); using (IRiakEndPoint endpoint = RiakCluster.FromConfig("riakConfig")) { IRiakClient client = endpoint.CreateClient(); Console.WriteLine("Storing Data"); client.Put(ToRiakObject(customer)); foreach (Order order in orders) { // NB: this adds secondary index data as well client.Put(ToRiakObject(order)); } client.Put(ToRiakObject(orderSummary)); Console.WriteLine("Fetching related data by shared key"); string key = "1"; var result = client.Get(customersBucketName, key); CheckResult(result); Console.WriteLine("Customer 1: {0}\n", GetValueAsString(result)); result = client.Get(orderSummariesBucketName, key); CheckResult(result); Console.WriteLine("OrderSummary 1: {0}\n", GetValueAsString(result)); Console.WriteLine("Index Queries"); // Query for order keys where the SalesPersonId index is set to 9000 var riakIndexId = new RiakIndexId(ordersBucketName, ordersSalesPersonIdIndexName); RiakResult <RiakIndexResult> indexRiakResult = client.GetSecondaryIndex(riakIndexId, 9000); // NB: *must* use 9000 as integer here. CheckResult(indexRiakResult); RiakIndexResult indexResult = indexRiakResult.Value; Console.WriteLine("Jane's orders (key values): {0}", string.Join(", ", indexResult.IndexKeyTerms.Select(ikt => ikt.Key))); // Query for orders where the OrderDate index is between 2013-10-01 and 2013-10-31 riakIndexId = new RiakIndexId(ordersBucketName, ordersOrderDateIndexName); indexRiakResult = client.GetSecondaryIndex(riakIndexId, "2013-10-01", "2013-10-31"); // NB: *must* use strings here. CheckResult(indexRiakResult); indexResult = indexRiakResult.Value; Console.WriteLine("October orders (key values): {0}", string.Join(", ", indexResult.IndexKeyTerms.Select(ikt => ikt.Key))); } }
public async Task <TResult> PbcWriteRead <TRequest, TResult>(IRiakEndPoint endPoint, TRequest request) where TRequest : class where TResult : class, new() { var result = await endPoint.GetSingleResultViaPbc(async socket => { await PbcWrite(socket, request).ConfigureAwait(false); var singleResult = await PbcRead <TResult>(socket).ConfigureAwait(false); return(singleResult); }).ConfigureAwait(false); return(result); }
private async Task InsertMessagesIntoDatabase(string table, List <Message> allMessages) { IRiakEndPoint cluster = RiakCluster.FromConfig("riakConfig"); IRiakClient client = cluster.CreateClient(); while (allMessages.Count() > 0) { List <Message> messages = allMessages.Take(80).ToList(); allMessages.RemoveRange(0, messages.Count()); var rows = new List <Row>(); foreach (Message message in messages) { var cells = new Cell[] { new Cell("LT"), new Cell(message.SerialNo), new Cell(message.DeviceName), new Cell(message.Timestamp), new Cell(message.Value) }; rows.Add(new Row(cells)); } var columns = new Column[] { new Column("Country", ColumnType.Varchar), new Column("SerialNo", ColumnType.Varchar), new Column("DeviceName", ColumnType.Varchar), new Column("Time", ColumnType.Timestamp), new Column("Value", ColumnType.Double) }; var cmd = new Store.Builder() .WithTable(table) .WithColumns(columns) .WithRows(rows) .Build(); RiakResult rslt = client.Execute(cmd); if (!rslt.IsSuccess) { throw new Exception("Connection to Riak was not successful. AllMessages: " + allMessages.Count()); } } }
public TestBase() { #if NOAUTH cluster = RiakCluster.FromConfig("riak1NodeNoAuthConfiguration"); #else if (MonoUtil.IsRunningOnMono) { cluster = RiakCluster.FromConfig("riak1NodeNoAuthConfiguration"); } else { cluster = RiakCluster.FromConfig("riak1NodeConfiguration"); } #endif client = cluster.CreateClient(); }
public TestBase(bool auth = true) { #if NOAUTH cluster = RiakCluster.FromConfig("riak1NodeNoAuthConfiguration"); #else if (auth == false || MonoUtil.IsRunningOnMono) { cluster = RiakCluster.FromConfig("riak1NodeNoAuthConfiguration"); } else { cluster = RiakCluster.FromConfig("riak1NodeConfiguration"); } #endif client = cluster.CreateClient(); }
public LiveRiakConnectionTestBase() { string configName = "riakConfiguration"; #if NOAUTH configName = "riakNoAuthConfiguration"; #else if (MonoUtil.IsRunningOnMono) { configName = "riakNoAuthConfiguration"; } else { configName = "riakConfiguration"; } #endif Cluster = RiakCluster.FromConfig(configName); }
public LiveRiakConnectionTestBase() { string configName = "riakConfiguration"; #if NOAUTH configName = "riakNoAuthConfiguration"; #else if (MonoUtil.IsRunningOnMono) { configName = "riakNoAuthConfiguration"; } else { configName = "riakConfiguration"; } #endif Cluster = RiakCluster.FromConfig(configName); }
private void InsertMessageIntoDatabase(string table, Message message) { IRiakEndPoint cluster = RiakCluster.FromConfig("riakConfig"); IRiakClient client = cluster.CreateClient(); var cells = new Cell[] { new Cell("LT"), new Cell(message.SerialNo), new Cell(message.DeviceName), new Cell(message.Timestamp), new Cell(message.Value) }; var rows = new Row[] { new Row(cells) }; var columns = new Column[] { new Column("Country", ColumnType.Varchar), new Column("SerialNo", ColumnType.Varchar), new Column("DeviceName", ColumnType.Varchar), new Column("Time", ColumnType.Timestamp), new Column("Value", ColumnType.Double) }; var cmd = new Store.Builder() .WithTable(table) .WithColumns(columns) .WithRows(rows) .Build(); RiakResult rslt = client.Execute(cmd); if (!rslt.IsSuccess) { throw new Exception("Connection to Riak was not successful."); } }
public LiveRiakConnectionTestBase() { string userName = Environment.GetEnvironmentVariable("USERNAME"); string configName = "riak1NodeConfiguration"; #if NOAUTH configName = userName == "buildbot" ? "riak1NodeNoAuthConfiguration" : "riakDevrelNoAuthConfiguration"; #else if (MonoUtil.IsRunningOnMono) { configName = "riak1NodeNoAuthConfiguration"; } else { configName = userName == "buildbot" ? "riak1NodeConfiguration" : "riakDevrelConfiguration"; } #endif Cluster = RiakCluster.FromConfig(configName); }
public static IRiakEndPoint GetConnectionManager(string host, int port) { if (cluster == null) { var tempFileName = Path.GetTempFileName(); File.AppendAllText(tempFileName, String.Format(@"<?xml version=""1.0"" encoding=""utf-8"" ?> <configuration> <configSections> <section name=""riakConfig"" type=""CorrugatedIron.Config.RiakClusterConfiguration, CorrugatedIron""/> </configSections> <riakConfig nodePollTime=""5000"" defaultRetryWaitTime=""200"" defaultRetryCount=""3""> <nodes> <node name=""dev1"" hostAddress=""{0}"" pbcPort=""{1}"" restScheme=""http"" restPort=""8098"" poolSize=""20"" /> </nodes> </riakConfig> </configuration> ", host, port)); cluster = RiakCluster.FromConfig("riakConfig", tempFileName); } return cluster; }
public MainForm() { InitializeComponent(); _cluster = RiakCluster.FromConfig("riakConfig"); _client = _cluster.CreateClient(); _worker = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = false }; _worker.DoWork += AsyncLoadImages; _resizeSettings = new ResizeSettings { MaxWidth = 120, MaxHeight = 100, Format = "jpg" }; }
public TestBase(bool useTtb = false, bool auth = true) { var config = RiakClusterConfiguration.LoadFromConfig("riakConfiguration"); var noAuthConfig = RiakClusterConfiguration.LoadFromConfig("riakNoAuthConfiguration"); if (useTtb) { config.UseTtbEncoding = true; noAuthConfig.UseTtbEncoding = true; } #if NOAUTH cluster = new RiakCluster(noAuthConfig); #else if (auth == false || MonoUtil.IsRunningOnMono) { cluster = new RiakCluster(noAuthConfig); } else { cluster = new RiakCluster(config); } #endif client = cluster.CreateClient(); }
public TestBase(bool useTtb = false, bool auth = true) { var config = RiakClusterConfiguration.LoadFromConfig("riakConfiguration"); var noAuthConfig = RiakClusterConfiguration.LoadFromConfig("riakNoAuthConfiguration"); if (useTtb) { config.UseTtbEncoding = true; noAuthConfig.UseTtbEncoding = true; } #if NOAUTH cluster = new RiakCluster(noAuthConfig); #else if (auth == false || MonoUtil.IsRunningOnMono) { cluster = new RiakCluster(noAuthConfig); } else { cluster = new RiakCluster(config); } #endif client = cluster.CreateClient(); }
public ExampleBase() { endpoint = RiakCluster.FromConfig("riakConfig"); }
public DinnerRepository() { _cluster = new RiakCluster(_clusterConfig, new RiakConnectionFactory()); _client = _cluster.CreateClient(); }
static Program() { cluster = RiakCluster.FromConfig("riakConfig"); }
static Program() { cluster = RiakCluster.FromConfig("riakConfig"); }
public Task <RiakRestResponse> RestRequest(IRiakEndPoint endPoint, RiakRestRequest request) { return(endPoint.GetSingleResultViaRest(async serverUrl => { var baseUri = new StringBuilder(serverUrl).Append(request.Uri); if (request.QueryParams.Count > 0) { baseUri.Append("?"); var first = request.QueryParams.First(); baseUri.Append(first.Key.UrlEncoded()).Append("=").Append(first.Value.UrlEncoded()); request.QueryParams.Skip(1) .ForEach( kv => baseUri.Append("&") .Append(kv.Key.UrlEncoded()) .Append("=") .Append(kv.Value.UrlEncoded())); } var targetUri = new Uri(baseUri.ToString()); var req = (HttpWebRequest)WebRequest.Create(targetUri); req.KeepAlive = true; req.Method = request.Method; req.Credentials = CredentialCache.DefaultCredentials; if (!string.IsNullOrWhiteSpace(request.ContentType)) { req.ContentType = request.ContentType; } if (!request.Cache) { req.Headers.Set(RiakConstants.Rest.HttpHeaders.DisableCacheKey, RiakConstants.Rest.HttpHeaders.DisableCacheValue); } request.Headers.ForEach(h => req.Headers.Set(h.Key, h.Value)); if (request.Body != null && request.Body.Length > 0) { req.ContentLength = request.Body.Length; var writer = await req.GetRequestStreamAsync().ConfigureAwait(false); writer.Write(request.Body, 0, request.Body.Length); } else { req.ContentLength = 0; } try { var response = (HttpWebResponse)await req.GetResponseAsync().ConfigureAwait(false); var result = new RiakRestResponse { ContentLength = response.ContentLength, ContentType = response.ContentType, StatusCode = response.StatusCode, Headers = response.Headers.AllKeys.ToDictionary(k => k, k => response.Headers[k]), ContentEncoding = !string.IsNullOrWhiteSpace(response.ContentEncoding) ? Encoding.GetEncoding(response.ContentEncoding) : Encoding.Default }; if (response.ContentLength > 0) { using (var responseStream = response.GetResponseStream()) { if (responseStream != null) { using (var reader = new StreamReader(responseStream, result.ContentEncoding)) { result.Body = reader.ReadToEnd(); } } } } if (result.StatusCode != HttpStatusCode.NoContent) { throw new RiakException((uint)ResultCode.InvalidResponse, "Unexpected Status Code: {0} ({1})".Fmt(result.StatusCode, (int)result.StatusCode), false); } return result; } catch (RiakException ex) { throw; } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { throw new RiakException((uint)ResultCode.HttpError, ex.Message, false); } throw new RiakException((uint)ResultCode.HttpError, ex.Message, true); } catch (Exception ex) { throw new RiakException((uint)ResultCode.CommunicationError, ex.Message, true); } })); }
internal RiakAsyncClient(IRiakEndPoint endPoint) { _endPoint = endPoint; }
public RiakStorage(byte[] infoHash) { _cluster = RiakCluster.FromConfig(ClusterConfig); _client = _cluster.CreateClient(); }
public Task PbcWrite(IRiakEndPoint endPoint, MessageCode messageCode) { return(endPoint.GetSingleResultViaPbc(async socket => await PbcWrite(socket, messageCode).ConfigureAwait(false))); }
public ExampleBase() { endpoint = RiakCluster.FromConfig("riakConfig"); }
public RiakBatch(IRiakEndPoint endPoint) { _endPoint = endPoint; _endPointContext = new RiakEndPointContext(); }
static RiakSessionStateStore() { EndPoint = RiakCluster.FromConfig("riakConfig"); }
public IObservable <TResult> PbcWriteStreamRead <TResult>(IRiakEndPoint endPoint, MessageCode messageCode, Func <TResult, bool> repeatRead) where TResult : class, new() { return(PbcWriteStreamReadIterator(endPoint, messageCode, repeatRead)); }
public override void SetUp() { base.SetUp(); cluster = RiakCluster.FromConfig("riakConfig"); client = cluster.CreateClient(); fixture.Inject(client); userDocumentMapper = fixture.Freeze<IMapper<User, UserDocument>>(); userMapper = fixture.Freeze<IMapper<UserDocument, User>>(); sut = fixture.Create<UserRepository>(); }
internal RiakClient(IRiakEndPoint endPoint) { _endPoint = endPoint; Async = new RiakAsyncClient(endPoint); }
static void Main(string[] args) { const string bucket = "test"; try { using (IRiakEndPoint endpoint = RiakCluster.FromConfig("riakConfig")) { IRiakClient client = endpoint.CreateClient(); // Creating Objects In Riak Console.WriteLine("Creating Objects In Riak..."); int val1 = 1; var objectId1 = new RiakObjectId(bucket, "one"); var riakObject1 = new RiakObject(objectId1, val1); var result = client.Put(riakObject1); CheckResult(result); string val2 = "two"; var objectId2 = new RiakObjectId(bucket, "two"); var riakObject2 = new RiakObject(objectId2, val2); result = client.Put(riakObject2); CheckResult(result); var val3 = new Dictionary <string, int> { { "myValue1", 3 }, { "myValue2", 4 } }; var objectId3 = new RiakObjectId(bucket, "three"); var riakObject3 = new RiakObject(objectId3, val3); result = client.Put(riakObject3); CheckResult(result); // Fetching Objects From Riak Console.WriteLine("Reading Objects From Riak..."); var fetchResult1 = client.Get(objectId1); CheckResult(fetchResult1); RiakObject fetchObject1 = fetchResult1.Value; int fetchVal1 = fetchObject1.GetObject <int>(); Debug.Assert(val1 == fetchVal1, "Assert Failed", "val1 {0} != fetchVal1 {1}", val1, fetchVal1); var fetchResult2 = client.Get(objectId2); CheckResult(fetchResult2); RiakObject fetchObject2 = fetchResult2.Value; string fetchVal2 = fetchObject2.GetObject <string>(); Debug.Assert(val2 == fetchVal2, "Assert Failed", "val2 {0} != fetchVal2 {1}", val2, fetchVal2); var fetchResult3 = client.Get(objectId3); CheckResult(fetchResult3); RiakObject fetchObject3 = fetchResult3.Value; var fetchVal3 = fetchObject3.GetObject <Dictionary <string, int> >(); Debug.Assert(dictEqualityComparer.Equals(val3, fetchVal3), "Assert Failed", "val3 {0} != fetchVal3 {1}", val3, fetchVal3); // Updating Objects In Riak Console.WriteLine("Updating Objects In Riak"); fetchVal3["myValue1"] = 42; var updateObject1 = new RiakObject(bucket, "three", fetchVal3); var updateResult1 = client.Put(updateObject1); CheckResult(updateResult1); var fetchResult4 = client.Get(objectId3); CheckResult(fetchResult4); RiakObject fetchObject4 = fetchResult4.Value; var fetchVal4 = fetchObject4.GetObject <Dictionary <string, int> >(); Debug.Assert(false == dictEqualityComparer.Equals(val3, fetchVal4), "Assert Failed", "val3 {0} == fetchVal4 {1}", val3, fetchVal4); Debug.Assert(fetchVal4["myValue1"] == 42, "Assert Failed", "myValue1 should have been 42"); // Deleting Objects From Riak Console.WriteLine("Deleting Objects From Riak..."); RiakResult delResult1 = client.Delete(objectId1); CheckResult(delResult1); RiakResult delResult2 = client.Delete(objectId2); CheckResult(delResult2); RiakResult delResult3 = client.Delete(objectId3); CheckResult(delResult3); // Working With Complex Objects Console.WriteLine("Working With Complex Objects..."); var book = new Book(); book.ISBN = "1111979723"; book.Title = "Moby Dick"; book.Author = "Herman Melville"; book.Body = "Call me Ishmael. Some years ago..."; book.CopiesOwned = 3; var bookId = new RiakObjectId("books", book.ISBN); var bookObject = new RiakObject(bookId, book); var bookPutResult = client.Put(bookObject); CheckResult(bookPutResult); var fetchBookResult = client.Get(bookId); CheckResult(fetchBookResult); RiakObject fetchedBookObject = fetchBookResult.Value; string bookJson = Encoding.UTF8.GetString(fetchedBookObject.Value); Console.WriteLine("Serialized Object: {0}", bookJson); var bookDeleteResult = client.Delete(bookId); CheckResult(bookDeleteResult); } } catch (Exception e) { Console.Error.WriteLine("Exception: {0}", e.Message); } }
private static void VerifyObjects(IRiakEndPoint cluster, ConcurrentBag<StoredObject> storedObjects) { var client = cluster.CreateClient(); foreach (var storedObj in storedObjects) { var result = client.Get(new RiakObjectId { Bucket = storedObj.Value.Bucket, Key = storedObj.Value.Key }); var hash = GetHash(result.Value.Value); if (hash != storedObj.Hash) throw new Exception("Put & Get checksums do not match"); } }
private static ConcurrentBag<StoredObject> StoreObjects(IRiakEndPoint cluster, string bucket, int maxThreads, int maxObjSizeKB, int minObjSizeKB, int itemsToStore, ConcurrentBag<Stopwatch> individualTimings, Stopwatch stopwatch) { // Create pool of Riak Clients and Random objects var riakResourcePool = new ConcurrentBag<RiakBenchmarkResource>(); for (int i = 0; i < maxThreads; ++i) riakResourcePool.Add(new RiakBenchmarkResource { Client = cluster.CreateClient(), Random = new Random() }); var size = maxObjSizeKB * 1024 * 2; // multiply by two to make random buffer copy math easier below var randomBytes = GetRandomByteArray(size); var storedObjects = new ConcurrentBag<StoredObject>(); stopwatch.Start(); int count = 0; int totalSize = 0; try { Console.WriteLine("Storing {0} objects in Riak", itemsToStore); Parallel.For(0, itemsToStore, new ParallelOptions { MaxDegreeOfParallelism = maxThreads }, i => { var iterationStopwatch = Stopwatch.StartNew(); RiakBenchmarkResource riakResource; riakResourcePool.TryTake(out riakResource); try { var rand = riakResource.Random; var item = new byte[rand.Next(minObjSizeKB * 1024, maxObjSizeKB * 1024) + 1]; Array.Copy(randomBytes, rand.Next(0, maxObjSizeKB * 1024), item, 0, item.Length); var obj = new RiakObject(bucket, Guid.NewGuid().ToString(), item, "application/binary", CorrugatedIron.Util.RiakConstants.CharSets.Utf8); var result = riakResource.Client.Put(obj, new RiakPutOptions { ReturnBody = false, W = 2 }); if (!result.IsSuccess) System.Diagnostics.Debugger.Break(); int countSnapshot = Interlocked.Increment(ref count); Interlocked.Add(ref totalSize, item.Length); if (countSnapshot % Math.Max(itemsToStore / 10, 1) == 0) Console.WriteLine("Processed {0} of {1}. Elapsed: {2}", count, itemsToStore, stopwatch.Elapsed); storedObjects.Add(new StoredObject { Value = result.Value, Size = item.Length, Hash = GetHash(item) }); } finally { riakResourcePool.Add(riakResource); iterationStopwatch.Stop(); individualTimings.Add(iterationStopwatch); } }); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } stopwatch.Stop(); return storedObjects; }
public LiveRiakConnectionTestBase() { string userName = Environment.GetEnvironmentVariable("USERNAME"); string configName = "riak1NodeConfiguration"; #if NOAUTH configName = userName == "buildbot" ? "riak1NodeNoAuthConfiguration" : "riakDevrelNoAuthConfiguration"; #else if (MonoUtil.IsRunningOnMono) { configName = "riak1NodeNoAuthConfiguration"; } else { configName = userName == "buildbot" ? "riak1NodeConfiguration" : "riakDevrelConfiguration"; } #endif Cluster = RiakCluster.FromConfig(configName); }