Exemplo n.º 1
0
	def __init__(self, file_paths, platform):
		"""
		ActionHandler constructor.
		Create the main window, setup the message handler, import the preferences,
		and connect all of the action handlers. Finally, enter the gtk main loop and block.
		@param file_paths a list of flow graph file passed from command line
		@param platform platform module
		"""
		self.clipboard = None
		for action in Actions.get_all_actions(): action.connect('activate', self._handle_action)
		#setup the main window
		self.main_window = MainWindow(platform)
		self.main_window.connect('delete-event', self._quit)
		self.main_window.connect('key-press-event', self._handle_key_press)
		self.get_page = self.main_window.get_page
		self.get_flow_graph = self.main_window.get_flow_graph
		self.get_focus_flag = self.main_window.get_focus_flag
		#setup the messages
		Messages.register_messenger(self.main_window.add_report_line)
		Messages.send_init(platform)
		#initialize
		self.init_file_paths = file_paths
		Actions.APPLICATION_INITIALIZE()
		#enter the mainloop
		gtk.main()
Exemplo n.º 2
0
def handle_user_gui(app, action, args):
    # FOR GUI. Handles basic user input
    # calling for other functions to complete the input
    # and make commands.
    msg.display_user_instructions()
    if action == "search sport":
        return hdlr.handle_search_sport_gui(app, args)
    elif action == "search sports in location":
        return hdlr.handle_search_sports_in_location_gui(app, args)
    elif action == "search sports in region":
        return hdlr.handle_search_sports_in_region_gui(app, args)
    elif action == "search sports in country":
        return hdlr.handle_search_sports_in_country_gui(app, args)
    elif action == "search sports in zone":
        return hdlr.handle_search_sports_in_zone_gui(app, args)
    elif action == "display locations":
        return hdlr.handle_display_locations_gui(app, args)
    elif action == "display regions":
        return hdlr.handle_display_regions_gui(app, args)
    elif action == "display countries":
        return hdlr.handle_display_countries_gui(app, args)
    elif action == "display zones":
        return hdlr.handle_display_zones_gui(app, args)
    elif action == "instructions":
        return hdlr.handle_display_user_instructions()
    elif action == "quit":
        return
Exemplo n.º 3
0
 def run(self):
     while True:
         _cpu, _mem, _disk = monitoring_resource()
         _cpu = 50.0
         _mem = 45.1
         #_disk = 66.3
         if Config.DELTA_SHARED != 0:
             self.delta = Config.DELTA_SHARED
             Config.DELTA_SHARED = 0
         elif Config.E_SHARED != 0:
             self.e = Config.E_SHARED
             Config.E_SHARED = 0
             self.delta = [0, 0, 0]
         self.calculate_u([_cpu, _mem, _disk])
         Config.U_SHARED = self.u
         Config.V_SHARED = self.v
         print("Node with reporting u: " + str(self.u))
         functionValue = Config.monitoringFunction(self.coeff, self.u)
         if functionValue > self.threshold:
             self.last_mode = "scale_up"
             print(
                 "Found a local violation on the monitored resources - SCALE UP"
             )
             try:
                 #move arduino to another position
                 client = MQTTClient(Config.MQTT_IP,
                                     Config.MQTT_CLIENT_NAME)
                 client.connect()
                 client.publish(Config.MQTT_TOPIC, Config.MQTT_MESSAGE)
                 client.disconnect()
             except:
                 print("Error to connect to MQTT broker")
             response = Messages.send(
                 "scale_up", v=self.v, u=self.u,
                 coeff=self.coeff)  #communication to cloud
             try:
                 self.e = response["e"]
                 self.delta = [0, 0, 0]
                 print("New estimation from coordinator - e:" + str(self.e))
             except KeyError:
                 self.delta = response['delta']
                 print("New estimation from coordinator - delta:" +
                       str(self.delta))
             except TypeError:
                 print("No node available")
             self.vLast = self.v
         elif functionValue < (-self.threshold):
             if self.last_mode == "scale_down":
                 print(
                     "Under the threshold but cannot scale down because not in cluster"
                 )
             else:
                 self.last_mode = "scale_down"
                 print(
                     "Found a local violation on the monitored resources - SCALE DOWN"
                 )
                 Messages.send_noresp("scale_down", v=self.v, u=self.u)
                 self.vLast = self.v
             self.last_mode = "scale_down"
         time.sleep(Config.MONITORING_TIMEFRAME)
Exemplo n.º 4
0
 def _gotShortHandshake(self, connId, connSet):
     success = False
     data = ''.join(connSet['inBuffer'])
     connSet['inBuffer'] = [data]
     
     #decode handshake
     length, proto, reserved, infohash = Messages.decodeShortHandshake(data)
     
     if not proto.lower()=='bittorrent protocol':
         #invalid handshake, close conn
         self._closeConn(connId, 'received invalid handshake')
         
     elif not infohash in self.torrents:
         #invalid handshake, close conn
         self._closeConn(connId, 'received handshake with unknown infohash')
         
     else:
         #valid handshake
         connSet['torrentIdent'] = self.torrents[infohash]
         if self.peerPool.establishedConnection(connSet['torrentIdent'], connSet['sock'].getpeername()):
             #no connection to this address exists up to now
             success = True
             connSet['added'] = True
             self.log.info("Conn %d: Got valid handshake, sending response", connId)
             connSet['sock'].send(Messages.generateHandshake(infohash, self.peerId))
             
         else:
             #we already have a connection to this address
             self._closeConn(connId, 'we already have a connection to this address')
     
     return success
