コード例 #1
0
ファイル: mycodo_client.py プロジェクト: ciscomonkey/Mycodo
def daemon_active():
    """ Used to determine if the daemon is reachable to communicate """
    try:
        rpyc.connect("localhost", 18813)
        return True
    except socket.error:
        return False
コード例 #2
0
ファイル: genschedule.py プロジェクト: pombreda/MoaT
	def handle(self, *args, **options):
		if options['trigger']:
			for s in Site.objects.all():
				if not s.var: continue
				try:
					c = rpyc.connect(s.host, int(s.port), ipv6=True)
					c.root.command("trigger","sync",*s.var.split())
					c.close()
				except EnvironmentError as e:
					if e.errno == errno.ECONNREFUSED:
						print >>sys.stderr,"Connecting to '%s' failed" % (s.host,)
						continue
					print_exc()
				except Exception:
					print_exc()
				else:
					print >>sys.stderr,"Connecting to '%s' succeeded" % (s.host,)
			sleep(10)
		q = Q()
		if options['site']:
			q &= Q(controller__site__name=options['site'])
		if options['group']:
			q &= Q(groups__name=options['group'])
		if options['controller']:
			q &= Q(controller__name=options['controller'])
		if options['feed']:
			q &= Q(feed__name=options['feed'])

		global soon
		if options['delay'] is not None:
			delay=float(options['delay'])
		elif options['trigger']:
			delay=1
		else:
			delay=10
		soon=n+timedelta(0,delay*60)

		sites = set()
		if len(args):
			for a in args:
				v = Valve.objects.get(q & Q(name=a))
				if options['trigger']:
					sites.add(v.controller.site)
				self.force_one_valve(v, options)
				self.one_valve(v, options)
		else:
			for v in Valve.objects.filter(q).order_by("level"):
				if options['trigger']:
					sites.add(v.controller.site)
				self.force_one_valve(v,options)
			for v in Valve.objects.filter(q).order_by("level"):
				self.one_valve(v,options)

		if options['trigger']:
			for s in sites:
				c = rpyc.connect(s.host, int(s.port), ipv6=True)
				c.root.command("trigger","read","schedule",*s.var.split())
				c.close()
コード例 #3
0
ファイル: sort.py プロジェクト: Raphael-De-Wang/Semestre02
 def connect_slave(self,slaveID):
     try:
         conn = rpyc.connect(self.slaveAliveList[slaveID],self.port)
     except:
         print "process [%d] first time fail"%slaveID
         time.sleep(5)
         try:
             conn = rpyc.connect(self.slaveAliveList[slaveID],self.port)
         except:
             print "process [%d] second time fail"%slaveID
             raise
     print "slave service on ", conn.root.slaveHostname(), ' is connected. '
     return conn
コード例 #4
0
ファイル: lxc.py プロジェクト: kopchik/perftest
def main():
  parser = argparse.ArgumentParser(description='Run experiments')
  parser.add_argument('--debug', default=False, const=True, action='store_const', help='enable debug mode')
  args = parser.parse_args()
  print(args)
  if args.debug:
    global WARMUP_TIME, MEASURE_TIME, IDLENESS
    log.critical("debug mode enabled")
    WARMUP_TIME = 0
    MEASURE_TIME = 0.5
    IDLENESS = 70

  lxcs = []
  for x in range(4):
    ip = str(IPv4Address("172.16.5.10")+x)
    print(ip)
    name = "perf%s" % x
    lxc = LXC(name=name, root=LXC_PREFIX+name, tpl=LXC_PREFIX+"/perftemplate/",
              addr=ip, gw="172.16.5.1", cpus=[x])
    lxcs += [lxc]
    lxc.destroy()
    #lxc.create()
    # lxc.start()
  #sys.exit()


  # single
  lxc = lxcs[0]
  lxc.create()
  lxc.start()
  log.debug("giving VMS time to start")
  events = get_useful_events()
  time.sleep(6)
  rpc = rpyc.connect(lxc.addr, port=6666)
  RPopen = rpc.root.Popen
  def stat(output):
    cgstat(path="lxc/"+lxc.name, cpus=lxc.cpus, events=events, t=MEASURE_TIME, out=output)  # TODO: hardcoded
  single(RPopen, outdir="/home/sources/perftest/results/u2/single", stat=stat)

  # double
  bglxc = lxcs[1]
  bglxc.create()
  bglxc.start()
  time.sleep(6)
  bgrpc = rpyc.connect(bglxc.addr, port=6666)
  BGPopen = bgrpc.root.Popen
  def stat(output):
    cgstat(path="lxc/"+lxc.name, cpus=lxc.cpus, events=events, t=MEASURE_TIME, out=output)
  double(RPopen, BGPopen, outdir="/home/sources/perftest/results/u2/double", stat=stat)
コード例 #5
0
ファイル: agent.py プロジェクト: devdeepray/loadagent
def dc_thread(id, ip, pt):
    global g_dc_loads
    g_dc_loads[id] = 0
    while True:
        try:
            s = rpyc.connect(ip, int(pt))
            print('Connected to ' + ip + ' on port ' + pt)
        except Exception:
            print('Could not connect to ' + ip + ' on port ' + pt)
            time.sleep(1)
            continue
        while True:
            dat = DCLoadRecords(ip)
            g_dc_loads[ip] = dat
            try:
                dat.networkload = s.root.get_load()
                dat.costs = s.root.get_cost_data()
                print(dat.costs)
                dat.bandwidthcap = s.root.get_bandwidthcap()
                dat.serveron = True
            except Exception:
                print('Connection to ' + ip + ', ' + pt + ' timed out.')
                g_dc_loads[id] = dat
                break
            g_dc_loads[ip] = dat
            time.sleep(INTERVAL)
        s.close()
コード例 #6
0
ファイル: SystemModel.py プロジェクト: henryeherman/elixys
  def ModelUpdated(self):
    """Called when the system model has been updated"""
    # Are we a fake PLC?
    #log.debug("ModelUpdate... are we fake?")
    if not self.hardwareComm.IsFakePLC():
      # No, so update the system
      #log.debug("We are not Fake... so update!")
      self.__UpdateState()

      # Attempt to connect to the state monitor
      if self.__pStateMonitor == None:
        try:
          self.__pStateMonitor = rpyc.connect("localhost", 18861)
          log.debug("Connection to state monitor established")
          self.__bStateMonitorError = False
        except socket.error, ex:
          if not self.__bStateMonitorError:
            log.error("Failed to connect to state monitor")
          self.__pStateMonitor = None
          self.__bStateMonitorError = True

      # Update the state monitor
      if self.__pStateMonitor != None:
        try:
          self.__pStateMonitor.root.UpdateState(self.GetStateString())
        except EOFError, ex:
          # Catch EOFErrors in the event that the state monitor process dies
          log.error("Failed to update state monitor")
          log.error("Traceback:\r\n%s\r\n" % traceback.format_exc())
          self.__pStateMonitor = None
          self.__bStateMonitorError = True
コード例 #7
0
ファイル: HComHoudiniClient.py プロジェクト: GJpy/HCom
def connectToServer(ID=None, clientType="NONE"):
    '''
        Try to connect to the server and launch the BG thread service
    '''
    
    if not ID:
        ID = getpass.getuser()
    
    global server_conn
    global bgsrv
    
    try:
        server_conn = rpyc.connect(HComHoudiniUtils.readIni()["SERVER"], int(HComHoudiniUtils.readIni()["PORT"]), service=HCom_ClientService, config={"allow_pickle":True})
    except Exception as e:
        print("ERROR: Can not connect to server: " + str(e))
        return False, False
    else:
        if ID in server_conn.root.getAllClients().keys():
            hou.ui.displayMessage("User ID already registered on the server")
            server_conn.close()
            return False
        
        hou.session.HCOMCLIENT = [server_conn, ID]
        
    global server_id
    server_id = ID
    
    bgsrv = rpyc.BgServingThread(server_conn)
    result = server_conn.root.registerClient(ID, clientType)
    
    if result:
        return ID
    else:
        return False
