def generate_text(self):
if self.post['text']:
log.info('[AP] Обнаружен текст. Извлечение...')
self.text = self.post['text']
self.text = self.text.replace(self.pattern, '')
if 'attachments' in self.post:
for attachment in self.post['attachments']:
if attachment['type'] == 'link':
self.text += '\n<a href="%(url)s">%(title)s</a>' % attachment[
'link']
# self.text += '\n[%(title)s](%(url)s)' % attachment['link']
if config.getboolean('global', 'sign') and self.user:
log.info(
'[AP] Подписывание поста и добавление ссылки на его оригинал.'
)
# Markdown Parsing
# self.text += '\nАвтор поста: [%(first_name)s %(last_name)s](https://vk.com/%(domain)s)' % self.user
# self.text += '\nОригинал поста: [ссылка](https://vk.com/wall%(owner_id)s_%(id)s)' % self.post
# HTML Parsing
self.text += '\nАвтор поста: <a href="https://vk.com/%(domain)s">%(first_name)s %(last_name)s</a>' % self.user
self.text += '\nОригинал поста: <a href="https://vk.com/wall%(owner_id)s_%(id)s">ссылка</a>' % self.post
elif config.getboolean('global', 'sign') and not self.user:
log.info(
'[AP] Добавление только ссылки на оригинал поста, так как в нем не указан автор.'
)
# Markdown Parsing
# self.text += '\nОригинал поста: [ссылка](https://vk.com/wall%(owner_id)s_%(id)s)' % self.post
# HTML Parsing
self.text += '\nОригинал поста: <a href="https://vk.com/wall%(owner_id)s_%(id)s">ссылка</a>' % self.post
def __init__(self, dbman, log, accountman, initialcmd, colourmode):
"""
:param dbman: :class:`~alot.db.DBManager`
:param log: :class:`logging.Logger`
:param accountman: :class:`~alot.account.AccountManager`
:param initialcmd: commandline applied after setting up interface
:type initialcmd: str
:param colourmode: determines which theme to chose
:type colourmode: int in [1,16,256]
"""
self.dbman = dbman
self.dbman.ui = self # register ui with dbman
self.logger = log
self.accountman = accountman
if not colourmode:
colourmode = config.getint('general', 'colourmode')
self.logger.info('setup gui in %d colours' % colourmode)
self.mainframe = urwid.Frame(urwid.SolidFill())
self.inputwrap = InputWrap(self, self.mainframe)
self.mainloop = urwid.MainLoop(self.inputwrap,
config.get_palette(),
handle_mouse=False,
event_loop=urwid.TwistedEventLoop(),
unhandled_input=self.unhandeled_input)
self.mainloop.screen.set_terminal_properties(colors=colourmode)
self.show_statusbar = config.getboolean('general', 'show_statusbar')
self.notificationbar = None
self.mode = 'global'
self.commandprompthistory = []
self.logger.debug('fire first command')
self.apply_command(initialcmd)
self.mainloop.run()
def __init__(self, dbman, log, accountman, initialquery, colourmode):
self.dbman = dbman
self.dbman.ui = self # register ui with dbman
self.logger = log
self.accountman = accountman
if not colourmode:
colourmode = config.getint('general', 'colourmode')
self.logger.info('setup gui in %d colours' % colourmode)
self.mainframe = MainWidget(self)
self.mainloop = urwid.MainLoop(self.mainframe,
config.get_palette(),
handle_mouse=False,
unhandled_input=self.keypress)
self.mainloop.screen.set_terminal_properties(colors=colourmode)
self.show_statusbar = config.getboolean('general', 'show_statusbar')
self.notificationbar = None
self.mode = ''
self.commandprompthistory = []
self.logger.debug('setup bindings')
cmd = commandfactory('search', query=initialquery)
self.apply_command(cmd)
self.mainloop.run()
def __init__(self, tid, dbman):
self.dbman = dbman
self.thread = dbman.get_thread(tid)
self.tag_widgets = []
self.display_content = config.getboolean('general',
'display_content_in_threadline')
self.rebuild()
urwid.AttrMap.__init__(self, self.columns,
'threadline', 'threadline_focus')
def start(args):
"""
Handles the start of the rosie application
"""
import time
from robot import Robot
# create the robot
Robot()
modules = []
def close_modules(signum, frame):
"""
Close running modules upon Crtl-c
"""
for module, thr in modules:
logging.info('closing %s...', module.__name__)
if hasattr(module, 'end'):
module.end()
while thr and thr.isAlive():
thr.join(3)
if thr.is_alive():
logging.warning(
'join timed out, killing thread!!')
if sys.version_info.major == 3:
thr._tstate_lock.release()
thr._stop()
else:
thr._Thread__stop()
logging.info('closed %s...', module.__name__)
event.clear()
signal.signal(signal.SIGTERM, close_modules)
signal.signal(signal.SIGINT, close_modules)
for sect in (s for s in config.sections()
if config.getboolean(s, 'active')):
logging.info('loading %s...', sect)
try:
module = importlib.import_module(sect)
except ImportError:
logging.error(traceback.format_exc())
logging.error('module %s not loaded\033[0m', sect)
# no exception was raised
else:
logging.info('loaded %s', sect)
thr = None
if hasattr(module, 'init'):
thr = threading.Thread(target=module.init)
thr.start()
modules.append((module, thr))
event = threading.Event()
event.set()
# main thread
while event.is_set():
time.sleep(2)
def init():
from settings import config
host = config.get('restAPI', 'host', fallback='0.0.0.0')
port = config.getint('restAPI', 'port', fallback=5000)
debug = config.getboolean('restAPI', 'debug', fallback=False)
app.debug = debug
global server
server = WebSocketServer((host, port), app, handler_class=WebSocketHandler)
server.serve_forever()
def __init__(self, tid, dbman):
self.dbman = dbman
#logging.debug('tid: %s' % tid)
self.thread = dbman.get_thread(tid)
#logging.debug('tid: %s' % self.thread)
self.tag_widgets = []
self.display_content = config.getboolean('general',
'display_content_in_threadline')
self.rebuild()
urwid.AttrMap.__init__(self, self.columns,
'search_thread', 'search_thread_focus')
def get_active_discovery_methods():
"""
Returns a list of active discovery methods
"""
global ACTIVE_DISCOVERY_METHODS, DISCOVERY_METHODS
if ACTIVE_DISCOVERY_METHODS is None:
ACTIVE_DISCOVERY_METHODS = [
m for m in DISCOVERY_METHODS
if (config.has_section(m) and
config.has_option(m, "enabled") and
config.getboolean(m, "enabled"))
]
return ACTIVE_DISCOVERY_METHODS
class DefaultRouter(BaseRouter):
_TEMPLATES = {}
_RULES = [] # List of MetricRule
CONFIG_SECTION = "pm_router"
@classmethod
def route(cls, object, settings):
"""
Default pm-to-graphite router
"""
model_id = cls.get_model_id(object)
logger.debug("Mapping %s %s (%s)",
model_id, object, settings.metric_type)
tpl = cls._TEMPLATES.get(model_id.lower())
if not tpl:
logger.debug("No template for model %s. Disabling metric",
model_id)
settings.is_active = False
return
settings.is_active = cls.is_active(model_id, object)
if not settings.is_active:
logger.debug(
"Deactivating metric for %s %s (%s)",
model_id, object, settings.metric_type
)
settings.is_active = False
return
settings.metric = tpl.render(Context({
"object": object,
"model_id": model_id,
"metric_type": settings.metric_type
}))
settings.probe = cls.route_probe(object, settings)
# Apply rules
for r in cls._RULES:
if r.rx.search(settings.metric):
logger.debug("Apply rule %s", r.n)
settings.probe = r.probe
settings.active = r.active
if not settings.active:
logger.debug("Metric disabled by rule %s", r.n)
settings.is_active = False
return
break
logger.debug(
"Setting metric for %s %s (%s) "
"to %s (probe %s)",
model_id, object, settings.metric_type,
settings.metric, settings.probe
)
@classmethod
def route_probe(cls, object, settings):
"""
Get probe name by object.
First, try to call model routers.
i.e, for sa.ManagedObject model try to call
route_probe_sa_managedobject function
"""
model_id = cls.get_model_id(object)
model_handler = "route_probe_%s" % model_id.replace(".", "_").lower()
if hasattr(cls, model_handler):
pn = getattr(cls, model_handler)(object, settings)
if isinstance(pn, basestring):
return cls.get_probe(pn)
else:
return pn
else:
return cls.get_default_probe()
@classmethod
def route_probe_sa_managedobject(cls, object, settings):
"""
Default probe router for managed object
"""
return cls.get_default_probe()
@classmethod
def route_probe_inv_interface(cls, object, settings):
"""
Default probe router for interface
"""
return cls.get_default_probe()
@classmethod
def is_active(cls, model_id, object):
if model_id == "inv.Interface":
return object.managed_object.is_managed
elif model_id == "sa.ManagedObject":
return object.is_managed
elif model_id in (
"sa.ManagedObjectProfile", "inv.InterfaceProfile"):
return False
else:
return True
@classmethod
def configure(cls):
rules = {}
for opt in config.options(cls.CONFIG_SECTION):
if opt.startswith("map."):
# Process metric mappings
_, model_id = opt.split(".", 1)
v = config.get(cls.CONFIG_SECTION, opt)
logger.info("Configuring metric mappings %s -> %s",
model_id, v)
try:
cls._TEMPLATES[model_id] = Template(v)
except TemplateSyntaxError, why:
logging.error("Template syntax error: %s", why)
elif opt.startswith("metric."):
# Process metric rules
n = int(opt.split(".")[1])
v = config.get(cls.CONFIG_SECTION, opt)
try:
rx = re.compile(v)
except re.error, why:
logging.error(
"Invalid regular expression in rule %s: %s",
n, why
)
continue
if config.has_option(cls.CONFIG_SECTION, "probe.%s" % n):
probe_name = config.get(cls.CONFIG_SECTION, "probe.%s" % n)
try:
probe = cls.get_probe(probe_name)
except:
logging.error(
"Invalid probe in rule %s: %s",
n, probe_name
)
else:
probe = cls.get_default_probe()
if config.has_option(cls.CONFIG_SECTION, "active.%s" % n):
active = config.getboolean(cls.CONFIG_SECTION, "active.%s" % n)
else:
active = True
rules[n] = MetricRule(
n=n, rx=rx, probe=probe, active=active)
from time import sleep
from datetime import datetime, time
from crawler import WebsiteCrawler
from helpers import convert_string_to_time
from settings import config
from telegram_bot import send_telegram
interval_minutes = config.getint("general", "interval_minutes")
send_live_bits = config.getboolean("general", "send_live_bits")
live_bit_only_on_weekdays = [1, 2, 3, 4, 5, 6, 7]
raw_start_time = config.get("general", "start_time")
start_time = convert_string_to_time(config.get("general", "start_time"))
end_time = convert_string_to_time(config.get("general", "end_time"))
if __name__ == '__main__':
crawler = WebsiteCrawler()
send_telegram("Service gestartet")
previous_day = -1
while True:
try:
now_time = datetime.now().time()
# check website between this time