Exemplo n.º 5
0
 def build(self, building):
     '''pokial sa jedna o pole da upgradovat najnizsi lvl jeho typu,
        pokial je uz budova postavena, da ju upgradovat, ked nie da ju stavat.
     '''
     if any(building == x for x in self.resources().keys()):
         id = self.get_id_of_lowest_res_lvl(building)
         self.upgrade(id)
     elif self.is_building_built(building) != -1:
         id = self.get_building_id(building)
         self.upgrade(id)
     else:
         id = self.get_free_building_place_id()
         soup = self.get_soup(self.build_url + id + '&category=' +
                              self.get_building_category(id, building))
         divs = soup.findAll('div', {'class': 'buildingWrapper'})
         for i in range(len(divs)):
             if divs[i].find('h2').string == building:
                 index = i
                 break
         button_link = divs[index].find(
             'button', {'class': 'green new'})['onclick'].split("'")[1]
         self.session.post(self.url[:-9] + button_link)
         id = self.get_building_id(building)
     if self.debug:
         Messages.building(building, id,
                           self.get_building_lvl(building, id=id))
Exemplo n.º 6
0
def warn_user(event, session_api, chat_id, msg_command, dict_of_users):
    if Connector.isAdmin(chat_id, event.object.message['from_id']):
        getConversationMembers(session_api, event, dict_of_users)
        # check forward messages
        if len(event.object.message['fwd_messages']) != 0:
            for temp in event.object.message['fwd_messages']:
                Messages.send_message(
                    session_api, chat_id, 'User with id: \'' +
                    str(int(temp['from_id'])) + '\' warned successful!')
                Connector.db_warn(chat_id, int(temp['from_id']))

        # check id in msg_command
        try:
            msg_ids = msg_command.split()[1:]
            for user_idd in msg_ids:
                user_id = (str(user_idd[3:]).split('|'))[0]
                if int(user_id) in dict_of_users.keys():
                    Messages.send_message(
                        session_api, chat_id, 'User with id: \'' +
                        str(user_id) + '\' warned successful!')
                    Connector.db_warn(chat_id, int(user_id))
                else:
                    Messages.send_message(
                        session_api, chat_id, 'User with id: \'' +
                        str(user_id) + '\' is not in chat!')
        except ValueError:
            Messages.send_message(session_api, chat_id, 'Id is incorrect!')
    else:
        Messages.send_message(session_api, chat_id,
                              'Permission denied! You is not admin!')
Exemplo n.º 7
0
 def OnModify(self, event):
     if self.selected == None:
         Messages.messageError('No se ha seleccionado ningun servidor', 'Modificar configuracion')
     else:
         NewConfigurationWindow.showModifWindow(self)
         
     event.Skip()
Exemplo n.º 8
0
    def generate_next_request(self):
        while True:
            #Ask the Requests Manager for new Blocks to request
            piece_index, block_index = self.torrent.requester.getNextBlock(
                self)

            if block_index < 0 or len(
                    self.set_of_blocks_requested) >= MAX_REQUEST_TO_PEER:
                if self.torrent.fileManager.StreamCompleted == True:
                    # Launch Finishing Sequences
                    reactor.stop()
                else:
                    break
            block_byte_offset = block_index * BLOCK_SIZE
            #Add this to the set of blocks requested.
            self.set_of_blocks_requested.add((piece_index, block_index))

            self.transport.write(
                str(
                    Messages.Request(
                        index=Messages.number_to_bytes(piece_index),
                        begin=Messages.number_to_bytes(block_byte_offset),
                        length=Messages.number_to_bytes(BLOCK_SIZE))))

            self.torrent.requester.requestSuccessful(self, piece_index,
                                                     block_index)
            #Add timeout for requests.
            Logger.info("Sending Request For Piece :" + str(piece_index) +
                        ", " + str(block_index) + " to " + str(self.ip))
            reactor.callLater(TIMEOUT, self.checkTimeout, piece_index,
                              block_index)
Exemplo n.º 9
0
 def answer_request(self, piece_index, begin, length):
     data = ""
     remaining_length = length
     while (remaining_length > 0):
         block_index = int(begin / BLOCK_SIZE)
         if (self.torrent.fileManager.blockExists(
                 piece_index,
                 block_index)):  #block_exists indicates if block is present
             if (remaining_length >= BLOCK_SIZE):
                 data = self.torrent.fileManager.readBlock(
                     piece_index, block_index)[
                         begin %
                         BLOCK_SIZE:]  #readBlock returns the data block
                 begin = math.ceil(begin / BLOCK_SIZE) * ConstantsBLOCK_SIZE
                 remaining_length -= BLOCK_SIZE - begin % BLOCK_SIZE
             else:
                 data = self.torrent.fileManager.readBlock(
                     piece_index,
                     block_index)[begin % BLOCK_SIZE:remaining_length]
                 remaining_length = 0
             self.transport.write(
                 str(
                     Messages.Piece(
                         index=Messages.number_to_bytes(piece_index),
                         begin=Messages.number_to_bytes(begin),
                         block=data)))  #send corresponding data block
             if (begin == self.torrent.fileManager.get_piece_length(
                     piece_index)
                 ):  #get piece length for corresponding piece index
                 piece_index += 1
                 begin = 0
def handle_add_region(app, db_file):
    msg.display_add_region_instructions()
    region = input("region: ")
    country = input("country: ")
    zone = input("zone: ")
    app.add_region(clss.Region(region), country, zone)
    db_file.write("\nadd region " + region + " " + country + " " + zone)