コード例 #8
0
ファイル: raft_node.py プロジェクト: Suraj-Rajesh/Raft
    def request_votes():
        total_votes = 0
        last_index, last_term = RaftService.get_last_log_index_and_term()

        # TODO Run this concurrently
        # Suggestion: Create a separate RPC call to handle response. This RPC only requests for vote.
        # For now we assume that the network wont fail
        for peer in RaftService.peers:
            try:
                vote = False
                connection = rpyc.connect(peer[1], peer[2], config={"allow_public_attrs": True})
                vote = connection.root.requestRPC(term=RaftService.term,
                                                  candidate_id=RaftService.server_id,
                                                  last_log_index=last_index,
                                                  last_log_term=last_term)

                RaftService.logger.info("Vote received: " + str(vote))
                if vote:
                    RaftService.logger.info("Received vote from server %d for leader election, term %d"
                                            % (peer[0], RaftService.term))
                    total_votes = total_votes + 1

            except Exception as details:
             #//   RaftService.logger.warning("request_votes: Unable to connect to server %d" % peer[0])  # +1 to account for self-vote
                pass

        return total_votes + 1
コード例 #9
0
ファイル: manage_game.py プロジェクト: slient2010/ManageGame
def return_result(return_status, current_time, *args, **kwargs):
    return_info = kwargs['node_name']
    project = return_info.split('-')[0]
    platname = return_info.split('-')[1]
    servername = return_info.split('-')[5].split('_')[1]    
    # updates 
    if args and current_time == None:
        arg = args
        #package_version = "%s" %  str(arg[0].split('&')[0])
        package_version = "%s" %  arg[0]
        #server_status = "%s" % str(arg[0].split('&')[1])
        server_status = "%s" % arg[1]
        put_string =  "%s-%s-%s-%s-%s" % (project, servername, platname, return_status, package_version)
    else:
        # get user online 
        if current_time:
            users = "%s" %  args[0]
            #put_string =  "%s-%s-%s-%s@%s" % (project, servername, platname, args,return_status, current_time)
            put_string =  "%s-%s-%s-%s@%s" % (project, servername, platname, users, current_time)

        # other actions
        else:
            put_string =  "%s-%s-%s-%s" % (project, servername, platname, return_status)

    put_string = m_encode(put_string, SECRET_KEY)
    try:
        # paramters host, port
        conn =rpyc.connect(SERVER, PORT)
        rLogin =conn.root.login("%s" % USER, "%s" % PASSWD) 
    except Exception, e:
        rLogin = False
        return 'Connect to rpyc server error:' + str(e)
        sys.exit()
コード例 #10
0
ファイル: views.py プロジェクト: coolcoding/OMdemo
def module_run(request):
    import rpyc
    from cPickle import loads
    put_string = ''
    if not 'ModuleID' in request.GET:
        Module_Id = ""
    else:
        Module_Id = request.GET['ModuleID']
        put_string+=Module_Id+"@@"

    if not 'hosts' in request.GET:
        Hosts = ""
    else:
        Hosts = request.GET['hosts']
        put_string+=Hosts+"@@"

    if not 'sys_param_1' in request.GET:
        Sys_param_1 = ""
    else:
        Sys_param_1 = request.GET['sys_param_1']
        put_string+=Sys_param_1+"@@"

    if not 'sys_param_2' in request.GET:
        Sys_param_2 = ""
    else:
        Sys_param_2 = request.GET['sys_param_2']
        put_string+=Sys_param_2+"@@"
    try:
        conn = rpyc.connect(host='127.0.0.1', port=11511)
        conn.root.login('OMuser','123456')
    except Exception,e:
        logger.error('connect rpyc server error:'+str(e))
        return HttpResponse('connect rpyc server error:'+str(e))
コード例 #11
0
def set_colour(colour):
    ''' All-in-one function to request a colour change '''
    connection = rpyc.connect(HOST, PORT)
    rgb_controller = connection.root
    return_value = rgb_controller.set_colour(colour)
    connection.close()
    return return_value
コード例 #12
0
ファイル: master.py プロジェクト: kopchik/perftest
    def start(self):
        cgroups = []
        rpcs = []
        self.stop()  # just to be sure

        # START KVMS
        info("starting kvms")
        for n in self.cpus:
            cgkvm = CGKVM(n)
            time.sleep(0.5)  # interval between launching

        # WAIT TILL THEY START UP
        idleness = self.idfactor * (len(self.cpus) + 2)
        self.log.info("waiting for instances, expected idleness is <%s" % idleness)
        time.sleep(15)
        wait_idleness(idleness)

        # CREATE RPC CONNECTIONS
        info("making connections")
        for cpu in self.cpus:
            host = "172.16.5.%s" % (cpu + 1)
            print("connecting to", host)
            rpcs += [rpyc.connect(host, port=6666)]

        for i, cg in enumerate(cgroups):
            instance = Instance(cg=cg, rpc=rpcs[i], Popen=rpcs[i].root.Popen)
コード例 #13
0
 def __init__(self):
     self.transmitting = False
     self.processed = True
     self.terminated = False
     self.c = rpyc.connect(ADDR, PORT)
     self.c.root.configureVideoStream(TCP_IP, TCP_PORT)
     self.image = None
コード例 #14
0
ファイル: __init__.py プロジェクト: bzyx/precious
 def __new__(cls):
     if not cls._instance or not not cls._instance.root:
         try:
             cls._instance = rpyc.connect(get_worker_host(), get_worker_port())
         except:
             cls._instance = None
     return cls._instance
コード例 #15
0
ファイル: supervisor.py プロジェクト: kyroskoh/borkedbot
def connect(bot):
    global sv_con
    # print 'connecting to bot'

    BorkedbotClientService.bot = bot
    sv_con = rpyc.connect('localhost', 29389, service=BorkedbotClientService, config={'allow_all_attrs': True, 'exposed_prefix': ''})
    sv_con.root.init_bot(bot)
コード例 #16
0
def commandLineProcess(scanConf):
	import scanner.logSetup
	import rpyc

	scanner.logSetup.initLogging()

	if not os.path.exists(scanConf.sourcePath):
		print("ERROR: Source file does not exist!")
		return
	if not os.path.isfile(scanConf.sourcePath):
		print("ERROR: Source is not a file!")
		return

	if scanConf.noContext:
		scanContext = None
	else:
		scanContext = [os.path.split(scanConf.sourcePath)]

	remote = rpyc.connect("localhost", 12345)

	status, bestMatch, intersections = remote.root.processDownload(
		scanConf.sourcePath,
		pathFilter=scanContext,
		distance=6,
		moveToPath=None,
		locked=True)
	print("Processed archive. Return status '%s'", status)
	if bestMatch:
		print("Matching archive '%s'", bestMatch)
	return status, bestMatch, intersections
コード例 #17
0
ファイル: views.py プロジェクト: smart00912/moserver
def module_run(req):
    import rpyc

    put_string = ""
    if not "ModuleID" in req.GET.get():
        Module_Id = ""
    else:
        Module_Id = req.GET.get("ModuleID")
        put_string += Module_Id + "@@"
    if not "hosts" in req.GET.get():
        Hosts = ""
    else:
        Hosts = req.GET.get("hosts")
        put_string = Hosts + "@@"
    """
	module extend params recive
	"""
    if not "sys_param_1" in req.GET.get():
        Sys_param_1 = ""
    else:
        Sys_param_1 = req.GET.get("sys_param_1")
        put_string = Sys_param_1 + "@@"
    if not "sys_param_2" in req.GET.get():
        Sys_param_2 = ""
    else:
        Sys_param_2 = req.GET.get("sys_param_1")
        put_string = Sys_param_2 + "@@"
    try:
        conn = rpyc.connect("127.0.0.1", 11511)
        conn.root.login("sean", "htbenet100")
    except Exception, e:
        logger.error("connect to rpyc server failed" + str(e))
        return HttpResponse("connect to rpyc server failed" + str(e))
