locking API returns objects instead of string messages.

- it's now possible to easily parse the output of lock functions

docs/api/api.rst

@@ -212,7 +212,13 b' INPUT::'
 OUTPUT::
 
     id : <id_given_in_input>
-    result : "User `<username>` set lock state for repo `<reponame>` to `true|false`"
+    result : {  
+                 "repo": "<reponame>",
+                 "locked": "<bool true|false>",
+                 "locked_since": "<float lock_time>",
+                 "locked_by": "<username>",
+                 "msg": "User `<username>` set lock state for repo `<reponame>` to `<false|true>`"
+             }               
     error :  null
 
 

rhodecode/controllers/api/api.py

@@ -25,6 +25,7 b''
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
+import time
 import traceback
 import logging
 
@@ -265,27 +266,47 b' class ApiController(JSONRPCController):'
             lockobj = Repository.getlock(repo)
 
             if lockobj[0] is None:
-                return ('Repo `%s` not locked. Locked=`False`.'
-                        % (repo.repo_name))
+                _d = {
+                    'repo': repo.repo_name,
+                    'locked': False,
+                    'locked_since': None,
+                    'locked_by': None,
+                    'msg': 'Repo `%s` not locked.' % repo.repo_name
+                }
+                return _d
             else:
                 userid, time_ = lockobj
-                user = get_user_or_error(userid)
+                lock_user = get_user_or_error(userid)
+                _d = {
+                    'repo': repo.repo_name,
+                    'locked': True,
+                    'locked_since': time_,
+                    'locked_by': lock_user.username,
+                    'msg': ('Repo `%s` locked by `%s`. '
+                            % (repo.repo_name,
+                               json.dumps(time_to_datetime(time_))))
+                }
+                return _d
 
-                return ('Repo `%s` locked by `%s`. Locked=`True`. '
-                        'Locked since: `%s`'
-                    % (repo.repo_name, user.username,
-                       json.dumps(time_to_datetime(time_))))
-
+        # force locked state through a flag
         else:
             locked = str2bool(locked)
             try:
                 if locked:
-                    Repository.lock(repo, user.user_id)
+                    lock_time = time.time()
+                    Repository.lock(repo, user.user_id, lock_time)
                 else:
+                    lock_time = None
                     Repository.unlock(repo)
-
-                return ('User `%s` set lock state for repo `%s` to `%s`'
-                        % (user.username, repo.repo_name, locked))
+                _d = {
+                    'repo': repo.repo_name,
+                    'locked': locked,
+                    'locked_since': lock_time,
+                    'locked_by': user.username,
+                    'msg': ('User `%s` set lock state for repo `%s` to `%s`'
+                            % (user.username, repo.repo_name, locked))
+                }
+                return _d
             except Exception:
                 log.error(traceback.format_exc())
                 raise JSONRPCError(

rhodecode/model/db.py

@@ -1007,8 +1007,10 b' class Repository(Base, BaseModel):'
         return data
 
     @classmethod
-    def lock(cls, repo, user_id):
-        repo.locked = [user_id, time.time()]
+    def lock(cls, repo, user_id, lock_time=None):
+        if not lock_time:
+            lock_time = time.time()
+        repo.locked = [user_id, lock_time]
         Session().add(repo)
         Session().commit()
 

rhodecode/tests/api/api_base.py

@@ -12,6 +12,7 b' from rhodecode.model.repo import RepoMod'
 from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Repository, User
+from rhodecode.lib.utils2 import  time_to_datetime
 
 
 API_URL = '/_admin/api'
@@ -291,8 +292,15 b' class BaseTestApi(object):'
                                   repoid=self.REPO,
                                   locked=True)
         response = api_call(self, params)
-        expected = ('User `%s` set lock state for repo `%s` to `%s`'
-                   % (TEST_USER_ADMIN_LOGIN, self.REPO, True))
+        expected = {
+            'repo': self.REPO,
+            'locked': True,
+            'locked_since': None,
+            'locked_by': TEST_USER_ADMIN_LOGIN,
+            'msg': ('User `%s` set lock state for repo `%s` to `%s`'
+                    % (TEST_USER_ADMIN_LOGIN, self.REPO, True))
+        }
+        expected['locked_since'] = json.loads(response.body)['result']['locked_since']
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_aquire_by_non_admin(self):
@@ -304,8 +312,15 b' class BaseTestApi(object):'
                                       repoid=repo_name,
                                       locked=True)
             response = api_call(self, params)
-            expected = ('User `%s` set lock state for repo `%s` to `%s`'
-                       % (self.TEST_USER_LOGIN, repo_name, True))
+            expected = {
+                'repo': repo_name,
+                'locked': True,
+                'locked_since': None,
+                'locked_by': self.TEST_USER_LOGIN,
+                'msg': ('User `%s` set lock state for repo `%s` to `%s`'
+                        % (self.TEST_USER_LOGIN, repo_name, True))
+            }
+            expected['locked_since'] = json.loads(response.body)['result']['locked_since']
             self._compare_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
@@ -339,8 +354,14 b' class BaseTestApi(object):'
                                   repoid=self.REPO,
                                   locked=False)
         response = api_call(self, params)
-        expected = ('User `%s` set lock state for repo `%s` to `%s`'
-                   % (TEST_USER_ADMIN_LOGIN, self.REPO, False))
+        expected = {
+            'repo': self.REPO,
+            'locked': False,
+            'locked_since': None,
+            'locked_by': TEST_USER_ADMIN_LOGIN,
+            'msg': ('User `%s` set lock state for repo `%s` to `%s`'
+                    % (TEST_USER_ADMIN_LOGIN, self.REPO, False))
+        }
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_aquire_optional_userid(self):
@@ -348,19 +369,33 b' class BaseTestApi(object):'
                                   repoid=self.REPO,
                                   locked=True)
         response = api_call(self, params)
-        expected = ('User `%s` set lock state for repo `%s` to `%s`'
-                   % (TEST_USER_ADMIN_LOGIN, self.REPO, True))
+        expected = {
+            'repo': self.REPO,
+            'locked': True,
+            'locked_since': None,
+            'locked_by': TEST_USER_ADMIN_LOGIN,
+            'msg': ('User `%s` set lock state for repo `%s` to `%s`'
+                    % (TEST_USER_ADMIN_LOGIN, self.REPO, True))
+        }
+        expected['locked_since'] = json.loads(response.body)['result']['locked_since']
         self._compare_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_optional_locked(self):
-        from rhodecode.lib.utils2 import  time_to_datetime
-        _locked_since = json.dumps(time_to_datetime(Repository\
-                                    .get_by_repo_name(self.REPO).locked[1]))
         id_, params = _build_data(self.apikey, 'lock',
                                   repoid=self.REPO)
         response = api_call(self, params)
-        expected = ('Repo `%s` locked by `%s`. Locked=`True`. Locked since: `%s`'
-                   % (self.REPO, TEST_USER_ADMIN_LOGIN, _locked_since))
+        time_ = json.loads(response.body)['result']['locked_since']
+        expected = {
+            'repo': self.REPO,
+            'locked': True,
+            'locked_since': None,
+            'locked_by': TEST_USER_ADMIN_LOGIN,
+            'msg': ('Repo `%s` locked by `%s`. '
+                            % (self.REPO,
+                               json.dumps(time_to_datetime(time_))))
+
+        }
+        expected['locked_since'] = time_
         self._compare_ok(id_, expected, given=response.body)
 
     @mock.patch.object(Repository, 'lock', crash)