Exemplo n.º 11
0
    def requestChatMessages(self, chat_id):
        chat = self.getChat(chat_id)
        c.log(
            'info', 'Requesting chat messages for chat %s "%s"' %
            (chat_id, chat['data']['title']))

        Messages.requestMessages({'chat_id': chat_id}, self.data[chat_id])
Exemplo n.º 12
0
    def __init__(self, file_paths, platform):
        """
		ActionHandler constructor.
		Create the main window, setup the message handler, import the preferences,
		and connect all of the action handlers. Finally, enter the gtk main loop and block.
		@param file_paths a list of flow graph file passed from command line
		@param platform platform module
		"""
        self.clipboard = None
        for action in Actions.get_all_actions():
            action.connect('activate', self._handle_action)
        #setup the main window
        self.main_window = MainWindow(platform)
        self.main_window.connect('delete-event', self._quit)
        self.main_window.connect('key-press-event', self._handle_key_press)
        self.get_page = self.main_window.get_page
        self.get_flow_graph = self.main_window.get_flow_graph
        self.get_focus_flag = self.main_window.get_focus_flag
        #setup the messages
        Messages.register_messenger(self.main_window.add_report_line)
        Messages.send_init(platform)
        #initialize
        self.init_file_paths = file_paths
        Actions.APPLICATION_INITIALIZE()
        #enter the mainloop
        gtk.main()
def handle_add_location(app, db_file):
    msg.display_add_location_instructions()
    location = input("location: ")
    region = input("region: ")
    country = input("country: ")
    zone = input("zone: ")
    app.add_location(clss.Location(location), region, country, zone)
    db_file.write("\nadd location " + location + " " + region + " " + country + " " + zone)
Exemplo n.º 14
0
    def get_addr(self):
        message = Messages.get_addr()
        self.socket.send(message)
        print("Wiadomość getaddr wysłana\nOczekuje na odpowiedź...\n")

        addr_list: List[Tuple[str, int]] = Messages.receive_addr(self.socket)
        for addr in addr_list:
            print("Adres: " + str(addr[0]) + " port:" + str(addr[1]))
Exemplo n.º 15
0
    def OnExecute(self, event):
        ix = self.choice.GetCurrentSelection()

        if ix < 0:
            Messages.messageError('Select a SAP Server', 'Execute ABAP Code')
        else:
            result = sap.executeCode(self.servers[ix], self.parent.code)
            self.parent.outtext.SetValue(result)
Exemplo n.º 16
0
 def OnTestConfig(self, event):
     message = Utils.setParams(self)
     if message != None:
         Messages.messageError(message, 'Probar')
     else:
         if sap.testServerConfig(*self.params):
             Messages.messageInformation('La configuracion es correcta, ahora puede guardar', 'Probar configuracion')
     event.Skip()
Exemplo n.º 17
0
    def OnExecute(self, event):
        ix = self.choice.GetCurrentSelection()

        if ix < 0:
            Messages.messageError('Select a SAP Server', 'Execute ABAP Code')
        else:
            result = sap.executeCode(self.servers[ix],  self.parent.code )
            self.parent.outtext.SetValue(result) 
Exemplo n.º 18
0
def random_band(session_api, chat_id, msg_command):
    try:
        min = int(str(msg_command).split(' ')[1])
        max = int(str(msg_command).split(' ')[2])
        result = random.randint(min, max)
        Messages.send_message(session_api, chat_id, 'Your random generated number is ' + str(result))
    except ValueError:
        Messages.send_message(session_api, chat_id, 'Input incorrect!')
	def cancelRequestFor(self,piece_index,block_index):
		if((piece_index,block_index) in self.set_of_blocks_requested):
			self.set_of_blocks_requested.remove((piece_index,block_index))
		begin = block_index*BLOCK_SIZE
		piece_index = Messages.number_to_bytes(piece_index)
		begin = Messages.number_to_bytes(block_index)
		length = Messages.number_to_bytes(BLOCK_SIZE)
		self.transport.write(str(Messages.Cancel(index = piece_index, begin = begin, length = length)))
Exemplo n.º 20
0
 def kick(self, bot, game):
     try:
         Messages.send_message(bot, self.real_id, Messages.YOU_LOSE)
         Messages.send_message(bot, game.group_id, "بازیکن " + self.first_name + " از بازی حذف شد")
         bot.restrict_chat_member(chat_id=game.group_id, user_id=self.real_id,
                                  permissions=telegram.ChatPermissions(can_send_messages=False))
         # bot.kick_chat_member(game.group_id, self.real_id)
     except Exception as e:
         print(e)
Exemplo n.º 21
0
 def OnDelete(self, event):
     if self.selected == None:
         Messages.messageError('No se ha seleccionado ningun servidor', 'Eliminar configuracion')
     else:
         ret = Messages.messageChoice('Realmente desea eliminar la configuracion?', 'Eliminar configuracion')
         if ret == wx.ID_YES:
             if db.deleteConfig(self.sel_text):
                 self.list.DeleteItem(self.selected)
     event.Skip()
Exemplo n.º 22
0
def kickfrom_user(event, session_api, chat_id, msg_command):
    if Connector.isAdmin(chat_id, event.object.message['from_id']):
        try:
            time = msg_command.split(' ')[1]
            Connector.db_kickfrom(chat_id, time)
        except ValueError:
            Messages.send_message(session_api, chat_id, 'Date is incorrect!')
    else:
        Messages.send_message(session_api, chat_id,
                              'Permission denied! You is not admin!')
