Пример #1
0
def send_req_wired(host, port):
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://" "%s:%d" % ((host), port))
    print("sending req to wired_sdn")
    sw = orc_to_wired.orc_to_wired()

    ob = sw.switch.addflow.flow.add("5674")
    ob.ip_src = "192.168.1.2"
    ob.ip_dst = "192.168.1.3"

    lm = sw.switch.deleteflow.flow.add("5644")
    lm.ip_src = "192.168.1.5"
    lm.ip_dst = "192.168.1.6"

    kd = sw.switch.changeflow.flow.add("5684")
    kd.ip_src_old = "192.168.1.98"
    kd.ip_dst_old = "192.168.1.45"
    kd.ip_src_new = "192.168.1.67"
    kd.ip_dst_new = "192.168.1.24"
    kd.port_new = '3453'
    a = sw.get()
    # this default should return a serializable version of obj or raise TypeError
    packet = (json.dumps(a, default=lambda x: x.__dict_))
    print(packet)
    # print(type(packet))
    socket.send_json(packet)
    msg = socket.recv(1024)
    print("received reply: %s" % msg)
Пример #2
0
def getSongBytes(server):
    try:
        socket = ctx.socket(zmq.REQ)
        ip = server["ip"]
        port = server["port"]
        socket.connect("tcp://" + ip + ":" + str(port))
        filenames = server["files"]
        files = {}
        for f in filenames:
            print("apending bytes")
            socket.send_json({
                "origin": "client",
                "type": "download",
                "data": {
                    "filename": f
                }
            })
            ans = socket.recv_json()
            if ans["status"] == "ok":
                files[f] = ans["data"]["bytes"].encode('iso8859-15')
            else:
                print("Error, ", ans)
        return files
    except Exception as e:
        print("Ocurrió un error al obtener la parte de la canción, ", e)
def send_array(socket, A, flags=0, copy=True, track=False):
    """send a numpy array with metadata"""
    md = dict(
        dtype = str(A.dtype),
        shape = A.shape,
    )
    socket.send_json(md, flags|zmq.SNDMORE)
    socket.send(A, flags, copy=copy, track=track)
Пример #4
0
def send_image(socket, im, flags=0, copy=False, track=False):
    """send a PIL image with metadata"""
    md = dict(
        size = im.size,
        mode = im.mode,
    )
    socket.send_json(md, flags|zmq.SNDMORE)    
    return socket.send(im.tostring(), flags, copy=copy, track=track)
def send_array(socket, A, f_num, flags=0, copy=True, track=False):
    """send a numpy array with metadata"""
    md = dict(
        dtype='uint8',
        shape=A.shape,
        frame_num=f_num,
    )
    socket.send_json(md, flags | zmq.SNDMORE)
    print("sending from collector 1")
    return socket.send(A, flags, copy=copy, track=track)
Пример #6
0
def send_array(socket, nparray, flags=0, copy=True, track=False):
    """send a numpy array with metadata
    from http://pyzmq.readthedocs.io/en/latest/serialization.html
    """
    md = dict(
        dtype=str(nparray.dtype),
        shape=nparray.shape,
    )
    socket.send_json(md, flags | zmq.SNDMORE)
    return socket.send(nparray, flags, copy=copy, track=track)
Пример #7
0
def send_array(socket, A, flags=0, copy=True, track=False):
    md = dict(
        dtype=str(A.dtype),
        shape=A.shape,
    )
    # Made a dictionary of dtype of array and shape of array so that at server side we know
    # at the time of transforming array from  buffer we must know the shape to get it back.

    socket.send_json(md, flags | zmq.SNDMORE)
    #Sent the image using json to the server
    return socket.send(A, flags, copy=copy, track=track)
