예제 #1
0
파일: ffLifx.py 프로젝트: zpriddy/Firefly
  def sendAll(self, args={}):
    logging.critical('Setting All Lights')

    data = args.get('lightCommand')

    url = self._api_url + 'all/state'
    treq.put(url, headers=self.header, data=data)
    #if r.status_code == 200:
    return True
예제 #2
0
    def sendAll(self, args={}):
        logging.critical('Setting All Lights')

        data = args.get('lightCommand')

        url = self._api_url + 'all/state'
        treq.put(url, headers=self.header, data=data)
        #if r.status_code == 200:
        return True
예제 #3
0
def test_no_read_permissions_queue_read_failure(admin_user):
    """
    Assert an errback occurs when unable to read from the queue due to
    permissions. This is a bit weird because the consumer has permission to
    register itself, but not to actually read from the queue so the result is
    what errors back.
    """
    url = "{base}permissions/%2F/{user}".format(base=HTTP_API, user=admin_user)
    body = {"configure": ".*", "write": ".*", "read": ""}
    resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)
    assert resp.code == 204

    queue = str(uuid.uuid4())
    queues = {
        queue: {
            "auto_delete": False,
            "arguments": {
                "x-expires": 60 * 1000
            }
        }
    }

    amqp_url = "amqp://{user}:guest@localhost:5672/%2F".format(user=admin_user)
    with mock.patch.dict(config.conf, {"amqp_url": amqp_url}):
        consumers = yield api.twisted_consume(lambda x: x, [], queues)
    _add_timeout(consumers[0].result, 5)
    try:
        yield consumers[0].result
        pytest.fail("Call failed to raise an exception")
    except exceptions.PermissionException as e:
        assert e.reason == (
            "ACCESS_REFUSED - access to queue '{}' in vhost '/' refused for user "
            "'{}'".format(queue, admin_user))
    except (defer.TimeoutError, defer.CancelledError):
        pytest.fail("Timeout reached without consumer calling its errback!")
예제 #4
0
    def put_doc(self, uuid, doc_id, content):
        """
        Make a PUT request to Soledad's incoming API, delivering a message into
        user's database.

        :param uuid: The uuid of a user
        :type uuid: str
        :param content: Message content.
        :type content: str

        :return: A deferred which fires after the HTTP request is complete, or
                 which fails with the correspondent exception if there was any
                 error.
        """
        url = self._incoming_url + "%s/%s" % (uuid, doc_id)
        try:
            response = yield treq.put(
                url,
                BytesIO(str(content)),
                headers=self._auth_header,
                persistent=False)
        except Exception as original_exception:
            error_message = "Server unreacheable or unknown error: %s"
            error_message %= (original_exception.message)
            our_exception = UnavailableIncomingAPIException(error_message)
            raise_from(our_exception, original_exception)
        if not response.code == 200:
            error_message = '%s returned status %s instead of 200'
            error_message %= (url, response.code)
            raise UnavailableIncomingAPIException(error_message)
예제 #5
0
def admin_user():
    """
    Fixture that creates a random admin user and deletes the user afterwards.

    Useful if the test wishes to alter permissions to test failure cases. Default
    permissions is complete access to the "/" vhost.

    Returns:
        The username of the new administrator. The password is "guest".
    """
    # Create a user with no permissions
    username = str(uuid.uuid4())
    url = "{base}users/{user}".format(base=HTTP_API, user=username)
    body = {"username": username, "password": "******", "tags": "administrator"}
    deferred_resp = treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)

    @pytest_twisted.inlineCallbacks
    def cp(resp):
        assert resp.code == 201
        url = "{base}permissions/%2F/{user}".format(base=HTTP_API,
                                                    user=username)
        body = {"configure": ".*", "write": ".*", "read": ".*"}
        resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)
        assert resp.code == 201

    deferred_resp.addCallbacks(cp, cp)
    pytest_twisted.blockon(deferred_resp)
    yield username

    # Cleanup
    deferred_resp = treq.delete(url, auth=HTTP_AUTH, timeout=3)
    pytest_twisted.blockon(deferred_resp)
