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_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_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_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_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_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_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_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_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_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 run():
global VERBOSE
parser = optparse.OptionParser()
parser.add_option("--i",
"--ignore_fields",
dest="ignore_fields",
help='fields to ignore while comparing')
parser.add_option("-q",
"--quiet",
action="store_false",
dest="verbose",
help="Quiet mode")
(option, argument) = parser.parse_args()
if len(argument) != 2:
my_print("Invalid arguments")
my_print("Need log1 and log2 as positional arguments")
sys.exit(1)
source_file = argument[0]
target_file = argument[1]
if option.verbose is not None:
VERBOSE = option.verbose
my_print(
"Comparing files " + str(source_file) + " with " + str(target_file),
VERBOSE)
if not os.path.isfile(source_file):
my_print("Could not find " + str(source_file))
sys.exit(1)
elif not os.path.isfile(target_file):
my_print("Could not find " + str(target_file))
sys.exit(1)
source_file = argument[0]
target_file = argument[1]
ignore_fields = option.ignore_fields
source_ticks = MamaTickGen(source_file, ignore_fields)
target_ticks = MamaTickGen(target_file, ignore_fields)
result = compare(source_ticks, target_ticks)
if result == 0:
sys.exit(0)
else:
sys.exit(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_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_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_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_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_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_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_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 run():
global VERBOSE
parser = optparse.OptionParser()
parser.add_option("--i", "--ignore_fields", dest="ignore_fields",help='fields to ignore while comparing')
parser.add_option("-q","--quiet",action="store_false",dest="verbose",help="Quiet mode")
(option,argument) = parser.parse_args()
if len(argument)!=2:
my_print("Invalid arguments")
my_print("Need log1 and log2 as positional arguments")
sys.exit(1)
source_file = argument[0]
target_file = argument[1]
if option.verbose is not None:
VERBOSE = option.verbose
my_print("Comparing files "+ str(source_file) + " with " + str(target_file),VERBOSE)
if not os.path.isfile(source_file):
my_print("Could not find " + str(source_file))
sys.exit(1)
elif not os.path.isfile(target_file):
my_print("Could not find " + str(target_file))
sys.exit(1)
source_file = argument[0]
target_file = argument[1]
ignore_fields = option.ignore_fields
source_ticks = MamaTickGen(source_file,ignore_fields)
target_ticks = MamaTickGen(target_file,ignore_fields)
result = compare(source_ticks, target_ticks)
if result==0 :
sys.exit(0)
else:
sys.exit(1)
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)
def print_result(result,source_tick,target_tick=None):
# if not VERBOSE:
# return
if source_tick is None:
my_print(result +":"+ "Could not find matching record for target at line:"+str(target_tick.line_num))
elif target_tick is None:
my_print(result+":"+"Could not find matching record for source at line:"+str(source_tick.line_num))
else:
my_print(result+":"+"Source line number="+str(source_tick.line_num)+",Target line number="+str(target_tick.line_num))
def print_result(result, source_tick, target_tick=None):
# if not VERBOSE:
# return
if source_tick is None:
my_print(result + ":" +
"Could not find matching record for target at line:" +
str(target_tick.line_num))
elif target_tick is None:
my_print(result + ":" +
"Could not find matching record for source at line:" +
str(source_tick.line_num))
else:
my_print(result + ":" + "Source line number=" +
str(source_tick.line_num) + ",Target line number=" +
str(target_tick.line_num))
def run():
'''
wait4text waits for appearance of 'searchtext' in the file. It waits TIMEOUT seconds for file creation and
specified optional time in seconds or number of lines for appearance of text
'''
parser = optparse.OptionParser()
parser.add_option("-t",
"--timeout",
dest="timeout",
default=TIMEOUT,
type=int,
help="Time to wait for the text to appear, in seconds")
parser.add_option("-l",
"--max-lines",
dest="maxlines",
default=1000,
type=int,
help="Prints comparison results")
parser.add_option("-q",
"--quiet",
action="store_false",
dest="verbose",
help="Quiet mode")
(option, argument) = parser.parse_args()
if len(argument) != 2:
my_print("Error: Invalid number of arguments")
my_print("Usage: wait4text 'SearchText' filename [options] ")
my_print("use wait4text -h for help")
sys.exit(1)
file_name = argument[1]
searchtext = argument[0]
timeout = option.timeout
maxlines = option.maxlines
if option.verbose is not None:
verbose = option.verbose
else:
verbose = True
wait_time = 0
while wait_time < TIMEOUT:
if os.path.isfile(file_name):
break
else:
my_print("waiting for " + str(file_name) + " file to appear",
verbose)
time.sleep(0.05)
wait_time = wait_time + 1
else:
my_print("Error: No file found with name:%s" % (file_name))
sys.exit(1)
line_count = 0
file_obj = open(file_name)
start_time = time.time()
my_print(
"Searching %s for text:%s, timeout=%d, maxlines=%d" %
(file_name, searchtext, timeout, maxlines), verbose)
while True:
line = file_obj.readline()
if line == '':
time.sleep(0.05)
else:
line_count += 1
if searchtext in line:
my_print(
"Found text: line_number=%s, line=%s" %
(line_count, line.rstrip()), verbose)
sys.exit(0)
duration = time.time() - start_time
if maxlines is not None:
if line_count >= maxlines:
my_print(
"Search exceeded max number of lines %d without finding match"
% (maxlines), verbose)
sys.exit(1)
if duration >= float(timeout):
my_print(
"Search exceeded max time (%d seconds) without finding match, lines read=%d"
% (timeout, line_count), verbose)
sys.exit(1)
def run():
'''
wait4text waits for appearance of 'searchtext' in the file. It waits TIMEOUT seconds for file creation and
specified optional time in seconds or number of lines for appearance of text
'''
parser = optparse.OptionParser()
parser.add_option("-t", "--timeout", dest="timeout",default=TIMEOUT,type=int,help="Time to wait for the text to appear, in seconds")
parser.add_option("-l","--max-lines",dest="maxlines",default=1000,type=int,help="Prints comparison results")
parser.add_option("-q","--quiet",action="store_false",dest="verbose",help="Quiet mode")
(option,argument) = parser.parse_args()
if len(argument)!=2:
my_print("Error: Invalid number of arguments")
my_print("Usage: wait4text 'SearchText' filename [options] ")
my_print("use wait4text -h for help")
sys.exit(1)
file_name = argument[1]
searchtext = argument[0]
timeout = option.timeout
maxlines = option.maxlines
if option.verbose is not None:
verbose = option.verbose
else:
verbose = True
wait_time = 0
while wait_time < TIMEOUT:
if os.path.isfile(file_name):
break
else:
my_print("waiting for "+ str(file_name) + " file to appear",verbose)
time.sleep(0.05)
wait_time = wait_time+1
else:
my_print("Error: No file found with name:%s" % (file_name))
sys.exit(1)
line_count = 0
file_obj = open(file_name)
start_time = time.time()
my_print("Searching %s for text:%s, timeout=%d, maxlines=%d" % (file_name, searchtext, timeout, maxlines),verbose)
while True:
line = file_obj.readline()
if line == '':
time.sleep(0.05)
else:
line_count+=1
if searchtext in line:
my_print("Found text: line_number=%s, line=%s" %(line_count, line.rstrip()),verbose)
sys.exit(0)
duration = time.time() - start_time
if maxlines is not None:
if line_count >= maxlines:
my_print("Search exceeded max number of lines %d without finding match" % (maxlines),verbose)
sys.exit(1)
if duration >= float(timeout):
my_print("Search exceeded max time (%d seconds) without finding match, lines read=%d" % (timeout, line_count),verbose)
sys.exit(1)
