Esempio n. 1
0
    def _test_with_client_delayed(self, message_list):  # pragma: no cover
        client = HelperClient(self.server_address)
        start_etag = None
        for message, expected in message_list:
            if message is not None:
                received_message = client.send_request(message)
                time.sleep(5)
            if received_message.etag is not None:
                if start_etag is None:
                    start_etag = received_message.etag
            if expected is not None:
                if expected.etag is not None:
                    if expected.etag == 1:
                        self.assertEqual(received_message, start_etag)
                    else:
                        self.assertNotEqual(received_message, start_etag)
                if expected.type is not None:
                    self.assertEqual(received_message.type, expected.type)
                if expected.mid is not None:
                    self.assertEqual(received_message.mid, expected.mid)
                self.assertEqual(received_message.code, expected.code)
                if expected.source is not None:
                    self.assertEqual(received_message.source,
                                     self.server_address)

        client.stop()
Esempio n. 2
0
 def _test_with_client_observe(self, message_list):  # pragma: no cover
     client = HelperClient(self.server_address)
     for message, expected in message_list:
         if message is not None:
             client.send_request(message, self.client_callback)
         if expected is not None:
             received_message = self.queue.get()
             if expected.type is not None:
                 self.assertEqual(received_message.type, expected.type)
             if expected.mid is not None:
                 self.assertEqual(received_message.mid, expected.mid)
             self.assertEqual(received_message.code, expected.code)
             if expected.source is not None:
                 self.assertEqual(received_message.source, self.server_address)
             if expected.token is not None:
                 self.assertEqual(received_message.token, expected.token)
             if expected.payload is not None:
                 self.assertEqual(received_message.payload, expected.payload)
             if expected.options:
                 self.assertEqual(len(received_message.options), len(expected.options))
                 for o in expected.options:
                     assert isinstance(o, Option)
                     option_value = getattr(expected, o.name.lower().replace("-", "_"))
                     option_value_rec = getattr(received_message, o.name.lower().replace("-", "_"))
                     self.assertEqual(option_value, option_value_rec)
     client.stop()
Esempio n. 3
0
    def _test_with_client_delayed(self, message_list):  # pragma: no cover
        client = HelperClient(self.server_address)
        for message, expected in message_list:
            if message is not None:
                received_message = client.send_request(message)
                time.sleep(5)

            if expected is not None:
                if expected.etag is not None:
                    self.assertEqual(received_message.etag, expected.etag)
                if expected.type is not None:
                    self.assertEqual(received_message.type, expected.type)
                if expected.mid is not None:
                    self.assertEqual(received_message.mid, expected.mid)
                self.assertEqual(received_message.code, expected.code)
                if expected.source is not None:
                    self.assertEqual(received_message.source, self.server_address)
                if expected.token is not None:
                    self.assertEqual(received_message.token, expected.token)
                if expected.payload is not None:
                    self.assertEqual(received_message.payload, expected.payload)
                if expected.max_age is not None:
                    if expected.max_age != 60:
                        self.assertNotEqual(received_message.max_age, 60)
                    else:
                        self.assertEqual(received_message.max_age, expected.max_age)
                if expected.options:
                    self.assertEqual(len(received_message.options), len(expected.options))
                    for o in expected.options:
                        assert isinstance(o, Option)
                        if o.name != defines.OptionRegistry.MAX_AGE.name and o.name != defines.OptionRegistry.ETAG.name:
                            option_value = getattr(expected, o.name.lower().replace("-", "_"))
                            option_value_rec = getattr(received_message, o.name.lower().replace("-", "_"))
                            self.assertEqual(option_value, option_value_rec)
        client.stop()