예제 #6
0
 def cp(resp):
     assert resp.code == 201
     url = "{base}permissions/%2F/{user}".format(base=HTTP_API,
                                                 user=username)
     body = {"configure": ".*", "write": ".*", "read": ".*"}
     resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)
     assert resp.code == 201
예제 #7
0
def test_no_read_permissions_queue_read_failure_pika1(admin_user,
                                                      queue_and_binding):
    """
    Assert an errback occurs when unable to read from the queue due to
    permissions. This is a bit weird because the consumer has permission to
    register itself, but not to actually read from the queue so the result is
    what errors back.
    """
    queues, bindings = queue_and_binding
    url = "{base}permissions/%2F/{user}".format(base=HTTP_API, user=admin_user)
    body = {"configure": ".*", "write": ".*", "read": ""}
    resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)
    assert resp.code == 204

    amqp_url = "amqp://{user}:guest@localhost:5672/%2F".format(user=admin_user)
    with mock.patch.dict(config.conf, {"amqp_url": amqp_url}):
        try:
            consumers = api.twisted_consume(lambda x: x, [], queues)
            _add_timeout(consumers, 5)
            yield consumers
            pytest.fail("Call failed to raise an exception")
        except exceptions.PermissionException as e:
            assert e.reason == (
                "ACCESS_REFUSED - access to queue '{}' in vhost '/' refused for user "
                "'{}'".format(list(queues.keys())[0], admin_user))
        except (defer.TimeoutError, defer.CancelledError):
            pytest.fail(
                "Timeout reached without consumer calling its errback!")
예제 #8
0
    def replace_group_config(self, rcs, replacement_config):
        """
        Replace the current group configuration with the provided config
        and update the stored groupConfiguration information.

        :param TestResources rcs: The integration test resources instance.
            This provides useful information to complete the request, like
            which endpoint to use to make the API request.
        :param dict replacement_config: A dictionary representation of
            the JSON description of a scaling group groupConfiguration
            Note that since this is a replacement config, all fields
            in the JSON descirptor are mandatory.

        """
        def record_results(_, replacement_config):
            # Replace the stored value in the group_config
            self.group_config["groupConfiguration"] = replacement_config
            # Find the correct group from the list (by id)
            for g in rcs.groups:
                if g['group']['id'] == self.group_id:
                    g['group']['groupConfiguration'] = replacement_config
            if verbosity > 0:
                print('Update group_config with {}'.format(replacement_config))
            return rcs

        return (treq.put(
            "{0}/groups/{1}/config".format(rcs.endpoints["otter"],
                                           self.group_id),
            json.dumps(replacement_config),
            headers=headers(str(rcs.token)),
            pool=self.pool,
        ).addCallback(check_success,
                      [204]).addCallback(record_results, replacement_config))
예제 #9
0
    def start_responding(self, server_name, challenge, response):
        validation = _validation(response)
        full_name = challenge.validation_domain_name(server_name)
        # subdomain = _split_zone(full_name, self._zone_name)
        zones_list_url = str(base.child("zones").set("name", self._zone_name))

        response = yield treq.get(zones_list_url, headers=self._headers())
        data = yield response.json()
        assert len(data['result']) == 1
        zone_id = data['result'][0]['id']
        records_base = base.child("zones").child(zone_id).child("dns_records")
        records_query_url = str(
            records_base.set("type", "TXT").set("name", full_name))
        response = yield treq.get(records_query_url, headers=self._headers())
        data = yield response.json()
        records = data['result']
        dns_record = {
            "type": "TXT",
            "ttl": 120,
            "name": full_name,
            "content": validation
        }
        if records:
            put_to = str(records_base.child(records[0]["id"]))
            response = yield treq.put(put_to,
                                      json=dns_record,
                                      headers=self._headers())
        else:
            post_to = str(records_base)
            response = yield treq.post(post_to,
                                       json=dns_record,
                                       headers=self._headers())
        yield response.json()
        yield deferLater(self._reactor, self._settle_delay, lambda: None)
