kallithea Changeset - 5a3252dd7fd9

Changeset - 5a3252dd7fd9

Parent rev.

Child rev.

[Not reviewed]

Merge beta

0 3 0

Marcin Kuzminski - 14 years ago 2011-09-29 02:38:45
marcin@python-works.com

Automated merge with https://secure.rhodecode.org/rhodecode

3 files changed with 51 insertions and 31 deletions:

docs/api/api.rst

rhodecode/controllers/api/__init__.py

rhodecode/lib/__init__.py

0 comments (0 inline, 0 general)

docs/api/api.rst

➞

Show inline comments

 .. _api:
 API
 ===
 Starting from RhodeCode version 1.2 a simple API was implemented.
 There's one schema for calling all api methods. API is implemented
 with JSON protocol both ways.
 with JSON protocol both ways. An url to send API request in RhodeCode is
 <your-server>/_admin/api
 Clients need to send JSON data in such format::
+    {
         "api_key":"<api_key>",
         "method":"<method_name>",
         "args":{"<arg_key>":"<arg_val>"}
+    }
 Simply provide api_key for access and permission validation
 method is name of method to call
@@ @@ -41,16 +42,16 @@ and result will be null. @@
 API METHODS
 +++++++++++
 pull
 ----
 Pulls given repo from remote location. Can be used to automatically keep
 remote repos upto date. This command can be executed only using admin users
 api_key
 ::
+    api_key:"<api_key>"
     method: "pull"
     args: {"repo":<repo_name>}

rhodecode/controllers/api/__init__.py

➞

Show inline comments

@@ @@ -30,25 +30,25 @@ import json @@
 import logging
 import types
 import urllib
 from paste.response import replace_header
 from pylons.controllers import WSGIController
 from pylons.controllers.util import Response
 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \
 HTTPBadRequest, HTTPError
-from rhodecode.model.user import User
+from rhodecode.model.db import User
 from rhodecode.lib.auth import AuthUser
 log = logging.getLogger('JSONRPC')
 class JSONRPCError(BaseException):
     def __init__(self, message):
         self.message = message
     def __str__(self):
         return str(self.message)
@@ @@ -76,95 +76,92 @@ class JSONRPCController(WSGIController): @@
     def _get_method_args(self):
         """
         Return `self._rpc_args` to dispatched controller method
         chosen by __call__
         """
         return self._rpc_args
     def __call__(self, environ, start_response):
         """
         Parse the request body as JSON, look up the method on the
         controller and if it exists, dispatch to it.
         """
         if 'CONTENT_LENGTH' not in environ:
             log.debug("No Content-Length")
-            return jsonrpc_error(0, "No Content-Length")
+            return jsonrpc_error(message="No Content-Length in request")
         else:
             length = environ['CONTENT_LENGTH'] or 0
             length = int(environ['CONTENT_LENGTH'])
             log.debug('Content-Length: %s', length)
         if length == 0:
             log.debug("Content-Length is 0")