Esempio n. 4
0
    def _test_with_client_delayed(self, message_list):  # pragma: no cover
        client = HelperClient(self.server_address)
        for message, expected in message_list:
            if message is not None:
                received_message = client.send_request(message)
                time.sleep(5)

            if expected is not None:
                if expected.etag is not None:
                    self.assertEqual(received_message.etag, expected.etag)
                if expected.type is not None:
                    self.assertEqual(received_message.type, expected.type)
                if expected.mid is not None:
                    self.assertEqual(received_message.mid, expected.mid)
                self.assertEqual(received_message.code, expected.code)
                if expected.source is not None:
                    self.assertEqual(received_message.source, self.server_address)
                if expected.token is not None:
                    self.assertEqual(received_message.token, expected.token)
                if expected.payload is not None:
                    self.assertEqual(received_message.payload, expected.payload)
                if expected.max_age is not None:
                    if expected.max_age != 60:
                        self.assertNotEqual(received_message.max_age, 60)
                    else:
                        self.assertEqual(received_message.max_age, expected.max_age)
                if expected.options:
                    self.assertEqual(len(received_message.options), len(expected.options))
                    for o in expected.options:
                        assert isinstance(o, Option)
                        if o.name != defines.OptionRegistry.MAX_AGE.name and o.name != defines.OptionRegistry.ETAG.name:
                            option_value = getattr(expected, o.name.lower().replace("-", "_"))
                            option_value_rec = getattr(received_message, o.name.lower().replace("-", "_"))
                            self.assertEqual(option_value, option_value_rec)
        client.stop()
Esempio n. 5
0
 def _test_with_client(self, message_list):  # pragma: no cover
     client = HelperClient(self.server_address)
     for message, expected in message_list:
         if message is not None:
             received_message = client.send_request(message)
         if expected is not None:
             # print(received_message.payload)
             # print(expected.payload)
             if expected.type is not None:
                 self.assertEqual(received_message.type, expected.type)
             if expected.mid is not None:
                 self.assertEqual(received_message.mid, expected.mid)
             self.assertEqual(received_message.code, expected.code)
             if expected.source is not None:
                 self.assertEqual(received_message.source,
                                  self.server_address)
             if expected.token is not None:
                 self.assertEqual(received_message.token, expected.token)
             if expected.payload is not None:
                 self.assertEqual(received_message.payload,
                                  expected.payload)
             if expected.options is not None:
                 self.assertEqual(received_message.options,
                                  expected.options)
                 for o in expected.options:
                     option_value = getattr(
                         expected,
                         o.name.lower().replace("-", "_"))
                     option_value_rec = getattr(
                         received_message,
                         o.name.lower().replace("-", "_"))
                     self.assertEqual(option_value, option_value_rec)
     client.stop()
Esempio n. 6
0
    def _forward_request(transaction, destination, path):
        """
        Forward requests.

        :type transaction: Transaction
        :param transaction: the transaction that owns the request
        :param destination: the destination of the request (IP, port)
        :param path: the path of the request.
        :rtype : Transaction
        :return: the edited transaction
        """
        client = HelperClient(destination)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = path
        request.destination = destination
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        return transaction
Esempio n. 7
0
 def discover_remote(self, destination, name):
     assert (isinstance(destination, str))
     split = destination.split(":", 1)
     host = split[0]
     port = int(split[1])
     server = (host, port)
     client = HelperClient(server)
     response = client.discover()
     client.stop()
     self.discover_remote_results(response, name)
Esempio n. 8
0
 def discover_remote(self, destination, name):
     assert isinstance(destination, str)
     split = destination.split(":", 1)
     host = split[0]
     port = int(split[1])
     server = (host, port)
     client = HelperClient(server)
     response = client.discover()
     client.stop()
     self.discover_remote_results(response, name)
Esempio n. 9
0
    def _handle_request(self, transaction, new_resource):
        """
        Forward requests. Used by reverse proxies to also create new virtual resources on the proxy 
        in case of created resources
        
        :type new_resource: bool
        :type transaction: Transaction
        :param transaction: the transaction that owns the request
        :rtype : Transaction
        :param new_resource: if the request will generate a new resource 
        :return: the edited transaction
        """
        client = HelperClient(transaction.resource.remote_server)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = "/".join(
            transaction.request.uri_path.split("/")[1:])
        request.destination = transaction.resource.remote_server
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        logger.info("forward_request - " + str(request))
        response = client.send_request(request)
        client.stop()
        logger.info("forward_response - " + str(response))
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        if response.code == defines.Codes.CREATED.number:
            lp = transaction.response.location_path
            del transaction.response.location_path
            transaction.response.location_path = transaction.request.uri_path.split(
                "/")[0] + "/" + lp
            # TODO handle observing
            if new_resource:
                resource = RemoteResource('server',
                                          transaction.resource.remote_server,
                                          lp,
                                          coap_server=self,
                                          visible=True,
                                          observable=False,
                                          allow_children=True)
                self._server.add_resource(transaction.response.location_path,
                                          resource)
        if response.code == defines.Codes.DELETED.number:
            del self._server.root["/" + transaction.request.uri_path]
        return transaction