예제 #10
0
def test_no_write_permissions(admin_user):
    """Assert the call to twisted_consume errbacks on write permissions errors."""
    url = "{base}permissions/%2F/{user}".format(base=HTTP_API, user=admin_user)
    body = {"configure": ".*", "write": "", "read": ".*"}
    resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)
    assert resp.code == 204

    queue = str(uuid.uuid4())
    queues = {
        queue: {
            "auto_delete": False,
            "arguments": {
                "x-expires": 60 * 1000
            }
        }
    }
    bindings = [{
        "queue": queue,
        "exchange": "amq.topic",
        "routing_keys": ["#"]
    }]

    amqp_url = "amqp://{user}:guest@localhost:5672/%2F".format(user=admin_user)
    try:
        with mock.patch.dict(config.conf, {"amqp_url": amqp_url}):
            yield api.twisted_consume(lambda x: x, bindings, queues)
        pytest.fail("Call failed to raise an exception")
    except exceptions.BadDeclaration as e:
        assert e.reason.args[0] == 403
        assert e.reason.args[1] == (
            "ACCESS_REFUSED - access to queue '{}' in vhost '/' refused for user"
            " '{}'".format(queue, admin_user))
예제 #11
0
 def set(self, key, value):
     value_serialized = json.dumps(value).encode()
     response = yield treq.put('{}/v2/keys/{}/{}'.format(self._select_host(), self._prefix, key),
                               data={'value': value_serialized},
                               headers={'Content-Type': ['application/x-www-form-urlencoded']})
     if response.code != 200:
         pass
     print(response.code)
예제 #12
0
파일: test2.py 프로젝트: arbal/scratchbox
 def set(self, key, value):
     value_serialized = json.dumps(value).encode()
     response = yield treq.put(
         '{}/v2/keys/{}/{}'.format(self._select_host(), self._prefix, key),
         data={'value': value_serialized},
         headers={'Content-Type': ['application/x-www-form-urlencoded']})
     if response.code != 200:
         pass
     print(response.code)
예제 #13
0
 def _put(self, path, headers, data):
     response = yield treq.put(path,
                               data=data,
                               agent=self.custom_agent,
                               headers=headers)
     content = yield treq.content(response)
     final_response = self.decode_results(content,
                                          self.response_headers(response),
                                          response.code, response.phrase)
     returnValue(final_response)
예제 #14
0
 def upload(self, local_path):
     log.debug("Uploading %s...", local_path)
     with open(local_path, 'rb') as f:
         resp = yield treq.put('{}uri'.format(self.nodeurl), f)
     if resp.code == 200:
         content = yield treq.content(resp)
         log.debug("Successfully uploaded %s", local_path)
         return content.decode('utf-8')
     content = yield treq.content(resp)
     raise TahoeWebError(content.decode('utf-8'))
예제 #15
0
 def upload(url, log_identifier, delay=0):
     logfile = open(path, "rb")
     if delay != 0:
         reactor.callLater(delay, upload, url, log_identifier=log_identifier)
     else:
         # FIXME persistent=False is a workaround to help with some
         # problems in unit testing.
         deferred = treq.put(url=url, data=logfile, headers={"Content-Type": ["text/csv"]}, persistent=False)
         deferred.addCallback(lambda x: result_callback(url, log_identifier, x))
         deferred.addErrback(lambda x: error_callback(url, log_identifier, x))
예제 #16
0
    def test_put_incoming_creates_a_document_using_couch(self):
        self.prepare('couch')
        user_id, doc_id = self.user_id, uuid4().hex
        content, scheme = 'Hi', EncryptionSchemes.PUBKEY
        formatter = IncomingFormatter()
        incoming_endpoint = self.uri + '%s/%s' % (user_id, doc_id)
        yield treq.put(incoming_endpoint, BytesIO(content), persistent=False)
        db = self.state.open_database(user_id)

        doc = db.get_doc(doc_id)
        self.assertEquals(doc.content, formatter.format(content, scheme))
