def slow_response(req, service_name): items = [] input_dict = { 'name': service_name, } zato_message, soap_response = invoke_admin_service(req.zato.cluster, 'zato:service.slow-response.get-list', input_dict) if zato_path('response.item_list.item').get_from(zato_message) is not None: for _item in zato_message.response.item_list.item: item = SlowResponse() item.cid = _item.cid.text item.req_ts = from_utc_to_user(_item.req_ts.text+'+00:00', req.zato.user_profile) item.resp_ts = from_utc_to_user(_item.resp_ts.text+'+00:00', req.zato.user_profile) item.proc_time = _item.proc_time.text item.service_name = service_name items.append(item) return_data = { 'cluster_id': req.zato.cluster_id, 'service': _get_service(req, service_name), 'items': items, } return TemplateResponse(req, 'zato/service/slow-response.html', return_data)
def shift(utc_base_date, user_start, user_profile, shift_type, duration, format): """ Shifts the base date by the amount specified and returns resulting start and stop dates in UTC and user timezone. """ if shift_type not in start_delta_kwargs: raise ValueError('Unknown shift_type:[{}]'.format(shift_type)) _start_delta_kwargs = start_delta_kwargs[shift_type] # Special-case month duration because UTC '2012-09-30 22:00:00+00:00' (which is 2012-10-01 CEST) # minus one month happens to be '2012-08-30 22:00:00+00:00' instead of '2012-09-31 22:00:00+00:00' # so it's 2012-08-30 CEST instead of 2012-09-01. In other words, we would've jumped from Oct 2012 to Aug 2012 directly. if duration != 'month': utc_start = utc_base_date + relativedelta(**_start_delta_kwargs) else: user_start = datetime.strptime(user_start, user_profile.month_year_format_strptime) current_month_start = datetime(user_start.year, user_start.month, 1) prev_month_start = current_month_start + relativedelta(**_start_delta_kwargs) utc_start = from_local_to_utc(prev_month_start, user_profile.timezone) _stop_delta_kwargs = stop_delta_kwargs[duration] utc_stop = utc_start + relativedelta(**_stop_delta_kwargs) user_start = from_utc_to_user(utc_start, user_profile, format) user_stop = from_utc_to_user(utc_stop, user_profile, format) return DateInfo(utc_start.isoformat(), utc_stop.isoformat(), user_start, user_stop)
def details(req, source_type, cluster_id, msg_id, topic_name): item = None pretty_print = asbool(req.GET.get('pretty_print')) input_dict = { 'cluster_id': cluster_id, 'msg_id': msg_id, } response = req.zato.client.invoke('zato.pubsub.message.get', input_dict) if response.has_data: item = Message() for name in('topic', 'producer', 'priority', 'mime_type', 'expiration', 'creation_time_utc', 'expire_at_utc', 'payload'): setattr(item, name, getattr(response.data, name, None)) item.creation_time = from_utc_to_user(item.creation_time_utc+'+00:00', req.zato.user_profile) item.expire_at = from_utc_to_user(item.expire_at_utc+'+00:00', req.zato.user_profile) return_data = { 'cluster_id': req.zato.cluster_id, 'item': item, 'pretty_print': not pretty_print, 'msg_id': msg_id, 'topic_name': topic_name, 'source_type': source_type, 'sub_key': req.GET.get('sub_key') } return TemplateResponse(req, 'zato/pubsub/message/details.html', return_data)
def _interval_based_job_def(user_profile, start_date, repeats, weeks, days, hours, minutes, seconds): buf = StringIO() if start_date: buf.write('Start on {0} at {1}.'.format( from_utc_to_user(start_date, user_profile, 'date'), from_utc_to_user(start_date, user_profile, 'time'))) if not repeats: buf.write(' Repeat indefinitely.') else: if repeats == 1: buf.write(' Execute once.') elif repeats == 2: buf.write(' Repeat twice.') # .. my hand is itching to add 'repeats thrice.' here ;-) elif repeats > 2: buf.write(' Repeat ') buf.write(str(repeats)) buf.write(' times.') interval = [] buf.write(' Interval: ') for name, value in (('week',weeks), ('day',days), ('hour',hours), ('minute',minutes), ('second',seconds)): if value: value = int(value) interval.append('{0} {1}{2}'.format(value, name, 's' if value > 1 else '')) buf.write(', '.join(interval)) buf.write('.') return buf.getvalue()
def audit_log(req, **kwargs): out = kwargs out['req'] = req out.update(get_js_dt_format(req.zato.user_profile)) for key in('batch_size', 'current_batch', 'start', 'stop', 'state', 'query'): value = req.GET.get(key) if value: out[key] = value out['form'] = AuditLogEntryList(initial=out) request = { 'conn_id': out['conn_id'], 'start': out.get('start', ''), 'stop': out.get('stop'), 'current_batch': out.get('current_batch', BATCH_DEFAULTS.PAGE_NO), 'batch_size': out.get('batch_size', BATCH_DEFAULTS.SIZE), 'query': out.get('query', ''), } out['items'] = [] response = req.zato.client.invoke('zato.http-soap.get-audit-item-list', request) if response.ok: for item in response.data: item.req_time = from_utc_to_user(item.req_time_utc+'+00:00', req.zato.user_profile) item.resp_time = from_utc_to_user(item.resp_time_utc+'+00:00', req.zato.user_profile) if item.resp_time_utc else '(None)' out['items'].append(item) out.update(**req.zato.client.invoke('zato.http-soap.get-audit-batch-info', request).data) return TemplateResponse(req, 'zato/http_soap/audit/log.html', out)
def _cron_style_job_def(user_profile, start_date, cron_definition): start_date = _get_start_date(start_date) buf = StringIO() buf.write('Start on {0} at {1}.'.format( from_utc_to_user(start_date, user_profile, 'date'), from_utc_to_user(start_date, user_profile, 'time'))) buf.write('<br/>{0}'.format(cron_definition)) return buf.getvalue()
def maintenance_delete(req): start = from_user_to_utc(req.POST['start'], req.zato.user_profile) stop = from_user_to_utc(req.POST['stop'], req.zato.user_profile) req.zato.client.invoke('zato.stats.delete', {'start':start, 'stop':stop}) msg = 'Submitted a request to delete statistics from [{}] to [{}]. Check the server logs for details.'.format( from_utc_to_user(start.isoformat() + '+00:00', req.zato.user_profile), from_utc_to_user(stop.isoformat() + '+00:00', req.zato.user_profile)) messages.add_message(req, messages.INFO, msg, extra_tags='success') return redirect('{}?cluster={}'.format(reverse('stats-maintenance'), req.zato.cluster_id))
def slow_response_details(req, cid, service_name): item = None service = _get_service(req, service_name) pretty_print = asbool(req.GET.get('pretty_print')) input_dict = { 'cid': cid, 'name': service_name, } response = req.zato.client.invoke('zato.service.slow-response.get', input_dict) if response.has_data: cid = response.data.cid if cid != ZATO_NONE: item = SlowResponse() item.cid = response.data.cid item.req_ts = from_utc_to_user(response.data.req_ts+'+00:00', req.zato.user_profile) item.resp_ts = from_utc_to_user(response.data.resp_ts+'+00:00', req.zato.user_profile) item.proc_time = response.data.proc_time item.service_name = service_name item.threshold = service.slow_threshold for name in('req', 'resp'): value = getattr(response.data, name) if value: #value = value.decode('base64') if isinstance(value, dict): value = dumps(value) data_format = 'json' else: data_format = known_data_format(value) if data_format: if pretty_print: value = get_pretty_print(value, data_format) attr_name = name + '_html' setattr(item, attr_name, highlight(value, data_format_lexer[data_format](), HtmlFormatter(linenos='table'))) return_data = { 'cluster_id': req.zato.cluster_id, 'service': service, 'item': item, 'pretty_print': not pretty_print, } return TemplateResponse(req, 'zato/service/slow-response-details.html', return_data)
def slow_response_details(req, cid, service_name): item = None service = _get_service(req, service_name) pretty_print = asbool(req.GET.get("pretty_print")) input_dict = {"cid": cid, "name": service_name} response = req.zato.client.invoke("zato.service.slow-response.get", input_dict) if response.has_data: cid = response.data.cid if cid != ZATO_NONE: item = SlowResponse() item.cid = response.data.cid item.req_ts = from_utc_to_user(response.data.req_ts + "+00:00", req.zato.user_profile) item.resp_ts = from_utc_to_user(response.data.resp_ts + "+00:00", req.zato.user_profile) item.proc_time = response.data.proc_time item.service_name = service_name item.threshold = service.slow_threshold for name in ("req", "resp"): value = getattr(response.data, name) if value: # value = value.decode('base64') if isinstance(value, dict): value = dumps(value) data_format = "json" else: data_format = known_data_format(value) if data_format: if pretty_print: value = get_pretty_print(value, data_format) attr_name = name + "_html" setattr( item, attr_name, highlight(value, data_format_lexer[data_format](), HtmlFormatter(linenos="table")), ) return_data = { "cluster_id": req.zato.cluster_id, "service": service, "item": item, "pretty_print": not pretty_print, } return TemplateResponse(req, "zato/service/slow-response-details.html", return_data)
def _common_edit_message( client, success_msg, id, name, host, up_status, up_mod_date, cluster_id, user_profile, fetch_lb_data=True ): """ Returns a common JSON message for both the actual 'edit' and 'add/remove to/from LB' actions. """ return_data = { "id": id, "name": name, "host": host if host else "(unknown)", "up_status": up_status if up_status else "(unknown)", "up_mod_date": from_utc_to_user(up_mod_date + "+00:00", user_profile) if up_mod_date else "(unknown)", "cluster_id": cluster_id if cluster_id else "", "lb_state": "(unknown)", "lb_address": "(unknown)", "in_lb": "(unknown)", "message": success_msg.format(name), } if fetch_lb_data: lb_server_data = _get_server_data(client, name) return_data.update( {"lb_state": lb_server_data.state, "lb_address": lb_server_data.lb_address, "in_lb": lb_server_data.in_lb} ) return HttpResponse(dumps(return_data), mimetype="application/javascript")
def _common_edit_message(client, success_msg, id, name, host, up_status, up_mod_date, cluster_id, user_profile, fetch_lb_data=True): """ Returns a common JSON message for both the actual 'edit' and 'add/remove to/from LB' actions. """ return_data = { 'id': id, 'name': name, 'host': host if host else '(unknown)', 'up_status': up_status if up_status else '(unknown)', 'up_mod_date': from_utc_to_user(up_mod_date+'+00:00', user_profile) if up_mod_date else '(unknown)', 'cluster_id': cluster_id if cluster_id else '', 'lb_state': '(unknown)', 'lb_address': '(unknown)', 'in_lb': '(unknown)', 'message': success_msg.format(name) } if fetch_lb_data: lb_server_data = _get_server_data(client, name) return_data.update({ 'lb_state': lb_server_data.state, 'lb_address': lb_server_data.lb_address, 'in_lb': lb_server_data.in_lb, }) return HttpResponse(dumps(return_data), mimetype='application/javascript')
def __call__(self, req, initial_input_dict={}, initial_return_data={}, *args, **kwargs): edit_name = req.POST.get('edit-name') name = req.POST.get('name', edit_name) initial_return_data = { 'current_depth': 0, 'consumers_count': 0, 'producers_count': 0, 'last_pub_time': None, 'cluster_id': req.zato.cluster_id, 'name': name, } if edit_name: response = req.zato.client.invoke('zato.pubsub.topics.get-info', { 'cluster_id': req.zato.cluster_id, 'name': edit_name }) if response.ok: initial_return_data.update(response.data) initial_return_data['last_pub_time'] = from_utc_to_user( initial_return_data['last_pub_time'] + '+00:00', req.zato.user_profile) return super(_CreateEdit, self).__call__( req, initial_input_dict={}, initial_return_data=initial_return_data, *args, **kwargs)
def post_process_return_data(self, return_data): is_active = False for name in('is_active', 'edit-is_active'): if name in self.req.POST: is_active = True break return_data['is_active'] = is_active return_data['topic_name'] = self.req.POST['topic_name'] return_data['message'] = 'Successfully {} consumer `{}`'.format(self.verb, return_data['name']) return_data['last_seen'] = None return_data['current_depth'] = 0 client_id = self.req.POST.get('id') if client_id: response = self.req.zato.client.invoke('zato.pubsub.consumers.get-info', {'id': client_id}) if response.ok: return_data['current_depth'] = response.data.current_depth return_data['in_flight_depth'] = response.data.in_flight_depth return_data['sub_key'] = response.data.sub_key if response.data.last_seen: return_data['last_seen'] = from_utc_to_user(response.data.last_seen + '+00:00', self.req.zato.user_profile) return return_data
def test_shift_prev_week_by_day(self): now = parse('2012-03-21T00:39:19+00:00') info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'today_prev_day_week', 'day', 'date') eq_(info.utc_start, '2012-03-14T00:39:19+00:00') eq_(info.utc_stop, '2012-03-15T00:39:19+00:00') eq_(info.user_start, '14-03-2012') eq_(info.user_stop, '15-03-2012') eq_(info.step, None)
def test_shift_prev_month_by_month(self): now = parse('2012-10-01T00:00:00+00:00') info = shift(now, from_utc_to_user(now, self.user_profile, 'month_year'), self.user_profile, 'this_month_prev_month', 'month', 'month_year') eq_(info.utc_start, '2012-08-31T22:00:00+00:00') eq_(info.utc_stop, '2012-09-30T22:00:00+00:00') eq_(info.user_start, '09-2012') eq_(info.user_stop, '10-2012') eq_(info.step, None)
def test_shift_prev_year_by_year(self): now = parse('2012-01-01T00:00:00+00:00') info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'this_year_prev', 'year', 'year') eq_(info.utc_start, '2011-01-01T00:00:00+00:00') eq_(info.utc_stop, '2012-01-01T00:00:00+00:00') eq_(info.user_start, '2011') eq_(info.user_stop, '2012') eq_(info.step, None)
def test_shift_prev_day_by_day(self): now = parse_datetime('2012-03-21T00:39:19+00:00') info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'today_prev_day', 'day', 'date') eq_(info.utc_start, '2012-03-20T00:39:19+00:00') eq_(info.utc_stop, '2012-03-21T00:39:19+00:00') eq_(info.user_start, '20-03-2012') eq_(info.user_stop, '21-03-2012') eq_(info.step, None)
def test_shift_prev_week_by_week(self): now = parse('2012-10-22T00:00:00+00:00') info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'today_prev_day_week', 'week', 'date') eq_(info.utc_start, '2012-10-15T00:00:00+00:00') eq_(info.utc_stop, '2012-10-22T00:00:00+00:00') eq_(info.user_start, '15-10-2012') eq_(info.user_stop, '22-10-2012') eq_(info.step, None)
def endpoint_queue_edit(req): sub_id = req.POST['id'] cluster_id = req.POST['cluster_id'] endpoint_type = req.POST['endpoint_type'] # Always available request = { 'id': sub_id, 'cluster_id': cluster_id, 'endpoint_type': endpoint_type } # Need form prefix for item in sorted(sub_attrs): if item not in ('id', 'cluster_id'): key = 'edit-{}'.format(item) value = req.POST.get(key) request[item] = value # Update subscription .. req.zato.client.invoke('zato.pubsub.endpoint.update-endpoint-queue', request) # .. and read it back - but this time it will include current data about depth. service = 'zato.pubsub.endpoint.get-endpoint-queue' request = bunchify({ 'id': sub_id, 'cluster_id': cluster_id, }) service_response = req.zato.client.invoke(service, request).data.response service_response.creation_time = from_utc_to_user(service_response.creation_time+'+00:00', req.zato.user_profile) if service_response.last_interaction_time: service_response.last_interaction_time = from_utc_to_user( service_response.last_interaction_time+'+00:00', req.zato.user_profile) response = {} response['id'] = sub_id response['message'] = 'Subscription updated successfully' response.update(**service_response) response.update(**request) response['name_slug'] = slugify(response['name']) return HttpResponse(dumps(response), content_type='application/javascript')
def slow_response_details(req, cid, service_name): item = None service = _get_service(req, service_name) pretty_print = asbool(req.GET.get('pretty_print')) input_dict = { 'cid': cid, 'name': service_name, } zato_message, soap_response = invoke_admin_service(req.zato.cluster, 'zato:service.slow-response.get', input_dict) if zato_path('response.item').get_from(zato_message) is not None: _item = zato_message.response.item cid = _item.cid.text if cid != ZATO_NONE: item = SlowResponse() item.cid = _item.cid.text item.req_ts = from_utc_to_user(_item.req_ts.text+'+00:00', req.zato.user_profile) item.resp_ts = from_utc_to_user(_item.resp_ts.text+'+00:00', req.zato.user_profile) item.proc_time = _item.proc_time.text item.service_name = service_name item.threshold = service.slow_threshold for name in('req', 'resp'): value = getattr(_item, name) if value: value = value.text.decode('base64') data_format = known_data_format(value) if data_format: if pretty_print: value = get_pretty_print(value, data_format) attr_name = name + '_html' setattr(item, attr_name, highlight(value, data_format_lexer[data_format](), HtmlFormatter(linenos='table'))) return_data = { 'cluster_id': req.zato.cluster_id, 'service': service, 'item': item, 'pretty_print': not pretty_print, } return TemplateResponse(req, 'zato/service/slow-response-details.html', return_data)
def test_shift_prev_hour(self): with patch('zato.common.util._utcnow', self._utcnow): now = utcnow() info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'last_hour_prev', 'hour', 'date_time') eq_(info.utc_start, '2012-02-29T23:47:24.054903+00:00') eq_(info.utc_stop, '2012-03-01T00:47:24.054903+00:00') eq_(info.user_start, '01-03-2012 00:47:24') eq_(info.user_stop, '01-03-2012 01:47:24') eq_(info.step, None)
def request_response(req, service_name): service = Service(name=service_name) pretty_print = asbool(req.GET.get('pretty_print')) input_dict = {'name': service_name, 'cluster_id': req.zato.cluster_id} service_response = req.zato.client.invoke( 'zato.service.get-request-response', input_dict) if service_response.ok: request = b64decode(service_response.data.sample_req if service_response.data.sample_req else '') request = request.decode('utf8') request_data_format = known_data_format(request) if request_data_format: if pretty_print: request = get_pretty_print(request, request_data_format) service.sample_req_html = highlight( request, data_format_lexer[request_data_format](), HtmlFormatter(linenos='table')) response = b64decode(service_response.data.sample_resp if service_response.data.sample_resp else '') response = response.decode('utf8') response_data_format = known_data_format(response) if response_data_format: if pretty_print: response = get_pretty_print(response, response_data_format) service.sample_resp_html = highlight( response, data_format_lexer[response_data_format](), HtmlFormatter(linenos='table')) service.sample_req = request service.sample_resp = response ts = {} for name in ('req', 'resp'): full_name = 'sample_{}_ts'.format(name) value = getattr(service_response.data, full_name, '') if value: value = from_utc_to_user(value + '+00:00', req.zato.user_profile) ts[full_name] = value service.id = service_response.data.service_id service.sample_cid = service_response.data.sample_cid service.sample_req_ts = ts['sample_req_ts'] service.sample_resp_ts = ts['sample_resp_ts'] service.sample_req_resp_freq = service_response.data.sample_req_resp_freq return_data = { 'cluster_id': req.zato.cluster_id, 'service': service, 'pretty_print': not pretty_print, } return TemplateResponse(req, 'zato/service/request-response.html', return_data)
def test_shift_prev_day(self): with patch('zato.common.util._utcnow', self._utcnow): now = utcnow() info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'today_prev_day', 'hour', 'date_time') eq_(info.utc_start, '2012-02-29T00:47:24.054903+00:00') eq_(info.utc_stop, '2012-02-29T01:47:24.054903+00:00') eq_(info.user_start, '29-02-2012 01:47:24') eq_(info.user_stop, '29-02-2012 02:47:24') eq_(info.step, None)
def slow_response(req, service_name): items = [] input_dict = {"name": service_name} for _item in req.zato.client.invoke("zato.service.slow-response.get-list", input_dict): item = SlowResponse() item.cid = _item.cid item.req_ts = from_utc_to_user(_item.req_ts + "+00:00", req.zato.user_profile) item.resp_ts = from_utc_to_user(_item.resp_ts + "+00:00", req.zato.user_profile) item.proc_time = _item.proc_time item.service_name = service_name items.append(item) return_data = {"cluster_id": req.zato.cluster_id, "service": _get_service(req, service_name), "items": items} return TemplateResponse(req, "zato/service/slow-response.html", return_data)
def test_shift_prev_week(self): with patch('zato.common.util._utcnow', self._utcnow): now = utcnow() info = shift(now, from_utc_to_user(now, self.user_profile), self.user_profile, 'today_prev_day_week', 'hour', 'date_time') eq_(info.utc_start, '2012-02-23T00:47:24.054903+00:00') eq_(info.utc_stop, '2012-02-23T01:47:24.054903+00:00') eq_(info.user_start, '23-02-2012 01:47:24') eq_(info.user_stop, '23-02-2012 02:47:24') eq_(info.step, None)
def on_before_append_item(self, item): item.current_depth_gd = item.current_depth_gd or 0 item.current_depth_non_gd = item.current_depth_non_gd or 0 item.name_slug = slugify(item.name) item.creation_time_utc = item.creation_time item.creation_time = from_utc_to_user(item.creation_time + '+00:00', self.req.zato.user_profile) if item.last_interaction_time: item.last_interaction_time_utc = item.last_interaction_time item.last_interaction_time = from_utc_to_user( item.last_interaction_time + '+00:00', self.req.zato.user_profile) return item
def _interval_based_job_def(user_profile, start_date, repeats, weeks, days, hours, minutes, seconds): buf = StringIO() if start_date: buf.write('Start on {0} at {1}.'.format( from_utc_to_user(start_date, user_profile, 'date'), from_utc_to_user(start_date, user_profile, 'time'))) if not repeats: buf.write(' Repeat indefinitely.') else: if repeats == 1: buf.write(' Execute once.') elif repeats == 2: buf.write(' Repeat twice.') # .. thrice or more elif repeats > 2: buf.write(' Repeat ') if isinstance(repeats, int): repeats = str(repeats) else: repeats = repeats if isinstance(repeats, unicode) else repeats.decode('utf8') buf.write(repeats) buf.write(' times.') interval = [] buf.write(' Interval: ') for name, value in (('week',weeks), ('day',days), ('hour',hours), ('minute',minutes), ('second',seconds)): if value: try: value = int(value) except ValueError: logger.warn('Cannot convert `%s` `%s` to an int, `%s` `%s` `%s` `%s` `%s` `%s` `%s`', name, value, start_date, repeats, weeks, days, hours, minutes, seconds) else: interval.append('{0} {1}{2}'.format(value, name, 's' if value > 1 else '')) buf.write(', '.join(interval)) buf.write('.') return buf.getvalue()
def handle_return_data(self, return_data): for item in return_data['items']: item.id = fs_safe_name('{}-{}'.format(item.name, item.pid)) if item.last_gd_run: item.last_gd_run_utc = item.last_gd_run item.last_gd_run = from_utc_to_user( item.last_gd_run_utc + '+00:00', self.req.zato.user_profile) if item.last_task_run: item.last_task_run_utc = item.last_task_run item.last_task_run = from_utc_to_user( item.last_task_run_utc + '+00:00', self.req.zato.user_profile) return return_data
def handle_return_data(self, return_data): for item in return_data['items']: item.id = fs_safe_name('{}-{}'.format(item.thread_id, item.object_id)) if item.last_gd_run: item.last_gd_run_utc = item.last_gd_run item.last_gd_run = from_utc_to_user( item.last_gd_run_utc + '+00:00', self.req.zato.user_profile) if item.last_delivery: item.last_delivery_utc = item.last_delivery item.last_delivery = from_utc_to_user( item.last_delivery_utc + '+00:00', self.req.zato.user_profile) return return_data
def on_before_append_item(self, item): if getattr(item, 'callback_list', None): item.callback_list = '\n'.join(item.callback_list.split(',')) for name_utc in('last_updated_utc', 'last_used_utc'): value = getattr(item, name_utc, None) if value: name = name_utc.replace('_utc', '') setattr(item, name, from_utc_to_user(value + '+00:00', self.req.zato.user_profile)) return item
def on_before_append_item(self, item, _to_user_dt=('expires_at', 'last_read', 'prev_read', 'last_write', 'prev_write')): item.key_escaped = item.key.encode('utf8') if isinstance(item.key, unicode) else item.key item.key_escaped = b64encode(item.key_escaped) for name in _to_user_dt: value = getattr(item, name) if value: setattr(item, name, from_utc_to_user(value, self.req.zato.user_profile)) return item
def request_response(req, service_name): service = Service(name=service_name) pretty_print = asbool(req.GET.get('pretty_print')) input_dict = { 'name': service_name, 'cluster_id': req.zato.cluster_id } zato_message, soap_response = invoke_admin_service(req.zato.cluster, 'zato:service.get-request-response', input_dict) if zato_path('response.item').get_from(zato_message) is not None: item = zato_message.response.item request = (item.sample_req.text if item.sample_req.text else '').decode('base64') request_data_format = known_data_format(request) if request_data_format: if pretty_print: request = get_pretty_print(request, request_data_format) service.sample_req_html = highlight(request, data_format_lexer[request_data_format](), HtmlFormatter(linenos='table')) response = (item.sample_resp.text if item.sample_resp.text else '').decode('base64') response_data_format = known_data_format(response) if response_data_format: if pretty_print: response = get_pretty_print(response, response_data_format) service.sample_resp_html = highlight(response, data_format_lexer[response_data_format](), HtmlFormatter(linenos='table')) service.sample_req = request service.sample_resp = response ts = {} for name in('req', 'resp'): full_name = 'sample_{}_ts'.format(name) value = getattr(item, full_name).text or '' if value: value = from_utc_to_user(value+'+00:00', req.zato.user_profile) ts[full_name] = value service.id = item.service_id.text service.sample_cid = item.sample_cid.text service.sample_req_ts = ts['sample_req_ts'] service.sample_resp_ts = ts['sample_resp_ts'] service.sample_req_resp_freq = item.sample_req_resp_freq.text return_data = { 'cluster_id': req.zato.cluster_id, 'service': service, 'pretty_print': not pretty_print, } return TemplateResponse(req, 'zato/service/request-response.html', return_data)
def post_process_return_data(self, return_data): return_data['publishers_link'] = '<a href="{}">{}</a>'.format( django_url_reverse('pubsub-topic-publishers', kwargs={ 'cluster_id': self.req.zato.cluster_id, 'topic_id': return_data['id'], 'name_slug': slugify(return_data['name']) }), 'Publishers') return_data['subscribers_link'] = '<a href="{}">{}</a>'.format( django_url_reverse('pubsub-topic-subscribers', kwargs={ 'cluster_id': self.req.zato.cluster_id, 'topic_id': return_data['id'], 'name_slug': slugify(return_data['name']) }), 'Subscribers') item = self.req.zato.client.invoke('zato.pubsub.topic.get', { 'cluster_id': self.req.zato.cluster_id, 'id': return_data['id'], }).data.response return_data['has_gd'] = item.has_gd if item.get('last_pub_time'): return_data['last_pub_time'] = from_utc_to_user( item.last_pub_time + '+00:00', self.req.zato.user_profile) else: return_data['last_pub_time'] = None return_data['current_depth_link'] = """ <a href="{}?cluster={}">{}</a> / <a href="{}?cluster={}">{}</a> """.format( # GD messages django_url_reverse('pubsub-topic-messages', kwargs={ 'topic_id': return_data['id'], 'name_slug': slugify(return_data['name']) }), self.req.zato.cluster_id, item.current_depth_gd, # Non-GD messages django_url_reverse('pubsub-topic-in-ram-backlog', kwargs={ 'topic_id': return_data['id'], 'name_slug': slugify(return_data['name']) }), self.req.zato.cluster_id, item.current_depth_gd)
def audit_log(req, **kwargs): out = kwargs out['req'] = req out.update(get_js_dt_format(req.zato.user_profile)) for key in ('batch_size', 'current_batch', 'start', 'stop', 'state', 'query'): value = req.GET.get(key) if value: out[key] = value out['form'] = AuditLogEntryList(initial=out) request = { 'conn_id': out['conn_id'], 'start': out.get('start', ''), 'stop': out.get('stop'), 'current_batch': out.get('current_batch', BATCH_DEFAULTS.PAGE_NO), 'batch_size': out.get('batch_size', BATCH_DEFAULTS.SIZE), 'query': out.get('query', ''), } out['items'] = [] response = req.zato.client.invoke('zato.http-soap.get-audit-item-list', request) if response.ok: for item in response.data: item.req_time = from_utc_to_user(item.req_time_utc + '+00:00', req.zato.user_profile) item.resp_time = from_utc_to_user( item.resp_time_utc + '+00:00', req.zato.user_profile) if item.resp_time_utc else '(None)' out['items'].append(item) out.update(**req.zato.client.invoke('zato.http-soap.get-audit-batch-info', request).data) return TemplateResponse(req, 'zato/http_soap/audit/log.html', out)
def manage(req, cluster_id): """ GUI for managing HAProxy configuration. """ cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one() client = get_lb_client(cluster) lb_start_time = from_utc_to_user(client.get_uptime_info(), req.zato.user_profile) lb_config = client.get_config() lb_work_config = client.get_work_config() lb_work_config['verify_fields'] = ', '.join(['%s=%s' % (k,v) for (k, v) in sorted(lb_work_config['verify_fields'].items())]) form_data = { 'global_log_host': lb_config['global_']['log']['host'], 'global_log_port': lb_config['global_']['log']['port'], 'global_log_level': lb_config['global_']['log']['level'], 'global_log_facility': lb_config['global_']['log']['facility'], 'timeout_connect': lb_config['defaults']['timeout_connect'], 'timeout_client': lb_config['defaults']['timeout_client'], 'timeout_server': lb_config['defaults']['timeout_server'], 'http_plain_bind_address':lb_config['frontend']['front_http_plain']['bind']['address'], 'http_plain_bind_port':lb_config['frontend']['front_http_plain']['bind']['port'], 'http_plain_log_http_requests':lb_config['frontend']['front_http_plain']['log_http_requests'], 'http_plain_maxconn':lb_config['frontend']['front_http_plain']['maxconn'], 'http_plain_monitor_uri':lb_config['frontend']['front_http_plain']['monitor_uri'], } backends = {} for backend_type in lb_config['backend']: for name in lb_config['backend'][backend_type]: # Is it a server? if 'address' in lb_config['backend'][backend_type][name]: if not name in backends: backends[name] = {} backends[name][backend_type] = {} backends[name][backend_type]['address'] = lb_config['backend'][backend_type][name]['address'] backends[name][backend_type]['port'] = lb_config['backend'][backend_type][name]['port'] backends[name][backend_type]['extra'] = lb_config['backend'][backend_type][name]['extra'] backends = OrderedDict(sorted(backends.items(), key=lambda t: t[0])) form = ManageLoadBalancerForm(initial=form_data) haproxy_alive = _haproxy_alive(client) cluster.stats_uri, cluster.stats_port = _haproxy_stat_config(lb_config=lb_config) servers_state = client.get_servers_state() return_data = {'cluster':cluster, 'lb_start_time':lb_start_time, 'lb_config':lb_config, 'lb_work_config':lb_work_config, 'form':form, 'backends':backends, 'haproxy_alive':haproxy_alive, 'servers_state':servers_state} return TemplateResponse(req, 'zato/load_balancer/manage.html', return_data)
def on_before_append_item(self, item): item.id = item.pub_client_id.replace('.', '-') item.connection_time_utc = item.connection_time item.connection_time = from_utc_to_user( item.connection_time_utc + '+00:00', self.req.zato.user_profile) if item.ext_client_name: item.ext_client_name = [ elem.strip() for elem in item.ext_client_name.split(';') ] item.ext_client_name = '\n'.join(item.ext_client_name) return item
def post_process_return_data(self, return_data): response = self.req.zato.client.invoke('zato.pubsub.endpoint.get-endpoint-summary', { 'cluster_id': self.req.zato.cluster_id, 'endpoint_id': self.input.endpoint_id, }).data if response['last_seen']: response['last_seen'] = from_utc_to_user(response['last_seen']+'+00:00', self.req.zato.user_profile) if response['last_deliv_time']: response['last_deliv_time'] = from_utc_to_user(response['last_deliv_time']+'+00:00', self.req.zato.user_profile) response['pubsub_endpoint_queues_link'] = \ django_url_reverse('pubsub-endpoint-queues', kwargs={ 'cluster_id':self.req.zato.cluster_id, 'endpoint_id':response['id'], 'name_slug':slugify(response['endpoint_name'])} ), return_data.update(response)
def request_response(req, service_name): service = Service(name=service_name) pretty_print = asbool(req.GET.get('pretty_print')) input_dict = { 'name': service_name, 'cluster_id': req.zato.cluster_id } service_response = req.zato.client.invoke('zato.service.get-request-response', input_dict) if service_response.ok: request = (service_response.data.sample_req if service_response.data.sample_req else '').decode('base64') request_data_format = known_data_format(request) if request_data_format: if pretty_print: request = get_pretty_print(request, request_data_format) service.sample_req_html = highlight(request, data_format_lexer[request_data_format](), HtmlFormatter(linenos='table')) response = (service_response.data.sample_resp if service_response.data.sample_resp else '').decode('base64') response_data_format = known_data_format(response) if response_data_format: if pretty_print: response = get_pretty_print(response, response_data_format) service.sample_resp_html = highlight(response, data_format_lexer[response_data_format](), HtmlFormatter(linenos='table')) service.sample_req = request service.sample_resp = response ts = {} for name in('req', 'resp'): full_name = 'sample_{}_ts'.format(name) value = getattr(service_response.data, full_name, '') if value: value = from_utc_to_user(value+'+00:00', req.zato.user_profile) ts[full_name] = value service.id = service_response.data.service_id service.sample_cid = service_response.data.sample_cid service.sample_req_ts = ts['sample_req_ts'] service.sample_resp_ts = ts['sample_resp_ts'] service.sample_req_resp_freq = service_response.data.sample_req_resp_freq return_data = { 'cluster_id': req.zato.cluster_id, 'service': service, 'pretty_print': not pretty_print, } return TemplateResponse(req, 'zato/service/request-response.html', return_data)
def _update_item(server_name, lb_address, lb_state): for item in items: if item.name == server_name: item.in_lb = True item.lb_address = lb_address item.lb_state = lb_state if item.up_mod_date: item.up_mod_date_user = from_utc_to_user(item.up_mod_date.replace(tzinfo=UTC).isoformat(), req.zato.user_profile) if item.up_status == SERVER_UP_STATUS.RUNNING: item.may_be_deleted = False else: item.may_be_deleted = True
def get_today(_user_profile, _format): """ user_start is today's midnight but it needs to be in user's TZ. user_stop is current time simply, in user's timezone again. """ user_now = now(timezone(_user_profile.timezone)).replace(tzinfo=None) user_today_midnight = datetime(user_now.year, user_now.month, user_now.day) utc_start = from_local_to_utc(user_today_midnight, _user_profile.timezone) utc_stop = from_local_to_utc(user_now, _user_profile.timezone) user_start = from_utc_to_user(utc_start, _user_profile, _format) user_stop = None return utc_start, utc_stop, user_start, user_stop
def servers(req): """ A view for server management. """ items = req.zato.odb.query(Server).order_by(Server.name).all() for item in items: if item.up_mod_date: item.up_mod_date_user = from_utc_to_user( item.up_mod_date.replace(tzinfo=UTC).isoformat(), req.zato.user_profile) try: client = get_lb_client(req.zato.get('cluster')) server_data_dict = client.get_server_data_dict() bck_http_plain = client.get_config()['backend']['bck_http_plain'] lb_client_invoked = True except Exception: logger.error(format_exc()) lb_client_invoked = False if lb_client_invoked: def _update_item(server_name, lb_address, lb_state): for item in items: if item.name == server_name: item.in_lb = True item.lb_address = lb_address item.lb_state = lb_state if item.up_status == SERVER_UP_STATUS.RUNNING: item.may_be_deleted = False else: item.may_be_deleted = True for server_name in bck_http_plain: lb_address = '{}:{}'.format(bck_http_plain[server_name]['address'], bck_http_plain[server_name]['port']) _update_item(server_name, lb_address, server_data_dict[server_name]['state']) return_data = { 'items': items, 'search_form': req.zato.search_form, 'zato_clusters': req.zato.clusters, 'cluster': req.zato.get('cluster'), 'edit_form': EditServerForm(prefix='edit') } return TemplateResponse(req, 'zato/cluster/servers.html', return_data)
def handle_return_data(self, return_data): for item in return_data['items']: item.id = fs_safe_name(item.py_object) if item.last_sync: item.last_sync_utc = item.last_sync item.last_sync = from_utc_to_user( item.last_sync_utc + '+00:00', self.req.zato.user_profile) if item.last_sync_sk: item.last_sync_sk_utc = item.last_sync_sk item.last_sync_sk = from_utc_to_user( item.last_sync_sk_utc + '+00:00', self.req.zato.user_profile) if item.last_iter_run: item.last_iter_run_utc = item.last_iter_run item.last_iter_run = from_utc_to_user( item.last_iter_run_utc + '+00:00', self.req.zato.user_profile) return return_data
def slow_response(req, service_name): items = [] input_dict = { 'name': service_name, } for _item in req.zato.client.invoke('zato.service.slow-response.get-list', input_dict): item = SlowResponse() item.cid = _item.cid item.req_ts = from_utc_to_user(_item.req_ts+'+00:00', req.zato.user_profile) item.resp_ts = from_utc_to_user(_item.resp_ts+'+00:00', req.zato.user_profile) item.proc_time = _item.proc_time item.service_name = service_name items.append(item) return_data = { 'cluster_id': req.zato.cluster_id, 'service': _get_service(req, service_name), 'items': items, } return TemplateResponse(req, 'zato/service/slow-response.html', return_data)
def _index(req, cluster_id, topic_name, source_name, source_type): items = [] input_dict = { 'cluster_id': cluster_id, 'source_name':source_name, 'source_type': source_type } for _item in req.zato.client.invoke('zato.pubsub.message.get-list', input_dict): _item = Message(**_item) _item.creation_time = from_utc_to_user(_item.creation_time_utc+'+00:00', req.zato.user_profile) _item.expire_at = from_utc_to_user(_item.expire_at_utc+'+00:00', req.zato.user_profile) _item.id = _item.msg_id items.append(_item) return_data = { 'topic_name': topic_name, 'cluster_id': req.zato.cluster_id, 'items': items, 'source_type': source_type, 'source_name': source_name } return TemplateResponse(req, 'zato/pubsub/message/index.html', return_data)
def _common_edit_message(client, success_msg, id, name, host, up_status, up_mod_date, cluster_id, user_profile, fetch_lb_data=True): """ Returns a common JSON message for both the actual 'edit' and 'add/remove to/from LB' actions. """ return_data = { 'id': id, 'name': name, 'host': host if host else '(unknown)', 'up_status': up_status if up_status else '(unknown)', 'up_mod_date': from_utc_to_user(up_mod_date + '+00:00', user_profile) if up_mod_date else '(unknown)', 'cluster_id': cluster_id if cluster_id else '', 'lb_state': '(unknown)', 'lb_address': '(unknown)', 'in_lb': '(unknown)', 'message': success_msg.format(name) } if fetch_lb_data: lb_server_data = _get_server_data(client, name) return_data.update({ 'lb_state': lb_server_data.state, 'lb_address': lb_server_data.lb_address, 'in_lb': lb_server_data.in_lb, }) return HttpResponse(dumps(return_data), content_type='application/javascript')
def request_response(req, service_name): service = Service(name=service_name) pretty_print = asbool(req.GET.get("pretty_print")) input_dict = {"name": service_name, "cluster_id": req.zato.cluster_id} service_response = req.zato.client.invoke("zato.service.get-request-response", input_dict) if service_response.ok: request = (service_response.data.sample_req if service_response.data.sample_req else "").decode("base64") request_data_format = known_data_format(request) if request_data_format: if pretty_print: request = get_pretty_print(request, request_data_format) service.sample_req_html = highlight( request, data_format_lexer[request_data_format](), HtmlFormatter(linenos="table") ) response = (service_response.data.sample_resp if service_response.data.sample_resp else "").decode("base64") response_data_format = known_data_format(response) if response_data_format: if pretty_print: response = get_pretty_print(response, response_data_format) service.sample_resp_html = highlight( response, data_format_lexer[response_data_format](), HtmlFormatter(linenos="table") ) service.sample_req = request service.sample_resp = response ts = {} for name in ("req", "resp"): full_name = "sample_{}_ts".format(name) value = getattr(service_response.data, full_name, "") if value: value = from_utc_to_user(value + "+00:00", req.zato.user_profile) ts[full_name] = value service.id = service_response.data.service_id service.sample_cid = service_response.data.sample_cid service.sample_req_ts = ts["sample_req_ts"] service.sample_resp_ts = ts["sample_resp_ts"] service.sample_req_resp_freq = service_response.data.sample_req_resp_freq return_data = {"cluster_id": req.zato.cluster_id, "service": service, "pretty_print": not pretty_print} return TemplateResponse(req, "zato/service/request-response.html", return_data)
def servers(req): """ A view for server management. """ items = req.zato.odb.query(Server).order_by(Server.name).all() for item in items: if item.up_mod_date: item.up_mod_date_user = from_utc_to_user( item.up_mod_date.replace(tzinfo=UTC).isoformat(), req.zato.user_profile) try: client = get_lb_client(req.zato.get('cluster')) server_data_dict = client.get_server_data_dict() bck_http_plain = client.get_config()['backend']['bck_http_plain'] lb_client_invoked = True except Exception, e: logger.error(format_exc(e)) lb_client_invoked = False
def handle(self): out = {} service = 'zato.pattern.delivery.get-history-list' req = {'task_id': self.input['task_id']} response = self.req.zato.client.invoke(service, req) if self.item: out['has_item'] = True out['show_resubmit_button'] = self.item.state in([DELIVERY_STATE.IN_DOUBT, DELIVERY_STATE.CONFIRMED, DELIVERY_STATE.FAILED]) out['show_update_button'] = not out['show_resubmit_button'] else: out['has_item'] = False if response.ok: for item in response.data: item.entry_time = from_utc_to_user(item.entry_time + '+00:00', self.req.zato.user_profile) out['history'] = response.data else: logger.warn(response.details) return out
def handle_return_data(self, return_data): # Get task metadata from a relevant service response = self.req.zato.client.invoke( 'zato.pubsub.task.delivery.get-delivery-task', { 'server_name': self.input.server_name, 'server_pid': self.input.server_pid, 'python_id': self.input.python_id, }) return_data['task'] = response.data # Handle the list of results now for item in return_data['items']: item.id = item.msg_id if item.recv_time: item.recv_time_utc = item.recv_time item.recv_time = from_utc_to_user( item.recv_time_utc + '+00:00', self.req.zato.user_profile) return return_data
def __call__(self, req, initial_input_dict={}, initial_return_data={}, *args, **kwargs): edit_name = req.POST.get('edit-name') name = req.POST.get('name', edit_name) initial_return_data = { 'current_depth': 0, 'consumers_count': 0, 'producers_count': 0, 'last_pub_time': None, 'cluster_id': req.zato.cluster_id, 'name': name, } if edit_name: response = req.zato.client.invoke('zato.pubsub.topics.get-info', { 'cluster_id': req.zato.cluster_id, 'name': edit_name }) if response.ok: initial_return_data.update(response.data) if initial_return_data['last_pub_time']: initial_return_data['last_pub_time'] = from_utc_to_user( initial_return_data['last_pub_time'] + '+00:00', req.zato.user_profile) return super(_CreateEdit, self).__call__(req, initial_input_dict={}, initial_return_data=initial_return_data, *args, **kwargs)
def on_before_append_item(self, item): item.recv_time = from_utc_to_user(item.recv_time + '+00:00', self.req.zato.user_profile) return item
def on_before_append_item(self, item): item.pub_time = from_utc_to_user(item.pub_time + '+00:00', self.req.zato.user_profile) item.endpoint_html = get_endpoint_html(item, self.req.zato.cluster_id) return item