コード例 #18
0
ファイル: ssdp_listen.py プロジェクト: elupus/ssdpgateway
def client():
    import rpyc
    c = rpyc.connect("localhost", 18861)
    sender = c.root.SsdpSender()
    listen = SsdpListen(sender)
    listen.open()
    listen.run()
コード例 #19
0
def run_training(head_host, head_port, debug_out=None):
    """Main worker training routine (creates the Seq2SeqTrainingService and connects it to the
    head.

    @param head_host: hostname of the head
    @param head_port: head port number
    @param debug_out: path to the debugging output file (debug output discarded if None)
    """
    # setup debugging output, if applicable
    if debug_out is not None:
        set_debug_stream(file_stream(debug_out, mode='w'))
    # start the server (in the background)
    log_info('Creating training server...')
    server = ThreadPoolServer(service=Seq2SeqTrainingService, nbThreads=1)
    server_thread = Thread(target=server.start)
    server_thread.start()
    my_host = socket.getfqdn()
    log_info('Worker server created at %s:%d. Connecting to head at %s:%d...' %
             (my_host, server.port, head_host, head_port))
    # notify main about this server
    conn = connect(head_host, head_port, config={'allow_pickle': True})
    conn.root.register_worker(my_host, server.port)
    conn.close()
    log_info('Worker is registered with the head.')
    # now serve until we're killed (the server thread will continue to run)
    server_thread.join()
コード例 #20
0
ファイル: RemoteThrill.py プロジェクト: Cyaagain/thrill
 def __init__(self, rpyc_hosts, thrill_hosts):
     # connect to rpyc servers
     self._conn = [rpyc.connect(*hp) for hp in rpyc_hosts]
     # set up background serving threads
     self._bgthr = [rpyc.BgServingThread(conn) for conn in self._conn]
     # make async objects to create Thrill contexts
     anetrefs = [rpyc.async(conn.root.Create) for conn in self._conn]
コード例 #21
0
ファイル: views.py プロジェクト: xrjk/itm
def module_run(request):
    import rpyc
    from cPickle import loads
    put_string=""
    
    if not 'ModuleID' in request.GET:
        Module_Id=""
    else:
        Module_Id=request.GET['ModuleID']
        put_string+=Module_Id+"@@"

    if not 'hosts' in request.GET:
        Hosts=""
    else:
        Hosts=request.GET['hosts']
        put_string+=Hosts+"@@"

    if not 'sys_param_1' in request.GET:
        Sys_param_1=""
    else:
        Sys_param_1=request.GET['sys_param_1']
        put_string+=Sys_param_1+"@@"

    if not 'sys_param_2' in request.GET:
        Sys_param_2=""
    else:
        Sys_param_2=request.GET['sys_param_2']
        put_string+=Sys_param_2+"@@"

    try:
        conn=rpyc.connect('172.16.28.246',11511)
        conn.root.login('OMuser','KJS23o4ij09gHF734iuhsdfhkGYSihoiwhj38u4h')
    except Exception,e:
        logger.error('connect rpyc server error:'+str(e))
        return HttpResponse('connect rpyc server error:'+str(e))
コード例 #22
0
    def __init__(self):
        """
            Initialises the whole environment and establishes connection
        """
        self.mgmt_node = ''
        self.clients = self.nodes = self.peers = self.gm_nodes = []
        self.gm_peers = self.gs_nodes = self.gs_peers = []
        self.number_nodes = self.number_peers = self.number_gm_nodes = 0
        self.number_gm_peers = self.number_gs_nodes = self.number_gs_peers = 0
        self.number_clients = self.number_servers = self.number_masters = 0
        self.number_slaves =0

        if 'MGMT_NODE' in os.environ:
            self.mgmt_node = os.environ['MGMT_NODE']
        if 'NODES' in os.environ:
            self.nodes = os.environ['NODES'].split(' ')
        if 'PEERS' in os.environ:
            self.peers = os.environ['PEERS'].split(' ')
        if 'CLIENTS' in os.environ:
            self.clients = os.environ['CLIENTS'].split(' ')
        if 'GM_NODES' in os.environ:
            self.gm_nodes = os.environ['GM_NODES'].split(' ')
        if 'GM_PEERS' in os.environ:
            self.gm_peers = os.environ['GM_PEERS'].split(' ')
        if 'GS_NODES' in os.environ:
            self.gs_nodes = os.environ['GS_NODES'].split(' ')
        if 'GS_PEERS' in os.environ:
            self.gs_peers = os.environ['GS_PEERS'].split(' ')

        self.number_nodes = len(self.nodes)
        self.number_peers = len(self.peers)
        self.number_clients = len(self.clients)
        self.number_gm_nodes = len(self.gm_nodes)
        self.number_gm_peers = len(self.gm_peers)
        self.number_gs_nodes = len(self.gs_nodes)
        self.number_gs_peers = len(self.gs_peers)


        self.servers = self.nodes + self.peers + self.gm_nodes + self.gm_peers \
                       + self.gs_nodes + self.gs_peers
        self.all_nodes = self.nodes + self.peers + self.clients + self.gm_nodes\
                         + self.gm_peers + self.gs_nodes + self.gs_peers
        self.connection_handles = {}
        for node in self.all_nodes:
            c0 = rpyc.connect(node, 18861)
            async_object = rpyc.async(c0.root.run)
            self.connection_handles[node] = ( c0, async_object)

        client_logfile = "/var/log/tests/client_rpyc.log"
        client_logdir = os.path.dirname(client_logfile)

        #Check if the log directory exits, if not create it
        if not os.path.exists(client_logdir):
            os.makedirs(client_logdir)
        self.logger = logging.getLogger('rpyc_client')
        self.lhndlr = logging.FileHandler(client_logfile)
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(funcName)s %(message)s')
        self.lhndlr.setFormatter(formatter)
        self.logger.addHandler(self.lhndlr)
        self.logger.setLevel(logging.DEBUG)
コード例 #23
0
ファイル: views.py プロジェクト: cl4es/homespot
def refresh(request):
    """ Clears the playlist database and rebuilds it from the homespot server. """
    Playlist.objects.all().delete()
    
    c = rpyc.connect("localhost", 10223, config = {"allow_public_attrs": True})
    hs = c.root.homespot()
    pc = hs.session.playlist_container()
    playlists = len(pc)
    homespot = []
    for pl in xrange(playlists):
        
        songs = len(pc[pl])
        
        playlist = Playlist.objects.create(name=pc[pl].name())
        playlist.save()
        
        sngs = []
        for song in xrange(songs-1):
            try:
                s = pc[pl][song]
                
                if s.is_loaded() and s.is_available():
                    artists = u", ".join([unicode(artist.name(), "utf-8") for artist in s.artists(None)])
                    name = unicode(s.name(), "utf-8")
                    album = unicode(s.album().name(), "utf-8")
                    Track.objects.create(name=name,artists=artists,album=album,playlist=playlist)
            except:
                import traceback
                traceback.print_exc()
                print "hmm: %s %s " % (playlist, song)

    return HttpResponse("OK")
