如何挑选备用机每个数据中心？数据中心、如何挑选、备用机
由于数据中心这是PHX，SLC，LVS和机器的列表，H0，H1，H2，H3如下所述的清单 -
数据中心= PHX，SLC，LVS
机器= H0，H1，H2，H3
我要生成以下组合只 -
A）PHX - H0
SLC - H1
LVS - H2
B）PHX - H1
SLC - H2
LVS - H3
C）PHX - H2
SLC - H3
LVS - H0
D）PHX - H3
SLC - H0
LVS - H1
我需要调用 getDatacenterMachineMapping 方法，它会给我上面的结果。对于第一次调用，它应该给我上面结果在 coloHost 地图，在第二次调用，它应该给我上面 B的结果在 coloHost 地图，在第三个电话，就应该给我上面 C测试结果在 coloHost 地图和第四个电话，就应该给我上面 D结果在 coloHost 地图和第五轮，它不应该给我任何东西，因为没有组合就走了。
私有静态列表＆LT;字符串＆GT;结肠= Arrays.asList（PHX，SLC，LVS）;
私有静态列表＆LT;字符串＆GT;主机= Arrays.asList（H0，H1，H2，H3）;
而（真）{
地图＆LT;字符串，字符串＆GT; coloHost = getDatacenterMachineMapping（）;
的System.out.println（coloHost）;
}
私有静态地图＆LT;字符串，字符串＆GT; getDatacenterMachineMapping（）{
//此处一些code？
}
在每遍每一个数据中心应该得到备用机/主机。他们不应该得到同样的机器。例如，在 A 如上图所示 - PHX得到H0 ， SLC获得H1 ， LVS得到H2 因此，所有的机器都为每个数据中心不同。而在如图 B 第二遍 - 现在 PHX获得H1 （监守PHX已经有了第一遍H0 ）， SLC了H2 （bcoz SLC已经拿到H1在第一遍）和 LVS有H3 （bcoz LVS已经得到了H2在第一遍）等等。
和一个例子 - 如果我只有三台主机，那么下面结合我应该得到的只有 -
数据中心= PHX，SLC，LVS
机器= H0，H1，H2
一）PHX - H0
SLC - H1
LVS - H2
B）PHX - H1
SLC - H2
LVS - H0
C）PHX - H2
SLC - H0
LVS - H1
任何思考如何可以做到这一点？
更新： -
我想你的低于code和它工作正常。我使用的无限循环，同时在我的主要方法，因此，这意味着，它会继续调用 getDatacenterMachineMapping 方法始终。因此，这里是我得到它看起来很不错。
{PHX = H0，SLC = H1，VS = H2}
{PHX = H1，SLC = H2，VS = H3}
{PHX = H2，SLC = H3，VS = H0}
{PHX = H3，SLC = H0，VS = H1}
{PHX = H0，SLC = H1，VS = H2}
{PHX = H1，SLC = H2，VS = H3}
{PHX = H2，SLC = H3，VS = H0}
所以，如果你看看成以上的映射，进行了打印出来。首先四是唯一的结果，我希望以后，我不想 getDatacenterMachineMapping 来给出任何结果，因为到那个时候，所有的四台机器的PHX得到打印出来，所有的四个机SLC得到打印出来，所有的四个机VS得到打印出来。如果你看到第五行，它再次开始，我不想 getDatacenterMachineMapping ，给出的结果。
下面是我的code，我曾尝试 -
公共静态无效的主要（字串[] args）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS），
Arrays.asList（H0，H1，H2，H3））;
而（真）{
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
的System.out.println（M1）;
}
}
类DatacenterMachineMapping {
私人布尔华美通= TRUE;
私人诠释hostListIndex = 0;
私人列表＆LT;字符串＆GT; datacenterList，主机列表;
公共DatacenterMachineMapping（名单＆LT;字符串＆GT; datacenterList，列表和LT;字符串＆GT;主机列表）{
this.datacenterList = datacenterList;
this.hostList =主机列表;
}
公共地图＆LT;字符串，字符串＆GT; getDatacenterMachineMapping（）{
地图＆LT;字符串，字符串＆GT; datacenterMachineMapping =新的HashMap＆LT;字符串，字符串＆GT;（）;
如果（！华美通）{
如果（hostListIndex == 0）{
hostListIndex = hostList.size（）;
}
hostListIndex--;
} 其他 {
新华美通= FALSE;
}
对于（字符串数据中心：datacenterList）{
如果（hostListIndex == hostList.size（））{
hostListIndex = 0;
}
datacenterMachineMapping.put（数据中心，hostList.get（hostListIndex ++））;
}
hostListIndex--;
返回datacenterMachineMapping;
}
}
解决方案
我可以从主索引中看到的模式是，每个后续调用 getDatacenterMachineMapping 启动该指数 I-1 ，其中我从previous通话的最后一个主机的索引。第一次通话开始于指数 0 ，并和身边旋转的可用主机。
例如，与第一主机列表： H0，H1，H2，H3
您
1）0 = H0，1 = H1，2 = H2
去年指数 2 ，减去1从它 - > 1 ，这是该指数在那里下一次调用应开始：
2）1 = H1，2 = H2，3 = H3
现在最后的指数为3，即你开始 2 下一次调用它留在你的名单只有两个主持人，你必须再旋转，即回去指数 0 再次，这给你
3）2 = H2，3 = H3，0 = H0
这同样适用于所述第二主机列表
下面上面的示例实现（可能需要进行调整，以完全符合您的要求，例如要检查数据中心是否已经有任何可能的主机，你可以把它包装成自己的类以及一套已分配主机（HashSet的））：
公共类DatacenterMachineMapping {
私人布尔华美通= TRUE;
私人诠释hostListIndex = 0;
私人列表＆LT;字符串＆GT; datacenterList，主机列表;
公共DatacenterMachineMapping（名单＆LT;字符串＆GT; datacenterList，列表和LT;字符串＆GT;主机列表）{
this.datacenterList = datacenterList;
this.hostList =主机列表;
}
公共地图＆LT;字符串，字符串＆GT; getDatacenterMachineMapping（）{
地图＆LT;字符串，字符串＆GT; datacenterMachineMapping =新的HashMap＆LT;＆GT;（）;
如果（！华美通）{
如果（hostListIndex == 0）{
hostListIndex = hostList.size（）;
}
hostListIndex--;
} 其他 {
新华美通= FALSE;
}
对于（字符串数据中心：datacenterList）{
如果（hostListIndex == hostList.size（））{
hostListIndex = 0;
}
datacenterMachineMapping.put（数据中心，hostList.get（hostListIndex ++））;
}
hostListIndex--;
返回datacenterMachineMapping;
}
}
和一些testings ...
公共类DatacenterMachineMappingTest {
@测试
公共无效的test1（）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS），
Arrays.asList（H0，H1，H2，H3））;
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m1.get（PHX））;
Assert.assertEquals（H1，m1.get（SLC））;
Assert.assertEquals（H2，m1.get（与））;
地图＆LT;字符串，字符串＆GT;平方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H1，m2.get（PHX））;
Assert.assertEquals（H2，m2.get（SLC））;
Assert.assertEquals（H3，m2.get（与））;
地图＆LT;字符串，字符串＆GT;立方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H2，m3.get（PHX））;
Assert.assertEquals（H3，m3.get（SLC））;
Assert.assertEquals（H0，m3.get（与））;
}
@测试
公共无效的test2（）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS），
Arrays.asList（H0，H1，H2））;
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m1.get（PHX））;
Assert.assertEquals（H1，m1.get（SLC））;
Assert.assertEquals（H2，m1.get（与））;
地图＆LT;字符串，字符串＆GT;平方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H1，m2.get（PHX））;
Assert.assertEquals（H2，m2.get（SLC））;
Assert.assertEquals（H0，m2.get（与））;
地图＆LT;字符串，字符串＆GT;立方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H2，m3.get（PHX））;
Assert.assertEquals（H0，m3.get（SLC））;
Assert.assertEquals（H1，m3.get（与））;
}
@测试
公共无效TEST3（）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS），
Arrays.asList（H0，H1））;
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m1.get（PHX））;
Assert.assertEquals（H1，m1.get（SLC））;
Assert.assertEquals（H0，m1.get（与））;
地图＆LT;字符串，字符串＆GT;平方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H1，m2.get（PHX））;
Assert.assertEquals（H0，m2.get（SLC））;
Assert.assertEquals（H1，m2.get（与））;
地图＆LT;字符串，字符串＆GT;立方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m3.get（PHX））;
Assert.assertEquals（H1，m3.get（SLC））;
Assert.assertEquals（H0，m3.get（与））;
}
@测试
公共无效TEST4（）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS），
Arrays.asList（H0，H1，H2，H3，H4，H5，H6））;
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m1.get（PHX））;
Assert.assertEquals（H1，m1.get（SLC））;
Assert.assertEquals（H2，m1.get（与））;
地图＆LT;字符串，字符串＆GT;平方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H1，m2.get（PHX））;
Assert.assertEquals（H2，m2.get（SLC））;
Assert.assertEquals（H3，m2.get（与））;
地图＆LT;字符串，字符串＆GT;立方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H2，m3.get（PHX））;
Assert.assertEquals（H3，m3.get（SLC））;
Assert.assertEquals（H4，m3.get（与））;
地图＆LT;字符串，字符串＆GT;的m4 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H3，m4.get（PHX））;
Assert.assertEquals（H4，m4.get（SLC））;
Assert.assertEquals（H5，m4.get（与））;
地图＆LT;字符串，字符串＆GT; M5 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H4，m5.get（PHX））;
Assert.assertEquals（H5，m5.get（SLC））;
Assert.assertEquals（H6，m5.get（与））;
地图＆LT;字符串，字符串＆GT; M6 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H5，m6.get（PHX））;
Assert.assertEquals（H6，m6.get（SLC））;
Assert.assertEquals（H0，m6.get（与））;
地图＆LT;字符串，字符串＆GT; M7 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H6，m7.get（PHX））;
Assert.assertEquals（H0，m7.get（SLC））;
Assert.assertEquals（H1，m7.get（与））;
}
@测试
公共无效TEST5（）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS，SLS），
Arrays.asList（H0，H1，H2，H3，H4，H5，H6））;
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m1.get（PHX））;
Assert.assertEquals（H1，m1.get（SLC））;
Assert.assertEquals（H2，m1.get（与））;
Assert.assertEquals（H3，m1.get（SLS））;
地图＆LT;字符串，字符串＆GT;平方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H2，m2.get（PHX））;
Assert.assertEquals（H3，m2.get（SLC））;
Assert.assertEquals（H4，m2.get（与））;
Assert.assertEquals（H5，m2.get（SLS））;
地图＆LT;字符串，字符串＆GT;立方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H4，m3.get（PHX））;
Assert.assertEquals（H5，m3.get（SLC））;
Assert.assertEquals（H6，m3.get（与））;
Assert.assertEquals（H0，m3.get（SLS））;
地图＆LT;字符串，字符串＆GT;的m4 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H6，m4.get（PHX））;
Assert.assertEquals（H0，m4.get（SLC））;
Assert.assertEquals（H1，m4.get（与））;
Assert.assertEquals（H2，m4.get（SLS））;
地图＆LT;字符串，字符串＆GT; M5 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H1，m5.get（PHX））;
Assert.assertEquals（H2，m5.get（SLC））;
Assert.assertEquals（H3，m5.get（与））;
Assert.assertEquals（H4，m5.get（SLS））;
地图＆LT;字符串，字符串＆GT; M6 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H3，m6.get（PHX））;
Assert.assertEquals（H4，m6.get（SLC））;
Assert.assertEquals（H5，m6.get（与））;
Assert.assertEquals（H6，m6.get（SLS））;
地图＆LT;字符串，字符串＆GT; M7 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H5，m7.get（PHX））;
Assert.assertEquals（H6，m7.get（SLC））;
Assert.assertEquals（H0，m7.get（与））;
Assert.assertEquals（H1，m7.get（SLS））;
}
}
编辑：
添加一个地图绘制每个数据中心的它已经收到了主机：
专用地图＆LT;字符串，设置＆LT;字符串＆GT;＆GT; dataCenterHostsMap =新的HashMap＆LT;＆GT;（）;
现在添加条件，用于将主机数据中心：如果它尚未加入的主机可以仅被添加
如果（addDataCenterHost（数据中心，hostList.get（hostListIndex）））{
datacenterMachineMapping.put（数据中心，hostList.get（hostListIndex ++））;
}
方法 addDataCenterHost 是这样的：
私人布尔addDataCenterHost（字符串数据中心，String host）在{
设置＆LT;字符串＆GT; dataCenterHostSet = dataCenterHostsMap.get（数据中心）;
如果（dataCenterHostSet == NULL）{
dataCenterHostSet =新的HashSet＆LT;字符串＆GT;（）;
dataCenterHostsMap.put（数据中心，dataCenterHostSet）;
}
返回dataCenterHostSet.add（主机）;
}
随着这一变化 TEST3 将不再运行成功，我想你知道为什么;-)。
下面是一个改变测试1 该测试为第五轮。
@Test
公共无效的test1（）{
DatacenterMachineMapping DCM =新DatacenterMachineMapping（
Arrays.asList（PHX，SLC，VS），
Arrays.asList（H0，H1，H2，H3））;
地图＆LT;字符串，字符串＆GT; M1 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H0，m1.get（PHX））;
Assert.assertEquals（H1，m1.get（SLC））;
Assert.assertEquals（H2，m1.get（与））;
地图＆LT;字符串，字符串＆GT;平方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H1，m2.get（PHX））;
Assert.assertEquals（H2，m2.get（SLC））;
Assert.assertEquals（H3，m2.get（与））;
地图＆LT;字符串，字符串＆GT;立方米= dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H2，m3.get（PHX））;
Assert.assertEquals（H3，m3.get（SLC））;
Assert.assertEquals（H0，m3.get（与））;
地图＆LT;字符串，字符串＆GT;的m4 = dcm.getDatacenterMachineMapping（）;
Assert.assertEquals（H3，m4.get（PHX））;
Assert.assertEquals（H0，m4.get（SLC））;
Assert.assertEquals（H1，m4.get（与））;
地图＆LT;字符串，字符串＆GT; M5 = dcm.getDatacenterMachineMapping（）;
Assert.assertNull（m5.get（PHX））;
Assert.assertNull（m5.get（SLC））;
Assert.assertNull（m5.get（与））;
}
Given List of datacenters which are phx, slc, lvs and list of machines, h0, h1, h2, h3 as mentioned below -
Datacenters = phx, slc, lvs
Machines = h0, h1, h2, h3
I want to generate below combinations only -
a) phx - h0
slc - h1
lvs - h2
b) phx - h1
slc - h2
lvs - h3
c) phx - h2
slc - h3
lvs - h0
d) phx - h3
slc - h0
lvs - h1
I need to call getDatacenterMachineMapping method which will give me above results. For the first call, it should give me above a result in the coloHost map, in the second call, it should give me above b result in the coloHost map, in the third call, it should give me above c result in the coloHost map and for the fourth call, it should give me above d result in the coloHost map and the fifth call, it should not give me anything as no combination is left.
private static List<String> colo = Arrays.asList("phx", "slc", "lvs");
private static List<String> hosts = Arrays.asList("h0","h1","h2", "h3");
while(true) {
Map<String, String> coloHost = getDatacenterMachineMapping();
System.out.println(coloHost);
}
private static Map<String, String> getDatacenterMachineMapping() {
// some code here?
}
Each datacenter in the each pass should get alternate machines/hosts. They should not get same machines. For example in a as shown above - phx gets h0, slc gets h1, lvs gets h2 so all the machines are different for each datacenters. And in the second pass as shown in b - now phx gets h1 (becuase phx already got h0 in the first pass), slc got h2 (bcoz slc already got h1 in the first pass), and lvs got h3(bcoz lvs already got h2 in the first pass) and etc etc.
And one more example - if I have only three hosts, then below combination I am supposed to get only -
Datacenters = phx, slc, lvs
Machines = h0, h1, h2
a) phx - h0
slc - h1
lvs - h2
b) phx - h1
slc - h2
lvs - h0
c) phx - h2
slc - h0
lvs - h1
Any thoughts how this can be done?
Update:-
I tried your below code and it works fine. I am using infinite while loop in my main method so which means, it will keep on calling getDatacenterMachineMapping method always. So here is the output I am getting which is looking good.
{phx=h0, slc=h1, vs=h2}
{phx=h1, slc=h2, vs=h3}
{phx=h2, slc=h3, vs=h0}
{phx=h3, slc=h0, vs=h1}
{phx=h0, slc=h1, vs=h2}
{phx=h1, slc=h2, vs=h3}
{phx=h2, slc=h3, vs=h0}
So if you take a look into above mapping that got printed out.. First four is the only result I am expecting and after that I don't want getDatacenterMachineMapping to give any result since by that time, all the four machines for phx got printed out, all four machines for slc got printed out and all four machines for vs got printed out. And if you see the fifth row, it is starting again which I don't want getDatacenterMachineMapping to give the result.
Below is my code which I have tried -
public static void main(String[] args) {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs"),
Arrays.asList("h0", "h1", "h2", "h3"));
while(true) {
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
System.out.println(m1);
}
}
class DatacenterMachineMapping {
private boolean firstCall = true;
private int hostListIndex = 0;
private List<String> datacenterList, hostList;
public DatacenterMachineMapping(List<String> datacenterList, List<String> hostList) {
this.datacenterList = datacenterList;
this.hostList = hostList;
}
public Map<String, String> getDatacenterMachineMapping() {
Map<String, String> datacenterMachineMapping = new HashMap<String, String>();
if(! firstCall) {
if(hostListIndex == 0) {
hostListIndex = hostList.size();
}
hostListIndex--;
} else {
firstCall = false;
}
for(String datacenter : datacenterList) {
if(hostListIndex == hostList.size()) {
hostListIndex = 0;
}
datacenterMachineMapping.put(datacenter, hostList.get(hostListIndex++));
}
hostListIndex--;
return datacenterMachineMapping;
}
}
解决方案
The pattern I could see from host indexing is that each subsequent call to getDatacenterMachineMapping starts at the index i-1 where i is the index of the last host from the previous call. The first call start at index 0 and is rotating aroud the available hosts.
For example, with the first host list: h0, h1, h2, h3
you have
1) 0=h0, 1=h1, 2=h2
last index is 2, subtract 1 from it -> 1 and this is the index where next call should start at:
2) 1=h1, 2=h2, 3=h3
Now the last index is 3, i.e you start the next call at 2 which leave you only two host in the list, you have then to rotate, i.e. go back to index 0 again, this gives you
3) 2=h2, 3=h3, 0=h0
The same applies to the second host list.
Here a sample implementation of the above (may need to be adapted to exactly match your requirements, for example to check whether or not a data center has already got any possible host, you may wrap it into an own class along with set (HashSet) of already assigned hosts):
public class DatacenterMachineMapping {
private boolean firstCall = true;
private int hostListIndex = 0;
private List<String> datacenterList, hostList;
public DatacenterMachineMapping(List<String> datacenterList, List<String> hostList) {
this.datacenterList = datacenterList;
this.hostList = hostList;
}
public Map<String, String> getDatacenterMachineMapping() {
Map<String, String> datacenterMachineMapping = new HashMap<>();
if(! firstCall) {
if(hostListIndex == 0) {
hostListIndex = hostList.size();
}
hostListIndex--;
} else {
firstCall = false;
}
for(String datacenter : datacenterList) {
if(hostListIndex == hostList.size()) {
hostListIndex = 0;
}
datacenterMachineMapping.put(datacenter, hostList.get(hostListIndex++));
}
hostListIndex--;
return datacenterMachineMapping;
}
}
And some testings...
public class DatacenterMachineMappingTest {
@Test
public void test1() {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs"),
Arrays.asList("h0", "h1", "h2", "h3"));
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m1.get("phx"));
Assert.assertEquals("h1", m1.get("slc"));
Assert.assertEquals("h2", m1.get("vs"));
Map<String, String> m2 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h1", m2.get("phx"));
Assert.assertEquals("h2", m2.get("slc"));
Assert.assertEquals("h3", m2.get("vs"));
Map<String, String> m3 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h2", m3.get("phx"));
Assert.assertEquals("h3", m3.get("slc"));
Assert.assertEquals("h0", m3.get("vs"));
}
@Test
public void test2() {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs"),
Arrays.asList("h0", "h1", "h2"));
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m1.get("phx"));
Assert.assertEquals("h1", m1.get("slc"));
Assert.assertEquals("h2", m1.get("vs"));
Map<String, String> m2 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h1", m2.get("phx"));
Assert.assertEquals("h2", m2.get("slc"));
Assert.assertEquals("h0", m2.get("vs"));
Map<String, String> m3 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h2", m3.get("phx"));
Assert.assertEquals("h0", m3.get("slc"));
Assert.assertEquals("h1", m3.get("vs"));
}
@Test
public void test3() {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs"),
Arrays.asList("h0", "h1"));
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m1.get("phx"));
Assert.assertEquals("h1", m1.get("slc"));
Assert.assertEquals("h0", m1.get("vs"));
Map<String, String> m2 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h1", m2.get("phx"));
Assert.assertEquals("h0", m2.get("slc"));
Assert.assertEquals("h1", m2.get("vs"));
Map<String, String> m3 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m3.get("phx"));
Assert.assertEquals("h1", m3.get("slc"));
Assert.assertEquals("h0", m3.get("vs"));
}
@Test
public void test4() {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs"),
Arrays.asList("h0", "h1", "h2", "h3", "h4", "h5", "h6"));
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m1.get("phx"));
Assert.assertEquals("h1", m1.get("slc"));
Assert.assertEquals("h2", m1.get("vs"));
Map<String, String> m2 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h1", m2.get("phx"));
Assert.assertEquals("h2", m2.get("slc"));
Assert.assertEquals("h3", m2.get("vs"));
Map<String, String> m3 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h2", m3.get("phx"));
Assert.assertEquals("h3", m3.get("slc"));
Assert.assertEquals("h4", m3.get("vs"));
Map<String, String> m4 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h3", m4.get("phx"));
Assert.assertEquals("h4", m4.get("slc"));
Assert.assertEquals("h5", m4.get("vs"));
Map<String, String> m5 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h4", m5.get("phx"));
Assert.assertEquals("h5", m5.get("slc"));
Assert.assertEquals("h6", m5.get("vs"));
Map<String, String> m6 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h5", m6.get("phx"));
Assert.assertEquals("h6", m6.get("slc"));
Assert.assertEquals("h0", m6.get("vs"));
Map<String, String> m7 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h6", m7.get("phx"));
Assert.assertEquals("h0", m7.get("slc"));
Assert.assertEquals("h1", m7.get("vs"));
}
@Test
public void test5() {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs", "sls"),
Arrays.asList("h0", "h1", "h2", "h3", "h4", "h5", "h6"));
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m1.get("phx"));
Assert.assertEquals("h1", m1.get("slc"));
Assert.assertEquals("h2", m1.get("vs"));
Assert.assertEquals("h3", m1.get("sls"));
Map<String, String> m2 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h2", m2.get("phx"));
Assert.assertEquals("h3", m2.get("slc"));
Assert.assertEquals("h4", m2.get("vs"));
Assert.assertEquals("h5", m2.get("sls"));
Map<String, String> m3 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h4", m3.get("phx"));
Assert.assertEquals("h5", m3.get("slc"));
Assert.assertEquals("h6", m3.get("vs"));
Assert.assertEquals("h0", m3.get("sls"));
Map<String, String> m4 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h6", m4.get("phx"));
Assert.assertEquals("h0", m4.get("slc"));
Assert.assertEquals("h1", m4.get("vs"));
Assert.assertEquals("h2", m4.get("sls"));
Map<String, String> m5 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h1", m5.get("phx"));
Assert.assertEquals("h2", m5.get("slc"));
Assert.assertEquals("h3", m5.get("vs"));
Assert.assertEquals("h4", m5.get("sls"));
Map<String, String> m6 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h3", m6.get("phx"));
Assert.assertEquals("h4", m6.get("slc"));
Assert.assertEquals("h5", m6.get("vs"));
Assert.assertEquals("h6", m6.get("sls"));
Map<String, String> m7 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h5", m7.get("phx"));
Assert.assertEquals("h6", m7.get("slc"));
Assert.assertEquals("h0", m7.get("vs"));
Assert.assertEquals("h1", m7.get("sls"));
}
}
EDIT:
Add a map for mapping each data center an the host it already has received:
private Map<String, Set<String>> dataCenterHostsMap = new HashMap<>();
Now add a condition for adding a host to a data center: a host may only be added if it has not already been added:
if(addDataCenterHost(datacenter, hostList.get(hostListIndex))) {
datacenterMachineMapping.put(datacenter, hostList.get(hostListIndex++));
}
The method addDataCenterHost looks like this:
private boolean addDataCenterHost(String datacenter, String host) {
Set<String> dataCenterHostSet = dataCenterHostsMap.get(datacenter);
if(dataCenterHostSet == null) {
dataCenterHostSet = new HashSet<String>();
dataCenterHostsMap.put(datacenter, dataCenterHostSet);
}
return dataCenterHostSet.add(host);
}
With this change test3 will no longer run successfully, I guess you know why ;-) .
Here is a changed test1 which test for the 5th call.
@Test
public void test1() {
DatacenterMachineMapping dcm = new DatacenterMachineMapping(
Arrays.asList("phx", "slc", "vs"),
Arrays.asList("h0", "h1", "h2", "h3"));
Map<String, String> m1 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h0", m1.get("phx"));
Assert.assertEquals("h1", m1.get("slc"));
Assert.assertEquals("h2", m1.get("vs"));
Map<String, String> m2 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h1", m2.get("phx"));
Assert.assertEquals("h2", m2.get("slc"));
Assert.assertEquals("h3", m2.get("vs"));
Map<String, String> m3 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h2", m3.get("phx"));
Assert.assertEquals("h3", m3.get("slc"));
Assert.assertEquals("h0", m3.get("vs"));
Map<String, String> m4 = dcm.getDatacenterMachineMapping();
Assert.assertEquals("h3", m4.get("phx"));
Assert.assertEquals("h0", m4.get("slc"));
Assert.assertEquals("h1", m4.get("vs"));
Map<String, String> m5 = dcm.getDatacenterMachineMapping();
Assert.assertNull(m5.get("phx"));
Assert.assertNull(m5.get("slc"));
Assert.assertNull(m5.get("vs"));
}