예제 #17
0
 def upload(self, local_path):
     log.debug("Uploading %s...", local_path)
     yield self.await_ready()
     with open(local_path, "rb") as f:
         resp = yield treq.put("{}uri".format(self.nodeurl), f)
     if resp.code == 200:
         content = yield treq.content(resp)
         log.debug("Successfully uploaded %s", local_path)
         return content.decode("utf-8")
     content = yield treq.content(resp)
     raise TahoeWebError(content.decode("utf-8"))
예제 #18
0
    def test_create_url_no_user_token(self):
        yield ShortenerTables(self.account, self.conn).create_tables()

        payload = {'long_url': 'foo'}
        resp = yield treq.put(self.make_url('/api/create'),
                              data=json.dumps(payload),
                              allow_redirects=False,
                              pool=self.pool)

        result = yield treq.json_content(resp)
        self.assertEqual(result['short_url'], 'http://wtxt.io/qr0')
        self.assertTrue(
            self.tr.value().startswith("test-account.wtxtio.created.count 1"))
예제 #19
0
    def test_cached_pool(self):
        """
        The first use of the module-level API populates the global connection
        pool, which is used for all subsequent requests.
        """
        pool = SyntacticAbominationHTTPConnectionPool()
        self.patch(treq.api, "HTTPConnectionPool", lambda reactor, persistent: pool)

        self.failureResultOf(treq.head("http://test.com"), TabError)
        self.failureResultOf(treq.get("http://test.com"), TabError)
        self.failureResultOf(treq.post("http://test.com"), TabError)
        self.failureResultOf(treq.put("http://test.com"), TabError)
        self.failureResultOf(treq.delete("http://test.com"), TabError)
        self.failureResultOf(treq.request("OPTIONS", "http://test.com"), TabError)

        self.assertEqual(pool.requests, 6)
예제 #20
0
    def test_put_incoming_creates_a_blob_using_filesystem(self):
        self.prepare('filesystem')
        user_id, doc_id = self.user_id, uuid4().hex
        content = 'Hi'
        formatter = IncomingFormatter()
        incoming_endpoint = self.uri + '%s/%s' % (user_id, doc_id)
        yield treq.put(incoming_endpoint, BytesIO(content), persistent=False)

        db = self.state.open_database(user_id)
        request = DummyRequest([user_id, doc_id])
        yield db.read_blob(user_id, doc_id, request, 'MX')
        flags = db.get_flags(user_id, doc_id, request, 'MX')
        flags = json.loads(flags)
        expected = formatter.preamble(content, doc_id) + ' ' + content
        self.assertEquals(expected, request.written[0])
        self.assertIn(Flags.PENDING, flags)
예제 #21
0
def handle_room_window_PUT(request):
    if xwot_app.resources['window']:
        data = request.content.read()
        content_type = request.getHeader('Content-Type')
        dic = deserialize(data, content_type)
        window.update(dic, content_type)
        _data = window.serialize('application/json')

        accept = request.getHeader('Accept')
        d = treq.put(xwot_app.resources['window'], data=_data, headers={'Content-Type': 'application/json'})
        request.setHeader('Content-Type', accept)
        d.addCallback(treq.content)

        return window.serialize(accept)
    else:
        request.setResponseCode(404)
    return ''