コード例 #24
0
ファイル: eierclock.py プロジェクト: faroit/midihack
def connect_to_live(scr, args):
    conn = None
    while conn == None:
        scr.clear()
        center_addstr(scr, 0, 'Connecting to Ableton Live...',
                      curses.color_pair(colors.connecting))
        scr.refresh()

        try:
            conn = rpyc.connect(args.host, args.port)
        except IOError:
            center_addstr(scr, 0, 'Connection to Ableton Live failed',
                          curses.color_pair(colors.error))
            center_addstr(scr, 1, 'Press any key to retry')
            scr.refresh()
            curses.flushinp()
            scr.getch()

    scr.clear()
    live = conn.root.Live.Application.get_application()
    center_addstr(scr, 0, 'Connected to to Ableton Live %s.%s.%s' %
                  (live.get_major_version(),
                   live.get_minor_version(),
                   live.get_bugfix_version()),
                  curses.color_pair(colors.success))
    return conn
コード例 #25
0
ファイル: live.py プロジェクト: faroit/midihack
 def __init__(self, host='127.0.0.1', port=17744):
     try:
         self.conn = rpyc.connect(host, port)
         self.live = self.conn.root.Live.Application.get_application()
         self.song = self.live.get_document()
     except IOError:
         print "Could not connect to Ableton, is it running?"
コード例 #26
0
def naxos():
	#Keypair generation
	#BOB#
	domain, bob_pub_key, bob_priv_key = ec.get_keypair()

	#connecting to a server
	conn = rpyc.connect("localhost", 18861, config = {"allow_all_attrs" : True})
	c = conn.root

	alice_pub_key = c.exchange_pubkey(bob_pub_key)
	print 'Alice pub key', alice_pub_key

	bob_esk = random.getrandbits(32) #32 bitowy ciag losowy
	G = domain.P #nasz publiczny punkt na krzywej

	#exch_bob H1(esk_B, sk_B)
	exch_bob = hashfun.sha(hashfun.concat(bob_esk, bob_priv_key.a))
	exch_alice = c.exchange(G * exch_bob)

	S0 = alice_pub_key.Q * exch_bob #punkt
	S1 = (exch_alice) * bob_priv_key.a #punkt
	S2 = (exch_alice) * exch_bob

	session_key = hashfun.sha(hashfun.concat(S0.x.n, S1.x.n, S2.x.n))
        
	print 'Session key:', session_key
	
	#AES PART
	print "Encoding AES message [Sample message]..."
	ac = AESCipher(session_key)
	enc = ac.encrypt('Sample message')

	print "Sending encrypted message [%s]..." % enc
	c.decrypt(enc)
コード例 #27
0
 def set_heat_state(on):
     try:
         device_conn = rpyc.connect(Config.service_config["device_service_address"],
                                    Config.service_config["device_service_port"])
         try:
             device_conn.root.set_heater_state(on)
             device_conn.close()
             ReactiveControl.current_heat_state = on
             if on:
                 ReactiveControl.current_air_speed = Config.control_config["max_fan_speed"]
             else:
                 ReactiveControl.current_air_speed = 0
             Config.logger.info("[Set Heater State][%s]" % str(on))
             return True
         except Exception, e:
             Config.logger.warning("Error sending heater state to %s:%s" %
                                   (Config.service_config["device_service_address"],
                                    Config.service_config["device_service_port"]))
             Config.logger.error(e)
             device_conn.close()
             return False
     except Exception, e:
         Config.logger.warning("Error connecting to %s:%s" %
                               (Config.service_config["device_service_address"],
                                Config.service_config["device_service_port"]))
         Config.logger.error(e)
         return False
コード例 #28
0
 def set_cool_state(on, speed):
     relative_speed = float(speed) / Config.control_config["max_fan_speed"]
     try:
         device_conn = rpyc.connect(Config.service_config["device_service_address"],
                                    Config.service_config["device_service_port"])
         try:
             device_conn.root.set_fan_state(on, relative_speed)
             device_conn.close()
             ReactiveControl.current_cool_state = on
             ReactiveControl.current_air_speed = float(speed)
             Config.logger.info("[Set Fan State][%s]" % str(on))
             Config.logger.info("[Set Fan Speed][Absolute][%s][Relative][%s]" %
                                (str(float(speed)), str(relative_speed)))
             return True
         except Exception, e:
             Config.logger.warning("Error sending fan state to %s:%s" %
                                   (Config.service_config["device_service_address"],
                                    Config.service_config["device_service_port"]))
             Config.logger.error(e)
             device_conn.close()
             return False
     except Exception, e:
         Config.logger.warning("Error connecting to %s:%s" %
                               (Config.service_config["device_service_address"],
                                Config.service_config["device_service_port"]))
         Config.logger.error(e)
         return False
コード例 #29
0
def diffie_hellman():
	#BOB#
	domain, bob_pub_key, bob_priv_key = ec.get_keypair()

	conn = rpyc.connect("localhost", 18861, config = {"allow_public_attrs" : True})
	c = conn.root

	#Agree upon a public key
	c.send_pub_key(bob_pub_key)
	alice_pub_key = c.get_pub_key()
	print "Alice:\n", alice_pub_key

	secret_bob = bob_priv_key.a * alice_pub_key.Q

	print "Sharing secret..."
	secret_alice = c.share_secret(secret_bob)

	print "Secrets:\nAlice: %s\nBob %s\n" % (secret_alice, secret_bob)

	print "Encoding AES message [Sample message]..."
	ac = AESCipher(secret_bob.x)
	enc = ac.encrypt('Sample message')

	print "Sending encrypted message [%s]..." % enc
	c.decrypt(enc)
コード例 #30
0
ファイル: raft_node.py プロジェクト: Suraj-Rajesh/Raft
    def exposed_config_changeRPC(self, list_of_config_changes, client_id):
        new_config_change_success = False

        RaftService.logger.info("Received Configuration Change Request from client %s" % client_id)
        if RaftService.server_id != RaftService.leader_id:
            try:
                RaftService.logger.info("Redirecting the request to Leader %s" % RaftService.server_id)
                (ip, port) = RaftService.config_reader.get_leaders_port_ip(RaftService.leader_id, RaftService.peers)
                connection = rpyc.connect(ip, port, config={"allow_public_attrs": True})
                new_config_change_success = connection.root.exposed_config_change_leaderRPC(list_of_config_changes, client_id)

            except Exception as details:
                RaftService.logger.info(details)
        else:

            entry = (JOINT_CONFIGURATION, list_of_config_changes)
            
            ### Apply Joint Configuration
            self.run_config_change(entry)

            joint_config_change_success = self.append_entries(entry, client_id)
            if joint_config_change_success:
                # Joint consensus is running. So start new config now

                ###Apply new configuration
                self.run_config_change((NEW_CONFIGURATION,list_of_config_changes))     
                new_config_change_success = self.append_entries((NEW_CONFIGURATION,list_of_config_changes), client_id)
                if new_config_change_success:
                    RaftService.trigger_next_heartbeat()

                    RaftService.logger.info("Successfully changed the configuration of the system.")

                    if RaftService.server_id == RaftService.leader_id:
                        reducted_peers = list()
                        for peer in RaftService.peers:
                            flag = True
                            for remove_id in RaftService.peers_to_remove:
                                if peer[0] == remove_id:
                                    flag = False
                            if flag:
                                reducted_peers.append(peer)

                        RaftService.peers_old = reducted_peers
                        RaftService.peers = reducted_peers
                        RaftService.peers_to_remove = list()

                    if RaftService.server_id == RaftService.leader_id:
                        self.config_reader.update_config_file(RaftService.server_id, RaftService.total_nodes, RaftService.majority_criteria,RaftService.peers)

                    if RaftService.should_i_die and RaftService.server_id == RaftService.leader_id:
                        RaftService.logger.info("Stepping down as I am not part of new config")
                        #os._exit(0)
                        RaftService.start_deathbeat_timer()
                else:
                    RaftService.logger.info("Couldn't change the configuration of system to new config.")
            else:
                RaftService.logger.info("Couldn't change the configuration of the system to joint config.")

        return new_config_change_success
