def test_ft_priorityjava(self):
'''start two basicftmemberjava with different priority and verify that the one with lower priority goes to standby
from active'''
my_print(
"\n----------Running basicftmemberjava test priority----------\n")
ftmemberjava1_out = open('priority_ftmemberjava1.out', 'w')
ftmemberjava2_out = open('priority_ftmemberjava2.out', 'w')
ret1 = start_javaapp("BasicFtMemberJava",
"pub",
args=["-g", "priority", "-w", "40", "-b"],
stdout=ftmemberjava1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE",
"priority_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava",
"sub",
args=["-g", "priority", "-w", "60", "-b"],
stdout=ftmemberjava2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE",
"priority_ftmemberjava2.out")
ret5 = call_wait4text("Current state is: FT_STATE_STANDBY",
"priority_ftmemberjava1.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_pubsubcpp(self):
'''publish messages using basicpubcpp and verify basicsubcpp receives the messages'''
my_print("\n----------Running pubsubcpp test----------\n")
basicsubcpp_out = open('pubsub_basicsubcpp.out','w')
basicsubcpp_err = open('pubsub_basicsubcpp.err','w')
basicpubcpp_out = open('pubsub_basicpubcpp.out','w')
ret1 = start_app("basicsubcpp","sub",args=["-v","-v","-v","-v"],stdout=basicsubcpp_out,stderr=basicsubcpp_err)
ret2 = call_wait4text("Created inbound subscription","pubsub_basicsubcpp.out")
ret3 = start_app("basicpubcpp","pub",stdout=basicpubcpp_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("EXIT", "pubsub_basicsubcpp.out")
ret5 = call_comparelog("pubsub_expectedsubcpp.out","pubsub_basicsubcpp.out")
basicsubcpp_out.close()
basicsubcpp_err.close()
basicpubcpp_out.close()
if ret1.poll() is None:
kill_process(ret1.pid)
if ret3.poll() is None:
kill_process(ret3.pid)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_active_standbyc(self):
'''start two basicftmemberc and verify the first one goes ot active and second to standby, if both belong to same group'''
my_print(
"\n--------------Running basicftmemberc test active-standby--------------\n"
)
ftmemberc1_out = open('active_standby_ftmemberc1.out', 'w')
ftmemberc2_out = open('active_standby_ftmemberc2.out', 'w')
ret1 = start_app("basicftmemberc",
"pub",
args=["-g", "active-standby", "-b"],
stdout=ftmemberc1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active",
"active_standby_ftmemberc1.out")
ret3 = start_app("basicftmemberc",
"sub",
args=["-g", "active-standby", "-b"],
stdout=ftmemberc2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is standby",
"active_standby_ftmemberc2.out")
ret5 = call_wait4text("Current state is standby",
"active_standby_ftmemberc1.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 1)
def test_req_replyjava(self):
'''Send request from basicinboxjava and verify it recives reply from basicpubjava'''
my_print("\n----------Running req_replyjava test----------\n")
basicpubjava_out = open('req_reply_basicpubjava.out', 'w')
basicpubjava_err = open('req_reply_basicpubjava.err', 'w')
basicinboxjava_out = open('req_reply_basicinboxjava.out', 'w')
ret1 = start_javaapp("BasicPubJava",
"pub",
args=["-v", "-v", "-v", "-v"],
stdout=basicpubjava_out,
stderr=basicpubjava_err)
ret2 = call_wait4text("Created inbound subscription",
"req_reply_basicpubcpp.out",
args=["-t", '1'])
ret3 = start_javaapp("BasicInboxJava",
"sub",
stdout=basicinboxjava_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Received reply", "req_reply_basicinboxjava.out")
basicpubjava_out.close()
basicpubjava_err.close()
basicinboxjava_out.close()
kill_process(ret3.pid)
self.assertTrue(ret4 == 0)
def test_pubsubc(self):
'''publish messages using basicpubc and verify basicsubc receives the messages'''
my_print(
"\n-------------------------Running pubsubc test-------------------------\n"
)
basicsubc_out = open('pubsub_basicsubc.out', 'w')
basicsubc_err = open('pubsub_basicsubc.err', 'w')
basicpubc_out = open('pubsub_basicpubc.out', 'w')
ret1 = start_app("basicsubc",
"sub",
args=["-v", "-v", "-v", "-v"],
stdout=basicsubc_out,
stderr=basicsubc_err)
ret2 = call_wait4text("Created inbound subscription",
"pubsub_basicsubc.out")
ret3 = start_app("basicpubc",
"pub",
stdout=basicpubc_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("EXIT", "pubsub_basicsubc.out")
ret5 = call_comparelog("pubsub_expectedsubc.out",
"pubsub_basicsubc.out")
basicsubc_out.close()
basicsubc_err.close()
basicpubc_out.close()
if ret1.poll() is None:
kill_process(ret1.pid)
if ret3.poll() is None:
kill_process(ret3.pid)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_ft_active_activec(self):
'''start two basicftmemberc and verify that both go to active, if they belong to different groups'''
my_print(
"\n---------------Running basicftmemberc test active-active--------------\n"
)
ftmemberc1_out = open('active_active_ftmemberc1.out', 'w')
ftmemberc2_out = open('active_active_ftmemberc2.out', 'w')
ret1 = start_app("basicftmemberc",
"pub",
args=["-g", "active-active1", "-b"],
stdout=ftmemberc1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active",
"active_active_ftmemberc1.out")
ret3 = start_app("basicftmemberc",
"sub",
args=["-g", "active-active2", "-b"],
stdout=ftmemberc2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is active",
"active_active_ftmemberc2.out")
ret5 = call_wait4text("Current state is standby",
"active_active_ftmemberc1.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 1)
def test_ft_priorityc(self):
'''start two basicftmemberc with different priority and verify that the one with lower priority goes to standby
from active'''
my_print(
"\n-----------------Running basicftmemberc test priority-----------------\n"
)
ftmemberc1_out = open('priority_ftmemberc1.out', 'w')
ftmemberc2_out = open('priority_ftmemberc2.out', 'w')
ret1 = start_app("basicftmemberc",
"pub",
args=["-g", "priority", "-w", "40", "-b"],
stdout=ftmemberc1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active",
"priority_ftmemberc1.out")
ret3 = start_app("basicftmemberc",
"sub",
args=["-g", "priority", "-w", "60", "-b"],
stdout=ftmemberc2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is active",
"priority_ftmemberc2.out")
ret5 = call_wait4text("Current state is standby",
"priority_ftmemberc1.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_ft_standby_to_activejava(self):
'''Start two basicftmemberjava with same group and stop the active one, verify the standby basicftmemberjava goes to active'''
my_print("\n----------Running basicftmemberjava test standby-to-active----------\n")
ftmemberjava1_out = open('standby_to_active_ftmemberjava1.out','w')
ftmemberjava2_out = open('standby_to_active_ftmemberjava2.out','w')
ret1 = start_javaapp("BasicFtMemberJava","pub",args=["-g","standby-to-active","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "standby_to_active_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","standby-to-active","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_STANDBY", "standby_to_active_ftmemberjava2.out")
kill_process(ret1.pid)
ret5 = call_wait4text("Current state is: FT_STATE_ACTIVE", "standby_to_active_ftmemberjava2.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_req_replyc(self):
'''Send request from basicinbox and verify it recives reply from basicpub'''
my_print(
"\n----------------------Running request_replyc test---------------------\n"
)
basicpubc_out = open('req_reply_basicpubc.out', 'w')
basicpubc_err = open('req_reply_basicpubc.err', 'w')
basicinboxc_out = open('req_reply_basicinboxc.out', 'w')
ret1 = start_app("basicpubc",
"pub",
args=["-v", "-v", "-v", "-v"],
stdout=basicpubc_out,
stderr=basicpubc_err)
ret2 = call_wait4text("Created inbound subscription",
"req_reply_basicpubc.out")
ret3 = start_app("basicinboxc",
"sub",
stdout=basicinboxc_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Received reply", "req_reply_basicinboxc.out")
basicpubc_out.close()
basicpubc_err.close()
basicinboxc_out.close()
kill_process(ret3.pid)
self.assertTrue(ret4 == 0)
def test_pubsubjava(self):
'''publish messages using basicpubjava and verify basicsubjava receives the messages'''
my_print("\n----------Running pubsubjava test----------\n")
basicsubjava_out = open('pubsub_basicsubjava.out', 'w')
basicsubjava_err = open('pubsub_basicsubjava.err', 'w')
basicpubjava_out = open('pubsub_basicpubjava.out', 'w')
ret1 = start_javaapp("BasicSubJava",
"sub",
stdout=basicsubjava_out,
stderr=basicsubjava_err)
ret2 = call_wait4text("Created inbound subscription",
"pubsub_basicsubjava.out")
ret3 = start_javaapp("BasicPubJava",
"pub",
stdout=basicpubjava_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("EXIT", "pubsub_basicsubjava.out")
ret5 = call_comparelog("pubsub_expectedsubjava.out",
"pubsub_basicsubjava.out")
basicsubjava_out.close()
basicsubjava_err.close()
basicpubjava_out.close()
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_ft_active_activejava(self):
'''start two basicftmemberjava and verify that both go to active, if they belong to different groups'''
my_print(
"\n----------Running basicftmemberjava test active-active----------\n"
)
ftmemberjava1_out = open('active_active_ftmemberjava1.out', 'w')
ftmemberjava2_out = open('active_active_ftmemberjava2.out', 'w')
ret1 = start_javaapp("BasicFtMemberJava",
"pub",
args=["-g", "active-active1", "-b"],
stdout=ftmemberjava1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE",
"active_active_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava",
"sub",
args=["-g", "active-active2", "-b"],
stdout=ftmemberjava2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE",
"active_active_ftmemberjava2.out")
ret5 = call_wait4text("Current state is: FT_STATE_STANDBY",
"active_active_ftmemberjava1.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 1)
def test_req_replycpp(self):
'''Send request from basicinboxcpp and verify it recives reply from basicpubcpp'''
my_print("\n----------Running req_replycpp test----------\n")
basicpubcpp_out = open('req_reply_basicpubcpp.out','w')
basicpubcpp_err = open('req_reply_basicpubcpp.err','w')
basicinboxcpp_out = open('req_reply_basicinboxcpp.out','w')
ret1 = start_app("basicpubcpp","pub",args=["-v","-v","-v","-v"],stdout=basicpubcpp_out,stderr=basicpubcpp_err)
ret2 = call_wait4text("Created inbound subscription","req_reply_basicpubcpp.out",args=["-t",'1'])
ret3 = start_app("basicinboxcpp","sub",stdout=basicinboxcpp_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Received reply", "req_reply_basicinboxcpp.out")
basicpubcpp_out.close()
basicpubcpp_err.close()
basicinboxcpp_out.close()
kill_process(ret3.pid)
self.assertTrue(ret4==0)
def test_ft_active_standbyjava(self):
'''start two basicftmemberjava and verify the first one goes ot active and second to standby, if both belong to same group'''
my_print("\n----------Running basicftmemberjava test active-standby----------\n")
ftmemberjava1_out = open('active_standby_ftmemberjava1.out','w')
ftmemberjava2_out = open('active_standby_ftmemberjava2.out','w')
ret1 = start_javaapp("BasicFtMemberJava","pub",args=["-g","active-standby","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "active_standby_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","active-standby","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_STANDBY", "active_standby_ftmemberjava2.out")
ret5 = call_wait4text("Current state is: FT_STATE_STANDBY", "active_standby_ftmemberjava1.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==1)
def test_ft_prioritycpp(self):
'''start two basicftmembercpp with different priority and verify that the one with lower priority goes to standby
from active'''
my_print("\n----------Running basicftmemberpp test priority----------\n")
ftmembercpp1_out = open('priority_ftmembercpp1.out','w')
ftmembercpp2_out = open('priority_ftmembercpp2.out','w')
ret1 =start_app("basicftmembercpp","pub",args=["-g","priority","-w","40","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active", "priority_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp","sub",args=["-g","priority","-w","60","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: active", "priority_ftmembercpp2.out")
ret5 = call_wait4text("Current state is: standby", "priority_ftmembercpp1.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_active_activejava(self):
'''start two basicftmemberjava and verify that both go to active, if they belong to different groups'''
my_print("\n----------Running basicftmemberjava test active-active----------\n")
ftmemberjava1_out = open('active_active_ftmemberjava1.out','w')
ftmemberjava2_out = open('active_active_ftmemberjava2.out','w')
ret1 = start_javaapp("BasicFtMemberJava","pub",args=["-g","active-active1","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "active_active_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","active-active2","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE", "active_active_ftmemberjava2.out")
ret5 = call_wait4text("Current state is: FT_STATE_STANDBY", "active_active_ftmemberjava1.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==1)
def test_ft_active_standbycpp(self):
'''start two basicftmembercpp and verify the first one goes to active and second to standby, if both belong to same group'''
my_print("\n----------Running basicftmembercpp test active-standby----------\n")
ftmembercpp1_out = open('active_standby_ftmembercpp1.out','w')
ftmembercpp2_out = open('active_standby_ftmembercpp2.out','w')
ret1 = start_app("basicftmembercpp","pub",args=["-g","active-standby","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active", "active_standby_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp","sub",args=["-g","active-standby","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: standby", "active_standby_ftmembercpp2.out")
ret5 = call_wait4text("Current state is: standby", "active_standby_ftmembercpp1.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==1)
def test_pubsubjava(self):
'''publish messages using basicpubjava and verify basicsubjava receives the messages'''
my_print("\n----------Running pubsubjava test----------\n")
basicsubjava_out = open('pubsub_basicsubjava.out','w')
basicsubjava_err = open('pubsub_basicsubjava.err','w')
basicpubjava_out = open('pubsub_basicpubjava.out','w')
ret1 = start_javaapp("BasicSubJava","sub",stdout=basicsubjava_out,stderr=basicsubjava_err)
ret2 = call_wait4text("Created inbound subscription","pubsub_basicsubjava.out")
ret3 = start_javaapp("BasicPubJava","pub",stdout=basicpubjava_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("EXIT", "pubsub_basicsubjava.out")
ret5 = call_comparelog("pubsub_expectedsubjava.out","pubsub_basicsubjava.out")
basicsubjava_out.close()
basicsubjava_err.close()
basicpubjava_out.close()
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_active_activecpp(self):
'''start two basicftmembercpp and verify that both go to active, if they belong to different groups'''
my_print("\n----------Running basicftmemberpp test active-active----------\n")
ftmembercpp1_out = open('active_active_ftmembercpp1.out','w')
ftmembercpp2_out = open('active_active_ftmembercpp2.out','w')
ret1 = start_app("basicftmembercpp","pub",args=["-g","active-active1","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active", "active_active_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp","sub",args=["-g","active-active2","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: active", "active_active_ftmembercpp2.out")
ret5 = call_wait4text("Current state is: standby", "active_active_ftmembercpp1.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==1)
def test_ft_standby_to_activejava(self):
'''Start two basicftmemberjava with same group and stop the active one, verify the standby basicftmemberjava goes to active'''
my_print(
"\n----------Running basicftmemberjava test standby-to-active----------\n"
)
ftmemberjava1_out = open('standby_to_active_ftmemberjava1.out', 'w')
ftmemberjava2_out = open('standby_to_active_ftmemberjava2.out', 'w')
ret1 = start_javaapp("BasicFtMemberJava",
"pub",
args=["-g", "standby-to-active", "-b"],
stdout=ftmemberjava1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE",
"standby_to_active_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava",
"sub",
args=["-g", "standby-to-active", "-b"],
stdout=ftmemberjava2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_STANDBY",
"standby_to_active_ftmemberjava2.out")
kill_process(ret1.pid)
ret5 = call_wait4text("Current state is: FT_STATE_ACTIVE",
"standby_to_active_ftmemberjava2.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_ft_priorityjava(self):
'''start two basicftmemberjava with different priority and verify that the one with lower priority goes to standby
from active'''
my_print("\n----------Running basicftmemberjava test priority----------\n")
ftmemberjava1_out = open('priority_ftmemberjava1.out','w')
ftmemberjava2_out = open('priority_ftmemberjava2.out','w')
ret1 =start_javaapp("BasicFtMemberJava","pub",args=["-g","priority","-w","40","-b"],stdout=ftmemberjava1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: FT_STATE_ACTIVE", "priority_ftmemberjava1.out")
ret3 = start_javaapp("BasicFtMemberJava","sub",args=["-g","priority","-w","60","-b"],stdout=ftmemberjava2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: FT_STATE_ACTIVE", "priority_ftmemberjava2.out")
ret5 = call_wait4text("Current state is: FT_STATE_STANDBY", "priority_ftmemberjava1.out")
ftmemberjava1_out.close()
ftmemberjava2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_standby_to_activec(self):
'''Start two basicftmemberc with same group and stop the active one, verify the standby basicftmember goes to active'''
my_print("\n-------------Running basicftmemberc test standby-to-active------------\n")
ftmemberc1_out = open('standby_to_active_ftmemberc1.out','w')
ftmemberc2_out = open('standby_to_active_ftmemberc2.out','w')
ret1 = start_app("basicftmemberc","pub",args=["-g","standby-to-active","-b"],stdout=ftmemberc1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active", "standby_to_active_ftmemberc1.out")
ret3 = start_app("basicftmemberc","sub",args=["-g","standby-to-active","-b"],stdout=ftmemberc2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is standby", "standby_to_active_ftmemberc2.out")
kill_process(ret1.pid)
ret5 = call_wait4text("Current state is active", "standby_to_active_ftmemberc2.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_standby_to_activecpp(self):
'''Start two basicftmembercpp with same group and stop the active one, verify the standby basicftmemberpp goes to active'''
my_print(
"\n----------Running basicftmemberpp test standby-to-active----------\n"
)
ftmembercpp1_out = open('standby_to_active_ftmembercpp1.out', 'w')
ftmembercpp2_out = open('standby_to_active_ftmembercpp2.out', 'w')
ret1 = start_app("basicftmembercpp",
"pub",
args=["-g", "standby-to-active", "-b"],
stdout=ftmembercpp1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active",
"standby_to_active_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp",
"sub",
args=["-g", "standby-to-active", "-b"],
stdout=ftmembercpp2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: standby",
"standby_to_active_ftmembercpp2.out")
kill_process(ret1.pid)
ret5 = call_wait4text("Current state is: active",
"standby_to_active_ftmembercpp2.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
