private void PersistTopology()
{
byte[] buffer;
var topology = master.Topology.GetTopology();
using (var stream = new MemoryStream())
{
var writer = new MessageStreamWriter <TopologyResultMessage>(stream);
writer.Write(topology);
writer.Flush();
buffer = stream.ToArray();
}
hashTable.Batch(actions =>
{
var values = actions.Get(new GetRequest
{
Key = Constants.Topology
});
actions.Put(new PutRequest
{
Key = Constants.Topology,
ParentVersions = values.Select(x => x.Version).ToArray(),
Bytes = buffer,
IsReadOnly = true
});
actions.Commit();
});
}
public void Initialize()
{
logger.DebugFormat("Initializing msmq subscription storage on: {0}", subscriptionPath);
pht.Initialize();
pht.Batch(actions =>
{
var items = actions.GetItems(new GetItemsRequest
{
Key = SubscriptionsKey
});
foreach (var item in items)
{
object[] msgs;
try
{
msgs = messageSerializer.Deserialize(new MemoryStream(item.Value));
}
catch (Exception e)
{
throw new SubscriptionException("Could not deserialize message from subscription queue", e);
}
try
{
currentlyLoadingPersistentData = true;
foreach (var msg in msgs)
{
HandleAdministrativeMessage(new CurrentMessageInformation
{
AllMessages = msgs,
Message = msg,
});
}
}
catch (Exception e)
{
throw new SubscriptionException("Failed to process subscription records", e);
}
finally
{
currentlyLoadingPersistentData = false;
}
}
actions.Commit();
});
}
public PutResult[] Put(int topologyVersion, params ExtendedPutRequest[] valuesToAdd)
{
AssertMatchingTopologyVersion(topologyVersion);
var results = new List <PutResult>();
using (var tx = new TransactionScope())
{
hashTable.Batch(actions =>
{
foreach (var request in valuesToAdd)
{
if (request.IsReplicationRequest == false && request.IsLocal == false)
{
AssertSegmentNotMoved(actions, request.Segment);
}
request.Tag = request.Segment;
if (request.ParentVersions == null)
{
throw new ArgumentException("Could not accept request with no ParentVersions");
}
if (request.Key.StartsWith(Constants.RhinoDhtStartToken) && request.IsLocal == false)
{
throw new ArgumentException(Constants.RhinoDhtStartToken + " is a reserved key prefix");
}
var put = actions.Put(request);
//prepare the value for replication
request.ReplicationVersion = put.Version;
results.Add(put);
}
HandleReplication(valuesToAdd);
actions.Commit();
});
tx.Complete();
}
return(results.ToArray());
}
public ReplicationResult ReplicateNextPage(NodeEndpoint replicationEndpoint,
ReplicationType type,
int segment)
{
var putRequests = new List <ExtendedPutRequest>();
var removalRequests = new List <ExtendedRemoveRequest>();
var done = false;
hashTable.Batch(actions =>
{
foreach (var getRequest in actions.GetKeysForTag(segment))
{
var alreadyReplicated = actions.HasReplicationInfo(getRequest.Key,
getRequest.SpecifiedVersion,
replicationEndpoint.GetHash());
if (alreadyReplicated)
{
continue;
}
var values = actions.Get(getRequest);
if (values.Length != 1)
{
continue;
}
var value = values[0];
putRequests.Add(new ExtendedPutRequest
{
Bytes = value.Data,
ExpiresAt = value.ExpiresAt,
IsReadOnly = value.ReadOnly,
IsReplicationRequest = true,
Key = value.Key,
ParentVersions = value.ParentVersions,
ReplicationTimeStamp = value.Timestamp,
ReplicationVersion = value.Version,
Tag = value.Tag,
Segment = value.Tag.Value,
});
actions.AddReplicationInfo(getRequest.Key,
getRequest.SpecifiedVersion,
replicationEndpoint.GetHash());
if (putRequests.Count >= 100)
{
break;
}
}
foreach (var request in actions.ConsumeRemovalReplicationInfo(replicationEndpoint.GetHash()))
{
removalRequests.Add(new ExtendedRemoveRequest
{
Key = request.Key,
SpecificVersion = request.SpecificVersion
});
if (removalRequests.Count >= 100)
{
break;
}
}
done = putRequests.Count == 0 && removalRequests.Count == 0;
if (done && type == ReplicationType.Ownership)
{
MarkSegmentAsAssignedToEndpoint(actions, replicationEndpoint, segment);
}
actions.Commit();
});
return(new ReplicationResult
{
PutRequests = putRequests.ToArray(),
RemoveRequests = removalRequests.ToArray(),
Done = done
});
}
