def web_root(self):
if os.getenv('AWS_REGION') is not None: # if we are in AWS
return Files.path_combine('.','./osbot_browser/web_root')
if 'test/browser' in Files.current_folder(): # if we are in an unit test
return Files.path_combine('.','../../osbot_browser/web_root')
parent_folder = Files.folder_name(__file__)
if 'serverless-render/osbot_browser/browser' in parent_folder:
return Files.path_combine(parent_folder,'../web_root')
return None
def __init__(self, base_folder=None, folder_oss=None):
self.folder_oss = folder_oss
self.base_folder = base_folder
if folder_oss is None:
self.folder_oss = Files.path_combine(__file__, '../../../..')
if base_folder is None: self.base_folder = '.'
self.file_template = Files.path_combine(
self.folder_oss, "{0}/{1}".format(self.base_folder,
'_template.md'))
self._all_md_files = None
def load_dependency(target):
if os.getenv('AWS_REGION') is None:
return
from osbot_aws.apis.S3 import S3
import shutil
import sys
s3 = S3()
s3_bucket = 'gw-bot-lambdas'
s3_key = 'lambdas-dependencies/{0}.zip'.format(target)
tmp_dir = Files.path_combine('/tmp/lambdas-dependencies', target)
#return s3.file_exists(s3_bucket,s3_key)
if s3.file_exists(s3_bucket, s3_key) is False:
raise Exception(
"In Lambda load_dependency, could not find dependency for: {0}".
format(target))
if Files.not_exists(
tmp_dir
): # if the tmp folder doesn't exist it means that we are loading this for the first time (on a new Lambda execution environment)
zip_file = s3.file_download(
s3_bucket, s3_key, False) # download zip file with dependencies
shutil.unpack_archive(zip_file, extract_dir=tmp_dir) # unpack them
sys.path.append(
tmp_dir
) # add tmp_dir to the path that python uses to check for dependencies
return Files.exists(tmp_dir)
def create_temp_file(self, new_code=None):
if new_code: self.lambda_code = new_code
self.tmp_file = Files.path_combine(self.folder,
'{0}.py'.format(self.file_name))
Files.write(self.tmp_file, self.lambda_code)
assert Files.exists(self.tmp_file)
return self
def __init__(self, web_root=None):
self.src_tmp = '/tmp/temp_web_server'
if web_root: self.web_root = web_root
else: self.web_root = self.src_tmp + '/html'
self.html_file = Files.path_combine(self.web_root, 'index.html')
self.port = Misc.random_number(10000, 60000)
self.server_proc = None
def get_files(self):
all_files = []
for root, dirs, files in os.walk(self.tmp_folder):
for file in files:
file_path = Files.path_combine(root, file).replace(
self.tmp_folder, '')
all_files.append(file_path)
return all_files
def __init__(self, headless=True):
self.web_page = '/vivagraph/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
def deploy(self, delete_before=False):
if delete_before:
self.osbot.delete()
code_folder = Files.path_combine(__file__, '..')
self.osbot.add_folder(code_folder)
self.osbot.add_root_folder()
self.osbot.add_pbx_gs_python_utils()
return self.osbot.update()
def __init__(self, tmp_img=None, clip=None, headless=False):
self.headless = headless
self.path_views = Files.path_combine(Files.parent_folder(__file__),
'../../osbot_browser/web_root')
self.render_page = Render_Page(headless=self.headless,
web_root=self.path_views)
self.tmp_img = tmp_img
self.clip = clip
def deploy(self, delete_before=False):
if delete_before:
self.package.delete()
code_folder = Files.path_combine(__file__, '..')
self.package.add_folder(code_folder)
self.package.add_root_folder()
self.package.add_pbx_gs_python_utils()
#Dev.pprint(self.package.get_files())
return self.package.update()
def use_lambda_file(self, lambda_file):
file_path = Files.path_combine(self.get_root_folder(), lambda_file)
if Files.exists(file_path) is False:
return {
'status':
'error',
'data':
'could not find lambda file `{0}` in root folder `{1}`'.format(
lambda_file, self.get_root_folder())
}
target_file = Files.path_combine(self.tmp_folder,
'{0}.py'.format(self.lambda_name))
Files.copy(file_path, target_file)
return {
'status': 'ok',
'file_path': file_path,
'target_file': target_file
}
def __init__(self, web_page, headless=True):
self.web_page = web_page
self.title = 'browser view'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
def run(event, context):
file_name = event.get('file_name') # get file_name from lambda params
tmp_path = '/tmp' # location of lambda temp folder
tmp_file = Files.path_combine(
tmp_path, file_name) # create file name (in temp folder)
Files.write(tmp_file, 'some text') # create file (with some text)
return Files.find(tmp_path + '/*.*') # return list of files in temp folder
def test_add_file(self):
lambda_file = Files.path_combine(
__file__, '../../../../osbot_aws/lambdas/dev/hello_world.py')
assert Files.exists(lambda_file)
self.package.add_file(lambda_file)
assert self.package.get_files() == ['/hello_world.py']
self.package.aws_lambda.handler = 'hello_world.run'
self.package.update()
assert self.package.invoke() == 'From lambda code, hello None'
def deploy_lambda__slack_web(self):
package = self.get_package('osbot_browser.lambdas.slack_web')
source_folder = Files.path_combine(
__file__, '../../modules/OSBot-Browser/osbot_browser')
package.add_folder(source_folder)
package.add_module('osbot_aws')
package.add_module('oss_bot')
package.add_pbx_gs_python_utils()
package.update()
return package
def __init__(self):
self.web_page = '/datatables/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser().sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser,
web_root=self.web_root)
self.table_width = '100%'
self.columns_defs = None
self.table_title = None
def __init__(self, headless=True):
self.web_page = '/gs/risk/risks-dashboard.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.headless = headless
self.api_browser = API_Browser(self.headless,
self.headless).sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser,
web_root=self.web_root)
self.graph_name = None
self.jira_key = None
def upload_dependency(target):
s3 = S3()
s3_bucket = 'gw-bot-lambdas'
s3_file = 'lambdas-dependencies/{0}.zip'.format(target)
path_libs = Files.path_combine('../../../_lambda_dependencies/', target)
if Files.not_exists(path_libs):
raise Exception(
"In Lambda upload_dependency, could not find dependency for: {0}".
format(target))
s3.folder_upload(path_libs, s3_bucket, s3_file)
return s3.file_exists(s3_bucket, s3_file)
def deploy_lambda__browser(self):
#package = Lambda_Package('osbot_browser.lambdas.lambda_browser')
#package._lambda.set_s3_bucket(self.oss_setup.s3_bucket_lambdas) \
# .set_role(self.oss_setup.role_lambdas)
#return package.update_code()
package = self.get_package('osbot_browser.lambdas.lambda_browser')
source_folder = Files.path_combine(
__file__, '../../modules/OSBot-Browser/osbot_browser')
#return source_folder, Files.exists(source_folder)
package.add_folder(source_folder)
package.add_module('osbot_aws')
package.add_pbx_gs_python_utils()
package.update()
#return package.update_code()
return package
def md_files_in_folder(self, target):
path = Files.path_combine(self.folder_oss, target)
return Files_Utils.all_files_recursive_with_extension(path, '.md')
def remove_files(self, pattern):
for file in self.get_files():
if pattern in file:
file_to_delete = Files.path_combine(self.tmp_folder, file[1:])
Files.delete(file_to_delete)
def __init__(self, contents='...', extension='tmp'):
self.tmp_file = Misc.random_filename(extension)
self.tmp_folder = tempfile.tempdir
self.file_path = Files.path_combine(self.tmp_folder, self.tmp_file)
self.contents = contents
def __init__(self):
self.images_path = Files.path_combine(__file__, '../../../docker')
def md_file_path(self, virtual_path: str):
if virtual_path.startswith('/'): virtual_path = virtual_path[1:]
return Files.path_combine(self.folder_oss, virtual_path)
def all_md_files(self):
if self._all_md_files is None:
path = Files.path_combine(self.folder_oss, self.base_folder)
self._all_md_files = Files_Utils.all_files_recursive_with_extension(
path, '.md')
return self._all_md_files
def build(self, build_name):
build_path = Files.path_combine(self.images_path, build_name)
params = ['build', '-t', build_name, build_path]
return self.docker_exec(params)
def __init__(self):
self.data_folder = Files.path_combine(__file__,
'../../../../data/_sync/json')
def data_participants_remote(self):
data = Json.load_json(
Files.path_combine(self.data_folder, 'participants_remote.json'))
return list(data.values())
def build_step__zip_src_folder(self):
zip_file = Files.path_combine(self.path_docker_folder, 'src')
src_folder = Files.path_combine(self.path_docker_folder, '../../src')
return shutil.make_archive(zip_file, "gztar", src_folder)
def repo_files(self):
return Files.files(Files.path_combine(self.path_repo, '**'))
