##// END OF EJS Templates
upstream » kallithea
RSS

Clone from https://kallithea-scm.org/repos/kallithea

api: decouple some parts from api CLI script...
marcink -
r3833:5055dd38 beta
parent child Browse files
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,148 b''
1 """
2 Base utils for shell scripts
3 """
4 import os
5 import sys
6 import random
7 import urllib2
8 import pprint
9
10 try:
11 from rhodecode.lib.ext_json import json
12 except ImportError:
13 try:
14 import simplejson as json
15 except ImportError:
16 import json
17
18 CONFIG_NAME = '.rhodecode'
19 FORMAT_PRETTY = 'pretty'
20 FORMAT_JSON = 'json'
21
22
23 def api_call(apikey, apihost, format, method=None, **kw):
24 """
25 Api_call wrapper for RhodeCode
26
27 :param apikey:
28 :param apihost:
29 :param format: formatting, pretty means prints and pprint of json
30 json returns unparsed json
31 :param method:
32 """
33 def _build_data(random_id):
34 """
35 Builds API data with given random ID
36
37 :param random_id:
38 :type random_id:
39 """
40 return {
41 "id": random_id,
42 "api_key": apikey,
43 "method": method,
44 "args": kw
45 }
46
47 if not method:
48 raise Exception('please specify method name !')
49 id_ = random.randrange(1, 9999)
50 req = urllib2.Request('%s/_admin/api' % apihost,
51 data=json.dumps(_build_data(id_)),
52 headers={'content-type': 'text/plain'})
53 if format == FORMAT_PRETTY:
54 sys.stdout.write('calling %s to %s \n' % (req.get_data(), apihost))
55 ret = urllib2.urlopen(req)
56 raw_json = ret.read()
57 json_data = json.loads(raw_json)
58 id_ret = json_data['id']
59 _formatted_json = pprint.pformat(json_data)
60 if id_ret == id_:
61 if format == FORMAT_JSON:
62 sys.stdout.write(str(raw_json))
63 else:
64 sys.stdout.write('rhodecode returned:\n%s\n' % (_formatted_json))
65
66 else:
67 raise Exception('something went wrong. '
68 'ID mismatch got %s, expected %s | %s' % (
69 id_ret, id_, _formatted_json))
70
71
72 class RcConf(object):
73 """
74 RhodeCode config for API
75
76 conf = RcConf()
77 conf['key']
78
79 """
80
81 def __init__(self, config_location=None, autoload=True, autocreate=False,
82 config=None):
83 self._conf_name = CONFIG_NAME if not config_location else config_location
84 self._conf = {}
85 if autocreate:
86 self.make_config(config)
87 if autoload:
88 self._conf = self.load_config()
89
90 def __getitem__(self, key):
91 return self._conf[key]
92
93 def __nonzero__(self):
94 if self._conf:
95 return True
96 return False
97
98 def __eq__(self):
99 return self._conf.__eq__()
100
101 def __repr__(self):
102 return 'RcConf<%s>' % self._conf.__repr__()
103
104 def make_config(self, config):
105 """
106 Saves given config as a JSON dump in the _conf_name location
107
108 :param config:
109 :type config:
110 """
111 update = False
112 if os.path.exists(self._conf_name):
113 update = True
114 with open(self._conf_name, 'wb') as f:
115 json.dump(config, f, indent=4)
116
117 if update:
118 sys.stdout.write('Updated config in %s\n' % self._conf_name)
119 else:
120 sys.stdout.write('Created new config in %s\n' % self._conf_name)
121
122 def update_config(self, new_config):
123 """
124 Reads the JSON config updates it's values with new_config and
125 saves it back as JSON dump
126
127 :param new_config:
128 """
129 config = {}
130 try:
131 with open(self._conf_name, 'rb') as conf:
132 config = json.load(conf)
133 except IOError, e:
134 sys.stderr.write(str(e) + '\n')
135
136 config.update(new_config)
137 self.make_config(config)
138
139 def load_config(self):
140 """
141 Loads config from file and returns loaded JSON object
142 """
143 try:
144 with open(self._conf_name, 'rb') as conf:
145 return json.load(conf)
146 except IOError, e:
147 #sys.stderr.write(str(e) + '\n')
148 pass
Show file before | Show file after | Hide comments
@@ -1,7 +1,7 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 rhodecode.bin.backup_manager
4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3 rhodecode.bin.api
4 ~~~~~~~~~~~~~~~~~
5 5
6 6 Api CLI client for RhodeCode
7 7
@@ -24,160 +24,18 b''
24 24 # along with this program. If not, see <http://www.gnu.org/licenses/>.
25 25
26 26 from __future__ import with_statement
27 import os
28 27 import sys
29 import random
30 import urllib2
31 import pprint
32 28 import argparse
33 29
34 try:
35 from rhodecode.lib.ext_json import json
36 except ImportError:
37 try:
38 import simplejson as json
39 except ImportError:
40 import json
41
42
43 CONFIG_NAME = '.rhodecode'
44 FORMAT_PRETTY = 'pretty'
45 FORMAT_JSON = 'json'
46
47
48 class RcConf(object):
49 """
50 RhodeCode config for API
51
52 conf = RcConf()
53 conf['key']
54
55 """
56
57 def __init__(self, config_location=None, autoload=True, autocreate=False,
58 config=None):
59 self._conf_name = CONFIG_NAME if not config_location else config_location
60 self._conf = {}
61 if autocreate:
62 self.make_config(config)
63 if autoload:
64 self._conf = self.load_config()
65
66 def __getitem__(self, key):
67 return self._conf[key]
68
69 def __nonzero__(self):
70 if self._conf:
71 return True
72 return False
73
74 def __eq__(self):
75 return self._conf.__eq__()
76
77 def __repr__(self):
78 return 'RcConf<%s>' % self._conf.__repr__()
79
80 def make_config(self, config):
81 """
82 Saves given config as a JSON dump in the _conf_name location
83
84 :param config:
85 :type config:
86 """
87 update = False
88 if os.path.exists(self._conf_name):
89 update = True
90 with open(self._conf_name, 'wb') as f:
91 json.dump(config, f, indent=4)
92
93 if update:
94 sys.stdout.write('Updated config in %s\n' % self._conf_name)
95 else:
96 sys.stdout.write('Created new config in %s\n' % self._conf_name)
97
98 def update_config(self, new_config):
99 """
100 Reads the JSON config updates it's values with new_config and
101 saves it back as JSON dump
102
103 :param new_config:
104 """
105 config = {}
106 try:
107 with open(self._conf_name, 'rb') as conf:
108 config = json.load(conf)
109 except IOError, e:
110 sys.stderr.write(str(e) + '\n')
111
112 config.update(new_config)
113 self.make_config(config)
114
115 def load_config(self):
116 """
117 Loads config from file and returns loaded JSON object
118 """
119 try:
120 with open(self._conf_name, 'rb') as conf:
121 return json.load(conf)
122 except IOError, e:
123 #sys.stderr.write(str(e) + '\n')
124 pass
125
126
127 def api_call(apikey, apihost, format, method=None, **kw):
128 """
129 Api_call wrapper for RhodeCode
130
131 :param apikey:
132 :param apihost:
133 :param format: formatting, pretty means prints and pprint of json
134 json returns unparsed json
135 :param method:
136 """
137 def _build_data(random_id):
138 """
139 Builds API data with given random ID
140
141 :param random_id:
142 :type random_id:
143 """
144 return {
145 "id": random_id,
146 "api_key": apikey,
147 "method": method,
148 "args": kw
149 }
150
151 if not method:
152 raise Exception('please specify method name !')
153 id_ = random.randrange(1, 9999)
154 req = urllib2.Request('%s/_admin/api' % apihost,
155 data=json.dumps(_build_data(id_)),
156 headers={'content-type': 'text/plain'})
157 if format == FORMAT_PRETTY:
158 sys.stdout.write('calling %s to %s \n' % (req.get_data(), apihost))
159 ret = urllib2.urlopen(req)
160 raw_json = ret.read()
161 json_data = json.loads(raw_json)
162 id_ret = json_data['id']
163 _formatted_json = pprint.pformat(json_data)
164 if id_ret == id_:
165 if format == FORMAT_JSON:
166 sys.stdout.write(str(raw_json))
167 else:
168 sys.stdout.write('rhodecode returned:\n%s\n' % (_formatted_json))
169
170 else:
171 raise Exception('something went wrong. '
172 'ID mismatch got %s, expected %s | %s' % (
173 id_ret, id_, _formatted_json))
30 from rhodecode.bin.base import api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY
174 31
175 32
176 33 def argparser(argv):
177 34 usage = (
178 "rhodecode_api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "
179 " [--config=CONFIG] "
180 "_create_config or METHOD <key:val> <key2:val> ..."
35 "rhodecode-api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "
36 "[--config=CONFIG] [--save-config] "
37 "METHOD <key:val> <key2:val> ...\n"
38 "Create config file: rhodecode-gist --apikey=<key> --apihost=http://rhodecode.server --save-config"
181 39 )
182 40
183 41 parser = argparse.ArgumentParser(description='RhodeCode API cli',
@@ -188,9 +46,10 b' def argparser(argv):'
188 46 group.add_argument('--apikey', help='api access key')
189 47 group.add_argument('--apihost', help='api host')
190 48 group.add_argument('--config', help='config file')
49 group.add_argument('--save-config', action='store_true', help='save the given config into a file')
191 50
192 51 group = parser.add_argument_group('API')
193 group.add_argument('method', metavar='METHOD', type=str,
52 group.add_argument('method', metavar='METHOD', nargs='?', type=str, default=None,
194 53 help='API method name to call followed by key:value attributes',
195 54 )
196 55 group.add_argument('--format', dest='format', type=str,
@@ -216,12 +75,13 b' def main(argv=None):'
216 75 parser, args, other = argparser(argv)
217 76
218 77 api_credentials_given = (args.apikey and args.apihost)
219 if args.method == '_create_config':
78 if args.save_config:
220 79 if not api_credentials_given:
221 raise parser.error('_create_config requires --apikey and --apihost')
80 raise parser.error('--save-config requires --apikey and --apihost')
222 81 conf = RcConf(config_location=args.config,
223 82 autocreate=True, config={'apikey': args.apikey,
224 83 'apihost': args.apihost})
84 sys.exit()
225 85
226 86 if not conf:
227 87 conf = RcConf(config_location=args.config, autoload=True)
@@ -233,8 +93,6 b' def main(argv=None):'
233 93 apikey = args.apikey or conf['apikey']
234 94 host = args.apihost or conf['apihost']
235 95 method = args.method
236 if method == '_create_config':
237 sys.exit()
238 96
239 97 try:
240 98 margs = dict(map(lambda s: s.split(':', 1), other))
General Comments 0
You need to be logged in to leave comments. Login now