예제 #1
0
    def submit_message(self, data, original=None):
        corpus = self.get_corpus()
        corpus.set_writable()
        if not original:
            (msg, labels) = message.create_message(corpus, data)
        else:
            doc = corpus.get_doc(original)
            (msg, labels) = message.create_message(corpus, data,
                                                   doc.get_msg(0))
            corpus.mark_deleted(original)

        # Get labels.
        # We silently ignore unknown labels,
        # because we shouldn't throw any exception.
        def get_labels(labels):
            for name in labels:
                try:
                    c = config.str2label(name)
                    yield c
                except config.UnknownLabel:
                    pass
            return

        labels = set(get_labels(labels))

        # Resolve addresses.
        # We silently ignore unresolved addresses.
        def resolve1((user, addr)):
            if user:
                return formataddr((user, addr))
            if addr in config.ADDRESS_ALIASES:
                return config.ADDRESS_ALIASES[addr]
            r = self.resolve_address(addr)
            if not r:
                return addr
            (n, x) = r[0]
            threshold = int(len(r) * config.RESOLVE_ADDRESS_RATIO + 0.5)
            if n <= threshold:
                return addr
            return x

        alt_headers = []
        for (k, v) in msg.items():
            if k.lower() in ('to', 'cc', 'bcc'):
                v = ', '.join(resolve1(addr) for addr in unicode_getaddrs(v))
                alt_headers.append((k, v))
        for (k, _) in alt_headers:
            del msg[k]
        for (k, v) in alt_headers:
            msg[k] = v

        loc = corpus.add_message(msg_repr(msg), labels)
        corpus.flush(self.notice_indexing)
        # show the edited message.
        self.select_tmp('edit', corpus, [loc])
        return loc
예제 #2
0
파일: kernel.py 프로젝트: yasusii/shaling
  def submit_message(self, data, original=None):
    corpus = self.get_corpus()
    corpus.set_writable()
    if not original:
      (msg, labels) = message.create_message(corpus, data)
    else:
      doc = corpus.get_doc(original)
      (msg, labels) = message.create_message(corpus, data, doc.get_msg(0))
      corpus.mark_deleted(original)

    # Get labels.
    # We silently ignore unknown labels,
    # because we shouldn't throw any exception.
    def get_labels(labels):
      for name in labels:
        try:
          c = config.str2label(name)
          yield c
        except config.UnknownLabel:
          pass
      return
    labels = set(get_labels(labels))
    
    # Resolve addresses.
    # We silently ignore unresolved addresses.
    def resolve1((user,addr)):
      if user:
        return formataddr((user, addr))
      if addr in config.ADDRESS_ALIASES:
        return config.ADDRESS_ALIASES[addr]
      r = self.resolve_address(addr)
      if not r:
        return addr
      (n, x) = r[0]
      threshold = int(len(r)*config.RESOLVE_ADDRESS_RATIO + 0.5)
      if n <= threshold:
        return addr
      return x
    alt_headers = []
    for (k,v) in msg.items():
      if k.lower() in ('to', 'cc', 'bcc'):
        v = ', '.join( resolve1(addr) for addr in unicode_getaddrs(v) )
        alt_headers.append((k,v))
    for (k,_) in alt_headers:
      del msg[k]
    for (k,v) in alt_headers:
      msg[k] = v
    
    loc = corpus.add_message(msg_repr(msg), labels)
    corpus.flush(self.notice_indexing)
    # show the edited message.
    self.select_tmp('edit', corpus, [loc])
    return loc
예제 #3
0
    def concat_fragments(self, fragments):
        frame = fragments[0]

        for f in fragments[1:]:
            frame.payload += f.payload

        frame.final = True
        frame = self.sock.apply_recv_hooks(frame, True)
        return create_message(frame.opcode, frame.payload)
예제 #4
0
def main():
    try:
        spend = slack.sum_spend(util.yesterday())
        if spend > 0:
            damage_message = message.create_message(spend)
            slack_api.post_message(damage_message)
    except Exception as e:
        print(e)
        raise e
예제 #5
0
 def on_receive(self, connection_handler, message):
     """ 
     on event of receiving a message from an existing connection 
     """
     if message.payload_descriptor == GnutellaBodyId.PING:
         # check if we saw this ping before. If not, then process
         forward_key = (message.message_id, GnutellaBodyId.PONG)
         now = time.time()
         not_seen_or_expire = forward_key not in self.forwarding_table or (self.forwarding_table[forward_key][1] < now)
         not_ignore_or_expire = message.message_id not in self.ignore or (self.ignore[message.message_id] < now) 
         if  not_seen_or_expire and not_ignore_or_expire:                                 
             # send Ping to any neighbor that not the one servent recceived the Ping from
             self.flood(connection_handler, message)
             # add ping to forwarding table to forward PONG
             self.put_into_forwarding_table(message, connection_handler)
             # reply with Pong (the return trip's ttl should be equals to hops)
             pong_message = create_message(GnutellaBodyId.PONG, 
                                           message.message_id, 
                                           message.hops+1,
                                           ip = self.reactor.ip,
                                           port = self.reactor.port,
                                           num_of_files = self.num_files,
                                           num_of_kb = self.num_kilobytes)
             self.log("Sending replied pong %s", pong_message)
             self.send_message(pong_message, connection_handler)
     elif message.payload_descriptor == GnutellaBodyId.PONG:
         # forwarding pong                 
         self.forward(message)
     elif message.payload_descriptor == GnutellaBodyId.QUERY:
         # check if we saw this query before. If not, then process
         forward_key = (message.message_id, GnutellaBodyId.QUERYHIT)
         now = time.time()
         not_seen_or_expire = forward_key not in self.forwarding_table or (self.forwarding_table[forward_key][1] < now)
         not_ignore_or_expire = message.message_id not in self.ignore or (self.ignore[message.message_id] < now)             
         if not_seen_or_expire and not_ignore_or_expire:
             # add to forwarding table to forward QUERYHIT
             self.put_into_forwarding_table(message, connection_handler)
             # forward query packet to neighbor servent
             self.flood(connection_handler, message)
     elif message.payload_descriptor == GnutellaBodyId.QUERYHIT:
         # don't route query hit if it is meant for this node            
         if not message.body.servent_id == self.id:
             # forwarding query hit
             if self.forward(message):
                 # add to forwarding table to forward PUSH
                 self.put_into_forwarding_table(message, connection_handler)                
     elif message.payload_descriptor == GnutellaBodyId.PUSH:
         # don't route push if it is meant for this node
         if not message.body.servent_id == self.id:
             # forward push
             self.forward(message)                
     else:
         raise ValueError('message type is not one of PING, PONG, QUERY, QUERYHIT, PUSH')
