def write_test(self, message, quit):
chunk_size = Convert2Bytes(self.chunk_size).convert2bytes()
file_size_bytes = Convert2Bytes(self.file_size).convert2bytes()
indX = 0
file_name = self.file + '_' + self.get_currentime() + '_' + str(indX) + ".txt"
if not os.path.exists(self.disk_path):
os.mkdir(self.disk_path)
while not quit.is_set():
with open(self.disk_path + "/" + file_name, "a") as fd:
for chunk in self.chunks(message, chunk_size):
fd.write(chunk)
if os.stat(self.disk_path + "/" + file_name).st_size > file_size_bytes:
indX += 1
file_name = self.file + '_' + self.get_currentime() + '_' + str(indX) + ".txt"
logger.info("%s: Rolling over to %s" % (self.name, file_name))
MasterComm().communicate_message(url=self.url,
msg="%s: Reached chunk limit for %s" % (self.name, file_name),
route="message")
# file_name = self.file + str(indX) + ".txt"
MasterComm().communicate_message(url=self.url,
msg="%s: Rolling over to %s" % (self.name, file_name),
route="message")
if indX < 1:
logger.error("%s: Not enough roll overs occurred to benchmark adequately" % self.name)
def test_communicatmessage_shutdown(self, mock_post):
sc = MasterComm()
sc.communicate_message(url="http://127.0.0.1:8989",
msg="Shutting down: Client1",
value={
"name":
"Client1",
"status":
"offline",
"heartbeat_time":
datetime.now().strftime("%Y-%m-%d %H:%M:%S")
},
route="shutdown")
self.assertEqual(len(mock_post.call_args_list), 1)
def send(self, quit):
while not quit.is_set():
heartbeat = {}
heartbeat["name"] = self.name
heartbeat["heartbeat_time"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
heartbeat["status"] = "alive"
MasterComm().communicate_message(url=self.url,
msg="Heartbeat %s is alive" % self.name,
route="heartbeat", value=heartbeat)
time.sleep(self.interval)
def measure(self, quit):
while not quit.is_set():
memory, cpu = self.prettify_out()
# procs = psutil.Process(self.pid)
# # procs.cpu_percent
# c = procs.cpu_percent()
# memoryUse = (procs.memory_info()[0] / 2. ** 30) / 1000
metrics = {}
metrics["cpu"] = cpu
metrics["memory"] = memory
metrics["disk"] = self.disk_path
metrics["name"] = self.client_name
MasterComm().communicate_message(
url=self.url,
msg="Metric for %s is CPU:: %s , Memory:: %s" %
(self.client_name, cpu, memory),
route="metric",
value=metrics)
time.sleep(self.interval)
def test_communicatmessage_message(self, mock_post):
sc = MasterComm()
sc.communicate_message(url="http://127.0.0.1:8989/message",
msg="Reached chunk limit for rotate0",
route="message")
self.assertEqual(len(mock_post.call_args_list), 1)
def test_communicatemessage_start(self, mock_post):
sc = MasterComm()
sc.communicate_message(url="http://127.0.0.1:8989",
msg="Starting Client",
route="start")
self.assertEqual(len(mock_post.call_args_list), 1)
'--disk-path',
help='Message to be written in chunks',
required=True)
argv = parser.parse_args(args)
return argv
if __name__ == "__main__":
start_time = time.time()
argv = argParser(sys.argv[1:])
logger = Logger.__call__("CLIENT", "../logs").get_logger()
logger.info("Starting %s " % argv.client_name)
MasterComm().communicate_message(url=argv.url,
msg="Starting %s" % argv.client_name,
route="start")
quit = Event()
data_process = Process(target=Benchmark(chunk_size=argv.chunk_size,
url=argv.url,
file_size=argv.file_size,
file=argv.file,
path=argv.disk_path,
name=argv.client_name).write_test,
args=(argv.message, quit),
name="data_process")
data_process.daemon = True
data_process.start()
data_pid = data_process.pid