def __init__(self, **kwargs):
"""Connection to a bucket.
Normally it's initialized through :meth:`couchbase.Couchbase.connect`
See :meth:`couchbase.Couchbase.connect` for constructor options
"""
bucket = kwargs.get('bucket', None)
host = kwargs.get('host', 'localhost')
username = kwargs.get('username', None)
password = kwargs.get('password', None)
# We don't pass this to the actual constructor
port = kwargs.pop('port', 8091)
_no_connect_exceptions = kwargs.pop('_no_connect_exceptions', False)
if not bucket:
raise exceptions.ArgumentError("A bucket name must be given")
kwargs['host'] = self._gen_host_string(host, port)
kwargs['bucket'] = bucket
if password and not username:
kwargs['username'] = bucket
# Internal parameters
kwargs['_errors'] = deque(maxlen=1000)
try:
super(Connection, self).__init__(**kwargs)
except exceptions.CouchbaseError as e:
if not _no_connect_exceptions:
raise
def __init__(self, **kwargs):
"""Connection to a bucket.
Normally it's initialized through :meth:`couchbase.Couchbase.connect`
See :meth:`couchbase.Couchbase.connect` for constructor options
"""
bucket = kwargs.get('bucket', None)
host = kwargs.get('host', 'localhost')
username = kwargs.get('username', None)
password = kwargs.get('password', None)
conncache = kwargs.get('conncache', None)
quiet = kwargs.get('quiet', False)
unlock_gil = kwargs.get('unlock_gil', False)
timeout = kwargs.get('timeout', 2.5)
transcoder = kwargs.get('transcoder', None)
# We don't pass this to the actual constructor
port = kwargs.pop('port', 8091)
_no_connect_exceptions = kwargs.pop('_no_connect_exceptions', False)
if not bucket:
raise exceptions.ArgumentError("A bucket name must be given")
if isinstance(host, (tuple, list)):
hosts_tmp = []
for curhost in host:
cur_hname = None
cur_hport = None
if isinstance(curhost, (list, tuple)):
cur_hname, cur_hport = curhost
else:
cur_hname = curhost
cur_hport = port
hosts_tmp.append("{0}:{1}".format(cur_hname, cur_hport))
host = ";".join(hosts_tmp)
else:
host = "{0}:{1}".format(host, port)
kwargs['host'] = host
kwargs['bucket'] = bucket
if password and not username:
kwargs['username'] = bucket
kwargs['_errors'] = deque(maxlen=1000)
kwargs['_flags'] = 0
try:
super(Connection, self).__init__(**kwargs)
except exceptions.CouchbaseError as e:
if not _no_connect_exceptions:
raise
def http_request(self,
path,
method='GET',
content=None,
content_type="application/json",
response_format=FMT_JSON):
"""
Perform an administrative HTTP request. This request is sent out to
the administrative API interface (i.e. the "Management/REST API")
of the cluster.
See <LINK?> for a list of available comments.
Note that this is a fairly low level function. This class will with
time contain more and more wrapper methods for common tasks such
as bucket creation or node allocation, and this method should
mostly be used if a wrapper is not available.
:param string path: The path portion (not including the host) of the
rest call to perform. This should also include any encoded arguments.
:param string method: This is the HTTP method to perform. Currently
supported values are `GET`, `POST`, `PUT`, and `DELETE`
:param bytes content: Content to be passed along in the request body.
This is only applicable on `PUT` and `POST` methods.
:param string content_type: Value for the HTTP ``Content-Type`` header.
Currently this is ``application-json``, and should probably not be
set to something else.
:param int response_format:
Hint about how to format the response. This goes into the
:attr:`~couchbase.libcouchbase.HttpResult.value` field of the
:class:`~couchbase.libcouchbase.HttpResult` object. The default is
:const:`~couchbase.libcouchbase.FMT_JSON`.
Note that if the conversion fails, the content will be returned as
``bytes``
:raise:
:exc:`couchbase.exceptions.ArgumentError` if the method supplied was
incorrect
:exc:`couchbase.exceptions.ConnectError` if there was a problem
establishing a connection.
:exc:`couchbase.exceptions.HTTPError` if the server responded with a
negative reply
:return: a :class:`~couchbase.libcouchbase.HttpResult` object.
"""
imeth = None
try:
imeth = METHMAP[method]
except KeyError:
raise E.ArgumentError({
"message": "unknown HTTP method",
"objextra": method
})
return self._http_request(type=LCB.LCB_HTTP_TYPE_MANAGEMENT,
path=path,
method=imeth,
content_type=content_type,
post_data=content,
response_format=response_format)
def user_upsert(self,
domain,
userid,
password=None,
roles=None,
name=None):
"""
Upsert a user in the cluster
:param AuthDomain domain: The authentication domain for the user.
:param userid: The user ID
:param password: The user password
:param roles: A list of roles. A role can either be a simple string,
or a list of `(role, bucket)` pairs.
:param name: Human-readable name
:raise: :exc:`couchbase.exceptions.HTTPError` if the request fails.
:return: :class:`~.HttpResult`
Creating a new read-only admin user ::
adm.upsert_user(AuthDomain.Local, 'mark', 's3cr3t', ['ro_admin'])
An example of using more complex roles ::
adm.upsert_user(AuthDomain.Local, 'mark', 's3cr3t',
[('data_reader', '*'),
('data_writer', 'inbox')])
.. warning::
Due to the asynchronous nature of Couchbase management APIs, it may
take a few moments for the new user settings to take effect.
"""
if not roles or not isinstance(roles, list):
raise E.ArgumentError("Roles must be a non-empty list")
if password and domain == AuthDomain.External:
raise E.ArgumentError("External domains must not have passwords")
tmplist = []
for role in roles:
if isinstance(role, basestring):
tmplist.append(role)
else:
tmplist.append('{0}[{1}]'.format(*role))
role_string = ','.join(tmplist)
params = {
'roles': role_string,
}
if password:
params['password'] = password
if name:
params['name'] = name
form = self._mk_formstr(params)
path = self._get_management_path(domain, userid)
return self.http_request(
path=path,
method='PUT',
content_type='application/x-www-form-urlencoded',
content=form)