-            return jsonrpc_error(0, "Content-Length is 0")
+            return jsonrpc_error(message="Content-Length is 0")
         raw_body = environ['wsgi.input'].read(length)
         try:
             json_body = json.loads(urllib.unquote_plus(raw_body))
         except ValueError as e:
             #catch JSON errors Here
             return jsonrpc_error("JSON parse error ERR:%s RAW:%r" \
+            return jsonrpc_error(message="JSON parse error ERR:%s RAW:%r" \
                                  % (e, urllib.unquote_plus(raw_body)))
         #check AUTH based on API KEY
         try:
             self._req_api_key = json_body['api_key']
             self._req_method = json_body['method']
             self._req_params = json_body['args']
             log.debug('method: %s, params: %s',
                       self._req_method,
                       self._req_params)
         except KeyError as e:
             return jsonrpc_error(message='Incorrect JSON query missing %s' % e)
         #check if we can find this session using api_key
         try:
             u = User.get_by_api_key(self._req_api_key)
             auth_u = AuthUser(u.user_id, self._req_api_key)
         except Exception as e:
             return jsonrpc_error(message='Invalid API KEY')
         self._error = None
         try:
             self._func = self._find_method()
         except AttributeError, e:
             return jsonrpc_error(str(e))
+            return jsonrpc_error(message=str(e))
         # now that we have a method, add self._req_params to
         # self.kargs and dispatch control to WGIController
         arglist = inspect.getargspec(self._func)[0][1:]
         # this is little trick to inject logged in user for
         # perms decorators to work they expect the controller class to have
         # rhodecode_user set
         self.rhodecode_user = auth_u
         if 'user' not in arglist:
             return jsonrpc_error('This method [%s] does not support '
+            return jsonrpc_error(message='This method [%s] does not support '
                                  'authentication (missing user param)' %
                                  self._func.__name__)
         # get our arglist and check if we provided them as args
         for arg in arglist:
             if arg == 'user':
                 # user is something translated from api key and this is
                 # checked before
                 continue
             if not self._req_params or arg not in self._req_params:
                 return jsonrpc_error('Missing %s arg in JSON DATA' % arg)
+                return jsonrpc_error(message='Missing %s arg in JSON DATA' % arg)
         self._rpc_args = dict(user=u)
         self._rpc_args.update(self._req_params)
         self._rpc_args['action'] = self._req_method
         self._rpc_args['environ'] = environ
         self._rpc_args['start_response'] = start_response
         status = []
         headers = []
         exc_info = []
         def change_content(new_status, new_headers, new_exc_info=None):

rhodecode/lib/__init__.py

➞

Show inline comments

@@ @@ -148,62 +148,84 @@ def generate_api_key(username, salt=None @@
     :rtype: str
     :returns: sha1 hash from username+salt
     """
     from tempfile import _RandomNameSequence
     import hashlib
     if salt is None:
         salt = _RandomNameSequence().next()
     return hashlib.sha1(username + salt).hexdigest()
-def safe_unicode(_str, from_encoding='utf8'):
+def safe_unicode(str_, from_encoding='utf8'):
     """
     safe unicode function. In case of UnicodeDecode error we try to return
     unicode with errors replaceed
     safe unicode function. Does few trick to turn str_ into unicode
     In case of UnicodeDecode error we try to return it with encoding detected
     by chardet library if it fails fallback to unicode with errors replaced
-    :param _str: string to decode
+    :param str_: string to decode
     :rtype: unicode
     :returns: unicode object
     """
     if isinstance(_str, unicode):
         return _str
     if isinstance(str_, unicode):
         return str_
     try:
-        u_str = unicode(_str, from_encoding)
+        return unicode(str_, from_encoding)
     except UnicodeDecodeError:
         u_str = unicode(_str, from_encoding, 'replace')
     return u_str
         pass
     try:
         import chardet
         encoding = chardet.detect(str_)['encoding']
         if encoding is None:
             raise UnicodeDecodeError()
         return str_.decode(encoding)
     except (ImportError, UnicodeDecodeError):
         return unicode(str_, from_encoding, 'replace')
-def safe_str(_unicode, to_encoding='utf8'):
+def safe_str(unicode_, to_encoding='utf8'):
     """
     safe str function. In case of UnicodeEncode error we try to return
     str with errors replaceed
     safe str function. Does few trick to turn unicode_ into string
     In case of UnicodeEncodeError we try to return it with encoding detected
     by chardet library if it fails fallback to string with errors replaced
-    :param _unicode: unicode to encode
+    :param unicode_: unicode to encode
     :rtype: str
     :returns: str object
     """
     if isinstance(_unicode, str):
         return _unicode
     if isinstance(unicode_, str):
         return unicode_
     try:
-        safe_str = str(_unicode)
+        return str(unicode_)
     except UnicodeEncodeError:
         safe_str = _unicode.encode(to_encoding, 'replace')
         pass
     try:
         import chardet
         encoding = chardet.detect(unicode_)['encoding']
         print encoding
         if encoding is None:
             raise UnicodeEncodeError()
         return unicode_.encode(encoding)
     except (ImportError, UnicodeEncodeError):
         return unicode_.encode(to_encoding, 'replace')
     return safe_str
 def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):
     """
     Custom engine_from_config functions that makes sure we use NullPool for
     file based sqlite databases. This prevents errors on sqlite. This only
     applies to sqlalchemy versions < 0.7.0
     """

0 comments (0 inline, 0 general)