Пример #8
0
 def _getIPCMsg(self, flag):
     context = zmq.Context()
     socket = context.socket(zmq.REQ)
     socket.setsockopt(zmq.LINGER, 0)
     #socket.connect("ipc://"+baseParams['IPCFile'])
     socket.connect(baseParams['tcpaddr'])
     socket.send_json(flag)
     poller = zmq.Poller()
     poller.register(socket, zmq.POLLIN)
     if poller.poll(360 * 1000):  # 10s timeout in milliseconds
         return (socket.recv_json())
     else:
         return ({'data': 'The process has no response'})
def keepalive(socket=None, subscriber=None):
    while True:
        msg = {
            "action": "announcement",
            "state": subscriber.state,
            "id": subscriber.id,
            "file": subscriber.file,
            "cfg": subscriber.cfg
        }
        socket.send_json(msg)
        msg = socket.recv_json()
        subscriber.cfg = msg["cfg"]
        time.sleep(10)
Пример #10
0
    def join_cluster(self, cluster_cmd_uri):
        socket = self.ctx.socket(zmq.REQ)
        socket.connect('tcp://{}'.format(cluster_cmd_uri))
        socket.send_json({
            'type': 'JOIN',
            'node': self.local_node.details,
            'timestamp': time.time()
        })
        resp = socket.recv_json()

        for node in resp['nodes']:
            self.add_node(node)

        socket.close()
Пример #11
0
def send_req_wired(host, port):
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://" "%s:%d" % ((host), port))
    print("sending req to wired_sdn")
    sw = orc_to_wired.orc_to_wired()
    a = sw.get()
    # this default should return a serializable version of obj or raise TypeError
    packet = (json.dumps(a, default=lambda x: x.__dict_))
    print(packet)
    # print(type(packet))
    socket.send_json(packet)
    msg = socket.recv(1024)
    print("received reply: %s" % msg)
Пример #12
0
    def _handle_message(self, message, args, socket, build_index):
        """
        Receives messages from the controller and calls the appropriate function.

        :param message: The message dict from controller.
        :param args: The args defined upon initializing this script defining binary.
        :param socket: The zmq socket from controller.
        :param build_index: The dict containing all active binaries.
        """
        if message["type"] == "start_build":
            build_info = self._start_binary(message, args)
            build_port = build_info["build_port"]
            build_index[build_port] = build_info
            socket.send_json(build_info)

        elif message["type"] == "keep_alive":
            build_port = message["build_port"]
            build_index[build_port]["last_keep_alive"] = time.time()
            socket.send_json(message)

        elif message["type"] == "kill_build":
            build_port = message["build_port"]
            pid = build_index[build_port]["build_pid"]
            os.kill(pid, signal.SIGKILL)
            socket.send_json({"type": "build_killed", "build_pid": pid})
            print("Killing build with pid: {} on port: {}".format(
                pid, build_port))

        else:
            socket.send_json({"type": "no_response"})
Пример #13
0
def crack(f_name=None, e=None, subscriber=None, socket=None):
    print("Começando quebra do arquivo ", f_name)
    # executa o john
    cmd = ""
    if len(subscriber.cfg):
        cmd = "exec john -i=" + subscriber.cfg + " " + f_name + " --session=" + subscriber.id
    else:
        cmd = "exec john " + f_name + " --session=" + subscriber.id
    print(cmd)
    p = subprocess.Popen(cmd,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT,
                         shell=True)
    while True:
        if e.isSet():
            e.clear()
            p.kill()
            subscriber.state = "ocioso"
            print("Recebido comando para parar.")
            break
        if p.poll() is not None:
            subscriber.state = "ocioso"
            cmd = "john --show " + f_name
            p = subprocess.run(cmd.split(),
                               stdout=subprocess.PIPE,
                               stderr=subprocess.STDOUT)
            results = p.stdout.decode("utf-8").splitlines()
            print(results)
            erro = p.stderr
            if erro is not None:
                print(erro.decode("utf-8"))
            if len(results) >= 2:
                print("Arquivo quebrado!!")
                results = results[:len(results) - 2]
                results = "\n".join(results)
            else:
                print("ERRO: Não foi possível quebrar o arquivo.")
                results = ""
            msg = {
                "action": "done",
                "f_name": f_name,
                "id": subscriber.id,
                "status": p.returncode,
                "results": results,
                "data": datetime.now().strftime("%d/%m/%Y %H:%M:%S")
            }
            socket.send_json(msg)
            socket.recv_json()
            break