Exemplo n.º 23
0
 def OnTestConfig(self, event):
     message = Utils.setParams(self)
     if message != None:
         Messages.messageError(message, 'Probar')
     else:
         if sap.testServerConfig(*self.params):
             Messages.messageInformation(
                 'La configuracion es correcta, ahora puede guardar',
                 'Probar configuracion')
     event.Skip()
Exemplo n.º 24
0
 def cancelRequestFor(self, piece_index, block_index):
     if ((piece_index, block_index) in self.set_of_blocks_requested):
         self.set_of_blocks_requested.remove((piece_index, block_index))
     begin = block_index * BLOCK_SIZE
     piece_index = Messages.number_to_bytes(piece_index)
     begin = Messages.number_to_bytes(block_index)
     length = Messages.number_to_bytes(BLOCK_SIZE)
     self.transport.write(
         str(Messages.Cancel(index=piece_index, begin=begin,
                             length=length)))
Exemplo n.º 25
0
    def _setLocalChoke(self, value):
        if value == True and self.localChoke == False:
            # choking
            self._delAllOutRequests()
            self._queueSend(Messages.generateChoke())
            self.localChoke = value

        elif value == False and self.localChoke == True:
            self._queueSend(Messages.generateUnChoke())
            self.localChoke = value
Exemplo n.º 26
0
 def _setLocalInterest(self, value):
     if value == False and self.localInterest == True:
         # changing to negative, we were interested before
         assert self._amountOfInRequests() == 0, "Local Requests are running and we are not interested?"
         # self._cancelAllInRequests()
         self._queueSend(Messages.generateNotInterested())
         self.localInterest = value
     elif value == True and self.localInterest == False:
         self._queueSend(Messages.generateInterested())
         self.localInterest = value
Exemplo n.º 27
0
def broadcast(session_api, chat_id, msg_command, event, dict_of_users):
    message = ''

    members = User.getConversationMembers(session_api, event, dict_of_users)
    for member in dict_of_users.keys():
        message += '@id' + str(member) + " "

    message += msg_command.split()[1]

    Messages.send_message(session_api, chat_id, message)
Exemplo n.º 28
0
def all_commands(session_api, peer_id):
    message = 'List of commands: \n ' \
              '     Date & Time:\n' \
              '         1. !date (return current date)\n' \
              '         2. !time (return current Moscow time)\n' \
              '         3. !datetime (return !date + !time)\n' \
              '     Chat members:\n' \
              '         1. !members (return list of this chat members)\n' \
              '         2. !kick {id} (kick user from id. Example to kick (id=567123): !kick 567123\n'
    Messages.send_message(session_api, peer_id, message)
Exemplo n.º 29
0
    def OnSave(self, event):
        message = Utils.setParams(self)

        if message != None:
            Messages.messageError(message, 'Guardar')
        else:
            r = db.saveServerConfig(*self.params)
            if r:
                for field, label in self.fields:
                    field.SetValue('')
        event.Skip()
Exemplo n.º 30
0
  def _clearJVMOutputFiles(self):
    """
    Clears JVM output files.
    """

    try:
      open(self._globJVMOutPath, 'w').close()
      open(self._globJVMErrPath, 'w').close()
      
    except:
      Messages.warning(__name__, "Cannot remove JVM output files!", verbose=2)
Exemplo n.º 31
0
  def _deleteJVMOutputFiles(self):
    """
    Deletes JVM output files.
    """

    try:
      IO.removeFile(self._globJVMOutPath)
      IO.removeFile(self._globJVMErrPath)
      
    except:
      Messages.warning(__name__, "Cannot remove JVM output files!", verbose=2)
Exemplo n.º 32
0
 def OnSave(self, event):
     message = Utils.setParams(self)
         
     if message != None:
         Messages.messageError(message, 'Guardar')
     else:
         r = db.saveServerConfig(*self.params)
         if r:
             for field, label in self.fields:
                 field.SetValue('')
     event.Skip()
Exemplo n.º 33
0
def dict_iterator_and_send(dict_of_users, session_api, chat_id, event):
    User.getConversationMembers(session_api, event, dict_of_users)

    message = ''
    temp = 1
    for user in dict_of_users.keys():
        message += str(temp) + '. vk.com/id' + str(user) + ' ' + dict_of_users.get(user)['first_name'] \
                   + ' ' + dict_of_users.get(user)['last_name'] + '\n'
        temp += 1

    Messages.send_message(session_api, chat_id, message)
Exemplo n.º 34
0
    def requestMessages(self, user_id):
        user = Users.getUser(user_id)
        c.log('info', 'Requesting messages for user %s %s %s' % (user_id, user['data']['first_name'], user['data']['last_name']))

        if user_id not in self.data:
            self.data[user_id] = {
                'id' :  user_id,
                'log' : []
            }

        Messages.requestMessages({'user_id': user_id}, self.data[user_id])
Exemplo n.º 35
0
    def _handle_page_change(self, notebook, page, page_num):
        """
		Handle a page change. When the user clicks on a new tab,
		reload the flow graph to update the vars window and
		call handle states (select nothing) to update the buttons.
		@param notebook the notebook
		@param page new page
		@param page_num new page number
		"""
        self.current_page = self.notebook.get_nth_page(page_num)
        Messages.send_page_switch(self.current_page.get_file_path())
        Actions.PAGE_CHANGE()
