def add_numbers():
a = request.args.get('a', 0, type=str)
summarizer = Summarizer()
# a = u"http://www.asriran.com/fa/news/332468/%D9%BE%DB%8C%D8%A7%D9%85-%D8%B3%DB%8C%D8%AF-%D9%85%D8%AD%D9%85%D8%AF-%D8%AE%D8%A7%D8%AA%D9%85%DB%8C-%D8%A8%D9%87-%DA%A9%D9%86%DA%AF%D8%B1%D9%87-%D9%8A%DA%A9-%D8%AD%D8%B2%D8%A8"
page = Fetch(a)
if page.service == 'iransamane':
service = IranSamane(page.page)
elif page.service == 'news-studio':
service = NewsStudio(page.page)
else:
service = Service(page.page)
print "fetching content"
content = service.fetch_content()
# print content
print "end fetching"
summarized = summarizer.summarize(content)
print "end summarize"
res = {
'summarized': summarized,
'title': service.fetch_title(),
'tags': service.fetch_tags(),
'image': service.fetch_image(),
}
# For log
log = (datetime.datetime.now(), res['title'], content, pickle.dumps(summarized))
query_db('INSERT INTO log (submitted_time, title, source, summarized_text) VALUES (?,?,?,?)', log)
#
return jsonify(result=res)
def admin_media(request):
""" Middleware for Jinja template
Args:
request (Django request)
Returns:
DICT: Variable for jinja template
"""
try:
cluster = Cluster.objects.get()
node = cluster.get_current_node()
assert node
node_name = node.name
except (ObjectDoesNotExist, AssertionError):
node_name = ""
menu = (System().menu, Service().menu, Authentication().menu,
Portal().menu, Darwin().menu, Apps().menu, Workflows().menu)
results = {
'MENUS': menu,
'VERSION': settings.VERSION,
'CURRENT_NODE': node_name,
'DEV_MODE': settings.DEV_MODE,
'TITLE': get_hostname(),
'COLLAPSE': request.session.get('collapse')
}
return results
def process_services(self, services_json):
services = []
for service in services_json.get("services", []):
auth = service.get("auth")
auth_service = None
if auth:
auth_service = self.get_auth_service(services_json, auth)
services.append(Service(service, auth=auth_service))
return services
from flask import Flask, jsonify
import gc
import os
import logging
from objdict import ObjDict
from services.service import Service
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
from flask_restplus import Namespace, Resource
api = Namespace('Test6', description='Test 6')
service = Service()
@api.route('/thread')
class Endpoint(Resource):
"""Test 6 thread"""
@api.doc('Test 6')
def get(self):
number_of_files = 100
bs = service.get_files_as_streams_thread(number_of_files)
result = service.get_file_streams_as_regularsurfaces_thread(bs)
l = len(result)
result = None
bs = None
gc.collect()
def setUp(self):
self.service = Service()
def monitor():
node = Cluster.get_current_node()
def get_service_status(service_class):
""" Get a service_class (eg HaproxyService)
:return a dict {'name':service_name, 'status': status} """
service_inst = service_class()
service_status = ServiceStatus.objects.filter(name=service_inst.service_name).first() \
or ServiceStatus(name=service_inst.service_name)
service_status.status = service_inst.status()[0]
service_status.friendly_name = service_inst.friendly_name
service_status.save()
return service_status
""" Initialize date and Monitor object """
date = datetime.now().strftime('%Y-%m-%d %H:%M:00')
date = datetime.strptime(date, '%Y-%m-%d %H:%M:00')
mon = Monitor(date=make_aware(date), node=node)
mon.services_id = set()
for service in [
HaproxyService, DarwinService, PFService, NetdataService,
StrongswanService, OpenvpnService, RsyslogService
]:
# Get some statuses outside for reusing variable later
if service == StrongswanService:
strongswan_status = get_service_status(StrongswanService)
elif service == OpenvpnService:
openvpn_status = get_service_status(OpenvpnService)
elif service == RsyslogService:
rsyslogd_status = get_service_status(RsyslogService)
mon.services.add(get_service_status(service))
""" Get status of Redis, Mongod and Sshd """
# Instantiate mother class to get status easily
service = Service()
for service_name in ("redis", "mongod", "sshd"):
service_status = ServiceStatus.objects.filter(name=service_name).first() \
or ServiceStatus(name=service_name)
service_status.status = service.status(service_name)[0]
mon.services.add(service_status)
mon.save()
""" HAPROXY """
frontends = Frontend.objects.all().only('name', 'status', 'enabled',
'mode', 'listening_mode')
backends = Backend.objects.all().only('name', 'status', 'enabled')
if frontends.count() > 0 or backends.count() > 0:
statuses = {}
try:
# Return a dict { frontend_name: frontend_status, backend_name: backend_status, ... }
statuses = get_stats()
except ServiceError as e:
logger.error(str(e))
except Exception as e:
logger.error("Failed to retrieve status of HAProxy: {}".format(
str(e)))
logger.exception(e)
""" FRONTENDS """
for frontend in frontends:
if node in frontend.get_nodes():
if not frontend.enabled:
status = "DISABLED"
elif frontend.rsyslog_only_conf:
status = {
'UP': "OPEN",
'DOWN': "STOP"
}.get(rsyslogd_status.status, rsyslogd_status.status)
else:
status = statuses.get("FRONTEND",
{}).get(frontend.name, "ERROR")
logger.debug("Status of frontend '{}': {}".format(
frontend.name, status))
if status != frontend.status.get(node.name):
frontend.status[node.name] = status
frontend.save()
elif frontend.status.get(node.name):
frontend.status.pop(node.name, None)
frontend.save()
""" BACKENDS """
for backend in backends:
status = "DISABLED" if not backend.enabled else statuses.get(
"BACKEND", {}).get(backend.name, "ERROR")
logger.debug("Status of backend '{}': {}".format(
backend.name, status))
if backend.status[node.name] != status:
backend.status[node.name] = status
backend.save()
""" STRONGSWAN """
try:
strongswan = Strongswan.objects.get(node=node)
except ObjectDoesNotExist:
# If there is no IPSEC conf on that node, pass
pass
else:
default = ("STOP", "")
try:
statusall, tunnel_statuses, ups, connectings = get_ipsec_tunnels_stats(
)
except ServiceError as e:
logger.exception(e)
default = ("ERROR", str(e))
statusall, tunnel_statuses, ups, connectings = "ERROR", {}, 0, 0
for network in strongswan.ipsec_rightsubnet.split(','):
strongswan.tunnels_status[network] = tunnel_statuses.get(
network, default)
logger.debug("Status of IPSEC Tunnel '{}' : {}".format(
network, strongswan.tunnels_status[network]))
strongswan.status = strongswan_status.status
strongswan.statusall = statusall
strongswan.tunnels_up = ups
strongswan.tunnels_connecting = connectings
strongswan.save()
""" OPENVPN """
try:
openvpn = Openvpn.objects.get(node=node)
except ObjectDoesNotExist:
# If there is no VPNSSL conf on that node, pass
pass
else:
openvpn.tunnels_status = get_ssl_tunnels_stats()
openvpn.status = openvpn_status.status
openvpn.save()
""" DARWIN """
filters = FilterPolicy.objects.all()
if filters.count() > 0:
filter_statuses = {}
default = "DOWN"
try:
filter_statuses = monitor_darwin_filters()
except ServiceError as e:
logger.error(str(e))
default = "ERROR"
for dfilter in filters:
dfilter.status[node.name] = default
filter_status = filter_statuses.get(dfilter.name, False)
if not dfilter.enabled:
dfilter.status[node.name] = "DISABLED"
elif filter_status is None:
dfilter.status[node.name] = "ERROR"
elif filter_statuses.get(dfilter.name,
{}).get('status') is not None:
dfilter.status[node.name] = filter_statuses.get(
dfilter.name).get('status').upper()
dfilter.save()
# Delete old monitoring
last_date = (timezone.now() - timedelta(days=30))
for m in Monitor.objects.filter(date__lte=last_date):
m.delete()
#Update Bhyve status
vm_update_status()
return True
def test_can_handle2(self):
service = Service(json.loads(self.CONFIG2))
self.assertFalse(service.can_handle('/test/as'))
self.assertTrue(service.can_handle('/test/12'))
def test_can_handle(self):
service = Service(json.loads(self.CONFIG1))
self.assertTrue(service.can_handle('/test/my'))