Esempio n. 10
0
 def _test_with_client_observe(self, message_list,
                               callback):  # pragma: no cover
     client = HelperClient(self.server_address)
     token = None
     last_mid = 0
     for message, expected in message_list:
         if message is not None:
             token = message.token
             client.send_request(message, callback)
         received_message = self.queue.get()
         if expected is not None:
             last_mid = expected.mid
             if expected.type is not None:
                 self.assertEqual(received_message.type, expected.type)
             if expected.mid is not None:
                 self.assertEqual(received_message.mid, expected.mid)
             self.assertEqual(received_message.code, expected.code)
             if expected.source is not None:
                 self.assertEqual(received_message.source,
                                  self.server_address)
             if expected.token is not None:
                 self.assertEqual(received_message.token, expected.token)
             if expected.payload is not None:
                 self.assertEqual(received_message.payload,
                                  expected.payload)
             if expected.options is not None:
                 self.assertEqual(received_message.options,
                                  expected.options)
     message = Message()
     message.type = defines.Types["RST"]
     message.token = token
     message._mid = last_mid
     message.destination = self.server_address
     client.send_empty(message)
     client.stop()
Esempio n. 11
0
    def _handle_request(self, transaction, new_resource):
        """
        Forward requests. Used by reverse proxies to also create new virtual resources on the proxy 
        in case of created resources
        
        :type new_resource: bool
        :type transaction: Transaction
        :param transaction: the transaction that owns the request
        :rtype : Transaction
        :param new_resource: if the request will generate a new resource 
        :return: the edited transaction
        """
        client = HelperClient(transaction.resource.remote_server)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = "/".join(transaction.request.uri_path.split("/")[1:])
        request.destination = transaction.resource.remote_server
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        if response.code == defines.Codes.CREATED.number:
            lp = transaction.response.location_path
            del transaction.response.location_path
            transaction.response.location_path = transaction.request.uri_path.split("/")[0] + "/" + lp
            # TODO handle observing
            if new_resource:
                resource = RemoteResource('server', transaction.resource.remote_server, lp, coap_server=self,
                                          visible=True,
                                          observable=False,
                                          allow_children=True)
                self._server.add_resource(transaction.response.location_path, resource)
        if response.code == defines.Codes.DELETED.number:
            del self._server.root["/" + transaction.request.uri_path]
        return transaction
Esempio n. 12
0
 def _test_with_client_observe(self, message_list, callback):
     client = HelperClient(self.server_address)
     token = None
     last_mid = 0
     for message, expected in message_list:
         if message is not None:
             token = message.token
             client.send_request(message, callback)
         received_message = self.queue.get()
         if expected is not None:
             last_mid = expected.mid
             if expected.type is not None:
                 self.assertEqual(received_message.type, expected.type)
             if expected.mid is not None:
                 self.assertEqual(received_message.mid, expected.mid)
             self.assertEqual(received_message.code, expected.code)
             if expected.source is not None:
                 self.assertEqual(received_message.source, self.server_address)
             if expected.token is not None:
                 self.assertEqual(received_message.token, expected.token)
             if expected.payload is not None:
                 self.assertEqual(received_message.payload, expected.payload)
             if expected.options is not None:
                 self.assertEqual(received_message.options, expected.options)
     message = Message()
     message.type = defines.Types["RST"]
     message.token = token
     message._mid = last_mid
     message.destination = self.server_address
     client.send_empty(message)
     client.stop()
