public string VoteAction(ChooserLbMessage message)
{
var _storage = NodeStorage.GetInstance();
NodeData worker;
var selected_Nodes = Distributor.FormateNodeList(3, out worker);
var neighbors = Mapping.Mapper.Map <List <NodeNeighbor> >(selected_Nodes);
var request_data = new NodeVoteMessage()
{
Message = message,
Neighbours = neighbors
};
var serialized = JsonConvert.SerializeObject(request_data);
var content = new StringContent(serialized, Encoding.UTF8, "application/json");
try
{
var response = worker.Sender.PostAsync(new Uri(new Uri(worker.IpAddress), "api/Vote"), content).Result;
return(response.Content.ReadAsStringAsync().Result);
}
catch (Exception e)
{
return("Error connection to Node" + e.Message);
}
}
public async Task <bool> SaveNodeDataAsync(NodeStorage <CindiClusterState> storage)
{
try
{
if (!DoesStateExist)
{
DoesStateExist = (await LoadNodeDataAsync() != null);
}
if (!DoesStateExist)
{
await _clusterState.InsertOneAsync(storage);
return(true);
}
else
{
//var filter = Builders<NodeStorage>.Filter.Eq("Id", storage.Id.ToString());
return((await _clusterState.ReplaceOneAsync(f => true, storage)).IsAcknowledged);
}
}
catch (Exception e)
{
if (e.Message.Contains("Collection was modified"))
{
}
else
{
Console.WriteLine("Failed to save state with error message " + e.Message + " with stack trace " + Environment.NewLine + e.StackTrace);
}
return(false);
}
}
public static NodeData GetExecutor()
{
var _storage = NodeStorage.GetInstance();
var totalNodeList = _storage.GetNodes();
var random = new Random();
var choosedIndex = random.Next(totalNodeList.Count());
var choosedNode = totalNodeList.ElementAt(choosedIndex);
return(choosedNode);
}
/// <summary>
/// Checks if a new entry set is being started. If so, sets the end offset of the previous
/// entry set and writes it to the output storage.
/// </summary>
/// <param name="endOffset">The end offset of the previous entry.</param>
/// <returns>The <see cref="Result"/> of the operation.</returns>
private Result FinalizePreviousEntrySet(long endOffset)
{
int prevEntrySetIndex = CurrentEntryIndex / EntriesPerEntrySet - 1;
int indexInEntrySet = CurrentEntryIndex % EntriesPerEntrySet;
// If the previous Add finished an entry set
if (CurrentEntryIndex > 0 && indexInEntrySet == 0)
{
// Set the end offset of that entry set
ref NodeHeader entrySetHeader = ref _entrySet.GetHeader();
entrySetHeader.Index = prevEntrySetIndex;
entrySetHeader.Count = EntriesPerEntrySet;
entrySetHeader.Offset = endOffset;
// Write the entry set to the entry storage
long storageOffset = (long)NodeSize * prevEntrySetIndex;
Result rc = EntryStorage.Write(storageOffset, _entrySet.GetBuffer());
if (rc.IsFailure())
{
return(rc);
}
// Clear the entry set buffer to begin the new entry set
_entrySet.FillZero();
// Check if we're writing in L2 nodes
if (CurrentL2OffsetIndex > OffsetsPerNode)
{
int prevL2NodeIndex = CurrentL2OffsetIndex / OffsetsPerNode - 2;
int indexInL2Node = CurrentL2OffsetIndex % OffsetsPerNode;
// If the previous Add finished an L2 node
if (indexInL2Node == 0)
{
// Set the end offset of that node
ref NodeHeader l2NodeHeader = ref _l2Node.GetHeader();
l2NodeHeader.Index = prevL2NodeIndex;
l2NodeHeader.Count = OffsetsPerNode;
l2NodeHeader.Offset = endOffset;
// Write the L2 node to the node storage
long nodeOffset = (long)NodeSize * (prevL2NodeIndex + 1);
rc = NodeStorage.Write(nodeOffset, _l2Node.GetBuffer());
if (rc.IsFailure())
{
return(rc);
}
// Clear the L2 node buffer to begin the new node
_l2Node.FillZero();
}
}
public void FormateNodeListTest()
{
List <NodeData> node_list = new List <NodeData>
{
new NodeData()
{
NodeId = "N00-1", Name = "Node1"
},
new NodeData()
{
NodeId = "N00-2", Name = "Node2"
},
new NodeData()
{
NodeId = "N00-3", Name = "Node3"
},
new NodeData()
{
NodeId = "N00-4", Name = "Node4"
},
new NodeData()
{
NodeId = "N00-5", Name = "Node5"
},
new NodeData()
{
NodeId = "N00-6", Name = "Node6"
},
new NodeData()
{
NodeId = "N00-7", Name = "Node7"
},
};
var _storage = NodeStorage.GetInstance();
foreach (var item in node_list)
{
_storage.AddNode(item);
}
NodeData selectedNode;
var selected_nodes = Distributor.FormateNodeList(3, out selectedNode);
var outputList = Mapper.Mapping.Mapper.Map <List <NodeNeighbor> >(selected_nodes);
Assert.IsNotNull(outputList);
}
public void RegisterNode(NodeData node)
{
var storage = NodeStorage.GetInstance();
var registered_nodes = storage.GetNodes();
if (registered_nodes.FirstOrDefault(m => m.NodeId == node.NodeId) == null)
{
storage.AddNode(node);
}
else
{
storage.ExcludeNode(node.NodeId);
storage.AddNode(node);
}
}
public static List <NodeNeighbor> FormateNodeList(int i, out NodeData Executor)
{
var _storage = NodeStorage.GetInstance();
var totalNodeList = _storage.GetNodes();
var random = new Random();
if (totalNodeList.Count() <= i)
{
throw new ArgumentOutOfRangeException("Number of registered Nodes is smaller than counter i");
}
else
{
var choosedIndex = 0; //random.Next(totalNodeList.Count());
var choosedNode = totalNodeList.ElementAt(choosedIndex);
Executor = choosedNode;
var choosedNodes = totalNodeList.OrderBy(x => random.Next()).Where(m => m.NodeId != choosedNode.NodeId).Take(i).Distinct();
var neighbours = Mapping.Mapper.Map <List <NodeNeighbor> >(choosedNodes);
return(neighbours);
}
}
public Task <bool> SaveNodeDataAsync(NodeStorage <Z> storage)
{
return(Task.FromResult(true));
}
/* public static RaftService<TestState> GetTestConsensusCoreNode()
* {
* var moqClusterOptions = new Mock<IOptions<ClusterOptions>>();
* moqClusterOptions.Setup(mqo => mqo.Value).Returns(new ClusterOptions()
* {
* NodeUrls = "localhost:5022",
* TestMode = true,
* NumberOfShards = 1,
* DataTransferTimeoutMs = 1000,
* ElectionTimeoutMs = 1000,
* LatencyToleranceMs = 1000,
* MinimumNodes = 1
* });
*
* var moqNodeOptions = new Mock<IOptions<NodeOptions>>();
* moqNodeOptions.Setup(mqo => mqo.Value).Returns(new NodeOptions() { });
*
* var serviceProvider = new ServiceCollection()
* .AddLogging()
* .BuildServiceProvider();
*
* var factory = serviceProvider.GetService<ILoggerFactory>();
*
* var logger = factory.CreateLogger<RaftService<TestState>>();
*
* NodeInMemoryRepository<TestState> inMemoryRepository = new NodeInMemoryRepository<TestState>();
* var NodeStorage = new NodeStorage<TestState>(inMemoryRepository) { };
* var _dataRouter = new TestDataRouter();
* var _stateMachine = new StateMachine<TestState>();
* var _connector = new ClusterClient(TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000));
*
* return new ConsensusCoreNode<TestState>(moqClusterOptions.Object,
* moqNodeOptions.Object,
* logger,
* _stateMachine,
* inMemoryRepository,
* _connector,
* _dataRouter,
* new ShardManager<TestState, IShardRepository>(_stateMachine,
* factory.CreateLogger<ShardManager<TestState, IShardRepository>>(),
* _connector,
* _dataRouter,
* moqClusterOptions.Object,
* inMemoryRepository),
* NodeStorage
* );
* }*/
public static DataService <TestState> GetTestShardManager()
{
var serviceProvider = new ServiceCollection()
.AddLogging()
.BuildServiceProvider();
var _stateMachine = new StateMachine <TestState>()
{
};
var factory = serviceProvider.GetService <ILoggerFactory>();
NodeInMemoryRepository <TestState> inMemoryRepository = new NodeInMemoryRepository <TestState>();
var _dataRouter = new TestDataRouter();
var moqClusterOptions = new Mock <IOptions <ClusterOptions> >();
var moqNodeOptions = new Mock <IOptions <NodeOptions> >();
moqNodeOptions.Setup(mqo => mqo.Value).Returns(new NodeOptions()
{
});
Guid nodeStorageId = Guid.NewGuid();
var NodeStorage = new NodeStorage <TestState>(factory.CreateLogger <NodeStorage <TestState> >(), inMemoryRepository)
{
Id = nodeStorageId
};
var nodeStateService = new NodeStateService()
{
Id = nodeStorageId
};
var services = new ServiceCollection();
var provider = services.BuildServiceProvider();
var _connector = new ClusterClient(new ClusterConnectionPool <TestState>(_stateMachine, TimeSpan.FromMilliseconds(10000), TimeSpan.FromMilliseconds(1000)), provider, nodeStateService);
_stateMachine.ApplyLogsToStateMachine(new List <ConsensusCore.Domain.Models.LogEntry>()
{
new ConsensusCore.Domain.Models.LogEntry()
{
Commands = new List <BaseCommand>()
{
new CreateIndex()
{
Type = "number",
Shards = new List <ShardAllocationMetadata>()
{
new ShardAllocationMetadata()
{
Id = DefaultShardId,
InsyncAllocations = new HashSet <Guid>()
{
nodeStorageId
},
PrimaryAllocation = nodeStorageId,
Type = "number",
StaleAllocations = new HashSet <Guid>()
}
}
}
}
}
});
moqClusterOptions.Setup(mqo => mqo.Value).Returns(new ClusterOptions()
{
NodeUrls = "localhost:5022",
TestMode = true,
NumberOfShards = 1,
DataTransferTimeoutMs = 1000,
ElectionTimeoutMs = 1000,
LatencyToleranceMs = 1000,
MinimumNodes = 1
});
var manager = new DataService <TestState>(
factory,
inMemoryRepository,
_dataRouter,
_stateMachine,
nodeStateService,
_connector,
moqClusterOptions.Object,
inMemoryRepository,
moqNodeOptions.Object
);
return(manager);
}