Exemplo n.º 36
0
	def _handle_page_change(self, notebook, page, page_num):
		"""
		Handle a page change. When the user clicks on a new tab,
		reload the flow graph to update the vars window and
		call handle states (select nothing) to update the buttons.
		@param notebook the notebook
		@param page new page
		@param page_num new page number
		"""
		self.current_page = self.notebook.get_nth_page(page_num)
		Messages.send_page_switch(self.current_page.get_file_path())
		self.handle_states()
Exemplo n.º 37
0
def online_list(event, session_api, chat_id, msg_command, dict_of_users):
    members = getConversationMembers(session_api, event, dict_of_users)
    print('\n\n\n', members)

    temp = 1
    message = 'Online list:\n'
    for k, v in members.items():
        for k2 in v.keys():
            if k2 == 'online' and v[k2] == 1:
                message += str(temp) + '. vk.com/id' + str(k) + '\n'
                temp += 1
    Messages.send_message(session_api, chat_id, message)
Exemplo n.º 38
0
def try_give_admin(event, session_api):
    try:
        chat_id = event.object.message['peer_id']
        Messages.send_message(
            session_api, chat_id,
            "Hello! \n Give me admin role to work with chat. "
            "\n1) Bot will start work after 20 seconds if you gave him an admin role"
            "\n2) Bot will not work if you give not an admin role"
            "\n\nP.s. If 2) was, try kick and invite again")
        time.sleep(20)
    except KeyError:
        pass
Exemplo n.º 39
0
 def update_selected_elements(self):
     """
     Update the selected elements.
     The update behavior depends on the state of the mouse button.
     When the mouse button pressed the selection will change when
     the control mask is set or the new selection is not in the current group.
     When the mouse button is released the selection will change when
     the mouse has moved and the control mask is set or the current group is empty.
     Attempt to make a new connection if the old and ports are filled.
     If the control mask is set, merge with the current elements.
     """
     selected_elements = None
     if self.mouse_pressed:
         new_selections = self.what_is_selected(self.get_coordinate())
         #update the selections if the new selection is not in the current selections
         #allows us to move entire selected groups of elements
         if self.get_ctrl_mask() or not (new_selections
                                         and new_selections[0]
                                         in self.get_selected_elements()):
             selected_elements = new_selections
         if self._old_selected_port:
             self._old_selected_port.force_label_unhidden(False)
             self.create_shapes()
             self.queue_draw()
         elif self._new_selected_port:
             self._new_selected_port.force_label_unhidden()
     else:  # called from a mouse release
         if not self.element_moved and (not self.get_selected_elements()
                                        or self.get_ctrl_mask()):
             selected_elements = self.what_is_selected(
                 self.get_coordinate(), self.press_coor)
     #this selection and the last were ports, try to connect them
     if self._old_selected_port and self._new_selected_port:
         try:
             self.connect(self._old_selected_port, self._new_selected_port)
             Actions.ELEMENT_CREATE()
         except:
             Messages.send_fail_connection()
         self._old_selected_port = None
         self._new_selected_port = None
         return
     #update selected elements
     if selected_elements is None: return
     old_elements = set(self.get_selected_elements())
     self._selected_elements = list(set(selected_elements))
     new_elements = set(self.get_selected_elements())
     #if ctrl, set the selected elements to the union - intersection of old and new
     if self.get_ctrl_mask():
         self._selected_elements = list(
             set.union(old_elements, new_elements) -
             set.intersection(old_elements, new_elements))
     Actions.ELEMENT_SELECT()
Exemplo n.º 40
0
	def write(self):
		#do throttle warning
		throttled = any(map(lambda b: b.throttle(), self._flow_graph.get_enabled_blocks()))
		if not throttled and self._generate_options != 'hb':
			Messages.send_warning('''\
This flow graph may not have flow control: no audio or usrp blocks found. \
Add a Misc->Throttle block to your flow graph to avoid CPU congestion.''')
		#generate
		open(self.get_file_path(), 'w').write(str(self))
		if self._generate_options == 'hb':
			#convert hier block to xml wrapper
			convert_hier.convert_hier(self._flow_graph, self.get_file_path())
		os.chmod(self.get_file_path(), self._mode)
Exemplo n.º 41
0
 def __shutdownJVM(self):
   """
   Shuts down the Java Virtual Machine
   """
   
   if self._globJVMOn:
     jpype.shutdownJVM()
     
     self._globJVMOn = False
     self._globJVMSymm = None
     Messages.log(__name__, "JVM shut down!", verbose=1)
     
     self._deleteJVMOutputFiles()
Exemplo n.º 42
0
	def write(self):
		#do throttle warning
		throttled = any(map(lambda b: b.throttle(), self._flow_graph.get_enabled_blocks()))
		if not throttled and self._generate_options != 'hb':
			Messages.send_warning('''\
This flow graph may not have flow control: no audio or usrp blocks found. \
Add a Misc->Throttle block to your flow graph to avoid CPU congestion.''')
		#generate
		open(self.get_file_path(), 'w').write(str(self))
		if self._generate_options == 'hb':
			#convert hier block to xml wrapper
			convert_hier.convert_hier(self._flow_graph, self.get_file_path())
		os.chmod(self.get_file_path(), self._mode)
Exemplo n.º 43
0
    def _handle_page_change(self, notebook, page, page_num):
        """
        Handle a page change. When the user clicks on a new tab,
        reload the flow graph to update the vars window and
        call handle states (select nothing) to update the buttons.

        Args:
            notebook: the notebook
            page: new page
            page_num: new page number
        """
        self.current_page = self.notebook.get_nth_page(page_num)
        Messages.send_page_switch(self.current_page.get_file_path())
        Actions.PAGE_CHANGE()