Esempio n. 13
0
    def _handle_request(self, transaction, new_resource):
        client = HelperClient(transaction.resource.remote_server)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = "/".join(
            transaction.request.uri_path.split("/")[1:])
        request.destination = transaction.resource.remote_server
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        if response.code == defines.Codes.CREATED.number:
            lp = transaction.response.location_path
            del transaction.response.location_path
            transaction.response.location_path = transaction.request.uri_path.split(
                "/")[0] + "/" + lp
            # TODO handle observing
            if new_resource:
                resource = RemoteResource('server',
                                          transaction.resource.remote_server,
                                          lp,
                                          coap_server=self,
                                          visible=True,
                                          observable=False,
                                          allow_children=True)
                self._server.add_resource(transaction.response.location_path,
                                          resource)
        if response.code == defines.Codes.DELETED.number:
            del self._server.root["/" + transaction.request.uri_path]
        return transaction
Esempio n. 14
0
 def _test_with_client(self, message_list):
     client = HelperClient(self.server_address)
     for message, expected in message_list:
         if message is not None:
             received_message = client.send_request(message)
         if expected is not None:
             if expected.type is not None:
                 self.assertEqual(received_message.type, expected.type)
             if expected.mid is not None:
                 self.assertEqual(received_message.mid, expected.mid)
             self.assertEqual(received_message.code, expected.code)
             if expected.source is not None:
                 self.assertEqual(received_message.source, self.server_address)
             if expected.token is not None:
                 self.assertEqual(received_message.token, expected.token)
             if expected.payload is not None:
                 self.assertEqual(received_message.payload, expected.payload)
             if expected.options is not None:
                 self.assertEqual(received_message.options, expected.options)
     client.stop()
Esempio n. 15
0
 def _test_with_client_observe(self, message_list):  # pragma: no cover
     client = HelperClient(self.server_address)
     for message, expected in message_list:
         if message is not None:
             client.send_request(message, self.client_callback)
         if expected is not None:
             received_message = self.queue.get()
             if expected.type is not None:
                 self.assertEqual(received_message.type, expected.type)
             if expected.mid is not None:
                 self.assertEqual(received_message.mid, expected.mid)
             self.assertEqual(received_message.code, expected.code)
             if expected.source is not None:
                 self.assertEqual(received_message.source,
                                  self.server_address)
             if expected.token is not None:
                 self.assertEqual(received_message.token, expected.token)
             if expected.payload is not None:
                 self.assertEqual(received_message.payload,
                                  expected.payload)
             if expected.options:
                 self.assertEqual(len(received_message.options),
                                  len(expected.options))
                 for o in expected.options:
                     assert isinstance(o, Option)
                     option_value = getattr(
                         expected,
                         o.name.lower().replace("-", "_"))
                     option_value_rec = getattr(
                         received_message,
                         o.name.lower().replace("-", "_"))
                     self.assertEqual(option_value, option_value_rec)
     client.stop()
Esempio n. 16
0
    def _forward_request(transaction, destination, path):
        client = HelperClient(destination)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = path
        request.destination = destination
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        return transaction
Esempio n. 17
0
    def _forward_request(transaction, destination, path):
        client = HelperClient(destination)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = path
        request.destination = destination
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        return transaction
Esempio n. 18
0
    def _forward_request(transaction, destination, path):
        """
        Forward requests.

        :type transaction: Transaction
        :param transaction: the transaction that owns the request
        :param destination: the destination of the request (IP, port)
        :param path: the path of the request.
        :rtype : Transaction
        :return: the edited transaction
        """
        client = HelperClient(destination)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = path
        request.destination = destination
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        if response is not None:
            transaction.response.payload = response.payload
            transaction.response.code = response.code
            transaction.response.options = response.options
        else:
            transaction.response.code = defines.Codes.SERVICE_UNAVAILABLE.number

        return transaction