コード例 #31
0
import rpyc
import socket
from constRPYC import *
from rpyc.utils.server import ThreadedServer


class DBList(rpyc.Service):
    value = []

    def exposed_append(self, data):
        self.value = self.value + [data]
        print("Appended value = ", data)
        return self.value

    def exposed_value(self):
        return self.value

    def exposed_delete(self, data):
        if data in self.value:
            print("Deleted value = " + data)
            self.value.remove(data)
            return self.value


if __name__ == "__main__":
    server = ThreadedServer(DBList, port=20202)
    conn_dir = rpyc.connect(DIR_SERVER, DIR_PORT)
    my_address = socket.gethostbyname(socket.gethostname())
    print(conn_dir.root.exposed_unregister("DBList"))
    print(conn_dir.root.exposed_register("DBList", my_address, 20202))
    server.start()
コード例 #32
0
        sys.exit()

    # initialize a StatsManager
    sm = StatsManager(conf)

    # initialize a CacheManager
    cm = CacheManager(conf)

    # word_forms service
    # rpyc client
    import sys
    import rpyc

    searchExtensionConfig = conf.getExtensionConfig("space.colabo.search_extension")
    if conf.isExtensionActive("space.colabo.search_extension"):
        rpcConn = rpyc.connect(searchExtensionConfig['host'], searchExtensionConfig['port'])
        rpcService = rpcConn.root

    colaboFlowAuditConfig = conf.getExtensionConfig("space.colabo.flow.audit")
    if conf.isExtensionActive("space.colabo.flow.audit"):
        import uuid
        # from colabo.flow.audit import ColaboFlowAudit, audit_pb2
        from colabo.flow.audit import audit_pb2
        from colabo.flow.audit import ColaboFlowAudit

        gRpcUrl = colaboFlowAuditConfig['host']+':'+str(colaboFlowAuditConfig['port'])
        # https://docs.python.org/2/library/uuid.html
        flowInstanceId = str(uuid.uuid1())
        cfAuditRequestDefualt = audit_pb2.SubmitAuditRequest(
            bpmn_type='activity',
            bpmn_subtype='task',
コード例 #33
0
def main():
    pygame.mixer.pre_init(44100, 16, 2, 4096)
    pygame.mixer.__PYGAMEinit__
    pygame.init()
    relogio = pygame.time.Clock()
    campo2 = 620, 261

    #Movimentação
    dir = [620 / 31, 0]
    esq = [-620 / 31, 0]
    up = [0, -261 / 13]
    down = [0, 261 / 13]

    #Tela e Campo
    screen = pygame.display.set_mode(campo2)
    pygame.display.set_caption("PoliciaLadrao")
    black = 0, 0, 0
    campo2 = pygame.image.load("images\\campo2.png")
    camporect = campo2.get_rect().move([0, 0])

    #Tela de Vitoria e Derrota
    lose = Objetos.lose()
    win = Objetos.win2()

    #Posição inicial do jogador
    #trocar para a chamada ao servidor que irá fornecer
    #pos = a posicao usada para desenhar na tela
    #p = posicao na matrix do campo para verificacao da movimentacao
    x1 = 620 / 31
    y1 = 261 / 13

    #Campo em matriz para criar as paredes internas.
    campo = np.zeros((13, 31))
    campo[2::2, 2::2] = 1
    campo[2, 3] = campo[2, 19] = campo[2, 27] = 1
    campo[1, 8] = campo[3, 22] = campo[5, 14] = campo[5, 20] = campo[11,
                                                                     12] = 1
    campo[4, 3] = campo[4, 13] = campo[4, 27] = 1
    campo[6, 1] = campo[6, 7] = campo[6, 23] = campo[6, 29] = 1
    campo[10, 1] = campo[10, 9] = campo[10, 13] = campo[10, 25] = campo[10,
                                                                        29] = 1
    campo[2, 1] = campo[2,
                        9] = campo[4,
                                   23] = campo[4,
                                               29] = campo[5,
                                                           16] = campo[6,
                                                                       11] = 2
    campo[7, 4] = campo[9, 18] = campo[10, 3] = campo[10, 11] = campo[10,
                                                                      27] = 2

    #Criacao do jogador e dos grupos
    #deverá ser feita no servidor
    #e o jogador recebera o seu sprite
    #e todos os grupos
    ladrao = pygame.image.load("images\\ladrao.png")
    policia = pygame.image.load("images\\pol.png")
    moedas = pygame.sprite.Group()
    pos_xMoeda = [x1, x1 * 29, x1 * 18, x1 * 13, x1 * 10, x1 * 24, x1, x1 * 10]
    pos_yMoeda = [y1 * 11, y1, y1 * 7, y1 * 11, y1 * 3, y1 * 5, y1 * 7, y1 * 9]
    for i in range(0, 7):
        moeda = Objetos.moeda(pos_xMoeda[i], pos_yMoeda[i])
        moedas.add(moeda)

    #Contador de moedas e condicao para fim
    #o contador sera guardado no servidor
    cont = 0

    #repeticao das teclas
    #em mls (pelo menos o segundo)

    conn = rpyc.connect("localhost", 18861)
    indole = conn.root.getIndole()
    indice = conn.root.getIndice()
    pos_x = conn.root.pos_x[indice]
    pos_y = conn.root.pos_y[indice]
    px = conn.root.x[indice]
    py = conn.root.y[indice]
    if indole == 'ladrao':
        jog1 = Objetos.ladrao(pos_x, pos_y)
        pygame.key.set_repeat(150)
    else:
        jog1 = Objetos.policia(pos_x, pos_y)
        pygame.key.set_repeat(50)
    conn.root.getCredenciais(jog1.rect, indole)
    #sons do jogo
    ncont = ["nada", "one", "two", "three", "four", "five"]
    you_sound = pygame.mixer.Sound("sounds\you.wav")
    win_sound = pygame.mixer.Sound("sounds\win.wav")
    lose_sound = pygame.mixer.Sound("sounds\lose.wav")
    soundtrack = 'sounds\open_stage.mp3'
    pygame.mixer_music.load(soundtrack)

    fim = conn.root.getFim()
    start_music = True
    fim1 = False
    winc = 3
    while not fim and not fim1:
        if start_music:
            pygame.mixer_music.set_volume(0.05)
            pygame.mixer_music.play(-1)
            start_music = False
        for event in pygame.event.get():
            pygame.key.get_repeat()
            if event.type == pygame.QUIT:
                fim1 = True
                pygame.mixer_music.pause()
                if indole == 'ladrao':
                    winc = 0
                else:
                    winc = 1

            if event.type == pygame.KEYDOWN:
                if (indole == 'ladrao'):
                    if event.key == pygame.K_UP and not (
                            pos_y - 261 / 13) <= 0 and not blockl(
                                px, py - 1, campo):
                        jog1.rect = jog1.rect.move(up)
                        py = py - 1
                        pos_y = pos_y - 261 / 13
                        conn.root.putJogador(indice, jog1.rect)
                    if event.key == pygame.K_DOWN and not (
                            pos_y + 261 / 13 > 261 -
                        (2 * 261 / 13)) and not blockl(px, py + 1, campo):
                        jog1.rect = jog1.rect.move(down)
                        py = py + 1
                        pos_y = pos_y + 261 / 13
                        conn.root.putJogador(indice, jog1.rect)
                    if event.key == pygame.K_RIGHT and not (
                            pos_x >= 620 -
                        (2 * 620 / 31)) and not blockl(px + 1, py, campo):
                        jog1.rect = jog1.rect.move(dir)
                        px = px + 1
                        pos_x = pos_x + 620 / 31
                        conn.root.putJogador(indice, jog1.rect)
                    if event.key == pygame.K_LEFT and not (
                            pos_x - 620 / 31 < 620 / 31) and not blockl(
                                px - 1, py, campo):
                        jog1.rect = jog1.rect.move(esq)
                        px = px - 1
                        pos_x = pos_x - 620 / 31
                        conn.root.putJogador(indice, jog1.rect)
                else:
                    if event.key == pygame.K_UP and not (
                            pos_y - 261 / 13) <= 0 and not block(
                                px, py - 1, campo):
                        jog1.rect = jog1.rect.move(up)
                        py = py - 1
                        pos_y = pos_y - 261 / 13
                        conn.root.putJogador(indice, jog1.rect)
                    if event.key == pygame.K_DOWN and not (
                            pos_y + 261 / 13 > 261 -
                        (2 * 261 / 13)) and not block(px, py + 1, campo):
                        jog1.rect = jog1.rect.move(down)
                        py = py + 1
                        pos_y = pos_y + 261 / 13
                        conn.root.putJogador(indice, jog1.rect)
                    if event.key == pygame.K_RIGHT and not (
                            pos_x >= 620 -
                        (2 * 620 / 31)) and not block(px + 1, py, campo):
                        jog1.rect = jog1.rect.move(dir)
                        px = px + 1
                        pos_x = pos_x + 620 / 31
                        conn.root.putJogador(indice, jog1.rect)
                    if event.key == pygame.K_LEFT and not (
                            pos_x - 620 / 31 < 620 / 31) and not block(
                                px - 1, py, campo):
                        jog1.rect = jog1.rect.move(esq)
                        px = px - 1
                        pos_x = pos_x - 620 / 31
                        conn.root.putJogador(indice, jog1.rect)

        #Verifica se o jogador passou por uma moeda
        #O servidor tem q fazer isso verificando
        #se algum ladrao passou por moeda
        aux = conn.root.Killmoeda
        for moeda in moedas:
            if (moeda.rect == aux):
                moeda.kill()
                cont += 1
                son = pygame.mixer.Sound("sounds\\" + ncont[cont] + ".wav")
                son.set_volume(0.7)
                son.play()

        for moeda in moedas:
            if pygame.sprite.collide_rect(jog1, moeda) and indole == 'ladrao':
                moeda.kill()
                cont += 1
                son = pygame.mixer.Sound("sounds\\" + ncont[cont] + ".wav")
                son.set_volume(0.7)
                son.play()
                conn.root.setKillmoeda(moeda.rect)
                conn.root.cont()

        #Verifica se algum larao colidiu com
        #algum policial
        joga = conn.root.getJogadores()
        minha = joga[indice]
        if (indole == 'ladrao'):
            for jog in joga:
                if jog['posicao'] == minha['posicao'] and jog[
                        'indole'] == 'policia':
                    conn.root.delJogador(indice)
                    fim1 = True

        #Desenho da tela
        screen.fill(black)
        screen.blit(campo2, camporect)
        for moeda in moedas:
            screen.blit(moeda.image, moeda.rect)
        screen.blit(jog1.image, jog1.rect)
        jogadores = conn.root.getJogadores()
        for jogador in jogadores:
            if (jogador['vivo']):
                if (jogador['indole'] == 'ladrao'):
                    screen.blit(ladrao, jogador['posicao'])
                else:
                    screen.blit(policia, jogador['posicao'])
        pygame.display.flip()
        relogio.tick(30)
        fim = conn.root.getFim()
        if fim:
            pygame.mixer_music.pause()

        winb = conn.root.win

    confirm = False
    c_sound = 0
    while (not confirm):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                confirm = True
            #if event.type == pygame.KEYDOWN:
            #    confirm = True

        screen.fill(black)
        screen.blit(campo2, camporect)
        for jogador in jogadores:
            if (jogador['vivo']):
                if (jogador['indole'] == 'ladrao'):
                    screen.blit(jog1.image, jogador['posicao'])
                else:
                    screen.blit(policia, jogador['posicao'])
        if indole == 'ladrao':
            if (winb == 0) or (winc == 0):
                screen.blit(lose.image, lose.rect)
                pygame.display.flip()
                if c_sound == 0:
                    c_sound += 1
                    time.sleep(1)
                    you_sound.play(0)
                    time.sleep(0.7)
                    lose_sound.play(0)
            else:
                screen.blit(win.image, win.rect)
                pygame.display.flip()
                if c_sound == 0:
                    c_sound += 1
                    time.sleep(1)
                    you_sound.play(0)
                    time.sleep(0.7)
                    win_sound.play(0)
        else:
            if winb == 1 or winc == 1:
                screen.blit(lose.image, lose.rect)
                pygame.display.flip()
            if c_sound == 0:
                c_sound += 1
                time.sleep(1)
                you_sound.play(0)
                time.sleep(0.7)
                lose_sound.play(0)
            else:
                screen.blit(win.image, win.rect)
                pygame.display.flip()
                if c_sound == 0:
                    c_sound += 1
                    time.sleep(1)
                    you_sound.play(0)
                    time.sleep(0.7)
                    win_sound.play(0)
        pygame.display.flip()

    #pygame.quit()
    print(cont)
コード例 #34
0
import time
import rpyc

#==============================================================================
#                                  GLOBAL VARS
#==============================================================================
conn = rpyc.connect("localhost", 50051)

GET_STR_PROMPT = ('Please insert string to operate:\n')

# All options; keys are numbers, sub dictionary contains titles and functions (via lambda)
OPTIONS = {
    '1': {
        'title': 'Upper',
        'function': (lambda string: conn.root.Upper(string))
    },
    '2': {
        'title': 'Lower',
        'function': (lambda string: conn.root.Lower(string))
    },
    '3': {
        'title': 'Capitalize',
        'function': (lambda string: conn.root.Proper(string))
    }
}


#==============================================================================
#                                     MAIN
#==============================================================================
def run():
コード例 #35
0
ファイル: client.py プロジェクト: kunniprudhvi/Projects
import rpyc
import sys

if len(sys.argv) == 2:
    temp = sys.argv[1]

else:
    temp = "localhost"

c = rpyc.connect(temp, port=18863)


def downl(bindata, fname):
    fc = open(fname, "wb")
    fc.write(bindata)
    fc.close
    print "Download Complete!"


def printlist(filename):
    print filename


bgsrv = rpyc.BgServingThread(c)

name = raw_input("Enter Your Name:")

while True:
    cmd = raw_input("Enter your command:")

    if cmd == 'list':
コード例 #36
0
 def __init__(self):
     try:
         self.rpyc_client = rpyc.connect("localhost", 18813)
     except socket.error:
         raise Exception("Connection refused. Is the daemon running?")
コード例 #37
0
import rpyc
from server_list import *

my_name = 'CalcServer'
my_ip = '172.31.16.204'
my_port = 4010

c = rpyc.connect("172.31.91.81", 4001)

registrado = c.root.exposed_register(my_name, my_ip, my_port)

if registrado:
    var = input("Deseja iniciar o servidor? Sim ou Não: ")
    if var.capitalize() == 'Sim':
        print('Server Startado')

        from rpyc.utils.server import ThreadedServer
        t = ThreadedServer(MyServer,
                           port=4010,
                           protocol_config={
                               'allow_public_attrs': True,
                           })

        print("O servidor CalcServer foi iniciado e está executando")
        print("Aguardando conexões...")
        t.start()
    else:
        print("Ok!")
コード例 #38
0
import rpyc

conn = rpyc.connect("localhost", 18861)
print(conn.root)

subobject = conn.root.get_sub_object()
print(type(subobject))
print(subobject.method1())
コード例 #39
0
def client():

    config = {'allow_public_attrs': True}
    cm = rpyc.connect('localhost', 18861, config=config)
    # The player chooses a location.
    def choose(b, k, startTime):
        # Variables 'n stuff.
        letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
        numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8']
        # Loop in case of invalid entry.
        while True:
            chosen = input('Escolha o quadrado (ex. E4) ou marque caso ache que exista bomba (ex. mE4): ').lower()
            # Checks for valid square.
            if len(chosen) == 3 and chosen[0] == 'm' and chosen[1] in letters and chosen[2] in numbers:
                c, r = (ord(chosen[1])) - 97, int(chosen[2])
                cm.root.marker(r, c, k)
                play(b, k, startTime)
                break
            elif len(chosen) == 2 and chosen[0] in letters and chosen[1] in numbers:
                return (ord(chosen[0])) - 97, int(chosen[1])
            else:
                choose(b, k, startTime)

        # The majority of the gameplay happens here.

    def printBoard(b):
        replit.clear()
        print('    A   B   C   D   E   F   G   H   I')
        print('  ╔═══╦═══╦═══╦═══╦═══╦═══╦═══╦═══╦═══╗')
        for r in range(0, 9):
            print(r, '║', cm.root.l(r, 0, b), '║', cm.root.l(r, 1, b), '║', cm.root.l(r, 2, b), '║', cm.root.l(r, 3, b), '║',
                  cm.root.l(r, 4, b), '║', cm.root.l(r, 5, b),
                  '║', cm.root.l(r, 6, b), '║', cm.root.l(r, 7, b), '║', cm.root.l(r, 8, b), '║')
            if not r == 8:
                print('  ╠═══╬═══╬═══╬═══╬═══╬═══╬═══╬═══╬═══╣')
        print('  ╚═══╩═══╩═══╩═══╩═══╩═══╩═══╩═══╩═══╝')


    def play(b, k, startTime):
        # Player chooses square.
        c, r = choose(b, k, startTime)
        # Gets the value at that location.
        v = cm.root.l(r, c, b)
        # If you hit a bomb, it ends the game.
        if v == '*':
            printBoard(b)
            print('Você Perdeu!')
            # Print timer result.
            print('Tempo: ' + str(round(time.time() - startTime)) + 's')
            # Offer to play again.
            playAgain = input('Jogar Novamente? (Y/N): ').lower()
            if playAgain == 'y':
                replit.clear()
                reset()
            else:
                quit()
        # Puts that value into the known grid (k).
        k[r][c] = v
        # Runs checkZeros() if that value is a 0.
        if v == 0:
            cm.root.checkZeros(k, b, r, c)
        printBoard(k)
        # Checks to see if you have won.
        squaresLeft = 0
        for x in range(0, 9):
            row = k[x]
            squaresLeft += row.count(' ')
            squaresLeft += row.count('⚐')
        if squaresLeft == 10:
            printBoard(b)
            print('Voce Venceu!')
            # Print timer result.
            print('Tempo: ' + str(round(time.time() - startTime)) + 's')
            # Offer to play again.
            playAgain = input('Jogar Novamente? (Y/N): ')
            playAgain = playAgain.lower()
            if playAgain == 'y':
                replit.clear()
                reset()
            else:
                quit()
        # Repeats!
        play(b, k, startTime)


    print()
    cprint('Bem-vindo ao Game Campos Minado', 'red')
    cprint('=============================', 'red')
    print()
    print('Espero que goste dessa aventura')


    # Sets up the game.
    def reset():
        print('''
MENU
=========

-> Para saber instruções, digite 'I'
-> Para jogar imediatamente, digite 'P'
'''
        )

        choice = input('Digite: ').upper()

        if choice == 'I':
            replit.clear()

            # Prints instructions.
            print(open('instructions.txt', 'r').read())

            input('Aperte [enter] para jogar!. ')

        elif choice != 'P':
            replit.clear()
            reset()

        # The solution grid.
        b = [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]

        for n in range(0, 10):
            cm.root.placeBomb(b)

        for r in range(0, 9):
            for c in range(0, 9):
                value = cm.root.l(r, c, b)
                if value == '*':
                    cm.root.updateValues(r, c, b)

        # Sets the variable k to a grid of blank spaces, because nothing is yet known about the grid.
        k = [[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
             [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
             [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
             [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
             [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']]

        printBoard(k)

        # Start timer
        startTime = time.time()

        # The game begins!
        play(b, k, startTime)

    reset()
コード例 #40
0
 def rpyc_root_fn():
     return rpyc.connect(rpyc_host,
                         8064,
                         config={
                             "sync_request_timeout": 600
                         }).root
コード例 #41
0
ファイル: client.py プロジェクト: eybisi/theFS
def delete_from_storage(block_uuid, storage):
    addr, port = storage
    con = rpyc.connect(addr, port=port)
    ss = con.root.Storage()
    return ss.delete(block_uuid)
コード例 #42
0
ファイル: client.py プロジェクト: eybisi/theFS
def read_from_storage(block_uuid, storage):
    addr, port = storage
    con = rpyc.connect(addr, port=port)
    ss = con.root.Storage()
    return ss.pull(block_uuid)
コード例 #43
0
 def __init__(self):
     self.semaphore = rpyc.connect("localhost", 18812, config={'sync_request_timeout': None})
コード例 #44
0
ファイル: Client.py プロジェクト: ComicShrimp/RPC-em-Python
import rpyc

turismo = rpyc.connect('localhost', 35000)
hotel = rpyc.connect('localhost', 35001)
restaurante = rpyc.connect('localhost', 35002)
area = rpyc.connect('localhost', 35003)

while True:
  cidade = input('Cidade para consulta (e para sair): ')
  
  if cidade == 'e':
    break

  resultadoTurismo = turismo.root.pesquisaTurismo(cidade)
  resultadoHotel = hotel.root.pesquisaHotel(cidade)
  resultadoRestaurante = restaurante.root.pesquisaRestaurante(cidade)
  resultadoAerea = area.root.pesquisaAerea(cidade)

  print(resultadoTurismo)
  print(resultadoHotel)
  print(resultadoRestaurante)
  print(resultadoAerea)
コード例 #45
0
def read_from_minion(block_uuid, minion):
    host, port = minion
    con = rpyc.connect(host, port=port)
    minion = con.root.Minion()
    return minion.get(block_uuid)
コード例 #46
0
def send_to_minion(block_uuid, data, minionInfo):
    host, port = minionInfo
    con = rpyc.connect(host, port=port)
    minion = con.root.Minion()
    minion.put(block_uuid, data)
コード例 #47
0
import rpyc

conn = rpyc.connect("localhost", 1337)
conn.root.print("OK")
コード例 #48
0
def connect(host='localhost', port=12345):
    """ Connect to SIP
    """
    global connection_
    connection_ = rpyc.connect(host, port)
コード例 #49
0
ファイル: hypertag.py プロジェクト: Zachpocalypse/HyperTag
    def index_texts(self, rebuild=False, cache=False, cores: int = 0):
        """ Vectorize text files (needed for semantic search) """
        # TODO: index images
        # TODO: auto index on file addition (import)
        from .vectorizer import TextVectorizer, extract_clean_text, get_text_documents

        print("Vectorizing text documents...")
        remote = True
        if remote:
            try:
                rpc = rpyc.connect("localhost", 18861)
                rpc._config["sync_request_timeout"] = None  # Disable timeout
                print("Connected to DaemonService successfully")
            except ConnectionRefusedError:
                print(
                    "DaemonService connection failed, falling back to local execution..."
                )
                remote = False
        if cache:
            print("Caching cleaned texts (database will grow big)")
        if rebuild:
            print("Rebuilding texts index")
            file_paths = self.db.get_vectorized_file_paths()
        else:
            file_paths = self.db.get_unvectorized_file_paths()
        i = 0
        compatible_files = get_text_documents(file_paths, verbose=True)
        min_words = 5
        min_word_length = 4
        args = []
        for file_path, file_type in compatible_files:
            args.append(
                (file_path, file_type, cache, min_words, min_word_length))
        inference_tuples = []

        # Preprocess using multi-processing (default uses all available cores)
        if cores <= 0:
            n_cores = os.cpu_count()
        else:
            n_cores = cores
        pool = Pool(processes=n_cores)
        print(f"Preprocessing texts using {n_cores} cores...")
        with tqdm(total=len(compatible_files)) as t:
            for file_path, sentences in pool.imap_unordered(
                    extract_clean_text, args):
                t.update(1)
                if sentences:
                    inference_tuples.append((file_path, sentences))
        print(f"Cleaned {len(inference_tuples)} text doc/s successfully")
        print("Starting inference...")
        # Compute embeddings
        if not remote:
            vectorizer = TextVectorizer(verbose=True)
        for file_path, sentences in tqdm(inference_tuples):
            if remote:
                document_vector = json.loads(
                    rpc.root.compute_text_embedding(json.dumps(sentences)))
            else:
                document_vector = vectorizer.compute_text_embedding(sentences)
            if (document_vector is not None and type(document_vector) is list
                    and len(document_vector) > 0):
                self.db.add_file_embedding_vector(file_path,
                                                  json.dumps(document_vector))
                self.db.add_text(file_path,
                                 ". ".join([" ".join(s) for s in sentences]))
                self.db.conn.commit()
                i += 1
            else:
                print(type(document_vector))
                self.db.add_file_embedding_vector(file_path, json.dumps([]))
                self.db.conn.commit()
                print("Failed to parse file - skipping:", file_path)
        print(f"Vectorized {str(i)} file/s successfully")
        print("Updating index...")
        if remote:
            rpc.root.update_text_index()
        else:
            vectorizer.update_index()
コード例 #50
0
ファイル: plcommon.py プロジェクト: harshadjs/xcache
def rpc(dest, cmd, args):
    c = rpyc.connect(dest, RPC_PORT)
    s = 'c.root.%s(*args)' % cmd
    out = copy.deepcopy(eval(s))
    c.close()
    return out
コード例 #51
0
ファイル: mr_service (1).py プロジェクト: aranya94/DFS
filetable = pickle.load(fl)
ports = list(filetable.keys())
map_file = input('Enter the location of the map file\n')
if not os.path.isfile(map_file):
    print('No such file exists\n')
    sys.exit()
with open(map_file, 'r') as f1:
    content = f1.read()
reduce_file = input('Enter the location of the reduce file\n')
if not os.path.isfile(reduce_file):
    print('No such file exists\n')
    sys.exit()
target_file = input(
    'Enter the name of the file on which you want to run Map Reduce\n')
if not os.path.isfile(target_file):
    print('No such file exists\n')
    sys.exit()
target_folder = ''.join(target_file.split('/')[-1].split('.')[:-1])
print(target_folder)

for port, folders in filetable.items():
    if target_folder in filetable[port].keys():
        # location=str(port)+'/'+target_folder+'/'
        c = rpyc.connect('localhost', port=port)
        print('File is present in:\n' + str(port))
        interm_output = str(c.root.submit_mr_job(content, target_folder))
int_med_file_loc = os.path.expanduser('~') + '/Desktop/interm_output.txt'
with open(int_med_file_loc, 'w') as inter_med:
    inter_med.write(interm_output)
print(subprocess.getoutput('python %s %s' % (reduce_file, int_med_file_loc)))
コード例 #52
0
import rpyc
import sys

try:
    conn = rpyc.connect("localhost",
                        18861,
                        config={"allow_public_attrs": True})
except:
    print 'Server not running'
    sys.exit(0)

# get remote objects

solution = conn.root.solution()(None)
dac_controller = conn.root.dac_controller()

# Do shuttle


class Region:
    def __init__(self, center, width, sym_scale, asym_scale):
        self.region_name = 'Q'
        self.sub_electrode = True
        self.width = width
        self.center = center
        self.sym_scale = sym_scale
        self.asym_scale = asym_scale
        self.solution = solution


start_region = Region(9, 0, 1, 0)
コード例 #53
0
ファイル: clientApp.py プロジェクト: ersinguven/PADS-myCloud
 def __init__(self):
     self.conn = rpyc.connect(HOST, PORT)
コード例 #54
0
if __name__ == "__main__":
    PORT = int(sys.argv[1])
    DATA_DIR = sys.argv[2]

    if not os.path.isdir(DATA_DIR):
        os.mkdir(DATA_DIR)

    logging.debug("starting minion")
    rpyc_logger = logging.getLogger('rpyc')
    rpyc_logger.setLevel(logging.WARN)

    getIp = http.client.HTTPConnection("ifconfig.me")
    getIp.request("GET", "/ip")
    ip = getIp.getresponse().read()

    con = rpyc.connect(MASTER_IP, port=MASTER_PORT)
    result = con.root.get_updates(ip, PORT)
    if result:
        logging.debug('Getting updates...')
        for file, minions_with_file in result:
            file_path = os.path.join(DATA_DIR, file)
            dir_arr = file.split('/')[:-1]
            create_dir = DATA_DIR
            for dir in dir_arr:
                create_dir = os.path.join(create_dir, dir)
                if not os.path.isdir(create_dir):
                    os.mkdir(create_dir)

            if not os.path.exists(file_path):
                logging.debug('Getting file ' + file)
                for minion in minions_with_file:
コード例 #55
0
import rpyc

if __name__ == '__main__':

    # 调用服务器端的方法,格式为:conn.root.xxx。xxx代表服务器端的方法名
    # sum是服务端的那个以"exposed_"开头的方法
    # RPYC没有认证机制,任何客户端都可以直接访问服务器端的暴露的方法
    conn = rpyc.connect('localhost', 9999)
    result = conn.root.sum(1234, 5678)
    conn.close()
    print('>>>', result)
コード例 #56
0
import sys
import rpyc
from master import MASTER_PORT

###############################################################################
# Connection
###############################################################################
try:
    Connection = rpyc.connect("localhost", port=MASTER_PORT)
    Master = Connection.root.Master()
except ConnectionRefusedError:
    print('Failed to connect to Master.')
    sys.exit(1)
###############################################################################
# End of Connection
###############################################################################

# there are some ADMIN APIs we might want to consider.


def create_minion_node():
    pass


def attach_minion_node():
    pass


def switch_master_node():
    pass
コード例 #57
0
import rpyc
import json

with open(
        "D:\Code\HackTest\CrowdCompute_Hackathon\src\demo\\recepient\donors.json"
) as f:
    active_donors = json.load(f)

connObjectList = []
results = []


def connObj(obj):
    connObjectList.append(obj)


for i in active_donors:
    connObj(rpyc.connect(f"{active_donors[i]}", 18861))

for i in connObjectList:
    results.append(rpyc.async_(i.root.get_answer))

k1 = results[0](82228)
k2 = results[1](10423)

while (k1.ready == False and k2.ready == False):
    pass

print(f" \n \n  {k1.value}, {k2.value}\n \n ")
コード例 #58
0
 def __init__(self, host="localhost", port=8001):
     self.c = rpyc.connect(host, port)
コード例 #59
0
 def __init__(self):
     # connect to the master
     con_master = rpyc.connect('localhost', port=18861)
     master_sever = con_master.root
     self.master = master_sever
コード例 #60
0
 def __init__(self, host, port, timeout=240):
     c = rpyc.connect(host, port)
     c._config['sync_request_timeout'] = timeout
     self.proxy = c.root