##// END OF EJS Templates
system-info: indicate http mode is default when not set inside config.
marcink -
r1198:a1d9f45b stable
parent child Browse files
Show More
@@ -1,640 +1,640 b''
1 import os
1 import os
2 import sys
2 import sys
3 import time
3 import time
4 import platform
4 import platform
5 import pkg_resources
5 import pkg_resources
6 import logging
6 import logging
7 import string
7 import string
8
8
9
9
10 log = logging.getLogger(__name__)
10 log = logging.getLogger(__name__)
11
11
12
12
13 psutil = None
13 psutil = None
14
14
15 try:
15 try:
16 # cygwin cannot have yet psutil support.
16 # cygwin cannot have yet psutil support.
17 import psutil as psutil
17 import psutil as psutil
18 except ImportError:
18 except ImportError:
19 pass
19 pass
20
20
21
21
22 _NA = 'NOT AVAILABLE'
22 _NA = 'NOT AVAILABLE'
23
23
24 STATE_OK = 'ok'
24 STATE_OK = 'ok'
25 STATE_ERR = 'error'
25 STATE_ERR = 'error'
26 STATE_WARN = 'warning'
26 STATE_WARN = 'warning'
27
27
28 STATE_OK_DEFAULT = {'message': '', 'type': STATE_OK}
28 STATE_OK_DEFAULT = {'message': '', 'type': STATE_OK}
29
29
30
30
31 # HELPERS
31 # HELPERS
32 def percentage(part, whole):
32 def percentage(part, whole):
33 whole = float(whole)
33 whole = float(whole)
34 if whole > 0:
34 if whole > 0:
35 return round(100 * float(part) / whole, 1)
35 return round(100 * float(part) / whole, 1)
36 return 0.0
36 return 0.0
37
37
38
38
39 def get_storage_size(storage_path):
39 def get_storage_size(storage_path):
40 sizes = []
40 sizes = []
41 for file_ in os.listdir(storage_path):
41 for file_ in os.listdir(storage_path):
42 storage_file = os.path.join(storage_path, file_)
42 storage_file = os.path.join(storage_path, file_)
43 if os.path.isfile(storage_file):
43 if os.path.isfile(storage_file):
44 try:
44 try:
45 sizes.append(os.path.getsize(storage_file))
45 sizes.append(os.path.getsize(storage_file))
46 except OSError:
46 except OSError:
47 log.exception('Failed to get size of storage file %s',
47 log.exception('Failed to get size of storage file %s',
48 storage_file)
48 storage_file)
49 pass
49 pass
50
50
51 return sum(sizes)
51 return sum(sizes)
52
52
53
53
54 class SysInfoRes(object):
54 class SysInfoRes(object):
55 def __init__(self, value, state=STATE_OK_DEFAULT, human_value=None):
55 def __init__(self, value, state=STATE_OK_DEFAULT, human_value=None):
56 self.value = value
56 self.value = value
57 self.state = state
57 self.state = state
58 self.human_value = human_value or value
58 self.human_value = human_value or value
59
59
60 def __json__(self):
60 def __json__(self):
61 return {
61 return {
62 'value': self.value,
62 'value': self.value,
63 'state': self.state,
63 'state': self.state,
64 'human_value': self.human_value,
64 'human_value': self.human_value,
65 }
65 }
66
66
67 def __str__(self):
67 def __str__(self):
68 return '<SysInfoRes({})>'.format(self.__json__())
68 return '<SysInfoRes({})>'.format(self.__json__())
69
69
70
70
71 class SysInfo(object):
71 class SysInfo(object):
72
72
73 def __init__(self, func_name, **kwargs):
73 def __init__(self, func_name, **kwargs):
74 self.func_name = func_name
74 self.func_name = func_name
75 self.value = _NA
75 self.value = _NA
76 self.state = None
76 self.state = None
77 self.kwargs = kwargs or {}
77 self.kwargs = kwargs or {}
78
78
79 def __call__(self):
79 def __call__(self):
80 computed = self.compute(**self.kwargs)
80 computed = self.compute(**self.kwargs)
81 if not isinstance(computed, SysInfoRes):
81 if not isinstance(computed, SysInfoRes):
82 raise ValueError(
82 raise ValueError(
83 'computed value for {} is not instance of '
83 'computed value for {} is not instance of '
84 '{}, got {} instead'.format(
84 '{}, got {} instead'.format(
85 self.func_name, SysInfoRes, type(computed)))
85 self.func_name, SysInfoRes, type(computed)))
86 return computed.__json__()
86 return computed.__json__()
87
87
88 def __str__(self):
88 def __str__(self):
89 return '<SysInfo({})>'.format(self.func_name)
89 return '<SysInfo({})>'.format(self.func_name)
90
90
91 def compute(self, **kwargs):
91 def compute(self, **kwargs):
92 return self.func_name(**kwargs)
92 return self.func_name(**kwargs)
93
93
94
94
95 # SysInfo functions
95 # SysInfo functions
96 def python_info():
96 def python_info():
97 value = dict(version=' '.join(platform._sys_version()),
97 value = dict(version=' '.join(platform._sys_version()),
98 executable=sys.executable)
98 executable=sys.executable)
99 return SysInfoRes(value=value)
99 return SysInfoRes(value=value)
100
100
101
101
102 def py_modules():
102 def py_modules():
103 mods = dict([(p.project_name, p.version)
103 mods = dict([(p.project_name, p.version)
104 for p in pkg_resources.working_set])
104 for p in pkg_resources.working_set])
105 value = sorted(mods.items(), key=lambda k: k[0].lower())
105 value = sorted(mods.items(), key=lambda k: k[0].lower())
106 return SysInfoRes(value=value)
106 return SysInfoRes(value=value)
107
107
108
108
109 def platform_type():
109 def platform_type():
110 from rhodecode.lib.utils import safe_unicode, generate_platform_uuid
110 from rhodecode.lib.utils import safe_unicode, generate_platform_uuid
111
111
112 value = dict(
112 value = dict(
113 name=safe_unicode(platform.platform()),
113 name=safe_unicode(platform.platform()),
114 uuid=generate_platform_uuid()
114 uuid=generate_platform_uuid()
115 )
115 )
116 return SysInfoRes(value=value)
116 return SysInfoRes(value=value)
117
117
118
118
119 def uptime():
119 def uptime():
120 from rhodecode.lib.helpers import age, time_to_datetime
120 from rhodecode.lib.helpers import age, time_to_datetime
121
121
122 value = dict(boot_time=0, uptime=0, text='')
122 value = dict(boot_time=0, uptime=0, text='')
123 state = STATE_OK_DEFAULT
123 state = STATE_OK_DEFAULT
124 if not psutil:
124 if not psutil:
125 return SysInfoRes(value=value, state=state)
125 return SysInfoRes(value=value, state=state)
126
126
127 boot_time = psutil.boot_time()
127 boot_time = psutil.boot_time()
128 value['boot_time'] = boot_time
128 value['boot_time'] = boot_time
129 value['uptime'] = time.time() - boot_time
129 value['uptime'] = time.time() - boot_time
130
130
131 human_value = value.copy()
131 human_value = value.copy()
132 human_value['boot_time'] = time_to_datetime(boot_time)
132 human_value['boot_time'] = time_to_datetime(boot_time)
133 human_value['uptime'] = age(time_to_datetime(boot_time), show_suffix=False)
133 human_value['uptime'] = age(time_to_datetime(boot_time), show_suffix=False)
134 human_value['text'] = 'Server started {}'.format(
134 human_value['text'] = 'Server started {}'.format(
135 age(time_to_datetime(boot_time)))
135 age(time_to_datetime(boot_time)))
136
136
137 return SysInfoRes(value=value, human_value=human_value)
137 return SysInfoRes(value=value, human_value=human_value)
138
138
139
139
140 def memory():
140 def memory():
141 from rhodecode.lib.helpers import format_byte_size_binary
141 from rhodecode.lib.helpers import format_byte_size_binary
142 value = dict(available=0, used=0, used_real=0, cached=0, percent=0,
142 value = dict(available=0, used=0, used_real=0, cached=0, percent=0,
143 percent_used=0, free=0, inactive=0, active=0, shared=0,
143 percent_used=0, free=0, inactive=0, active=0, shared=0,
144 total=0, buffers=0, text='')
144 total=0, buffers=0, text='')
145
145
146 state = STATE_OK_DEFAULT
146 state = STATE_OK_DEFAULT
147 if not psutil:
147 if not psutil:
148 return SysInfoRes(value=value, state=state)
148 return SysInfoRes(value=value, state=state)
149
149
150 value.update(dict(psutil.virtual_memory()._asdict()))
150 value.update(dict(psutil.virtual_memory()._asdict()))
151 value['used_real'] = value['total'] - value['available']
151 value['used_real'] = value['total'] - value['available']
152 value['percent_used'] = psutil._common.usage_percent(
152 value['percent_used'] = psutil._common.usage_percent(
153 value['used_real'], value['total'], 1)
153 value['used_real'], value['total'], 1)
154
154
155 human_value = value.copy()
155 human_value = value.copy()
156 human_value['text'] = '%s/%s, %s%% used' % (
156 human_value['text'] = '%s/%s, %s%% used' % (
157 format_byte_size_binary(value['used_real']),
157 format_byte_size_binary(value['used_real']),
158 format_byte_size_binary(value['total']),
158 format_byte_size_binary(value['total']),
159 value['percent_used'],)
159 value['percent_used'],)
160
160
161 keys = value.keys()[::]
161 keys = value.keys()[::]
162 keys.pop(keys.index('percent'))
162 keys.pop(keys.index('percent'))
163 keys.pop(keys.index('percent_used'))
163 keys.pop(keys.index('percent_used'))
164 keys.pop(keys.index('text'))
164 keys.pop(keys.index('text'))
165 for k in keys:
165 for k in keys:
166 human_value[k] = format_byte_size_binary(value[k])
166 human_value[k] = format_byte_size_binary(value[k])
167
167
168 if state['type'] == STATE_OK and value['percent_used'] > 90:
168 if state['type'] == STATE_OK and value['percent_used'] > 90:
169 msg = 'Critical: your available RAM memory is very low.'
169 msg = 'Critical: your available RAM memory is very low.'
170 state = {'message': msg, 'type': STATE_ERR}
170 state = {'message': msg, 'type': STATE_ERR}
171
171
172 elif state['type'] == STATE_OK and value['percent_used'] > 70:
172 elif state['type'] == STATE_OK and value['percent_used'] > 70:
173 msg = 'Warning: your available RAM memory is running low.'
173 msg = 'Warning: your available RAM memory is running low.'
174 state = {'message': msg, 'type': STATE_WARN}
174 state = {'message': msg, 'type': STATE_WARN}
175
175
176 return SysInfoRes(value=value, state=state, human_value=human_value)
176 return SysInfoRes(value=value, state=state, human_value=human_value)
177
177
178
178
179 def machine_load():
179 def machine_load():
180 value = {'1_min': _NA, '5_min': _NA, '15_min': _NA, 'text': ''}
180 value = {'1_min': _NA, '5_min': _NA, '15_min': _NA, 'text': ''}
181 state = STATE_OK_DEFAULT
181 state = STATE_OK_DEFAULT
182 if not psutil:
182 if not psutil:
183 return SysInfoRes(value=value, state=state)
183 return SysInfoRes(value=value, state=state)
184
184
185 # load averages
185 # load averages
186 if hasattr(psutil.os, 'getloadavg'):
186 if hasattr(psutil.os, 'getloadavg'):
187 value.update(dict(
187 value.update(dict(
188 zip(['1_min', '5_min', '15_min'], psutil.os.getloadavg())))
188 zip(['1_min', '5_min', '15_min'], psutil.os.getloadavg())))
189
189
190 human_value = value.copy()
190 human_value = value.copy()
191 human_value['text'] = '1min: {}, 5min: {}, 15min: {}'.format(
191 human_value['text'] = '1min: {}, 5min: {}, 15min: {}'.format(
192 value['1_min'], value['5_min'], value['15_min'])
192 value['1_min'], value['5_min'], value['15_min'])
193
193
194 if state['type'] == STATE_OK and value['15_min'] > 5:
194 if state['type'] == STATE_OK and value['15_min'] > 5:
195 msg = 'Warning: your machine load is very high.'
195 msg = 'Warning: your machine load is very high.'
196 state = {'message': msg, 'type': STATE_WARN}
196 state = {'message': msg, 'type': STATE_WARN}
197
197
198 return SysInfoRes(value=value, state=state, human_value=human_value)
198 return SysInfoRes(value=value, state=state, human_value=human_value)
199
199
200
200
201 def cpu():
201 def cpu():
202 value = 0
202 value = 0
203 state = STATE_OK_DEFAULT
203 state = STATE_OK_DEFAULT
204
204
205 if not psutil:
205 if not psutil:
206 return SysInfoRes(value=value, state=state)
206 return SysInfoRes(value=value, state=state)
207
207
208 value = psutil.cpu_percent(0.5)
208 value = psutil.cpu_percent(0.5)
209 human_value = '{} %'.format(value)
209 human_value = '{} %'.format(value)
210 return SysInfoRes(value=value, state=state, human_value=human_value)
210 return SysInfoRes(value=value, state=state, human_value=human_value)
211
211
212
212
213 def storage():
213 def storage():
214 from rhodecode.lib.helpers import format_byte_size_binary
214 from rhodecode.lib.helpers import format_byte_size_binary
215 from rhodecode.model.settings import VcsSettingsModel
215 from rhodecode.model.settings import VcsSettingsModel
216 path = VcsSettingsModel().get_repos_location()
216 path = VcsSettingsModel().get_repos_location()
217
217
218 value = dict(percent=0, used=0, total=0, path=path, text='')
218 value = dict(percent=0, used=0, total=0, path=path, text='')
219 state = STATE_OK_DEFAULT
219 state = STATE_OK_DEFAULT
220 if not psutil:
220 if not psutil:
221 return SysInfoRes(value=value, state=state)
221 return SysInfoRes(value=value, state=state)
222
222
223 try:
223 try:
224 value.update(dict(psutil.disk_usage(path)._asdict()))
224 value.update(dict(psutil.disk_usage(path)._asdict()))
225 except Exception as e:
225 except Exception as e:
226 log.exception('Failed to fetch disk info')
226 log.exception('Failed to fetch disk info')
227 state = {'message': str(e), 'type': STATE_ERR}
227 state = {'message': str(e), 'type': STATE_ERR}
228
228
229 human_value = value.copy()
229 human_value = value.copy()
230 human_value['used'] = format_byte_size_binary(value['used'])
230 human_value['used'] = format_byte_size_binary(value['used'])
231 human_value['total'] = format_byte_size_binary(value['total'])
231 human_value['total'] = format_byte_size_binary(value['total'])
232 human_value['text'] = "{}/{}, {}% used".format(
232 human_value['text'] = "{}/{}, {}% used".format(
233 format_byte_size_binary(value['used']),
233 format_byte_size_binary(value['used']),
234 format_byte_size_binary(value['total']),
234 format_byte_size_binary(value['total']),
235 value['percent'])
235 value['percent'])
236
236
237 if state['type'] == STATE_OK and value['percent'] > 90:
237 if state['type'] == STATE_OK and value['percent'] > 90:
238 msg = 'Critical: your disk space is very low.'
238 msg = 'Critical: your disk space is very low.'
239 state = {'message': msg, 'type': STATE_ERR}
239 state = {'message': msg, 'type': STATE_ERR}
240
240
241 elif state['type'] == STATE_OK and value['percent'] > 70:
241 elif state['type'] == STATE_OK and value['percent'] > 70:
242 msg = 'Warning: your disk space is running low.'
242 msg = 'Warning: your disk space is running low.'
243 state = {'message': msg, 'type': STATE_WARN}
243 state = {'message': msg, 'type': STATE_WARN}
244
244
245 return SysInfoRes(value=value, state=state, human_value=human_value)
245 return SysInfoRes(value=value, state=state, human_value=human_value)
246
246
247
247
248 def storage_inodes():
248 def storage_inodes():
249 from rhodecode.model.settings import VcsSettingsModel
249 from rhodecode.model.settings import VcsSettingsModel
250 path = VcsSettingsModel().get_repos_location()
250 path = VcsSettingsModel().get_repos_location()
251
251
252 value = dict(percent=0, free=0, used=0, total=0, path=path, text='')
252 value = dict(percent=0, free=0, used=0, total=0, path=path, text='')
253 state = STATE_OK_DEFAULT
253 state = STATE_OK_DEFAULT
254 if not psutil:
254 if not psutil:
255 return SysInfoRes(value=value, state=state)
255 return SysInfoRes(value=value, state=state)
256
256
257 try:
257 try:
258 i_stat = os.statvfs(path)
258 i_stat = os.statvfs(path)
259
259
260 value['used'] = i_stat.f_ffree
260 value['used'] = i_stat.f_ffree
261 value['free'] = i_stat.f_favail
261 value['free'] = i_stat.f_favail
262 value['total'] = i_stat.f_files
262 value['total'] = i_stat.f_files
263 value['percent'] = percentage(value['used'], value['total'])
263 value['percent'] = percentage(value['used'], value['total'])
264 except Exception as e:
264 except Exception as e:
265 log.exception('Failed to fetch disk inodes info')
265 log.exception('Failed to fetch disk inodes info')
266 state = {'message': str(e), 'type': STATE_ERR}
266 state = {'message': str(e), 'type': STATE_ERR}
267
267
268 human_value = value.copy()
268 human_value = value.copy()
269 human_value['text'] = "{}/{}, {}% used".format(
269 human_value['text'] = "{}/{}, {}% used".format(
270 value['used'], value['total'], value['percent'])
270 value['used'], value['total'], value['percent'])
271
271
272 if state['type'] == STATE_OK and value['percent'] > 90:
272 if state['type'] == STATE_OK and value['percent'] > 90:
273 msg = 'Critical: your disk free inodes are very low.'
273 msg = 'Critical: your disk free inodes are very low.'
274 state = {'message': msg, 'type': STATE_ERR}
274 state = {'message': msg, 'type': STATE_ERR}
275
275
276 elif state['type'] == STATE_OK and value['percent'] > 70:
276 elif state['type'] == STATE_OK and value['percent'] > 70:
277 msg = 'Warning: your disk free inodes are running low.'
277 msg = 'Warning: your disk free inodes are running low.'
278 state = {'message': msg, 'type': STATE_WARN}
278 state = {'message': msg, 'type': STATE_WARN}
279
279
280 return SysInfoRes(value=value, state=state, human_value=human_value)
280 return SysInfoRes(value=value, state=state, human_value=human_value)
281
281
282
282
283 def storage_archives():
283 def storage_archives():
284 import rhodecode
284 import rhodecode
285 from rhodecode.lib.utils import safe_str
285 from rhodecode.lib.utils import safe_str
286 from rhodecode.lib.helpers import format_byte_size_binary
286 from rhodecode.lib.helpers import format_byte_size_binary
287
287
288 msg = 'Enable this by setting ' \
288 msg = 'Enable this by setting ' \
289 'archive_cache_dir=/path/to/cache option in the .ini file'
289 'archive_cache_dir=/path/to/cache option in the .ini file'
290 path = safe_str(rhodecode.CONFIG.get('archive_cache_dir', msg))
290 path = safe_str(rhodecode.CONFIG.get('archive_cache_dir', msg))
291
291
292 value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
292 value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
293 state = STATE_OK_DEFAULT
293 state = STATE_OK_DEFAULT
294 try:
294 try:
295 items_count = 0
295 items_count = 0
296 used = 0
296 used = 0
297 for root, dirs, files in os.walk(path):
297 for root, dirs, files in os.walk(path):
298 if root == path:
298 if root == path:
299 items_count = len(files)
299 items_count = len(files)
300
300
301 for f in files:
301 for f in files:
302 try:
302 try:
303 used += os.path.getsize(os.path.join(root, f))
303 used += os.path.getsize(os.path.join(root, f))
304 except OSError:
304 except OSError:
305 pass
305 pass
306 value.update({
306 value.update({
307 'percent': 100,
307 'percent': 100,
308 'used': used,
308 'used': used,
309 'total': used,
309 'total': used,
310 'items': items_count
310 'items': items_count
311 })
311 })
312
312
313 except Exception as e:
313 except Exception as e:
314 log.exception('failed to fetch archive cache storage')
314 log.exception('failed to fetch archive cache storage')
315 state = {'message': str(e), 'type': STATE_ERR}
315 state = {'message': str(e), 'type': STATE_ERR}
316
316
317 human_value = value.copy()
317 human_value = value.copy()
318 human_value['used'] = format_byte_size_binary(value['used'])
318 human_value['used'] = format_byte_size_binary(value['used'])
319 human_value['total'] = format_byte_size_binary(value['total'])
319 human_value['total'] = format_byte_size_binary(value['total'])
320 human_value['text'] = "{} ({} items)".format(
320 human_value['text'] = "{} ({} items)".format(
321 human_value['used'], value['items'])
321 human_value['used'], value['items'])
322
322
323 return SysInfoRes(value=value, state=state, human_value=human_value)
323 return SysInfoRes(value=value, state=state, human_value=human_value)
324
324
325
325
326 def storage_gist():
326 def storage_gist():
327 from rhodecode.model.gist import GIST_STORE_LOC
327 from rhodecode.model.gist import GIST_STORE_LOC
328 from rhodecode.model.settings import VcsSettingsModel
328 from rhodecode.model.settings import VcsSettingsModel
329 from rhodecode.lib.utils import safe_str
329 from rhodecode.lib.utils import safe_str
330 from rhodecode.lib.helpers import format_byte_size_binary
330 from rhodecode.lib.helpers import format_byte_size_binary
331 path = safe_str(os.path.join(
331 path = safe_str(os.path.join(
332 VcsSettingsModel().get_repos_location(), GIST_STORE_LOC))
332 VcsSettingsModel().get_repos_location(), GIST_STORE_LOC))
333
333
334 # gist storage
334 # gist storage
335 value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
335 value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
336 state = STATE_OK_DEFAULT
336 state = STATE_OK_DEFAULT
337
337
338 try:
338 try:
339 items_count = 0
339 items_count = 0
340 used = 0
340 used = 0
341 for root, dirs, files in os.walk(path):
341 for root, dirs, files in os.walk(path):
342 if root == path:
342 if root == path:
343 items_count = len(dirs)
343 items_count = len(dirs)
344
344
345 for f in files:
345 for f in files:
346 try:
346 try:
347 used += os.path.getsize(os.path.join(root, f))
347 used += os.path.getsize(os.path.join(root, f))
348 except OSError:
348 except OSError:
349 pass
349 pass
350 value.update({
350 value.update({
351 'percent': 100,
351 'percent': 100,
352 'used': used,
352 'used': used,
353 'total': used,
353 'total': used,
354 'items': items_count
354 'items': items_count
355 })
355 })
356 except Exception as e:
356 except Exception as e:
357 log.exception('failed to fetch gist storage items')
357 log.exception('failed to fetch gist storage items')
358 state = {'message': str(e), 'type': STATE_ERR}
358 state = {'message': str(e), 'type': STATE_ERR}
359
359
360 human_value = value.copy()
360 human_value = value.copy()
361 human_value['used'] = format_byte_size_binary(value['used'])
361 human_value['used'] = format_byte_size_binary(value['used'])
362 human_value['total'] = format_byte_size_binary(value['total'])
362 human_value['total'] = format_byte_size_binary(value['total'])
363 human_value['text'] = "{} ({} items)".format(
363 human_value['text'] = "{} ({} items)".format(
364 human_value['used'], value['items'])
364 human_value['used'], value['items'])
365
365
366 return SysInfoRes(value=value, state=state, human_value=human_value)
366 return SysInfoRes(value=value, state=state, human_value=human_value)
367
367
368
368
369 def storage_temp():
369 def storage_temp():
370 import tempfile
370 import tempfile
371 from rhodecode.lib.helpers import format_byte_size_binary
371 from rhodecode.lib.helpers import format_byte_size_binary
372
372
373 path = tempfile.gettempdir()
373 path = tempfile.gettempdir()
374 value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
374 value = dict(percent=0, used=0, total=0, items=0, path=path, text='')
375 state = STATE_OK_DEFAULT
375 state = STATE_OK_DEFAULT
376
376
377 if not psutil:
377 if not psutil:
378 return SysInfoRes(value=value, state=state)
378 return SysInfoRes(value=value, state=state)
379
379
380 try:
380 try:
381 value.update(dict(psutil.disk_usage(path)._asdict()))
381 value.update(dict(psutil.disk_usage(path)._asdict()))
382 except Exception as e:
382 except Exception as e:
383 log.exception('Failed to fetch temp dir info')
383 log.exception('Failed to fetch temp dir info')
384 state = {'message': str(e), 'type': STATE_ERR}
384 state = {'message': str(e), 'type': STATE_ERR}
385
385
386 human_value = value.copy()
386 human_value = value.copy()
387 human_value['used'] = format_byte_size_binary(value['used'])
387 human_value['used'] = format_byte_size_binary(value['used'])
388 human_value['total'] = format_byte_size_binary(value['total'])
388 human_value['total'] = format_byte_size_binary(value['total'])
389 human_value['text'] = "{}/{}, {}% used".format(
389 human_value['text'] = "{}/{}, {}% used".format(
390 format_byte_size_binary(value['used']),
390 format_byte_size_binary(value['used']),
391 format_byte_size_binary(value['total']),
391 format_byte_size_binary(value['total']),
392 value['percent'])
392 value['percent'])
393
393
394 return SysInfoRes(value=value, state=state, human_value=human_value)
394 return SysInfoRes(value=value, state=state, human_value=human_value)
395
395
396
396
397 def search_info():
397 def search_info():
398 import rhodecode
398 import rhodecode
399 from rhodecode.lib.index import searcher_from_config
399 from rhodecode.lib.index import searcher_from_config
400
400
401 backend = rhodecode.CONFIG.get('search.module', '')
401 backend = rhodecode.CONFIG.get('search.module', '')
402 location = rhodecode.CONFIG.get('search.location', '')
402 location = rhodecode.CONFIG.get('search.location', '')
403
403
404 try:
404 try:
405 searcher = searcher_from_config(rhodecode.CONFIG)
405 searcher = searcher_from_config(rhodecode.CONFIG)
406 searcher = searcher.__class__.__name__
406 searcher = searcher.__class__.__name__
407 except Exception:
407 except Exception:
408 searcher = None
408 searcher = None
409
409
410 value = dict(
410 value = dict(
411 backend=backend, searcher=searcher, location=location, text='')
411 backend=backend, searcher=searcher, location=location, text='')
412 state = STATE_OK_DEFAULT
412 state = STATE_OK_DEFAULT
413
413
414 human_value = value.copy()
414 human_value = value.copy()
415 human_value['text'] = "backend:`{}`".format(human_value['backend'])
415 human_value['text'] = "backend:`{}`".format(human_value['backend'])
416
416
417 return SysInfoRes(value=value, state=state, human_value=human_value)
417 return SysInfoRes(value=value, state=state, human_value=human_value)
418
418
419
419
420 def git_info():
420 def git_info():
421 from rhodecode.lib.vcs.backends import git
421 from rhodecode.lib.vcs.backends import git
422 state = STATE_OK_DEFAULT
422 state = STATE_OK_DEFAULT
423 value = human_value = ''
423 value = human_value = ''
424 try:
424 try:
425 value = git.discover_git_version(raise_on_exc=True)
425 value = git.discover_git_version(raise_on_exc=True)
426 human_value = 'version reported from VCSServer: {}'.format(value)
426 human_value = 'version reported from VCSServer: {}'.format(value)
427 except Exception as e:
427 except Exception as e:
428 state = {'message': str(e), 'type': STATE_ERR}
428 state = {'message': str(e), 'type': STATE_ERR}
429
429
430 return SysInfoRes(value=value, state=state, human_value=human_value)
430 return SysInfoRes(value=value, state=state, human_value=human_value)
431
431
432
432
433 def hg_info():
433 def hg_info():
434 from rhodecode.lib.vcs.backends import hg
434 from rhodecode.lib.vcs.backends import hg
435 state = STATE_OK_DEFAULT
435 state = STATE_OK_DEFAULT
436 value = human_value = ''
436 value = human_value = ''
437 try:
437 try:
438 value = hg.discover_hg_version(raise_on_exc=True)
438 value = hg.discover_hg_version(raise_on_exc=True)
439 human_value = 'version reported from VCSServer: {}'.format(value)
439 human_value = 'version reported from VCSServer: {}'.format(value)
440 except Exception as e:
440 except Exception as e:
441 state = {'message': str(e), 'type': STATE_ERR}
441 state = {'message': str(e), 'type': STATE_ERR}
442 return SysInfoRes(value=value, state=state, human_value=human_value)
442 return SysInfoRes(value=value, state=state, human_value=human_value)
443
443
444
444
445 def svn_info():
445 def svn_info():
446 from rhodecode.lib.vcs.backends import svn
446 from rhodecode.lib.vcs.backends import svn
447 state = STATE_OK_DEFAULT
447 state = STATE_OK_DEFAULT
448 value = human_value = ''
448 value = human_value = ''
449 try:
449 try:
450 value = svn.discover_svn_version(raise_on_exc=True)
450 value = svn.discover_svn_version(raise_on_exc=True)
451 human_value = 'version reported from VCSServer: {}'.format(value)
451 human_value = 'version reported from VCSServer: {}'.format(value)
452 except Exception as e:
452 except Exception as e:
453 state = {'message': str(e), 'type': STATE_ERR}
453 state = {'message': str(e), 'type': STATE_ERR}
454 return SysInfoRes(value=value, state=state, human_value=human_value)
454 return SysInfoRes(value=value, state=state, human_value=human_value)
455
455
456
456
457 def vcs_backends():
457 def vcs_backends():
458 import rhodecode
458 import rhodecode
459 value = map(
459 value = map(
460 string.strip, rhodecode.CONFIG.get('vcs.backends', '').split(','))
460 string.strip, rhodecode.CONFIG.get('vcs.backends', '').split(','))
461 human_value = 'Enabled backends in order: {}'.format(','.join(value))
461 human_value = 'Enabled backends in order: {}'.format(','.join(value))
462 return SysInfoRes(value=value, human_value=human_value)
462 return SysInfoRes(value=value, human_value=human_value)
463
463
464
464
465 def vcs_server():
465 def vcs_server():
466 import rhodecode
466 import rhodecode
467 from rhodecode.lib.vcs.backends import get_vcsserver_version
467 from rhodecode.lib.vcs.backends import get_vcsserver_version
468
468
469 server_url = rhodecode.CONFIG.get('vcs.server')
469 server_url = rhodecode.CONFIG.get('vcs.server')
470 enabled = rhodecode.CONFIG.get('vcs.server.enable')
470 enabled = rhodecode.CONFIG.get('vcs.server.enable')
471 protocol = rhodecode.CONFIG.get('vcs.server.protocol')
471 protocol = rhodecode.CONFIG.get('vcs.server.protocol') or 'http'
472 state = STATE_OK_DEFAULT
472 state = STATE_OK_DEFAULT
473 version = None
473 version = None
474
474
475 try:
475 try:
476 version = get_vcsserver_version()
476 version = get_vcsserver_version()
477 connection = 'connected'
477 connection = 'connected'
478 except Exception as e:
478 except Exception as e:
479 connection = 'failed'
479 connection = 'failed'
480 state = {'message': str(e), 'type': STATE_ERR}
480 state = {'message': str(e), 'type': STATE_ERR}
481
481
482 value = dict(
482 value = dict(
483 url=server_url,
483 url=server_url,
484 enabled=enabled,
484 enabled=enabled,
485 protocol=protocol,
485 protocol=protocol,
486 connection=connection,
486 connection=connection,
487 version=version,
487 version=version,
488 text='',
488 text='',
489 )
489 )
490
490
491 human_value = value.copy()
491 human_value = value.copy()
492 human_value['text'] = \
492 human_value['text'] = \
493 '{url}@ver:{ver} via {mode} mode, connection:{conn}'.format(
493 '{url}@ver:{ver} via {mode} mode, connection:{conn}'.format(
494 url=server_url, ver=version, mode=protocol, conn=connection)
494 url=server_url, ver=version, mode=protocol, conn=connection)
495
495
496 return SysInfoRes(value=value, state=state, human_value=human_value)
496 return SysInfoRes(value=value, state=state, human_value=human_value)
497
497
498
498
499 def rhodecode_app_info():
499 def rhodecode_app_info():
500 import rhodecode
500 import rhodecode
501 edition = rhodecode.CONFIG.get('rhodecode.edition')
501 edition = rhodecode.CONFIG.get('rhodecode.edition')
502
502
503 value = dict(
503 value = dict(
504 rhodecode_version=rhodecode.__version__,
504 rhodecode_version=rhodecode.__version__,
505 rhodecode_lib_path=os.path.abspath(rhodecode.__file__),
505 rhodecode_lib_path=os.path.abspath(rhodecode.__file__),
506 text=''
506 text=''
507 )
507 )
508 human_value = value.copy()
508 human_value = value.copy()
509 human_value['text'] = 'RhodeCode {edition}, version {ver}'.format(
509 human_value['text'] = 'RhodeCode {edition}, version {ver}'.format(
510 edition=edition, ver=value['rhodecode_version']
510 edition=edition, ver=value['rhodecode_version']
511 )
511 )
512 return SysInfoRes(value=value, human_value=human_value)
512 return SysInfoRes(value=value, human_value=human_value)
513
513
514
514
515 def rhodecode_config():
515 def rhodecode_config():
516 import rhodecode
516 import rhodecode
517 path = rhodecode.CONFIG.get('__file__')
517 path = rhodecode.CONFIG.get('__file__')
518 rhodecode_ini_safe = rhodecode.CONFIG.copy()
518 rhodecode_ini_safe = rhodecode.CONFIG.copy()
519
519
520 blacklist = [
520 blacklist = [
521 'rhodecode_license_key',
521 'rhodecode_license_key',
522 'routes.map',
522 'routes.map',
523 'pylons.h',
523 'pylons.h',
524 'pylons.app_globals',
524 'pylons.app_globals',
525 'pylons.environ_config',
525 'pylons.environ_config',
526 'sqlalchemy.db1.url',
526 'sqlalchemy.db1.url',
527 'channelstream.secret',
527 'channelstream.secret',
528 'beaker.session.secret',
528 'beaker.session.secret',
529 'rhodecode.encrypted_values.secret',
529 'rhodecode.encrypted_values.secret',
530 'rhodecode_auth_github_consumer_key',
530 'rhodecode_auth_github_consumer_key',
531 'rhodecode_auth_github_consumer_secret',
531 'rhodecode_auth_github_consumer_secret',
532 'rhodecode_auth_google_consumer_key',
532 'rhodecode_auth_google_consumer_key',
533 'rhodecode_auth_google_consumer_secret',
533 'rhodecode_auth_google_consumer_secret',
534 'rhodecode_auth_bitbucket_consumer_secret',
534 'rhodecode_auth_bitbucket_consumer_secret',
535 'rhodecode_auth_bitbucket_consumer_key',
535 'rhodecode_auth_bitbucket_consumer_key',
536 'rhodecode_auth_twitter_consumer_secret',
536 'rhodecode_auth_twitter_consumer_secret',
537 'rhodecode_auth_twitter_consumer_key',
537 'rhodecode_auth_twitter_consumer_key',
538
538
539 'rhodecode_auth_twitter_secret',
539 'rhodecode_auth_twitter_secret',
540 'rhodecode_auth_github_secret',
540 'rhodecode_auth_github_secret',
541 'rhodecode_auth_google_secret',
541 'rhodecode_auth_google_secret',
542 'rhodecode_auth_bitbucket_secret',
542 'rhodecode_auth_bitbucket_secret',
543
543
544 'appenlight.api_key',
544 'appenlight.api_key',
545 ('app_conf', 'sqlalchemy.db1.url')
545 ('app_conf', 'sqlalchemy.db1.url')
546 ]
546 ]
547 for k in blacklist:
547 for k in blacklist:
548 if isinstance(k, tuple):
548 if isinstance(k, tuple):
549 section, key = k
549 section, key = k
550 if section in rhodecode_ini_safe:
550 if section in rhodecode_ini_safe:
551 rhodecode_ini_safe[section] = '**OBFUSCATED**'
551 rhodecode_ini_safe[section] = '**OBFUSCATED**'
552 else:
552 else:
553 rhodecode_ini_safe.pop(k, None)
553 rhodecode_ini_safe.pop(k, None)
554
554
555 # TODO: maybe put some CONFIG checks here ?
555 # TODO: maybe put some CONFIG checks here ?
556 return SysInfoRes(value={'config': rhodecode_ini_safe, 'path': path})
556 return SysInfoRes(value={'config': rhodecode_ini_safe, 'path': path})
557
557
558
558
559 def database_info():
559 def database_info():
560 import rhodecode
560 import rhodecode
561 from sqlalchemy.engine import url as engine_url
561 from sqlalchemy.engine import url as engine_url
562 from rhodecode.model.meta import Base as sql_base, Session
562 from rhodecode.model.meta import Base as sql_base, Session
563 from rhodecode.model.db import DbMigrateVersion
563 from rhodecode.model.db import DbMigrateVersion
564
564
565 state = STATE_OK_DEFAULT
565 state = STATE_OK_DEFAULT
566
566
567 db_migrate = DbMigrateVersion.query().filter(
567 db_migrate = DbMigrateVersion.query().filter(
568 DbMigrateVersion.repository_id == 'rhodecode_db_migrations').one()
568 DbMigrateVersion.repository_id == 'rhodecode_db_migrations').one()
569
569
570 db_url_obj = engine_url.make_url(rhodecode.CONFIG['sqlalchemy.db1.url'])
570 db_url_obj = engine_url.make_url(rhodecode.CONFIG['sqlalchemy.db1.url'])
571
571
572 try:
572 try:
573 engine = sql_base.metadata.bind
573 engine = sql_base.metadata.bind
574 db_server_info = engine.dialect._get_server_version_info(
574 db_server_info = engine.dialect._get_server_version_info(
575 Session.connection(bind=engine))
575 Session.connection(bind=engine))
576 db_version = '.'.join(map(str, db_server_info))
576 db_version = '.'.join(map(str, db_server_info))
577 except Exception:
577 except Exception:
578 log.exception('failed to fetch db version')
578 log.exception('failed to fetch db version')
579 db_version = 'UNKNOWN'
579 db_version = 'UNKNOWN'
580
580
581 db_info = dict(
581 db_info = dict(
582 migrate_version=db_migrate.version,
582 migrate_version=db_migrate.version,
583 type=db_url_obj.get_backend_name(),
583 type=db_url_obj.get_backend_name(),
584 version=db_version,
584 version=db_version,
585 url=repr(db_url_obj)
585 url=repr(db_url_obj)
586 )
586 )
587
587
588 human_value = db_info.copy()
588 human_value = db_info.copy()
589 human_value['url'] = "{} @ migration version: {}".format(
589 human_value['url'] = "{} @ migration version: {}".format(
590 db_info['url'], db_info['migrate_version'])
590 db_info['url'], db_info['migrate_version'])
591 human_value['version'] = "{} {}".format(db_info['type'], db_info['version'])
591 human_value['version'] = "{} {}".format(db_info['type'], db_info['version'])
592 return SysInfoRes(value=db_info, state=state, human_value=human_value)
592 return SysInfoRes(value=db_info, state=state, human_value=human_value)
593
593
594
594
595 def server_info(environ):
595 def server_info(environ):
596 import rhodecode
596 import rhodecode
597 from rhodecode.lib.base import get_server_ip_addr, get_server_port
597 from rhodecode.lib.base import get_server_ip_addr, get_server_port
598
598
599 value = {
599 value = {
600 'server_ip': '%s:%s' % (
600 'server_ip': '%s:%s' % (
601 get_server_ip_addr(environ, log_errors=False),
601 get_server_ip_addr(environ, log_errors=False),
602 get_server_port(environ)
602 get_server_port(environ)
603 ),
603 ),
604 'server_id': rhodecode.CONFIG.get('instance_id'),
604 'server_id': rhodecode.CONFIG.get('instance_id'),
605 }
605 }
606 return SysInfoRes(value=value)
606 return SysInfoRes(value=value)
607
607
608
608
609 def get_system_info(environ):
609 def get_system_info(environ):
610 environ = environ or {}
610 environ = environ or {}
611 return {
611 return {
612 'rhodecode_app': SysInfo(rhodecode_app_info)(),
612 'rhodecode_app': SysInfo(rhodecode_app_info)(),
613 'rhodecode_config': SysInfo(rhodecode_config)(),
613 'rhodecode_config': SysInfo(rhodecode_config)(),
614 'python': SysInfo(python_info)(),
614 'python': SysInfo(python_info)(),
615 'py_modules': SysInfo(py_modules)(),
615 'py_modules': SysInfo(py_modules)(),
616
616
617 'platform': SysInfo(platform_type)(),
617 'platform': SysInfo(platform_type)(),
618 'server': SysInfo(server_info, environ=environ)(),
618 'server': SysInfo(server_info, environ=environ)(),
619 'database': SysInfo(database_info)(),
619 'database': SysInfo(database_info)(),
620
620
621 'storage': SysInfo(storage)(),
621 'storage': SysInfo(storage)(),
622 'storage_inodes': SysInfo(storage_inodes)(),
622 'storage_inodes': SysInfo(storage_inodes)(),
623 'storage_archive': SysInfo(storage_archives)(),
623 'storage_archive': SysInfo(storage_archives)(),
624 'storage_gist': SysInfo(storage_gist)(),
624 'storage_gist': SysInfo(storage_gist)(),
625 'storage_temp': SysInfo(storage_temp)(),
625 'storage_temp': SysInfo(storage_temp)(),
626
626
627 'search': SysInfo(search_info)(),
627 'search': SysInfo(search_info)(),
628
628
629 'uptime': SysInfo(uptime)(),
629 'uptime': SysInfo(uptime)(),
630 'load': SysInfo(machine_load)(),
630 'load': SysInfo(machine_load)(),
631 'cpu': SysInfo(cpu)(),
631 'cpu': SysInfo(cpu)(),
632 'memory': SysInfo(memory)(),
632 'memory': SysInfo(memory)(),
633
633
634 'vcs_backends': SysInfo(vcs_backends)(),
634 'vcs_backends': SysInfo(vcs_backends)(),
635 'vcs_server': SysInfo(vcs_server)(),
635 'vcs_server': SysInfo(vcs_server)(),
636
636
637 'git': SysInfo(git_info)(),
637 'git': SysInfo(git_info)(),
638 'hg': SysInfo(hg_info)(),
638 'hg': SysInfo(hg_info)(),
639 'svn': SysInfo(svn_info)(),
639 'svn': SysInfo(svn_info)(),
640 }
640 }
General Comments 0
You need to be logged in to leave comments. Login now