Esempio n. 19
0
    def _handle_request(self, transaction, new_resource):
        client = HelperClient(transaction.resource.remote_server)
        request = Request()
        request.options = copy.deepcopy(transaction.request.options)
        del request.block2
        del request.block1
        del request.uri_path
        del request.proxy_uri
        del request.proxy_schema
        # TODO handle observing
        del request.observe
        # request.observe = transaction.request.observe

        request.uri_path = "/".join(transaction.request.uri_path.split("/")[1:])
        request.destination = transaction.resource.remote_server
        request.payload = transaction.request.payload
        request.code = transaction.request.code
        response = client.send_request(request)
        client.stop()
        transaction.response.payload = response.payload
        transaction.response.code = response.code
        transaction.response.options = response.options
        if response.code == defines.Codes.CREATED.number:
            lp = transaction.response.location_path
            del transaction.response.location_path
            transaction.response.location_path = transaction.request.uri_path.split("/")[0] + "/" + lp
            # TODO handle observing
            if new_resource:
                resource = RemoteResource('server', transaction.resource.remote_server, lp, coap_server=self,
                                          visible=True,
                                          observable=False,
                                          allow_children=True)
                self._server.add_resource(transaction.response.location_path, resource)
        if response.code == defines.Codes.DELETED.number:
            del self._server.root["/" + transaction.request.uri_path]
        return transaction