예제 #22
0
def test_no_write_permissions(admin_user, queue_and_binding):
    """Assert the call to twisted_consume errbacks on write permissions errors."""
    queues, bindings = queue_and_binding
    url = "{base}permissions/%2F/{user}".format(base=HTTP_API, user=admin_user)
    body = {"configure": ".*", "write": "", "read": ".*"}
    resp = yield treq.put(url, json=body, auth=HTTP_AUTH, timeout=3)
    assert resp.code == 204

    amqp_url = "amqp://{user}:guest@localhost:5672/%2F".format(user=admin_user)
    try:
        with mock.patch.dict(config.conf, {"amqp_url": amqp_url}):
            yield api.twisted_consume(lambda x: x, bindings, queues)
        pytest.fail("Call failed to raise an exception")
    except exceptions.BadDeclaration as e:
        assert e.reason.args[0] == 403
        assert e.reason.args[1] == (
            "ACCESS_REFUSED - access to queue '{}' in vhost '/' refused for user"
            " '{}'".format(list(queues.keys())[0], admin_user))
예제 #23
0
    def set_launch_config(self, rcs, launch_config):
        """Changes the launch configuration used by the scaling group.

        :param TestResources rcs: The integration test resources instance.
            This provides useful information to complete the request, like
            which endpoint to use to make the API request.

        :param dict launch_config: The new launch configuration.

        :return: A :class:`Deferred` which, upon firing, alters the scaling
            group's launch configuration.  If successful, the test resources
            provided will be returned.  Otherwise, an exception will rise.
        """
        return (treq.put(
            "{0}/groups/{1}/launch".format(rcs.endpoints["otter"],
                                           self.group_id),
            json.dumps(launch_config),
            headers=headers(str(rcs.token)),
            pool=self.pool).addCallback(check_success,
                                        [204]).addCallback(lambda _: rcs))
예제 #24
0
    def test_put_incoming_creates_a_blob_using_filesystem(self):
        self.prepare('filesystem')
        user_id, doc_id = self.user_id, uuid4().hex
        content = 'Hi'
        formatter = IncomingFormatter()
        incoming_endpoint = self.uri + '%s/%s' % (user_id, doc_id)
        yield treq.put(incoming_endpoint, BytesIO(content), persistent=False)

        db = self.state.open_database(user_id)
        consumer = DummyRequest([''])
        yield db.read_blob(user_id, doc_id, consumer, namespace='MX')
        flags = yield db.get_flags(user_id, doc_id, namespace='MX')
        data = consumer.written.pop()
        expected_preamble = formatter.preamble(content, doc_id)
        expected_preamble = decode_preamble(expected_preamble, True)
        written_preamble, written_content = data.split()
        written_preamble = decode_preamble(written_preamble, True)
        self.assertEquals(expected_preamble, written_preamble)
        self.assertEquals(content, written_content)
        self.assertIn(Flags.PENDING, flags)
예제 #25
0
def sendToCollector(client, session, settings, useZmq=True):
    """deferred to the time in seconds it took to get a response from collector"""
    sendTime = time.time()
    msg = toCollectorJson(client, session, settings)

    if useZmq:
        d = sendToCollectorZmq(msg)
    else:
        d = treq.put(networking.collector.path('attrs'), data=msg)
    
    def onDone(result):
        dt = time.time() - sendTime
        if dt > .1:
            log.warn('sendToCollector request took %.1fms', dt * 1000)
        return dt
    d.addCallback(onDone)
    def onErr(err):
        log.warn('sendToCollector failed: %r', err)
    d.addErrback(onErr)
    return d
예제 #26
0
    def makeRequest(self):
        if self.payload is None:
            log.debug("PUT None to %s - waiting", self.url)
            return
        h = {}
        if self.foafAgent:
            h['x-foaf-agent'] = self.foafAgent
        if self.nextCall and self.nextCall.active():
            self.nextCall.cancel()
            self.nextCall = None
        self.lastErr = None
        log.debug("PUT %s payload=%s agent=%s",
                  self.url, self.payload, self.foafAgent)
        if not self.mockOutput:
            self.currentRequest = treq.put(self.url, data=self.payload.encode('utf8'),
                                           headers=h, timeout=3)
            self.currentRequest.addCallback(self.onResponse).addErrback(
                self.onError)
        else:
            reactor.callLater(.2, self.onResponse, None)

        self.numRequests += 1