Exemplo n.º 44
0
    def OnDownload(self, event):
        message = Utils.setParams(self)
        if message != None:
            Messages.messageError(message, 'Error downloading code')
        else:
            ix = self.choice.GetCurrentSelection()

            if ix < 0:
                Messages.messageError('Select a server',
                                      'Download ABAP Source code')
            else:
                abap = sap.getCode(self.servers[ix], self.params[0])
                if abap != "":
                    self.parent.code = abap
                    self.parent.codetext.SetValue(abap)
                    self.parent.ReloadHighlight()
                    Messages.messageInformation(
                        'Source Code downloaded successfully!', 'Download')
                    self.parent.local = False
                    self.parent.ChangeRootName(self.params[0].upper(), True)
                    self.parent.sap_program = self.params[0].upper()
                    self.parent.sap_server = self.servers[ix]
                    self.parent.tree.SetBackgroundColour('blue violet')
                    self.parent.SetTitle('Zorse - SAP:\\' +
                                         self.params[0].upper())
                    self.Destroy()
                else:
                    Messages.messageError('Error downloading program',
                                          'Error downloading code')
Exemplo n.º 45
0
    def OnDownload(self, event):
        message = Utils.setParams(self)
        if message != None:
            Messages.messageError(message, 'Error downloading code')
        else:
            ix = self.choice.GetCurrentSelection()

            if ix < 0:
                Messages.messageError('Select a server', 'Download ABAP Source code')
            else:    
                abap = sap.getCode(self.servers[ix], self.params[0])
                if abap != "":
                    self.parent.code = abap
                    self.parent.codetext.SetValue(abap)
                    self.parent.ReloadHighlight()
                    Messages.messageInformation('Source Code downloaded successfully!', 'Download')
                    self.parent.local = False
                    self.parent.ChangeRootName(self.params[0].upper(), True)
                    self.parent.sap_program = self.params[0].upper()
                    self.parent.sap_server  = self.servers[ix]
                    self.parent.tree.SetBackgroundColour('blue violet')
                    self.parent.SetTitle('Zorse - SAP:\\' + self.params[0].upper())
                    self.Destroy()
                else:
                    Messages.messageError('Error downloading program', 'Error downloading code')               
Exemplo n.º 46
0
    def _handle_server(self, prefix, cmd, suffix, params, caller):
        if cmd == "cmd":
            self.serv.executor.execute(suffix, params.split(' '),
                                       PluginUser(caller))
            return True
        if cmd == "table":
            # https://github.com/stasivs/Messenger/issues/4
            self.serv.resend(
                Bcast("""
<table>
	<tbody>
		<tr>
			<td>1</td>
			<td>2</td>
		</td>
		<tr>
			<td>3</td>
			<td>4</td>
		</td>
	</tbody>
</table>
            """))
            return True
        if cmd == "stop":
            sys.exit()
            return True
        if cmd == "say":
            if not prefix:
                self.serv.resend(Messages.Bcast(params))
            else:
                self.serv.resend(UserMessage(params, prefix))
            return True
        if cmd == "tell":
            if not suffix:
                return False
            user = self.serv.get_user_by_nick(suffix)
            if not prefix:
                user.send(Messages.Info(params))
            else:
                user.send(UserMessage(params, prefix))
            return True
        if cmd == "eval":
            res = eval(params)
            self.serv.resend(Messages.Info(res))
            return True
        if cmd == "exec":
            exec(params)
            return True
        return False
Exemplo n.º 47
0
 def update_selected_elements(self):
     """
     Update the selected elements.
     The update behavior depends on the state of the mouse button.
     When the mouse button pressed the selection will change when
     the control mask is set or the new selection is not in the current group.
     When the mouse button is released the selection will change when
     the mouse has moved and the control mask is set or the current group is empty.
     Attempt to make a new connection if the old and ports are filled.
     If the control mask is set, merge with the current elements.
     """
     selected_elements = None
     if self.mouse_pressed:
         new_selections = self.what_is_selected(self.get_coordinate())
         #update the selections if the new selection is not in the current selections
         #allows us to move entire selected groups of elements
         if self.get_ctrl_mask() or not (
             new_selections and new_selections[0] in self.get_selected_elements()
         ): selected_elements = new_selections
         if self._old_selected_port:
             self._old_selected_port.force_label_unhidden(False)
             self.create_shapes()
             self.queue_draw()
         elif self._new_selected_port:
             self._new_selected_port.force_label_unhidden()
     else:  # called from a mouse release
         if not self.element_moved and (not self.get_selected_elements() or self.get_ctrl_mask()):
             selected_elements = self.what_is_selected(self.get_coordinate(), self.press_coor)
     #this selection and the last were ports, try to connect them
     if self._old_selected_port and self._new_selected_port:
         try:
             self.connect(self._old_selected_port, self._new_selected_port)
             Actions.ELEMENT_CREATE()
         except: Messages.send_fail_connection()
         self._old_selected_port = None
         self._new_selected_port = None
         return
     #update selected elements
     if selected_elements is None: return
     old_elements = set(self.get_selected_elements())
     self._selected_elements = list(set(selected_elements))
     new_elements = set(self.get_selected_elements())
     #if ctrl, set the selected elements to the union - intersection of old and new
     if self.get_ctrl_mask():
         self._selected_elements = list(
             set.union(old_elements, new_elements) - set.intersection(old_elements, new_elements)
         )
     Actions.ELEMENT_SELECT()