Esempio n. 20
0
def callback():
    try:
        index = listbox.curselection()[0]
        # get the line's text
        server_text = str(listbox.get(index))
        if (server_text == ""):
            print "ERROR : Empty selection"
            return
    except:
        print "ERROR !"
        return AttributeError
    proxy_texter = str(label_proxy.cget("text"))
    text_test = path_text.get("1.0", END)
    path_texter = str(text_test)
    print "Selected : " + str(server_text)
    print "chosen path : " + str(path_texter)
    server_text = "198.199.92.83"
    proxy_texter = "104.236.174.175"
    # Setting up the application
    setup_time_begin = time.time()
    server_address = (str(proxy_texter), 5684)
    current_mid = random.randint(1, 1000)
    client = HelperClient(server_address)
    setup_time_end = time.time()

    print "Starting the first request"
    print "\nRequesting for Resource 1"
    first_request_begin = time.time()
    # Starting first request
    path = "/basic1"
    req = Request()
    req._usecache = use_cache
    req.code = defines.Codes.GET.number
    req.uri_path = path
    req.type = defines.Types["CON"]
    req._mid = current_mid
    req.destination = server_address
    req.proxy_uri = "coap://" + str(server_text) + ":5683/basic1"
    received_message = client.send_request(req)
    first_request_end = time.time()
    time.sleep(5)

    print "Starting the second request"
    print "\nRequesting for Resource 2"
    second_request_begin = time.time()
    # Starting second request
    current_mid = current_mid + 1
    req2 = Request()
    req2._usecache = use_cache
    req2.code = defines.Codes.GET.number
    path = "/basic2"
    req2.uri_path = path
    req2.type = defines.Types["CON"]
    req2._mid = current_mid
    req2.destination = server_address
    req2.proxy_uri = "coap://" + server_text + ":5683/basic2"
    received_message = client.send_request(req2)
    second_request_end = time.time()

    time.sleep(5)

    print "Starting the third request"
    print "\nRequesting for Resource 3"
    third_request_begin = time.time()
    # Starting third request
    current_mid = current_mid + 1
    req3 = Request()
    req3._usecache = use_cache
    req3.code = defines.Codes.GET.number
    path = "/basic3"
    req3.uri_path = path
    req3.type = defines.Types["CON"]
    req3._mid = current_mid
    req3.destination = server_address
    req3.proxy_uri = "coap://" + server_text + ":5683/basic3"
    received_message = client.send_request(req3)
    third_request_end = time.time()
    time.sleep(5)

    print "Starting the fourth request"
    print "\nRequesting for Resource 1 again"
    fourth_request_begin = time.time()
    # Starting first request
    path = "/basic1"
    current_mid = current_mid + 1
    req4 = Request()
    req4._usecache = use_cache
    req4.code = defines.Codes.GET.number
    req4.uri_path = path
    req4.type = defines.Types["CON"]
    req4._mid = current_mid
    req4.destination = server_address
    req4.proxy_uri = "coap://" + server_text + ":5683/basic1"
    received_message = client.send_request(req4)
    fourth_request_end = time.time()
    time.sleep(5)

    print "Starting the fifth request"
    print "\nRequesting for Resource 2 again"
    fifth_request_begin = time.time()
    # Starting second request
    current_mid = current_mid + 1
    req5 = Request()
    req5._usecache = use_cache
    req5.code = defines.Codes.GET.number
    path = "/basic2"
    req5.uri_path = path
    req5.type = defines.Types["CON"]
    req5._mid = current_mid
    req5.destination = server_address
    req5.proxy_uri = "coap://" + server_text + ":5683/basic2"
    received_message = client.send_request(req5)
    fifth_request_end = time.time()
    time.sleep(5)

    print "Starting the sixth request"
    print "\nRequesting for Resource 3 again"
    # Starting third request
    sixth_request_begin = time.time()
    current_mid = current_mid + 1
    req6 = Request()
    req6._usecache = use_cache
    req6.code = defines.Codes.GET.number
    path = "/basic3"
    req6.uri_path = path
    req6.type = defines.Types["CON"]
    req6._mid = current_mid
    req6.destination = server_address
    req6.proxy_uri = "coap://" + server_text + ":5683/basic3"
    received_message = client.send_request(req6)
    sixth_request_end = time.time()
    time.sleep(5)

    print "Starting the seventh request"
    print "\nRequesting for Resource 4"
    seventh_request_begin = time.time()
    # Starting first request
    path = "/basic4"
    current_mid = current_mid + 1
    req7 = Request()
    req7._usecache = use_cache
    req7.code = defines.Codes.GET.number
    req7.uri_path = path
    req7.type = defines.Types["CON"]
    req7._mid = current_mid
    req7.destination = server_address
    req7.proxy_uri = "coap://" + server_text + ":5683/basic4"
    received_message = client.send_request(req7)
    seventh_request_end = time.time()
    time.sleep(5)

    print "Starting the eighth request"
    print "\nRequesting for Resource 5"
    eighth_request_begin = time.time()
    # Starting second request
    current_mid = current_mid + 1
    req8 = Request()
    req8._usecache = use_cache
    req8.code = defines.Codes.GET.number
    path = "/basic5"
    req8.uri_path = path
    req8.type = defines.Types["CON"]
    req8._mid = current_mid
    req8.destination = server_address
    req8.proxy_uri = "coap://" + server_text + ":5683/basic5"
    received_message = client.send_request(req8)
    eighth_request_end = time.time()
    time.sleep(5)

    print "Starting the ninth request"
    print "\nRequesting for Resource 6"
    ninth_request_begin = time.time()
    # Starting third request
    current_mid = current_mid + 1
    req9 = Request()
    req9._usecache = use_cache
    req9.code = defines.Codes.GET.number
    path = "/basic6"
    req9.uri_path = path
    req9.type = defines.Types["CON"]
    req9._mid = current_mid
    req9.destination = server_address
    req9.proxy_uri = "coap://" + server_text + ":5683/basic6"
    received_message = client.send_request(req9)
    ninth_request_end = time.time()
    time.sleep(5)

    print "Starting the tenth request"
    print "\nRequesting for Resource 4 again"
    tenth_request_begin = time.time()
    # Starting third request
    current_mid = current_mid + 1
    req10 = Request()
    req10._usecache = use_cache
    req10.code = defines.Codes.GET.number
    path = "/basic4"
    req10.uri_path = path
    req10.type = defines.Types["CON"]
    req10._mid = current_mid
    req10.destination = server_address
    req10.proxy_uri = "coap://" + server_text + ":5683/basic4"
    received_message = client.send_request(req10)
    tenth_request_end = time.time()
    time.sleep(5)

    print "Starting the eleven request"
    print "\nRequesting for Resource 7"
    eleventh_request_begin = time.time()
    # Starting third request
    current_mid = current_mid + 1
    req11 = Request()
    req11._usecache = use_cache
    req11.code = defines.Codes.GET.number
    path = "/basic7"
    req11.uri_path = path
    req11.type = defines.Types["CON"]
    req11._mid = current_mid
    req11.destination = server_address
    req11.proxy_uri = "coap://" + server_text + ":5683/basic7"
    received_message = client.send_request(req11)
    eleventh_request_end = time.time()
    print "Tearing down application"
    # Tearing down application
    print "DONE !"
    print "-------------------"
    print "Printing Analytics"
    print "--------------------"
    print "Build Time : " + str(setup_time_end - setup_time_begin)
    print "First request : " + str(first_request_end - first_request_begin)
    print "Second request : " + str(second_request_end - second_request_begin)
    print "Third request : " + str(third_request_end - third_request_begin)
    print "Fourth request : " + str(fourth_request_end - fourth_request_begin)
    print "Fifth request : " + str(fifth_request_end - fifth_request_begin)
    print "Sixth request : " + str(sixth_request_end - sixth_request_begin)
    print "Seventh request : " + str(seventh_request_end -
                                     seventh_request_begin)
    print "Eighth request : " + str(eighth_request_end - eighth_request_begin)
    print "Ninth request : " + str(ninth_request_end - ninth_request_begin)
    print "Tenth request : " + str(tenth_request_end - tenth_request_begin)
    print "Eleventh request : " + str(eleventh_request_end -
                                      eleventh_request_begin)
    print "--------------------------"
    print "TOTAL TIME TAKEN : " + str(
        (first_request_end - first_request_begin) +
        (second_request_end - second_request_begin) +
        (third_request_end - third_request_begin) +
        (fourth_request_end - fourth_request_begin) +
        (fifth_request_end - fifth_request_begin) +
        (sixth_request_end - sixth_request_begin) +
        (seventh_request_end - seventh_request_begin) +
        (eighth_request_end - eighth_request_begin) +
        (ninth_request_end - ninth_request_begin) +
        (tenth_request_end - tenth_request_begin) +
        (eleventh_request_end - eleventh_request_begin))
    print "--------------------------"
