class SocketServer(asyncore.dispatcher): def __init__(self, host, port): self.clients = Clients() asyncore.dispatcher.__init__(self) self.port = port self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.set_reuse_addr() self.bind((host, port)) self.bind = host self.listen(5) def __sock_process(self, socket): self.clients.append(socket) self.socketHandler = SocketHandler(self, socket) #handle when a connection is established and a connect() has been issued, add client def handle_accept(self): pair = self.accept() if pair != None: socket, addr = pair self.s = Process(target=self.__sock_process(socket), args=[]) try: self.s.start() except: self.s.terminate() #handle when connection is closed and remove client def handle_close(self): self.clients.remove_all() self.s.close() print 'Sockets closed'
def __init__(self):
self.queue = Queue()
self.lc = LockContainer(self.queue)
self.lc.setDaemon(True)
self.lc.start()
self.lg = LockSeverDiag(self.lc)
self.lg.setDaemon(True)
self.lg.start()
self.clients = Clients(self.queue)
self.clients.setDaemon(True)
self.clients.start()
def mainstart(self):
bucle = True
while bucle:
try:
option = int(input("Digita la opción que desees ejecutar: "))
print()
if option == 1:
Clients().start()
self.menu()
elif option == 2:
Vehicles().start()
self.menu()
elif option == 3:
Service().start()
self.menu()
elif option == 4:
Facturas().get_all()
self.menu()
elif option == 5:
Facturas().hola()
self.menu()
elif option == 6:
self.menu()
elif option == 7:
bucle = False
print()
except NameError:
print(NameError)
print("7. Mostrar menú de modulos [7]")
print(
"La opción digitada es invalida (debe ser un número en el menú)."
)
print()
def __init__(self, host, port): self.clients = Clients() asyncore.dispatcher.__init__(self) self.port = port self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.set_reuse_addr() self.bind((host, port)) self.bind = host self.listen(5)
def __init__(self):
self.queue = Queue()
self.lc = LockContainer(self.queue)
self.lc.setDaemon(True)
self.lc.start()
self.lg = LockSeverDiag(self.lc)
self.lg.setDaemon(True)
self.lg.start()
self.clients = Clients(self.queue)
self.clients.setDaemon(True)
self.clients.start()
def main():
init_logging('/tmp/lockserver.log')
ebus = eventbus()
clients = Clients(ebus)
clients.setDaemon(True)
clients.start()
lc = LockContainer(ebus)
ebus.register_consumer(lc, common.LOCKOP_TOPIC)
ebus.register_consumer(lc, common.UNREGISTER_TOPIC)
ebus.register_consumer(clients, common.RESPONSE_TOPIC)
f = DistComFactory(ebus)
f.protocol = DistLockComm
reactor.listenTCP(8000, f)
reactor.run()
def run():
clients = Clients()
clients._load_clients()
while True:
command = str(input('''
Bienvenido, a BanPlatzi tu app de gestion de filas de tu banco
[A]Agregar cliente a fila de deposito
[B]Agregar cliente a fila de apertura de cuenta
[C]Atender cliente
[D]Listar clientes en fila
[S]Salir
''')).lower()
if command == 'a':
depositor_name = _get_input_data('nombre del depositante')
depositor_uid = _get_input_data('numero de identificaion del depositante')
number_account = _get_input_data('numero de cuenta del cliente')
found_account = clients.search(number_account)
if found_account:
add_to_deposit_queue(number_account, depositor_name, depositor_uid)
else:
print(f'La cuenta numero {number_account}, no fue encontrada')
elif command == 'b':
name = _get_input_data('nombre del cliente')
identification = _get_input_data('identificacion de cliente')
add_to_opening_account_queue(name, identification)
elif command == 'c':
queue = input('''
Elije que fila deseas atender :
[A] Fila de Depositos
[B] Fila de Apertura de Cuenta
''').lower()
print('Siguiente Cliente...')
if queue == 'a':
try:
print('Cliente a atender >> Nombre del depositante: {} - Identificado con C.C N° {} | Numero de cuenta a depositar: {}'.format(deposit_queue[0]['depositor_name'], deposit_queue[0]['depositor_uid'], deposit_queue[0]['number_account']))
value = _get_input_data('monto a consignar, no incluyas puntos ni comas - $ ')
client = clients.search(deposit_queue[0]['number_account'])
clients.deposit(client, value)
deposit_queue.popleft()
except IndexError:
print('La fila de Depositos no tiene clientes')
elif queue == 'b':
try:
print('Cliente a atender >> Nombre del futuro cliente: {} - Identificado con C.C N° {}'.format(account_opening_queue[0]['name'], account_opening_queue[0]['identification']))
number_phone = _get_input_data('numero de telefono del cliente: ')
email = _get_input_data('email del cliente: ')
clients.add(account_opening_queue[0]['name'], account_opening_queue[0]['identification'], number_phone, email)
account_opening_queue.popleft()
except IndexError:
print('La fila de Apertura de clientes no tiene clientes')
elif command == 'd':
list_clients_queues()
elif command == 's':
print('Saliendo...')
sys.exit()
else:
print('Comando invalido, vuelve a intentar.')
def __init__(self, server, socket): self.clients = Clients() self.server = server self.handshaken = False asyncore.dispatcher_with_send.__init__(self, socket);
SA_SERVICE_PORT = 5000
TM_SERVICE_HOST = os.environ.get('TM_SERVICE_HOST', 'localhost')
TM_SERVICE_PORT = 5001
MONGODB_HOST = os.environ.get('MONGODB_HOST', 'localhost')
MONGODB_PORT = 27017
MONGODB_DATABASE = os.environ.get('MONGODB_DATABASE', 'tmdata')
print('SA_SERVICE_HOST: {}'.format(SA_SERVICE_HOST))
print('SA_SERVICE_PORT: {}'.format(SA_SERVICE_PORT))
print('TM_SERVICE_HOST: {}'.format(TM_SERVICE_HOST))
print('TM_SERVICE_PORT: {}'.format(TM_SERVICE_PORT))
print('MONGODB_HOST: {}'.format(MONGODB_HOST))
print('MONGODB_PORT: {}'.format(MONGODB_PORT))
db = DBWorker(MONGODB_HOST, MONGODB_PORT, 'taskmaster')
clients = Clients(db)
startTime = datetime.now()
tm = ThematicModeller(host=TM_SERVICE_HOST, port=TM_SERVICE_PORT)
sa = SentimentalAnalyzer(host=SA_SERVICE_HOST, port=SA_SERVICE_PORT)
# using dict of required fields and their types to validate request
def check_request(request, fields):
errors = []
if not request.json:
errors.append('No JSON sent. ' +
'Did you forget to set Content-Type header' +
' to application/json?')
return errors
class SocketHandler(asyncore.dispatcher_with_send):
handshake = (
'HTTP/1.1 101 Web Socket Protocol Handshake\r\n'
'Upgrade: WebSocket\r\n'
'Connection: Upgrade\r\n'
'WebSocket-Origin: %(origin)s\r\n'
'WebSocket-Location: ws://%(bind)s:%(port)s/\r\n'
'Sec-Websocket-Origin: %(origin)s\r\n'
'Sec-Websocket-Location: ws://%(bind)s:%(port)s/\r\n'
'Sec-Websocket-Accept: %(response)s\r\n'
'\r\n'
)
def __init__(self, server, socket):
self.clients = Clients()
self.server = server
self.handshaken = False
asyncore.dispatcher_with_send.__init__(self, socket);
def __create_handshake(self, headers):
print 'Beginning handshake...'
print headers
h = httpParse(headers)
#create response key for handshake accept
guid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
key = h['Sec-WebSocket-Key']
response_key = b64encode(sha1(key + guid).digest())
handshake = SocketHandler.handshake % {
'origin': h['Origin'],
'port': self.server.port,
'bind': self.server.bind,
'response': response_key
}
return handshake
#TODO: encode message frame to send message to desktop client
def __create_frame(self, string):
encoded = ""
b1 = 0x80
b1 |= 0x01
payload = string
#add FIN flag
encoded += chr(b1)
#second byte never masked
b2 = 0
length = payload.__len__()
if length < 126:
b2 |= length
encoded += chr(b2)
elif length < 65535: # 2^16 -1
b2 |= 126
encoded += chr(b2)
x = struct.pack(">H", length)
encoded += x
else:
x = struct.pack(">Q", length)
b2 = 126
encoded += chr(b2)
encoded += x
encoded += payload
return str(encoded)
#decode message from mobile client
def __decode_message(self, data):
bytes = [ord(character) for character in data]
length = bytes[1] & 127 #following eight bytes used for length
firstMask = 2
#special cases
if length == 126:
firstMask = 4
elif length == 127:
firstMask = 10
#extract masks to find first data byte
masks = [m for m in bytes[firstMask : firstMask + 4]]
firstDataByte = firstMask + 4
decoded = []
i = firstDataByte
j = 0
while i < bytes.__len__():
#unmask current byte and add to decoded array
decoded.append(chr(bytes[i] ^ masks[j % 4]))
i += 1
j += 1
return str(decoded)
#send data to desktop client
def __send_to_desktop(self, data):
clientList = self.clients.get()
print clientList
#for our purpose there should only be two clients, one desktop, one mobile (for now)
for c in clientList:
if c is not self:
encodedData = self.__create_frame(data)
c.send(encodedData)
#handle a read() call
def handle_read(self):
data = self.recv(8192)
if data:
if self.handshaken is False:
handshake = self.__create_handshake(data)
self.handshaken = True
self.send(handshake)
else:
decodedMessage = self.__decode_message(data)
print 'Decoded Message:'
print decodedMessage
print '\n\n'
self.__send_to_desktop(decodedMessage)
class LockServiceHandler:
def __init__(self):
self.queue = Queue()
self.lc = LockContainer(self.queue)
self.lc.setDaemon(True)
self.lc.start()
self.lg = LockSeverDiag(self.lc)
self.lg.setDaemon(True)
self.lg.start()
self.clients = Clients(self.queue)
self.clients.setDaemon(True)
self.clients.start()
def __del__(self):
self.clients.stop()
def lockOp(self, clientId, lockCmd):
if not self.clients.is_registered(clientId):
return StatusMsg.CLIENT_NOT_REGISTERED
if lockCmd.op == LockOperation.UNLOCK:
logging.debug('Unlock ' + lockCmd.lockId + ' by ' + clientId)
return self.lc.unlock(clientId, lockCmd.lockId)
return self.lc.add_lock(clientId, lockCmd.lockId, lockCmd.op)
def registerClient(self, clientId):
self.clients.add_client(clientId)
return StatusMsg.SUCCESS
def sendHeartBeat(self, clientId):
if not self.clients.is_registered(clientId):
return StatusMsg.CLIENT_NOT_REGISTERED
self.clients.heartbeat(clientId)
return StatusMsg.SUCCESS
def reRegisterLocks(self, clientId, locks):
if not self.clients.is_registered(clientId):
return StatusMsg.CLIENT_NOT_REGISTERED
for lock in locks.locks:
self.lc.add_lock(clientId, lock.lockId, lock.op)
return StatusMsg.SUCCESS
def getLockDetails(self, lockid):
return self.lc.getLockDetails(lockid)
def getLiveClients(self):
return self.clients.getClients()
def unRegisterClient(self, clientId):
return self.clients.unRegisterClient(clientId)
def shutDown(self):
self.clients.stop()
self.lc.stop()
self.lg.stop()
def __init__(self, cnxt):
self.clients = Clients(**cnxt)
class Discoverer(object):
def __init__(self, cnxt):
self.clients = Clients(**cnxt)
def list_servers(self, *args, **kwargs):
servers = {}
for server in self.clients.nova().servers.list():
servers[server.id] = Server(server.to_dict(), *args, **kwargs)
return servers
def list_keypairs(self):
keypairs = {}
for keypair in self.clients.nova().keypairs.list():
keypairs[keypair.id] = KeyPair(keypair.to_dict()['keypair'])
return keypairs
def list_netowrks(self):
networks = {}
for net in self.clients.neutron().list_networks()['networks']:
networks[net['id']] = Net(net)
return networks
def list_subnets(self):
subnets = {}
for subnet in self.clients.neutron().list_subnets()['subnets']:
subnets[subnet['id']] = Subnet(subnet)
return subnets
def list_routers(self):
routers = {}
for router in self.clients.neutron().list_routers()['routers']:
routers[router['id']] = Router(router)
return routers
def list_ports(self):
ports = {}
for port in self.clients.neutron().list_ports()['ports']:
device_owner = port.get('device_owner')
if device_owner is not None and device_owner == 'compute:None':
ports[port['id']] = Port(port)
return ports
def list_floating_ips(self):
fips = {}
for floating_ip in \
self.clients.neutron().list_floatingips()['floatingips']:
fips[floating_ip['id']] = FloatingIP(floating_ip)
return fips
def list_security_groups(self):
sec_groups = {}
for sec_group in \
self.clients.neutron().list_security_groups()[
'security_groups']:
sec_groups[sec_group['id']] = SecurityGroups(sec_group)
return sec_groups
def list_resources(self, *args, **kwargs):
resources = {}
resources.update(self.list_servers(*args, **kwargs))
resources.update(self.list_keypairs())
resources.update(self.list_netowrks())
resources.update(self.list_subnets())
resources.update(self.list_routers())
resources.update(self.list_ports())
resources.update(self.list_floating_ips())
resources.update(self.list_security_groups())
return resources
#PREPROCESSOR AM-CTAC
#Script for the preprocesing of URLs from tickets for the Analizer Module
#____________________________________________________________________________
#____________________________________________________________________________
#Configuration:
#
#The unique parameter that have to be configured is the hours, that represents
#the interval of time in that the script is executed.
#
#_____________________________________________________________________________
from clients import Clients
from tickets import Tickets
from ticketspaths import Ticketpaths
from paths import Paths
# unique parameter
#Tables |
#ticketpaths V
ticpaths = Ticketpaths(Clients(),Tickets(8))
paths=Paths(ticpaths)
#Client_score and recurrence
paths.paths_recurrence()
paths.paths_client_score()
#insert_data
#ticketpaths
ticpaths.tp_insert_data()
#paths
paths.paths_insert_data()
def run(type, server_conf, memtier_conf, output_dir, base_port=11120, instances=1, duration=30, zipf=False, pin=False, iterations=3):
server = Server(type, server_conf, base_port, instances)
clients = Clients(type, memtier_conf, base_port, instances, zipf=zipf)
server.start_cache()
if pin:
server.pin()
# Warm up
print('[Main] Warming up cache')
client_results = clients.warmup()
memtier_parser = MemtierResultsParser(client_results)
memtier_parser.read()
cpu_stats = []
total_stats = []
latency_stats = []
for i in range(iterations):
print('[Main] Iteration {} started'.format(i))
server_cpu = server.log_cpu(duration + 1)
cpu_parser = CPUParser()
client_results = clients.run_memtier(False)
memtier_parser = MemtierResultsParser(client_results)
memtier_parser.read()
averaged_totals = memtier_parser.get_averaged_totals()
average_99th = memtier_parser.get_average_99th()
server_cpu_averages = cpu_parser.get_average_stats(server_cpu)
server_cpu_labels = cpu_parser.get_labels()
total_stats.append(averaged_totals)
latency_stats.append(average_99th)
cpu_stats.append([server_cpu_averages[key] for key in server_cpu_labels])
print('[Main] Iteration {} finished'.format(i))
print('[Main] Totals:', averaged_totals)
print('[Main] 99th:', average_99th)
print('[Main] CPU:', server_cpu_averages)
avg_latency = sum(latency_stats) / float(iterations)
avg_cpu_stats = []
for index in range(len(cpu_stats[0])):
values = [cpu[index] for cpu in cpu_stats]
avg_cpu_stats.append(sum(values) / float(iterations))
avg_total_stats = []
for index in range(len(total_stats[0])):
values = [cpu[index] for cpu in total_stats]
avg_total_stats.append(sum(values) / float(iterations))
print('[Main] Totals:', avg_total_stats)
print('[Main] 99th:', avg_latency)
print('[Main] CPU:', avg_cpu_stats)
# write results
write(
', '.join(memtier_parser.get_totals_headers()),
avg_total_stats,
'%s/totals.csv' % output_dir
)
write(
'99th latency',
[avg_latency],
'%s/latency.csv' % output_dir
)
server_cpu_labels = cpu_parser.get_labels()
write(
', '.join(server_cpu_labels),
avg_cpu_stats,
'%s/cpu.csv' % output_dir
)
# Clean up
server.kill_cache()
class LockServiceHandler:
def __init__(self):
self.queue = Queue()
self.lc = LockContainer(self.queue)
self.lc.setDaemon(True)
self.lc.start()
self.lg = LockSeverDiag(self.lc)
self.lg.setDaemon(True)
self.lg.start()
self.clients = Clients(self.queue)
self.clients.setDaemon(True)
self.clients.start()
def __del__(self):
self.clients.stop()
def lockOp(self, clientId, lockCmd):
if not self.clients.is_registered(clientId):
return StatusMsg.CLIENT_NOT_REGISTERED
if lockCmd.op == LockOperation.UNLOCK:
logging.debug('Unlock ' + lockCmd.lockId + ' by ' + clientId)
return self.lc.unlock(clientId, lockCmd.lockId)
return self.lc.add_lock(clientId, lockCmd.lockId, lockCmd.op)
def registerClient(self, clientId):
self.clients.add_client(clientId)
return StatusMsg.SUCCESS
def sendHeartBeat(self, clientId):
if not self.clients.is_registered(clientId):
return StatusMsg.CLIENT_NOT_REGISTERED
self.clients.heartbeat(clientId)
return StatusMsg.SUCCESS
def reRegisterLocks(self, clientId, locks):
if not self.clients.is_registered(clientId):
return StatusMsg.CLIENT_NOT_REGISTERED
for lock in locks.locks:
self.lc.add_lock(clientId, lock.lockId, lock.op)
return StatusMsg.SUCCESS
def getLockDetails(self, lockid):
return self.lc.getLockDetails(lockid)
def getLiveClients(self):
return self.clients.getClients()
def unRegisterClient(self, clientId):
return self.clients.unRegisterClient(clientId)
def shutDown(self):
self.clients.stop()
self.lc.stop()
self.lg.stop()
# import setup_path
import airsim
from slam import Slam
import assistant
from clients import Clients
import numpy as np
tmp_dir = "./img"
assistant.create_directory(tmp_dir)
clients = Clients()
slam = Slam()
airsim.wait_key('Press any key to takeoff')
slam.calibrate_camera(clients.client_2)
clients.takeoff()
assistant.print_state(clients.client_1)
clients.move_and_take_photos()
slam.append(np.array(clients.queue.queue))
#print(slam.images)
#print(slam.images.shape)
slam.estimate_trajectory_dataset()
slam.plot_trajectory()
clients.end()
import time
from clients import Clients, Crandom
# curl -i -H "Content-Type: application/json" -H "Accept: application/json" -X POST -d "{\"task\":\"Read a book\"}" http://127.0.0.1:5000/api/v1/testing
start = True
clc = 1
api_url = 'http://127.0.0.1:5000/api/v1/auth/signin'
# api_url = 'http://127.0.0.1:5000/api/v1/auth/signup'
clientsList = []
json = {'type': "simple", 'user': "******", 'pswd': "q"}
for count in range(clc):
x = Clients(count, api_url, json)
clientsList.append(x)
while start:
for client in clientsList:
Crandom(client).client_run()
print("---" * 20)
time.sleep(2)
def display():
print(
"=============================>Networker Ver 1.0<==========================="
)
print()
print("-c => client")
print("-s => server")
print("-TCP => establish a TCP client or server")
print("-UDP => establish a UDP client or server")
print(
"--basic => Basic type of server of client which sends and receives the packets"
)
print("--type=cat => Bit advanced to the --basic mode")
def about():
print(
"""=============================>Networker Ver 1.0<===========================
Networker the Network Bozooka
Programmed by Visweswaran
Product of India
A standard all in 1 tool for performing pen-testing in an environment where other packages failed
Do not worry if other tools aren't there now for you got a Bazooka with you"""
)
clients = Clients()
servers = Servers()
from clients import Clients
from parsers.cpu import CPUParser
from parsers.memtier import MemtierResultsParser
from server import Server
s = Server('memcached', '-d -p 11120 -m 1024', 11120, 4)
s.start_cache()
c = Clients('memcached', '-s nsl200 -p 11123 --test-time=30 -c 1 -t 1 -P memcache_binary', 11120, 4)
cpu = s.log_cpu()
cpu_parser = CPUParser()
results = c.run_memtier()
parser = MemtierResultsParser(results)
parser.read()
averages = parser.get_averaged_totals()
average_99th = parser.get_average_99th()