예제 #6
0
 def create_out_buffer(self, socket):
     if socket.isJson:
         socket.inBuffer.decode()
         socket.request_body = json.loads(socket.inBuffer)
         command = socket.request_body["command"]
         #if the command on the request is a supported command, we will generate a response according to the command
         #callback, otherwise we return an error to the client
         response = self.actions[command](
             socket) if command in self.actions else {
                 'error': "no such command"
             }
         socket.inBuffer = b''
         socket.outBuffer = message.create_message(response)
예제 #7
0
def send_messages(service, users, mes, subject, attachments=None):
    print(users)
    for k, v in users:
        f = m.format_message(k, mes)
        s = m.format_message(k, subject)
        if attachments:
            formed_message = m.create_message_with_attachment(v, s, f, attachments)
            print("sending to: " + k)
            m.send_message(service, "me", formed_message)
        else:
            formed_message = m.create_message(v, s, f)
            print("sending to: " + k)
            m.send_message(service, "me", formed_message)
예제 #8
0
 def handle(self, data, address):
     message = create_message(data)
     if (address[0] in settings.OWN_IP_ADDRESSES):
         return
     elif message is None:
         # discard message
         print "Datagram with unknown message received"
     elif isinstance(message, HiMessage):
         self.handle_hi_message(message, address[0])
     elif isinstance(message, YoMessage):
         self.handle_yo_message(message, address[0])
     elif isinstance(message, ByeMessage):
         self.handle_bye_message(message, address[0])
     elif isinstance(message, FileMessage):
         self.handle_file_message(message, address[0])
예제 #9
0
        t.add_row(dic.values())
    print(t)
    return


s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 50000))
greeting = read_message(s)
path = greeting["path"]
print(greeting["message"])
while True:
    inputStr = input(path + ">")
    if inputStr == "exit":
        break
    request = create_request(inputStr)
    s.send(message.create_message(request))
    response = read_message(s)
    if type(response) is dict and "error" in response:
        print(response["error"])
        continue

    command = request["command"]
    if command == 'cd':
        path = response['path']
    elif command == 'dirlist':
        print("Path: " + path)
        print("Files:")
        print_table(response['files'])
    elif command == "download":
        f = open(request["arg"], "wb")
        f.write(response)
예제 #10
0
    def listen(self):
        self.server_socket.listen(5)
        inputs = [self.server_socket]
        outputs = []
        sockets = {}

        while True:
            readable, writable, exceptional = select.select(
                inputs, outputs, inputs)
            for s in readable:
                if s is self.server_socket:
                    newSocket = s.accept()[0]
                    newSocket.setblocking(0)
                    inputs.append(newSocket)
                    sockets[newSocket] = socketData.SocketData()
                    sockets[newSocket].set_path(self.filesDir)
                    greeting = {
                        "message": "Welcome to the server",
                        "path": str(PurePath(sockets[newSocket].path))
                    }
                    sockets[newSocket].outBuffer = message.create_message(
                        greeting)
                    outputs.append(newSocket)
                else:
                    try:
                        data = s.recv(CHUNK)
                    except:
                        data = b''
                    if data:
                        if sockets[s].inSize == 0:
                            sockets[s].inSize = int(
                                data[:HEADER_SIZE].decode())
                            sockets[s].isJson = True if int(
                                data[HEADER_SIZE:HEADER_SIZE +
                                     1].decode()) else False
                            data = data[HEADER_SIZE + 1:]
                        sockets[s].inBuffer += data
                        sockets[s].inSize -= len(data)
                        if sockets[s].inSize == 0:
                            #if were done receiving a request from a socket,
                            #we are now ready to generate a response and it send back.
                            self.create_out_buffer(sockets[s])
                            outputs.append(s)
                    else:
                        if s in outputs:
                            outputs.remove(s)
                        inputs.remove(s)
                        s.close()
                        del sockets[s]

            for s in writable:
                nextPiece = sockets[s].outBuffer[:CHUNK]
                sockets[s].outBuffer = sockets[s].outBuffer[CHUNK:]
                try:
                    s.send(nextPiece)
                except:
                    outputs.remove(s)
                    continue
                if not sockets[s].outBuffer:
                    outputs.remove(s)

            for s in exceptional:
                inputs.remove(s)
                if s in outputs:
                    outputs.remove(s)
                s.close()
                del sockets[s]