Exemplo n.º 48
0
    def run(self):
        try:
            self.lock.acquire()
            while not self.shouldStop:
                self.lock.release()
                recvable, sendable, errored = self.samSockManager.select(
                    self.connsWithRecvInterest, self.connsWithSendInterest, self.allConns, timeout=1
                )
                self.lock.acquire()

                for connId in errored:
                    # conn failed, close it
                    self._failedConn(connId, "connection failed")

                for connId in sendable:
                    if connId in self.conns:
                        # connected
                        connSet = self.conns[connId]
                        torrentInfo = self.torrents[connSet["torrentIdent"]]
                        connSet["sock"].send(Messages.generateHandshake(torrentInfo["infohash"], self.peerId))
                        self.connsWithSendInterest.remove(connId)
                        self.connsWithRecvInterest.add(connId)

                for connId in recvable:
                    if connId in self.conns:
                        # received data
                        self._recvFromConn(connId)

            self.thread = None
            self.log.info("Stopping")
            self.lock.release()
        except:
            self.log.error("Error in main loop:\n%s", logTraceback())
Exemplo n.º 49
0
    def _gotFullHandshake(self, connId, connSet):
        data = "".join(connSet["inBuffer"])

        # decode handshake
        length, proto, reserved, infohash, remotePeerId = Messages.decodeHandshake(data)

        if not proto.lower() == "bittorrent protocol":
            # invalid handshake, close conn
            self._failedConn(connId, "received invalid handshake")

        elif not infohash == self.torrents[connSet["torrentIdent"]]["infohash"]:
            # invalid infohash
            self._failedConn(connId, "received handshake with wrong infohash")

        else:
            # valid handshake
            if not self.peerPool.establishedConnection(connSet["torrentIdent"], connSet["sock"].getpeername()):
                # we already have a connection to this address
                self._failedConn(connId, "we already have a connection to this address")

            else:
                # no connection to this address exists up to now
                self.log.info("Conn %i: Got valid handshake, established connections", connId)

                # add to handler
                self.connHandler.addConnection(connSet["torrentIdent"], connSet["sock"], "out", remotePeerId)

                # remove from local structures
                self._removeConn(connId)
Exemplo n.º 50
0
 def _addConnection(self, torrentIdent, connSock, direction, remotePeerId):
     assert torrentIdent in self.torrents,'connection for not running torrent or something?!'
     torrent = self.torrents[torrentIdent]
     remoteAddr = connSock.getpeername()
     assert not remoteAddr in torrent['connRemoteAddrs'],'Already have a connection to that address?!'
     
     if remotePeerId in torrent['connPeerIds']:
         #already connected to this peer
         self.log.info('Conn %i: Closing because we are already connected to that peer', connSock.fileno())
         connSock.close()
         self.peerPool.lostConnection(torrentIdent, remoteAddr)
     else:
         #really add this conn
         conn = BtConnection(torrentIdent, torrent['pieceStatus'], self.connStatsCache, self.connStatus,\
                             remotePeerId, self.scheduler, connSock, direction, remoteAddr,\
                             torrent['inMeasure'], torrent['outMeasure'], self.outLimiter, self.inLimiter)
         connId = conn.fileno()
         self.conns[connId] = conn
         torrent['connIds'].add(connId)
         torrent['connPeerIds'].add(remotePeerId)
         torrent['connRemoteAddrs'].add(remoteAddr)
         
         if torrent['superSeedingEnabled']:
             #add to handler
             torrent['superSeedingHandler'].addConn(connId, conn)
         else:
             #send bitfield
             conn.send(Messages.generateBitfield(torrent['ownStatus'].getBitfield()))
Exemplo n.º 51
0
def menu():
	print('1. Messages        2. Contacts')
	print('3. Phone           4. Media')
	print('b. Back            0. Exit')
	choice = ''
	while(choice!=0):
		choice = input('Enter Choice : ')

		if( choice == '1' ):
			Messages.menu()
		elif( choice == '2'):
			Contacts.menu()
		elif( choice == '3'):
			Phone.menu()
		elif( choice == '4'):
			Media.menu()
Exemplo n.º 52
0
 def connGotBitfield(self, connId):
     #got a bitfield from the peer, need to check if the peer already has some of the offered pieces
     self.lock.acquire()
     connSet = self.connInfo[connId]
     connStatus = connSet['conn'].getStatus()
     
     #check for offered pieces which the peer already has
     for pieceIndex in connStatus.getMatchingGotPieces(connSet['upPieces']):
         connSet['upPieces'].remove(pieceIndex)
         self.pieceStatus.decreaseAssignedUploads(pieceIndex)
         
     #offer new pieces if needed
     if len(connSet['upPieces']) < 2:
         wantedPieces = connStatus.getMatchingMissingPieces(self.ownStatus.getGotPieces())
         wantedPieces.difference_update(connSet['upPieces'])
         pieces = self.pieceStatus.getUpPieces(wantedPieces, 2 - len(connSet['upPieces']))
         if len(pieces) == 0:
             #no piece to offer
             self.log.debug('Conn %-6i - Nothing to offer (adding to waiting list)', connId)
             self.waitingConns.add(connId)
         else:
             #offer pieces
             self.log.debug('Conn %-6i - Offering pieces %s', connId, ', '.join(str(x) for x in pieces))
             for pieceIndex in pieces:
                 connSet['upPieces'].add(pieceIndex)
                 connSet['conn'].send(Messages.generateHave(pieceIndex))
     self.lock.release()
 def get_msgs(self):
     self.m1 = Msg.get_m1()
     self.m2 = Msg.get_m2()
     self.m3 = Msg.get_m3()
     self.m4 = Msg.get_m4()
     self.m5 = Msg.get_m5()
     self.m6 = Msg.get_m6()
     self.m7 = Msg.get_m7()
     self.m8 = Msg.get_m8()