Esempio n. 21
0
def callback():
    try:
        index = listbox.curselection()[0]
        # get the line's text
        server_text = str(listbox.get(index))
        if (server_text == ""):
            print "ERROR : Empty selection"
            return
    except:
        print "ERROR !"
        return AttributeError
    proxy_texter = str(label_proxy.cget("text"))
    text_test = path_text.get("1.0", END)
    path_texter = str(text_test)
    print "Selected : " + str(server_text)
    print "chosen path : " + str(path_texter)
    server_text = "198.199.92.83"
    proxy_texter = "104.236.174.175"
    # Setting up the application
    setup_time_begin = time.time()
    server_address = (str(proxy_texter), 5684)
    current_mid = random.randint(1, 1000)
    client = HelperClient(server_address)
    setup_time_end = time.time()

    print "Starting the first request"
    print "\nRequesting for Resource 1"
    first_request_begin = time.time()
    # Starting first request
    path = "/basic1"
    req = Request()
    req._usecache = use_cache
    req.code = defines.Codes.GET.number
    req.uri_path = path
    req.type = defines.Types["CON"]
    req._mid = current_mid
    req.destination = server_address
    req.proxy_uri = "coap://" + str(server_text) + ":5683/basic1"
    received_message = client.send_request(req)
    first_request_end = time.time()
    time.sleep(21)

    print "Starting the second request"
    print "\nRequesting for Resource 1 again"
    second_request_begin = time.time()
    # Starting second request
    current_mid = current_mid + 1
    req2 = Request()
    req2._usecache = use_cache
    req2.code = defines.Codes.GET.number
    path = "/basic1"
    req2.uri_path = path
    req2.type = defines.Types["CON"]
    req2._mid = current_mid
    req2.destination = server_address
    req2.proxy_uri = "coap://" + server_text + ":5683/basic1"
    received_message = client.send_request(req2)
    second_request_end = time.time()

    time.sleep(5)

    print "Tearing down application"
    # Tearing down application
    print "DONE !"
    print "-------------------"
    print "Printing Analytics"
    print "--------------------"
    print "Build Time : " + str(setup_time_end - setup_time_begin)
    print "First request : " + str(first_request_end - first_request_begin)
    print "Second request : " + str(second_request_end - second_request_begin)
    print "--------------------------"
    print "TOTAL TIME TAKEN : " + str(
        (second_request_end - second_request_begin) +
        (first_request_end - first_request_begin))
    print "--------------------------"