def setUpClass(cls):
'''Test simpleserver and simpleclient.
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# start server
server_cmd = "/opt/iotivity/examples/resource/cpp/simpleserver > /tmp/svr_output &"
run_as("iotivity-tester", server_cmd)
time.sleep(1)
# start client to get info
client_cmd = "/opt/iotivity/examples/resource/cpp/simpleclient > /tmp/output &"
run_as("iotivity-tester", client_cmd)
print "\npatient... simpleclient needs long time for its observation"
time.sleep(60)
# If there is no 'Observe is used', give a retry.
(status, output) = cls.tc.target.run('cat /tmp/output')
if "Observe is used." in output:
pass
else:
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
time.sleep(2)
(status, output) = cls.tc.target.run(server_cmd)
cls.tc.target.run(client_cmd)
time.sleep(60)
def setUpClass(cls):
'''Test simpleserver and simpleclient.
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# start server
server_cmd = "/opt/iotivity/examples/resource/cpp/simpleserver > /tmp/svr_output &"
run_as("iotivity-tester", server_cmd)
time.sleep(1)
# start client to get info
client_cmd = "/opt/iotivity/examples/resource/cpp/simpleclient > /tmp/output &"
run_as("iotivity-tester", client_cmd)
print "\npatient... simpleclient needs long time for its observation"
time.sleep(60)
# If there is no 'Observe is used', give a retry.
(status, output) = cls.tc.target.run('cat /tmp/output')
if "Observe is used." in output:
pass
else:
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
time.sleep(2)
(status, output) = cls.tc.target.run(server_cmd)
cls.tc.target.run(client_cmd)
time.sleep(60)
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
# Init main target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[0])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[0])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[0])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[0])
# Init second target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[1])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[1])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[1])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[1])
# Clean output file on two targets, main is client part and second is server part
run_as("root", "rm -f /tmp/svr_output", target=cls.tc.targets[1])
run_as("root", "rm -f /tmp/output", target=cls.tc.targets[0])
# add group and non-root user on both sides
add_group("tester", target=cls.tc.targets[0])
add_user("iotivity-tester", "tester", target=cls.tc.targets[0])
add_group("tester", target=cls.tc.targets[1])
add_user("iotivity-tester", "tester", target=cls.tc.targets[1])
# Setup firewall accept for multicast, on both sides
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[1])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[1])
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run(
"killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient"
)
cls.tc.target.run(
"killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient"
)
cls.tc.target.run(
"killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ"
)
cls.tc.target.run("killall simpleclientserver threadingsample")
cls.tc.target.run("rm -f /tmp/svr_output")
cls.tc.target.run("rm -f /tmp/output")
# check if image contains iotivity example applications
(status,
output) = cls.tc.target.run("ls /opt/iotivity/examples/resource/")
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed'
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# Setup firewall accept for multicast
cls.tc.target.run(
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT")
cls.tc.target.run(
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT")
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run("killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient")
cls.tc.target.run("killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient")
cls.tc.target.run("killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ")
cls.tc.target.run("killall simpleclientserver threadingsample")
cls.tc.target.run("rm -f /tmp/svr_output")
cls.tc.target.run("rm -f /tmp/output")
# check if image contains iotivity example applications
(status, output) = cls.tc.target.run("ls /opt/iotivity/examples/resource/")
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed'
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# Setup firewall accept for multicast
(status, output) = cls.tc.target.run("cat /proc/sys/net/ipv4/ip_local_port_range")
port_range = output.split()
cls.tc.target.run("/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT")
cls.tc.target.run("/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport 5683 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport 5684 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport %s:%s -j ACCEPT" % (port_range[0], port_range[1]))
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run(
"killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient"
)
cls.tc.target.run(
"killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient"
)
cls.tc.target.run(
"killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ"
)
cls.tc.target.run("killall simpleclientserver threadingsample")
cls.tc.target.run("rm -f /tmp/svr_output")
cls.tc.target.run("rm -f /tmp/output")
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# Setup firewall accept for multicast
cls.tc.target.run(
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT")
cls.tc.target.run(
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT")
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
# Init main target
run_as(
"root",
"killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient",
target=cls.tc.targets[0])
run_as(
"root",
"killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient",
target=cls.tc.targets[0])
run_as(
"root",
"killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ",
target=cls.tc.targets[0])
run_as("root",
"killall simpleclientserver threadingsample",
target=cls.tc.targets[0])
# Init second target
run_as(
"root",
"killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient",
target=cls.tc.targets[1])
run_as(
"root",
"killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient",
target=cls.tc.targets[1])
run_as(
"root",
"killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ",
target=cls.tc.targets[1])
run_as("root",
"killall simpleclientserver threadingsample",
target=cls.tc.targets[1])
# Clean output file on two targets, main is client part and second is server part
run_as("root", "rm -f /tmp/svr_output", target=cls.tc.targets[1])
run_as("root", "rm -f /tmp/output", target=cls.tc.targets[0])
# add group and non-root user on both sides
add_group("tester", target=cls.tc.targets[0])
add_user("iotivity-tester", "tester", target=cls.tc.targets[0])
add_group("tester", target=cls.tc.targets[1])
add_user("iotivity-tester", "tester", target=cls.tc.targets[1])
# Setup firewall accept for multicast, on both sides
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT",
target=cls.tc.targets[0])
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT",
target=cls.tc.targets[0])
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT",
target=cls.tc.targets[1])
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT",
target=cls.tc.targets[1])
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run("killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient")
cls.tc.target.run("killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient")
cls.tc.target.run("killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ")
cls.tc.target.run("killall simpleclientserver threadingsample")
cls.tc.target.run("rm -f /tmp/svr_output")
cls.tc.target.run("rm -f /tmp/output")
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# Setup firewall accept for multicast
cls.tc.target.run("/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT")
cls.tc.target.run("/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT")
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
# Init main target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[0])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[0])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[0])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[0])
# Init second target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[1])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[1])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[1])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[1])
# Clean output file on two targets, main is client part and second is server part
run_as("root", "rm -f /tmp/svr_output", target=cls.tc.targets[1])
run_as("root", "rm -f /tmp/output", target=cls.tc.targets[0])
# add group and non-root user on both sides
add_group("tester", target=cls.tc.targets[0])
add_user("iotivity-tester", "tester", target=cls.tc.targets[0])
add_group("tester", target=cls.tc.targets[1])
add_user("iotivity-tester", "tester", target=cls.tc.targets[1])
# Setup firewall accept for multicast, on both sides
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[1])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[1])
# check if image contains iotivity example applications
(status, output) = run_as("root", "ls /opt/iotivity/examples/resource/", target=cls.tc.targets[0])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target0'
(status, output) = run_as("root", "ls /opt/iotivity/examples/resource/", target=cls.tc.targets[1])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target1'
def setUpClass(cls):
# Kill simpleserver and simpleclient
cls.tc.target.run("killall simpleserver simpleclient")
# Create test user
add_group("tester")
add_user("iotivity-tester", "tester")
# Set up firewall
port_range_cmd = "cat /proc/sys/net/ipv4/ip_local_port_range"
(status, output) = cls.tc.target.run(port_range_cmd)
port_range = "%s:%s" % tuple(output.split())
iptables_cmd = "/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 \
-p udp -m udp --dport %s -j ACCEPT"
cls.tc.target.run(iptables_cmd % "5683")
cls.tc.target.run(iptables_cmd % "5684")
cls.tc.target.run(iptables_cmd % port_range)
# Start server
resource_cmd = "/opt/iotivity/examples/resource/cpp/%s > /tmp/%s &"
run_as("iotivity-tester",
resource_cmd % ("simpleserver", "svr_output"))
time.sleep(1)
# Start client to get info
run_as("iotivity-tester", resource_cmd % ("simpleclient", "output"))
print("\npatient... simpleclient needs long time for its observation")
time.sleep(10)
# If there is no 'Observe is used', give a retry.
(status, __) = cls.tc.target.run('grep "Observe is used." /tmp/output')
if status != 0:
cls.tc.target.run("killall simpleserver simpleclient")
time.sleep(2)
cls.tc.target.run(resource_cmd % ("simpleserver", "svr_output"))
cls.tc.target.run(resource_cmd % ("simpleclient", "output"))
time.sleep(10)
def setUpClass(cls):
'''Clean all the server and client firstly
@fn setUpClass
@param cls
@return
'''
# Init main target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[0])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[0])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[0])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[0])
# Init second target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[1])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[1])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[1])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[1])
# Clean output file on two targets, main is client part and second is server part
run_as("root", "rm -f /tmp/svr_output", target=cls.tc.targets[1])
run_as("root", "rm -f /tmp/output", target=cls.tc.targets[0])
# add group and non-root user on both sides
add_group("tester", target=cls.tc.targets[0])
add_user("iotivity-tester", "tester", target=cls.tc.targets[0])
add_group("tester", target=cls.tc.targets[1])
add_user("iotivity-tester", "tester", target=cls.tc.targets[1])
# Setup firewall accept for multicast, on both sides
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[1])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[1])
# check if image contains iotivity example applications
(status, output) = run_as("root", "ls /opt/iotivity/examples/resource/", target=cls.tc.targets[0])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target0'
(status, output) = run_as("root", "ls /opt/iotivity/examples/resource/", target=cls.tc.targets[1])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target1'
def setUpClass(cls):
'''Test simpleserver and simpleclient.
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# set up firewall
(status, output) = cls.tc.target.run("cat /proc/sys/net/ipv4/ip_local_port_range")
port_range = output.split()
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport 5683 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport 5684 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport %s:%s -j ACCEPT" % (port_range[0], port_range[1]))
# start server
server_cmd = "/opt/iotivity/examples/resource/cpp/simpleserver > /tmp/svr_output &"
run_as("iotivity-tester", server_cmd)
time.sleep(1)
# start client to get info
client_cmd = "/opt/iotivity/examples/resource/cpp/simpleclient > /tmp/output &"
run_as("iotivity-tester", client_cmd)
print ("\npatient... simpleclient needs long time for its observation")
time.sleep(60)
# If there is no 'Observe is used', give a retry.
(status, output) = cls.tc.target.run('cat /tmp/output')
if "Observe is used." in output:
pass
else:
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
time.sleep(2)
(status, output) = cls.tc.target.run(server_cmd)
cls.tc.target.run(client_cmd)
time.sleep(60)
def setUpClass(cls):
# Kill simpleserver and simpleclient
cls.tc.target.run("killall simpleserver simpleclient")
# Create test user
add_group("tester")
add_user("iotivity-tester", "tester")
# Set up firewall
port_range_cmd = "cat /proc/sys/net/ipv4/ip_local_port_range"
(status, output) = cls.tc.target.run(port_range_cmd)
port_range = output.split()
cls.tc.target.run(
"/usr/sbin/nft add chain inet filter iotivity { type filter hook input priority 0\; }"
)
cls.tc.target.run(
"/usr/sbin/nft add rule inet filter iotivity ip6 saddr fe80::/10 udp dport {5683, 5684, %s-%s} mark set 1"
% (port_range[0], port_range[1]))
# Start server
resource_cmd = "/opt/iotivity/examples/resource/cpp/%s > /tmp/%s &"
run_as("iotivity-tester",
resource_cmd % ("simpleserver", "svr_output"))
time.sleep(1)
# Start client to get info
run_as("iotivity-tester", resource_cmd % ("simpleclient", "output"))
print("\npatient... simpleclient needs long time for its observation")
time.sleep(10)
# If there is no 'Observe is used', give a retry.
(status, __) = cls.tc.target.run('grep "Observe is used." /tmp/output')
if status != 0:
cls.tc.target.run("killall simpleserver simpleclient")
time.sleep(2)
cls.tc.target.run(resource_cmd % ("simpleserver", "svr_output"))
cls.tc.target.run(resource_cmd % ("simpleclient", "output"))
time.sleep(10)
def setUpClass(cls):
'''Test simpleserver and simpleclient.
@fn setUpClass
@param cls
@return
'''
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
# add group and non-root user
add_group("tester")
add_user("iotivity-tester", "tester")
# set up firewall
(status, output) = cls.tc.target.run("cat /proc/sys/net/ipv4/ip_local_port_range")
port_range = output.split()
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport 5683 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport 5684 -j ACCEPT")
cls.tc.target.run("/usr/sbin/ip6tables -w -A INPUT -s fe80::/10 -p udp -m udp --dport %s:%s -j ACCEPT" % (port_range[0], port_range[1]))
# start server
server_cmd = "/opt/iotivity/examples/resource/cpp/simpleserver > /tmp/svr_output &"
run_as("iotivity-tester", server_cmd)
time.sleep(1)
# start client to get info
client_cmd = "/opt/iotivity/examples/resource/cpp/simpleclient > /tmp/output &"
run_as("iotivity-tester", client_cmd)
print ("\npatient... simpleclient needs long time for its observation")
time.sleep(10)
# If there is no 'Observe is used', give a retry.
(status, output) = cls.tc.target.run('cat /tmp/output')
if "Observe is used." in output:
pass
else:
cls.tc.target.run("killall simpleserver")
cls.tc.target.run("killall simpleclient")
time.sleep(2)
(status, output) = cls.tc.target.run(server_cmd)
cls.tc.target.run(client_cmd)
time.sleep(10)
def setUpClass(cls):
'''Connect to WiFi AP, which contains simpleserver running on it
@fn setUpClass
@param cls
@return
'''
client_wifi = wifi.WiFiFunction(cls.tc.targets[0])
server_wifi = wifi.WiFiFunction(cls.tc.targets[1])
ap_type = ssid_config.get("Connect", "type")
ssid = ssid_config.get("Connect", "ssid")
pwd = ssid_config.get("Connect", "passwd")
# Connect wifi of two devices
client_wifi.execute_connection(ap_type, ssid, pwd)
server_wifi.execute_connection(ap_type, ssid, pwd)
# Init main target
run_as(
"root",
"killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient",
target=cls.tc.targets[0])
run_as(
"root",
"killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient",
target=cls.tc.targets[0])
run_as(
"root",
"killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ",
target=cls.tc.targets[0])
run_as("root",
"killall simpleclientserver threadingsample",
target=cls.tc.targets[0])
# Init second target
run_as(
"root",
"killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient",
target=cls.tc.targets[1])
run_as(
"root",
"killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient",
target=cls.tc.targets[1])
run_as(
"root",
"killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ",
target=cls.tc.targets[1])
run_as("root",
"killall simpleclientserver threadingsample",
target=cls.tc.targets[1])
# Clean output file on two targets, main is client part and second is server part
run_as("root", "rm -f /tmp/svr_output", target=cls.tc.targets[1])
run_as("root", "rm -f /tmp/output", target=cls.tc.targets[0])
# add group and non-root user on both sides
add_group("tester", target=cls.tc.targets[0])
add_user("iotivity-tester", "tester", target=cls.tc.targets[0])
add_group("tester", target=cls.tc.targets[1])
add_user("iotivity-tester", "tester", target=cls.tc.targets[1])
# Setup firewall accept for multicast, on both sides
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT",
target=cls.tc.targets[0])
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT",
target=cls.tc.targets[0])
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT",
target=cls.tc.targets[1])
run_as("root",
"/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT",
target=cls.tc.targets[1])
# check if image contains iotivity example applications
(status, output) = run_as("root",
"ls /opt/iotivity/examples/resource/",
target=cls.tc.targets[0])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target0'
(status, output) = run_as("root",
"ls /opt/iotivity/examples/resource/",
target=cls.tc.targets[1])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target1'
for i in range(3):
# Do simpleclient test
server_cmd = "/opt/iotivity/examples/resource/cpp/simpleserver > /tmp/srv_output &"
run_as("iotivity-tester", server_cmd, target=cls.tc.targets[1])
client_cmd = "/opt/iotivity/examples/resource/cpp/simpleclient > /tmp/output &"
run_as("iotivity-tester", client_cmd, target=cls.tc.targets[0])
print(
"\npatient... simpleclient needs long time for its observation"
)
time.sleep(70)
(status, output) = run_as("iotivity-tester",
'cat /tmp/output',
target=cls.tc.targets[0])
if "Observe is used." in output:
break
# if not pass, will retry. Clean the app
run_as("root",
"killall simpleserver simpleclient",
target=cls.tc.targets[0])
time.sleep(1)
run_as("root",
"killall simpleserver simpleclient",
target=cls.tc.targets[1])
time.sleep(1)
def setUpClass(cls):
'''Connect to WiFi AP, which contains simpleserver running on it
@fn setUpClass
@param cls
@return
'''
client_wifi = wifi.WiFiFunction(cls.tc.targets[0])
server_wifi = wifi.WiFiFunction(cls.tc.targets[1])
ap_type = ssid_config.get("Connect","type")
ssid = ssid_config.get("Connect","ssid")
pwd = ssid_config.get("Connect","passwd")
# Connect wifi of two devices
client_wifi.execute_connection(ap_type, ssid, pwd)
server_wifi.execute_connection(ap_type, ssid, pwd)
# Init main target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[0])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[0])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[0])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[0])
# Init second target
run_as("root", "killall presenceserver presenceclient devicediscoveryserver devicediscoveryclient", target=cls.tc.targets[1])
run_as("root", "killall fridgeserver fridgeclient garageserver garageclient groupserver groupclient", target=cls.tc.targets[1])
run_as("root", "killall roomserver roomclient simpleserver simpleclient simpleserverHQ simpleclientHQ", target=cls.tc.targets[1])
run_as("root", "killall simpleclientserver threadingsample", target=cls.tc.targets[1])
# Clean output file on two targets, main is client part and second is server part
run_as("root", "rm -f /tmp/svr_output", target=cls.tc.targets[1])
run_as("root", "rm -f /tmp/output", target=cls.tc.targets[0])
# add group and non-root user on both sides
add_group("tester", target=cls.tc.targets[0])
add_user("iotivity-tester", "tester", target=cls.tc.targets[0])
add_group("tester", target=cls.tc.targets[1])
add_user("iotivity-tester", "tester", target=cls.tc.targets[1])
# Setup firewall accept for multicast, on both sides
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[0])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5683 -j ACCEPT", target=cls.tc.targets[1])
run_as("root", "/usr/sbin/iptables -w -A INPUT -p udp --dport 5684 -j ACCEPT", target=cls.tc.targets[1])
# check if image contains iotivity example applications
(status, output) = run_as("root", "ls /opt/iotivity/examples/resource/", target=cls.tc.targets[0])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target0'
(status, output) = run_as("root", "ls /opt/iotivity/examples/resource/", target=cls.tc.targets[1])
if "cpp" in output:
pass
else:
assert 1 == 0, 'There is no iotivity exmaple app installed in target1'
for i in range(3):
# Do simpleclient test
server_cmd = "/opt/iotivity/examples/resource/cpp/simpleserver > /tmp/srv_output &"
run_as("iotivity-tester", server_cmd, target=cls.tc.targets[1])
client_cmd = "/opt/iotivity/examples/resource/cpp/simpleclient > /tmp/output &"
run_as("iotivity-tester", client_cmd, target=cls.tc.targets[0])
print "\npatient... simpleclient needs long time for its observation"
time.sleep(70)
(status, output) = run_as("iotivity-tester", 'cat /tmp/output', target=cls.tc.targets[0])
if "Observe is used." in output:
break
# if not pass, will retry. Clean the app
run_as("root", "killall simpleserver simpleclient", target=cls.tc.targets[0])
time.sleep(1)
run_as("root", "killall simpleserver simpleclient", target=cls.tc.targets[1])
time.sleep(1)