Пример #14
0
    def _send_kill_build(socket, build_info: dict) -> dict:
        """
        This sends a command to the launch_binaries daemon running on a remote node to terminate a given binary.

        :param socket: The zmq socket.
        :param build_info: A diciontary containing the build_port.

        :return A kill_status indicating build has been succesfully terminated.
        """

        build_port = build_info["build_port"]
        request = {"type": "kill_build", "build_port": build_port}
        socket.send_json(request)
        kill_status = socket.recv_json()
        return kill_status
Пример #15
0
def tryConnect(ip=getLocalIp(), port=PORT, timeout=10, dt=0.01):
    ok = None
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://" + str(ip) + ":" + str(port))
    socket.send_json({"action": "list"})
    # print "send at ", time.time()
    t = time.time()
    while t + timeout > time.time():
        try:
            socket.recv_json(zmq.DONTWAIT)
            ok = (ip, port)
        except Exception, e:
            time.sleep(dt)
            continue
def send_ack_master():
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://%s:%s" % (MASTER_IP, master_ACK_port))
    header_data = {
        "machine": machine_name,  ##ID instead don't forget to modify
        "username": "******",
        "filename": "vid_1.mp4",
        "numberofchunks": 15
    }
    header_data_sent_to_master = json.dumps(header_data)
    socket.send_json(header_data_sent_to_master)
    replica_list = socket.recv_json()
    print(replica_list)
    socket.close()
    return replica_list
Пример #17
0
    def _send_keep_alive(socket, build_info: dict) -> dict:
        """
        This sends a command to the launch_binaries daemon running on a remote node
        to mark a given binary as still alive, preventing garbage collection.

        :param socket: The zmq socket.
        :param build_info: A diciontary containing the build_port.

        :return a heartbeat indicating build is still alive.
        """

        build_port = build_info["build_port"]
        request = {"type": "keep_alive", "build_port": build_port}
        socket.send_json(request)
        heartbeat = socket.recv_json()
        return heartbeat
Пример #18
0
    def _send_start_build(socket, controller_address: str) -> dict:
        """
        This sends a command to the launch_binaries daemon running on a remote node
        to start a binary connected to the given controller address.

        :param socket: The zmq socket.
        :param controller_address: The host name or ip address of node running the controller.

        :return Build info dictionary containing build port.
        """
        request = {
            "type": "start_build",
            "controller_address": controller_address
        }
        socket.send_json(request)
        build_info = socket.recv_json()
        return build_info
Пример #19
0
def send_req_wireless(host, port):
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://" "%s:%d" % ((host), port))
    print("sending req to wireless sdn")
    sw = orc_to_wireless.orc_to_wireless()
    ob = sw.handover.client.add('01:22:45:67:89:ac')
    ob.old_mac = '01:32:35:67:90:ab'
    ob.new_mac = '01:12:45:67:89:ab'
    a = sw.get()
    # this default should return a serializable version of obj or raise TypeError
    packet = (json.dumps(a, default=lambda x: x.__dict_))
    print(packet)
    # print(type(packet))
    socket.send_json(packet)
    msg = socket.recv(1024)
    print("received reply: %s" % msg)