Exemplo n.º 54
0
 def _cancelInRequest(self, pieceIndex, offset, length):
     # try to find the request, send cancel and then delete it
     inRequest = (pieceIndex, offset, length)
     self.inRequestQueue.remove(inRequest)
     requestInfo = self.inRequestInfo.pop(inRequest)
     if not self._abortSend(requestInfo["messageId"]):
         # the request was already send
         self._queueSend(Messages.generateCancel(pieceIndex, offset, length))
	def answer_request(self, piece_index, begin, length):
		data = ""
		remaining_length = length
		while(remaining_length>0):
			block_index = int(begin/BLOCK_SIZE)
			if(self.torrent.fileManager.blockExists(piece_index,block_index)):	#block_exists indicates if block is present
				if(remaining_length >= BLOCK_SIZE):
					data = self.torrent.fileManager.readBlock(piece_index,block_index)[begin%BLOCK_SIZE:]	#readBlock returns the data block
					begin = math.ceil(begin/BLOCK_SIZE)*ConstantsBLOCK_SIZE
					remaining_length -= BLOCK_SIZE-begin%BLOCK_SIZE
				else:
					data = self.torrent.fileManager.readBlock(piece_index,block_index)[begin%BLOCK_SIZE:remaining_length]
					remaining_length = 0
				self.transport.write(str(Messages.Piece(
				index = Messages.number_to_bytes(piece_index), 
				begin = Messages.number_to_bytes(begin), 
				block = data)))	#send corresponding data block
				if(begin == self.torrent.fileManager.get_piece_length(piece_index)):	#get piece length for corresponding piece index
					piece_index += 1
					begin = 0
Exemplo n.º 56
0
def welcome_screen():
  global LAST_NAME
  global DAY

  raw_input(Messages.WELCOME)

  name = raw_input(Messages.ASK_LAST_NAME)
  # TODO: but aren't we already creating a Player in CharacterDB?
  GAME_STATE.player = Character.Player(name=name)
  bully = CharacterDB.random_character(cclass='Camper', gender='m')

  print 'Your name is Pickett %s' % GAME_STATE.player.name

  Messages.print_messages([
    Messages.EXPLANATION,
    Messages.BUS_LOADING,
    Messages.CRACK,
    Messages.GAME_KID_LOST])

  return week_one(bully)
Exemplo n.º 57
0
def week_one(bully):
  if GAME_STATE.day == 1:
    Messages.print_messages(Messages.WEEK_ONE[GAME_STATE.day])
    campers = CharacterDB.random_character_sample(cclass='Camper', count=5)
    troid = CharacterDB.find('Troid')
    people_outside_theater = campers + [troid]

    while GAME_STATE.characters_talked_to < 3:
      GAME_STATE.characters_talked_to += 1
      person = CharacterDB.choose_person(
        people_outside_theater, Messages.LEAVING_THEATER)

      GameState.GAME_STATE.already_talked_to.append('Troid')

      character_talking = person.name

      if person == troid:
        Messages.print_messages([
          Messages.TROID_DESCRIPTION,
          Messages.PERSON_TALKING % character_talking + Messages.TROID_HEY_BRO,
          Messages.PERSON_TALKING % character_talking + Messages.TROID_CONVO_ONE])

        answer = raw_input(Messages.TROID_CONVO_ONE_ANSWERS)

        if answer == '1':
          troid.dispo += 1
          Messages.print_messages([
            Messages.PERSON_TALKING % character_talking + Messages.TROID_LOVES_X])

        elif answer == '2':
          troid.dispo -= 1
          Messages.print_messages([
            Messages.PERSON_TALKING % character_talking + Messages.TROID_WHATEVER_SMELL])

        elif answer == '3':
          troid.dispo -= 1
          Messages.print_messages([
            Messages.PERSON_TALKING % character_talking + Messages.TROID_WOW])

        else:
          answer = raw_input(Messages.TROID_CONVO_ONE_ANSWERS)
Exemplo n.º 58
0
	def generate_next_request(self):
		while True:
			#Ask the Requests Manager for new Blocks to request
			piece_index,block_index = self.torrent.requester.get_next_block(self)
			if block_index < 0 or len(self.set_of_blocks_requested) >= MAX_REQUEST_TO_PEER:
				if self.torrent.file_manager.StreamCompleted == True:
					reactor.stop()
				else:
					break
			block_byte_offset = block_index*BLOCK_SIZE
			#Add this to the set of blocks requested.
			self.set_of_blocks_requested.add((piece_index,block_index))

			self.transport.write(str(Messages.Request(
				index = Messages.number_to_bytes(piece_index), 
				begin = Messages.number_to_bytes(block_byte_offset), 
				length = Messages.number_to_bytes(BLOCK_SIZE))))
			self.torrent.requester.requestSuccessful(self, piece_index,block_index)
			#Add timeout for requests.
			Logger.info("Sending Request For Piece :" + str(Messages.number_to_bytes(piece_index)) + " to " + str(self.ip))
			reactor.callLater(TIMEOUT,self.checkTimeout,piece_index,block_index)