예제 #27
0
파일: autoscale.py 프로젝트: meker12/otter
    def set_launch_config(self, rcs, launch_config):
        """Changes the launch configuration used by the scaling group.

        :param TestResources rcs: The integration test resources instance.
            This provides useful information to complete the request, like
            which endpoint to use to make the API request.

        :param dict launch_config: The new launch configuration.

        :return: A :class:`Deferred` which, upon firing, alters the scaling
            group's launch configuration.  If successful, the test resources
            provided will be returned.  Otherwise, an exception will rise.
        """
        return (
            treq.put(
                "{0}/groups/{1}/launch".format(rcs.endpoints["otter"],
                                               self.group_id),
                json.dumps(launch_config),
                headers=headers(str(rcs.token)),
                pool=self.pool
            ).addCallback(check_success, [204])
            .addCallback(lambda _: rcs)
        )
예제 #28
0
파일: autoscale.py 프로젝트: meker12/otter
    def replace_group_config(self, rcs, replacement_config):
        """
        Replace the current group configuration with the provided config
        and update the stored groupConfiguration information.

        :param TestResources rcs: The integration test resources instance.
            This provides useful information to complete the request, like
            which endpoint to use to make the API request.
        :param dict replacement_config: A dictionary representation of
            the JSON description of a scaling group groupConfiguration
            Note that since this is a replacement config, all fields
            in the JSON descirptor are mandatory.

        """

        def record_results(_, replacement_config):
            # Replace the stored value in the group_config
            self.group_config["groupConfiguration"] = replacement_config
            # Find the correct group from the list (by id)
            for g in rcs.groups:
                if g['group']['id'] == self.group_id:
                    g['group']['groupConfiguration'] = replacement_config
            if verbosity > 0:
                print('Update group_config with {}'.format(replacement_config))
            return rcs

        return (
            treq.put(
                "{0}/groups/{1}/config".format(rcs.endpoints["otter"],
                                               self.group_id),
                json.dumps(replacement_config),
                headers=headers(str(rcs.token)),
                pool=self.pool,
            )
            .addCallback(check_success, [204])
            .addCallback(record_results, replacement_config)
        )
예제 #29
0
파일: ffLifx.py 프로젝트: zpriddy/Firefly
 def sendLightCommand(self, args={}):
   logging.critical(args)
   data = args.get('lightCommand')
   url = self._api_url + 'id:' + str(args.get('lightID')) + '/state'
   treq.put(url, headers=self.header, data=data)
   return True
예제 #30
0
def deliver_using_incoming_api(url, user_uuid, token, data):
    auth = 'Token %s' % base64.b64encode('%s:%s' % (user_uuid, token))
    uri = "%s/incoming/%s/%s?namespace=MX" % (url, user_uuid, uuid.uuid4().hex)
    return treq.put(uri, headers={'Authorization': auth}, data=BytesIO(data))
예제 #31
0
def deliver_using_incoming_api(url, user_uuid, token, data):
    auth = 'Token %s' % base64.b64encode('%s:%s' % (user_uuid, token))
    uri = "%s/incoming/%s/%s?namespace=MX" % (url, user_uuid, uuid.uuid4().hex)
    return treq.put(uri, headers={'Authorization': auth}, data=BytesIO(data))
예제 #32
0
 def sendLightCommand(self, args={}):
     logging.critical(args)
     data = args.get('lightCommand')
     url = self._api_url + 'id:' + str(args.get('lightID')) + '/state'
     treq.put(url, headers=self.header, data=data)
     return True
예제 #33
0
 def put_mapping(_):
     print("Putting mapping {0}".format(event_mapping))
     with open(event_mapping) as f:
         d = treq.put('http://localhost:9200/history/event/_mapping',
                      f.read())
         return d.addCallback(treq.json_content).addCallback(print)
예제 #34
0
 def ensure(_):
     d = treq.put('http://localhost:9200/history')
     d.addCallback(treq.json_content)
     return d.addCallback(print)