Пример #20
0
 def update_ctr(self, ctr_ip):
     try:
         LOG.info("Controller IP Address= {0}".format(ctr_ip))
         context = zmq.Context()
         socket = context.socket(zmq.REQ)
         socket.connect("tcp://{0}:50165".format(ctr_ip))
         ip = str(subprocess.check_output('hostname -I', shell=True))
         nc = len(ip) - 3
         ip = ip[2:nc]
         host_ip = ip.strip()
         LOG.info("HOST IP Address= {0}".format(host_ip))
         mapping = {"VLAN": "10", "IP": host_ip, "MAC": "00:50:56:b8:11:c9"}
         socket.send_json(mapping)
         LOG.info("Received " + socket.recv_json()["reply"] +
                  " event from SDN controller.")
     except BaseException as err:
         LOG.error("Passing IP to SDN controller failed! ERROR: {0}".format(
             str(err)))
Пример #21
0
def ping(seed, q, time, log):
    """
    Process that make ping to a seed.
    """
    context = zmq.Context()
    socket = noBlockREQ(context, timeout=time)
    socket.connect(f"tcp://{seed[0]}:{seed[1]}")
    status = True

    log.debug(f"PING to {seed[0]}:{seed[1]}", "Ping")
    try:
        socket.send_json(("PING", ))
        msg = socket.recv_json()
        log.info(f"Received {msg} from {seed[0]}:{seed[1]} after ping", "Ping")
    except zmq.error.Again as e:
        log.debug(f"PING failed -- {e}", "Ping")
        status = False
    q.put(status)
Пример #22
0
def tryConnect(ip=getLocalIp(), port=PORT, timeout=4, dt=0.01):
    ok = None
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://" + str(ip) + ":" + str(port))
    socket.send_json({"action": "list"})
    # print "send at ", time.time()
    t = time.time()
    while t + timeout > time.time():
        try:
            socket.recv_json(zmq.DONTWAIT)
            ok = (ip, port)
        except Exception as e:
            time.sleep(dt)
            continue
    socket.setsockopt(zmq.LINGER, 0)
    socket.close()
    context.term()
    return ok
Пример #23
0
def main():
    sim = Simulation(SpeedLimit=0.5, RandomChanges=10)  # instantiate the simulation wrapper

    # Setup comm sockets
    context = zmq.Context()
    socket = context.socket(zmq.PUB)  # publish to all upstreams services
    socket.bind("tcp://127.0.0.1:5550")  # localhost only, no encryption

    # Main Loop
    while True:
        # --------------------------------------------------------------------------
        # Calculate next round
        # --------------------------------------------------------------------------
        sim.Solve()

        # TODO destabilization code - restore?

        # --------------------------------------------------------------------------
        # Send state to visualization/freq model
        # --------------------------------------------------------------------------
        socket.send_json(sim.Output())
Пример #24
0
def send_manage_message(endpoint: str, action: dict, timeout: int = 5):
    """
    Sends a 'management' message, following the threatbus-zmq-app protocol to
    either subscribe or unsubscribe this application to/from Threat Bus.
    @param endpoint A host:port string to connect to via ZeroMQ
    @param action The message to send as JSON
    @param timeout The period after which the connection attempt is aborted
    """
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.setsockopt(zmq.LINGER, 0)
    socket.connect(f"tcp://{endpoint}")
    socket.send_json(action)
    poller = zmq.Poller()
    poller.register(socket, zmq.POLLIN)

    reply = None
    if poller.poll(timeout * 1000):
        reply = socket.recv_json()
    socket.close()
    context.term()
    return reply
Пример #25
0
  def post(self, experiment_id, user_id):
    if self.get_cookie('sessionid') not in self.db['user']:
      self.set_status(500)
      self.finish()
      return

    client_query = {}
    client_query['QUERY'] = self.get_argument('QUERY')
    client_query['CLIENT_ID'] = self.get_cookie('sessionid')
    client_query['CLIENT_RESPONSE'] = {}
    client_query['CLIENT_RESPONSE']['WORKSITE'] = self.get_argument('CLIENT_RESPONSE_WORKSITE', None)
    client_query['CLIENT_RESPONSE']['CONCLUSION'] = self.get_argument('CLIENT_RESPONSE_CONCLUSION', None)
    client_query['QUERY_INDEX'] = int(self.get_argument('QUERY_INDEX', -1))
    client_query['QUERY_STATUS'] = self.get_argument('QUERY_STATUS', '')

    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect('ipc://%s'%self.totem)
    socket.send_json(client_query)
    server_response = socket.recv_json()
    socket.close()

    # return
    self.write(json.dumps(server_response))
