def run(event, context):
load_dependency('pydot')
channel = event.get('channel')
data = event.get('dot')
#slack_message("in dot to svg: {0}".format(event), [], channel)
log_to_elk("in dot to svg: {0}".format(event))
import dot_parser
try:
(fd, tmp_file) = tempfile.mkstemp('dot)')
dot_static = '/tmp/lambdas-dependencies/pydot/dot_static'
Process.run("chmod", ['+x', dot_static])
data = data.replace('<', '<').replace('>','>') # this solved a really nasty bug caused by the fact that Slack will html encode the < and >
# graph = pydot.graph_from_dot_data(data).pop()
# <from pydot> use code below (instead of above) to get a better error message from dot parser
graphparser = dot_parser.graph_definition()
graphparser.parseWithTabs()
tokens = graphparser.parseString(data)
graph = list(tokens).pop()
# </from pydot>
graph.write_svg(tmp_file, prog=dot_static)
svg_raw = Files.contents(tmp_file)
return base64.b64encode(svg_raw.encode()).decode()
except Exception as error:
slack_message("[dot_to_svg] Error: {0} ".format(error), [], channel)
return None
def risks_test_data(team_id=None, channel=None, params=None):
load_dependency('syncer') ;
load_dependency('requests')
from osbot_browser.view_helpers.Risk_Dashboard import Risk_Dashboard
return Risk_Dashboard().create_dashboard_with_test_data().send_screenshot_to_slack(team_id, channel)
def sync__setup_browser(
self
): # weirdly this works but the version below (using @sync) doesn't (we get an 'Read-only file system' error)
import asyncio
if os.getenv(
'AWS_REGION'
) is None: # we not in AWS so run the normal browser connect using pyppeteer normal method
asyncio.get_event_loop().run_until_complete(self.browser_connect())
return self
load_dependency('pyppeteer')
path_headless_shell = '/tmp/lambdas-dependencies/pyppeteer/headless_shell' # path to headless_shell AWS Linux executable
os.environ[
'PYPPETEER_HOME'] = '/tmp' # tell pyppeteer to use this read-write path in Lambda aws
async def set_up_browser():
from pyppeteer import launch # import pyppeteer dependency
Process.run("chmod",
['+x', path_headless_shell
]) # set the privs of path_headless_shell to execute
self._browser = await launch(
executablePath=
path_headless_shell, # lauch chrome (i.e. headless_shell)
args=[
'--no-sandbox',
'--single-process',
#'--disable-dev-shm-usage'
]) # two key settings or the requests will not work
asyncio.get_event_loop().run_until_complete(set_up_browser())
return self
def run(event, context):
load_dependency('plantuml')
dot_static = '/tmp/lambdas-dependencies/plantuml/dot_static'
plantuml_jar = '/tmp/lambdas-dependencies/plantuml/plantuml.jar'
Process.run("chmod", ['+x', dot_static])
Process.run("chmod", ['+x', plantuml_jar])
os.environ['PLANTUML_LIMIT_SIZE'] = str(
4096 * 4) # set max with to 4 times the default (16,384)
os.environ['GRAPHVIZ_DOT'] = dot_static
(fd, puml_file) = tempfile.mkstemp('.puml')
png_file = puml_file.replace(".puml", ".png")
code = event.get('puml')
Files.write(puml_file, code)
subprocess.run([
'java', '-jar', plantuml_jar, '-Xmx2512m', '-tpng', '-o', '/tmp',
puml_file
],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if os.path.exists(png_file):
with open(png_file, "rb") as image_file:
png = base64.b64encode(image_file.read()).decode()
else:
png = None
return {"png_base64": png}
def elk(team_id=None, channel=None, params=None):
load_dependency('syncer')
from osbot_browser.browser.sites.Site_ELK import ELK_Commands
from osbot_browser.browser.sites.Site_ELK import Site_ELK
if len(params) == 0:
Slack_Commands_Helper(ELK_Commands).invoke(team_id, channel,
params)
return None
browser_helper = Browser_Lamdba_Helper().setup()
elk = Site_ELK(browser_helper.api_browser, team_id, channel)
elk.sync__connect_and_login()
params.append(browser_helper)
params.append(elk)
result = Slack_Commands_Helper(ELK_Commands).invoke(
team_id, channel, params)
if team_id:
return None
else:
return result
def run(event, context):
load_dependency('syncer')
from osbot_browser.browser.sites.Web_Jira import Web_Jira
issue_id = event.get('issue_id')
channel = event.get('channel')
team_id = event.get('team_id')
width = event.get('width')
height = event.get('height')
web_jira = Web_Jira().setup()
web_jira.login() #web_jira.fix_set_list_view()
web_jira.issue(issue_id)
web_jira.fix_issue_remove_ui_elements()
if width is None:
width = 1200
if height is None:
height = 300
png_data = web_jira.screenshot(width, height)
if channel:
from osbot_browser.browser.Browser_Lamdba_Helper import Browser_Lamdba_Helper
title = "Issue: {0}".format(issue_id)
Browser_Lamdba_Helper().send_png_data_to_slack(team_id, channel, title,
png_data)
return "send png to slack"
return png_data
def run(event, context):
load_dependency('syncer')
target = event.get('target')
channel = event.get('channel')
team_id = event.get('team_id')
width = event.get('width')
height = event.get('height')
if width is None:
width = 1200
if height is None:
height = 1000
from osbot_browser.browser.sites.Web_Slack import Web_Slack
web_slack = Web_Slack(team_id=team_id).setup()
web_slack.login()
web_slack.page.width(width, height)
if target:
web_slack.open(target)
web_slack.fix_ui_for_screenshot()
png_data = web_slack.screenshot()
return png_data
def risks(team_id=None, channel=None, params=None):
load_dependency('syncer')
load_dependency('requests')
from osbot_browser.view_helpers.Risk_Dashboard import Risk_Dashboard
jira_key = params.pop(0)
return (Risk_Dashboard().create_dashboard_for_jira_key(
jira_key).send_graph_name_to_slack(
team_id, channel).send_screenshot_to_slack(team_id, channel))
def run(event, context):
from osbot_aws.apis.Lambda import load_dependency
load_dependency('slack')
from pbx_gs_python_utils.utils.slack.API_Slack import API_Slack
channel = event.get('channel')
team_id = event.get('team_id')
text = event.get('text')
attachments = event.get('attachments')
return API_Slack(channel=channel,
team_id=team_id).send_message(text, attachments)
def run(event, context):
from osbot_aws.apis.Lambda import load_dependency
from pbx_gs_python_utils.utils.slack.Slack_Commands_Helper import Slack_Commands_Helper
data = event.get('data')
if data is not None:
load_dependency('slack')
channel = data.get('channel')
team_id = data.get('team_id')
params = event.get('params')
from pbx_gs_python_utils.gsbot.Slack_Commands import Slack_Commands
return Slack_Commands_Helper(Slack_Commands).invoke(
team_id, channel, params)
def get_screenshot_png(self,
url=None,
clip=None,
full_page=None,
close_browser=True,
delay=None):
load_dependency('syncer')
return self.api_browser.sync__screenshot_base64(
url,
close_browser=close_browser,
clip=clip,
full_page=full_page,
delay=delay)
def setup(self):
if os.getenv('AWS_REGION'):
load_dependency('syncer')
load_dependency('requests')
#self.setup_AWS()
# else:
# self.setup_local()
from osbot_browser.browser.API_Browser import API_Browser
from osbot_browser.browser.Render_Page import Render_Page
self.api_browser = API_Browser(headless=self.headless).sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser, web_root=self.web_root())
return self
def send_file_to_slack(file_path, title, bot_token,
channel): # refactor into Slack_API class
load_dependency('requests')
import requests
my_file = {'file': ('/tmp/file.pdf', open(file_path, 'rb'), 'pdf')}
payload = {
"filename": '{0}.pdf'.format(title),
"token": bot_token,
"channels": [channel],
}
requests.post("https://slack.com/api/files.upload",
params=payload,
files=my_file)
return 'send pdf: {0}'.format(title)
def run(event, context):
from osbot_aws.apis.Lambda import load_dependency
load_dependency('elastic')
from pbx_gs_python_utils.utils.Log_To_Elk import Log_To_Elk
try:
log_to_elk = Log_To_Elk()
level = event.get('level')
category = event.get('category')
message = event.get('message')
data = event.get('data')
index = event.get('index')
if message:
if level == 'info':
return log_to_elk.log_info(message=message,
category=category,
data=data,
index=index)
elif level == 'debug':
return log_to_elk.log_debug(message=message,
category=category,
data=data,
index=index)
elif level == 'error':
return log_to_elk.log_error(message=message,
category=category,
data=data,
index=index)
else:
return log_to_elk.log_error(
"Error: not supported error level: {0} \n\nmessage: {1}\ncategory: {2}\ndata: {3}"
.format(level, message, category, data))
return message
except Exception as error:
return log_to_elk.log_error('Error: ' + str(error),
'Lambda.utils.log_to_elk')
import sys
sys.path.append('..')
print('***** loading dependency')
from osbot_aws.apis.Lambda import load_dependency
load_dependency('elastic')
print('***** done')
from unittest import TestCase
from pbx_gs_python_utils.utils.Dev import Dev
from pbx_gs_python_utils.utils.Json import Json
from pbx_gs_python_utils.utils.Elastic_Search import Elastic_Search
class Pytest_To_Elk:
def __init__(self):
self.pytest_json = './report.json'
self.index_id = 'pytest_data'
self.aws_secret_id = 'elastic-logs-server-1'
self._elastic = None
# helper methods
def elastic(self):
if self._elastic is None:
self._elastic = Elastic_Search(index=self.index_id,
aws_secret_id=self.aws_secret_id)
return self._elastic
def run(event, context):
load_dependency('elastic')
from gs.API_Elastic_Lambda import API_Elastic_Lambda
return API_Elastic_Lambda().handle_lambda_event(event)
import sys
import unittest
sys.path.append('..')
from osbot_aws.apis.Lambda import load_dependency
load_dependency('slack')
from pbx_gs_python_utils.utils.slack.API_Slack import API_Slack
class test_API_Slack(unittest.TestCase):
def setUp(self):
self.channel = 'GDL2EC3EE' #''gs-bot-tests'
self.api = API_Slack(self.channel)
def test_add_reaction(self):
response = self.api.send_message("Testing reaction")
ts = response['message']['ts']
response = self.api.add_reaction(ts, "thumbsup")
assert response['ok'] is True
def test_channels_public(self):
channels = self.api.channels_public()
assert len(set(channels)) > 40
assert channels['random']['id'] == 'C7EUMACGJ'
def test_channels_private(self):
channels = self.api.channels_private()