Пример #26
0
    def run(self):
        self.isStopped = False

        print "Starting nameserver on", getLocalIp(), str(PORT)
        time.sleep(1)
        self.canGo = True
        context = zmq.Context()
        socket = context.socket(zmq.REP)
        # socket.bind("tcp://" + config.local_ip + ":" + str(config.name_port))
        socket.bind("tcp://*:" + str(PORT))
        programs = {}
        counter = 0
        
        import SimpleHTTPServer, SocketServer
        WPORT = 8080
        import pprint, StringIO
        class MyHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
            def do_GET(self):    
                self.send_response(200)
                self.send_header('Content-Type', 'text/html')
                self.end_headers()
                self.wfile.write("<html><body>");
                self.wfile.write("<h1>Programs</h1><pre>");
                s = StringIO.StringIO()
                pprint.pprint(programs, s)
                self.wfile.write(s.getvalue()) 
                self.wfile.write("</pre>");
                
                self.wfile.write("</body></html>");
                self.wfile.close();
        Handler = MyHandler

        # self.httpd = SocketServer.ThreadingTCPServer(("", WPORT), Handler)
        
        
        print "serving WWW at port", WPORT
        # self.www = threading.Thread(target=self.httpd.serve_forever).start()

        while self.canGo:
            data = {}
            try:
                data = socket.recv_json(zmq.DONTWAIT)
                print data
            except Exception, e:
                time.sleep(0.01)
                continue
            print 'NS recive at', time.time()
            try:
                data['action']
            except:
                data['action'] = 'ping'
            try:
                if data['action'] == 'register':
                    try:
                        data['location']
                    except:
                        data['location'] = 'local'
                    programs[data['name']] = dict(time=time.time(), ip=data['ip'], port=data['port'], location=data['location'])
                    print "registrating ", data['name'], programs[data['name']] 
                    socket.send_json(dict(status='ok'))
                    continue
                if data['action'] == 'list':
                    d = []
                    for k, v in programs.iteritems():
                        d.append(dict(name=k, data=v)) 
                    socket.send_json(d)
                    print 'send at', time.time()
                    continue
                if data['action'] == 'ping':
                    socket.send_json(dict(status='ok'))
                    continue
            except Exception, e:
                print e
                socket.send_json(dict(status='fail', text=str(e)))
                continue
Пример #27
0
def test_resultsServer():
    """ tests pyneal.src.resultsServer """

    # create settings dictionary
    settings = {'pynealScannerPort': port,
                'pynealHost': host,
                'numTimepts': 3,
                'launchDashboard': False,
                'seriesOutputDir': paths['testDataDir']}
    scanReceiver = ScanReceiver(settings)
    scanReceiver.daemon = True
    scanReceiver.start()

    # Set up Pyneal Scanner simulator for making a connection to the scanReceiver
    context = zmq.Context.instance()
    socket = context.socket(zmq.PAIR)
    socket.connect('tcp://{}:{}'.format(host, port))

    while True:
        msg = 'hello from test pyneal scanner simulator'
        socket.send_string(msg)
        resp = socket.recv_string()
        if resp == msg:
            break

    # Send data to scan receiver
    ds = nib.load(join(paths['testDataDir'], 'testSeries.nii.gz'))
    ds_array = ds.get_data()
    ds_affine = ds.affine

    for volIdx in range(ds_array.shape[3]):
        # grab this volume from the dataset
        thisVol = np.ascontiguousarray(ds_array[:, :, :, volIdx])

        # build header
        volHeader = {'volIdx': volIdx,
                     'dtype': str(thisVol.dtype),
                     'shape': thisVol.shape,
                     'affine': json.dumps(ds_affine.tolist()),
                     'TR': str(1000)}

        # send header as json
        socket.send_json(volHeader, zmq.SNDMORE)

        # now send the voxel array for this volume
        socket.send(thisVol, flags=0, copy=False, track=False)

        # list for response
        socketResponse = socket.recv_string()

    # test scanReceiver get functions
    np.testing.assert_equal(scanReceiver.get_affine(), ds_affine)
    np.testing.assert_equal(scanReceiver.get_slice(1,10), ds_array[:, :, 10, 1])
    np.testing.assert_equal(scanReceiver.get_vol(2), ds_array[:, :, :, 2])

    # test saving (then delete)
    scanReceiver.saveResults()
    os.remove(join(paths['testDataDir'], 'receivedFunc.nii.gz'))

    # assuming nothing crashed, shutdown scanReceiver server
    scanReceiver.killServer()
Пример #28
0
import socket
import zmq
import sys
import time
import os

context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://localhost:1337")
while True:
    filename = socket.recv()
    if os.path.isfile(filename):
        socket.send_json({'result' : 'success', 'content' : open(filename).read()})
    else:
        socket.send_json({'result' : 'fail', 'error' : 'not found')
    print("done")
Пример #29
0
 def ack(addr, socket_type=zmq.PAIR, **additional_info):
     socket = ctx.socket(socket_type)
     socket.connect(addr)
     socket.send_json(msg(act='ack', **additional_info))
     socket.close()
Пример #30
0
    def _ipcFun(self, socket):

        message = socket.recv_json()
        if message['action'] == 'status':
            socket.send_json({
                'data': {
                    "server response! PID:" + str(os.getpid()): systemDict
                }
            })

        elif message['action'] == 'stop':
            self.flag = False
            systemDict['main']['target'] = 'off'
            self._checkProcessEnd()
            stdLogger.info('check Process completion.')
            socket.send_json({'data': 'Process stop completion.'})
            systemDict['main']['state'] = 'off'

        elif message['action'] == 'forcestop':
            self.flag = False
            socket.send_json({'data': 'Process forcestop completion.'})
            #time.sleep(5)
            systemDict['main']['state'] = 'off'
        elif message['action'] == 'start':
            socket.send_json(
                {'data': "Start to finish,pid:" + str(os.getpid())})
        elif message['action'] == 'addlog':
            stdLogger.info(message['data'])
            socket.send_json({'data': 'addlog completion.'})
        else:
            socket.send_json({'data': 'unknow parameter'})
Пример #31
0
	userlist = list(set(userlist))
	loggedinusers = len(userlist)
	WHO.close()

        # NEW: now sending a dictionary of the statistics
        senddict = {'version':labstatsversion, 'timestamp':timestmp, 
                    'hostname':localhost, 'os':os, 'model':model, 
                    'totalmem':totalmem, 'totalcommit':totalcommit, 
                    'totalcpus':totalcpus, 'usedmem':usedmem, 
                    'committedmem':committedmem, 
                    'pagefaultspersec':pagefaultspersec, 
                    'cpupercent':cpupercent, 'cpuload':cpuload, 
                    'loggedinusers':loggedinusers, 
                    'loggedinuserbool':loggedinuserbool}
        socket.send_json(senddict)
        response = socket.recv()
        print "Recieved reply: %s" % response

	if debug:
		print "Labstats Version: ", labstatsversion
		print "Time: ", timestmp
		print "Hostname: ", localhost
		print "OS: ", os
		print "Model: ", model
		print "Total Memory: ", totalmem
		print "Total Committed Memory: ", totalcommit
		print "Total CPUs: ", totalcpus
		print "Used Memory: ", usedmem
		print "Committed memory: ", committedmem
		print "Page Faults per second: ", pagefaultspersec