syncloud-lib 333__py3-none-any.whl

syncloudlib/application/config.py

@@ -0,0 +1,9 @@
+from syncloudlib.application.connection import api_post, api_get
+
+
+def set_dkim_key(dkim_key):
+    return api_post('/config/set_dkim_key', data={"dkim_key": dkim_key})
+
+
+def get_dkim_key():
+    return api_get('/config/get_dkim_key')

syncloudlib/application/connection.py

@@ -0,0 +1,40 @@
+import requests_unixsocket
+import json
+import os
+
+socket_file = '/var/snap/platform/common/api.socket'
+socket = 'http+unix://{0}'.format(socket_file.replace('/', '%2F'))
+
+
+def api_post(url, data):
+    session = requests_unixsocket.Session()
+    try:
+        response = session.post('{0}{1}'.format(socket, url), data=data)
+        if response.status_code == 200:
+            response_json = json.loads(response.text)
+            if 'success' in response_json and response_json['success']:
+                return response_json['data']
+            else:
+                raise Exception('service error: {0}'.format(response_json['message']))
+            
+        else:
+            raise Exception('unable to connect to {0} with error code: {1}'.format(socket, response.status_code))
+    except Exception as e:
+        raise Exception('unable to connect to {0}'.format(socket), e)
+
+
+def api_get(url):
+    session = requests_unixsocket.Session()
+    try:
+        response = session.get('{0}{1}'.format(socket, url))
+        if response.status_code == 200:
+            response_json = json.loads(response.text)
+            if 'success' in response_json and response_json['success']:
+                return response_json['data']
+            else:
+                raise Exception('service error: {0}'.format(response_json['message']))
+            
+        else:
+            raise Exception('unable to connect to {0} with error code: {1}'.format(socket, response.status_code))
+    except Exception as e:
+        raise Exception('unable to connect to {0}'.format(socket), e)

syncloudlib/application/paths.py

@@ -0,0 +1,9 @@
+from syncloudlib.application.connection import api_get
+
+
+def get_app_dir(app):
+    return api_get('/app/install_path?name={0}'.format(app))
+
+
+def get_data_dir(app):
+    return api_get('/app/data_path?name={0}'.format(app))

syncloudlib/application/ports.py

@@ -0,0 +1,9 @@
+from syncloudlib.application.connection import api_post
+
+
+def add_port(port, protocol):
+    return api_post('/port/add', data={"port": port, "protocol": protocol})
+
+
+def remove_port(port, protocol):
+    return api_post('/port/remove', data={"port": port, "protocol": protocol})

syncloudlib/application/service.py

@@ -0,0 +1,6 @@
+from syncloudlib.application.connection import api_post
+
+
+def restart(service_name):
+    return api_post('/service/restart', data={"name": service_name})
+

syncloudlib/application/storage.py

@@ -0,0 +1,9 @@
+from syncloudlib.application.connection import api_post, api_get
+
+
+def init_storage(app, user):
+    return api_post('/app/init_storage', data={"app_name": app, "user_name": user})
+
+
+def get_storage_dir(app):
+    return api_get('/app/storage_dir?name={0}'.format(app))

syncloudlib/application/urls.py

@@ -0,0 +1,11 @@
+from syncloudlib.application.connection import api_get
+
+
+def get_app_url(app):
+    return api_get('/app/url?name={0}'.format(app))
+
+def get_device_domain_name():
+    return api_get('/app/device_domain_name')
+
+def get_app_domain_name(app):
+    return api_get('/app/domain_name?name={0}'.format(app))

syncloudlib/application/users.py

@@ -0,0 +1,5 @@
+from syncloudlib.application.connection import api_get
+
+
+def get_email():
+    return api_get('/user/email')

syncloudlib/error.py

@@ -0,0 +1,6 @@
+class PassthroughJsonError(Exception):
+    def __init__(self, message, json):
+        Exception.__init__(self)
+        self.message = message
+        self.json = json
+     

syncloudlib/fs.py

@@ -0,0 +1,44 @@
+from os import makedirs, chown, utime
+from os.path import isdir
+from grp import getgrnam
+from pwd import getpwnam
+from shutil import rmtree
+from subprocess import check_output
+
+
+def makepath(path):
+    if not isdir(path):
+        makedirs(path)
+
+
+def removepath(path):
+    if isdir(path):
+        rmtree(path, ignore_errors=True)
+
+
+def createfile(filepath):
+    try:
+        f = open(filepath, 'w+')
+        f.close()
+    except:
+        pass
+
+
+def chownpath(path, user, recursive=False):
+    if recursive:
+        chownrecursive(path, user)
+    else:
+        chown(path, getpwnam(user).pw_uid, getgrnam(user).gr_gid)
+
+
+def chownrecursive(path, user):
+    estimate_count = int(check_output('find {0} -maxdepth 3 | wc -l'.format(path), shell=True).decode())
+    if estimate_count > 1000:
+        return 'not changing permissions, too many files'
+
+    return check_output('chown -RLf {0}. {1}'.format(user, path), shell=True).decode()
+
+
+def touchfile(file):
+    with open(file, 'a'):
+        utime(file, None)

syncloudlib/http.py

@@ -0,0 +1,28 @@
+import time
+
+
+def wait_for_rest(web_session, url, code, attempts=10):
+    def pred(resp):
+        return resp.status_code == code
+
+    wait_for_response(web_session, url, pred, attempts)
+
+
+def wait_for_response(web_session, url, resp_predicate, attempts=10):
+    
+    attempt=0
+    attempt_limit=attempts
+    response = None
+    while attempt < attempt_limit:
+        try:
+            response = web_session.get(url, verify=False)
+            print('code: {0}'.format(response.status_code))
+            if resp_predicate(response):
+                return
+        except Exception as e:
+            print(str(e))
+        time.sleep(10)
+        attempt = attempt + 1
+    if response and response.text:
+        print(response.text)
+    raise Exception('exhausted')

syncloudlib/integration/conftest.py

@@ -0,0 +1,247 @@
+import pytest
+import os
+from os.path import join, exists
+from selenium import webdriver
+
+from syncloudlib.integration.installer import get_data_dir, get_app_dir, get_service_prefix, get_ssh_env_vars, get_snap_data_dir
+from syncloudlib.integration.device import Device
+from syncloudlib.integration.selenium_wrapper import SeleniumWrapper
+
+
+def pytest_addoption(parser):
+    parser.addoption("--domain", action="store", default="device.com")
+    parser.addoption("--device-host", action="store")
+    parser.addoption("--app-archive-path", action="store")
+    parser.addoption("--app", action="store")
+    parser.addoption("--ui-mode", action="store", default="desktop")
+    parser.addoption("--device-user", action="store", default="user")
+    parser.addoption("--build-number", action="store", default="local")
+    parser.addoption("--browser", action="store", default="firefox")
+    parser.addoption("--browser-height", action="store", default=1000)
+    parser.addoption("--redirect-user", action="store", default="redirect-user-notset")
+    parser.addoption("--redirect-password", action="store", default="redirect-password-notset")
+    parser.addoption("--distro", action="store", default="distro")
+    parser.addoption("--arch", action="store", default="unset-arch")
+
+
+@pytest.fixture(scope='session')
+def build_number(request):
+    return request.config.getoption("--build-number")
+    
+
+@pytest.fixture(scope='session')
+def device_user(request):
+    return request.config.getoption("--device-user")
+    
+    
+@pytest.fixture(scope='session')
+def device_password():
+    return 'Password1'
+    
+
+@pytest.fixture(scope='session')
+def redirect_user(request):
+    return request.config.getoption("--redirect-user")
+
+
+@pytest.fixture(scope='session')
+def redirect_password(request):
+    return request.config.getoption("--redirect-password")
+    
+    
+@pytest.fixture(scope='session')
+def app(request):
+    return request.config.getoption("--app")
+
+
+@pytest.fixture(scope='session')
+def ui_mode(request):
+    return request.config.getoption("--ui-mode")
+
+
+@pytest.fixture(scope='session')
+def app_archive_path(request):
+    return request.config.getoption("--app-archive-path")
+
+
+@pytest.fixture(scope='session')
+def device_host(request, app, domain):
+    device_host = request.config.getoption("--device-host")
+    if device_host:
+        return device_host
+    return '{0}.{1}'.format(app, domain)
+
+
+@pytest.fixture(scope='session')
+def domain(request, distro):
+    domain = request.config.getoption("--domain")
+    if domain:
+        return domain
+    return '{0}.com'.format(distro)
+
+
+@pytest.fixture(scope='session')
+def browser(request):
+    return request.config.getoption("--browser")
+
+
+@pytest.fixture(scope='session')
+def browser_height(request):
+    return int(request.config.getoption("--browser-height"))
+
+
+@pytest.fixture(scope='session')
+def distro(request):
+    return request.config.getoption("--distro")
+
+
+@pytest.fixture(scope='session')
+def arch(request):
+    return request.config.getoption("--arch")
+
+
+@pytest.fixture(scope='session')
+def app_domain(app, domain):
+    return '{0}.{1}'.format(app, domain)
+    
+
+@pytest.fixture(scope="session")
+def platform_data_dir():
+    return get_data_dir('platform')
+
+    
+@pytest.fixture(scope="session")
+def data_dir(app):
+    return get_data_dir(app)
+
+
+@pytest.fixture(scope="session")
+def snap_data_dir(app):
+    return get_snap_data_dir(app)
+
+
+@pytest.fixture(scope="session")
+def app_dir(app):
+    return get_app_dir(app)
+    
+
+@pytest.fixture(scope="session")
+def service_prefix():
+    return get_service_prefix()
+
+
+def new_firefox_driver(hub_url, ui_mode):
+    #desktop_agent = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:104.0) Gecko/20100101 Firefox/100.0"
+    mobile_agent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Mobile/15E148 Safari/604.1"
+        
+    options = webdriver.FirefoxOptions()
+    options.set_preference('app.update.auto', False)
+    options.set_preference('app.update.enabled', False)
+    if ui_mode == "mobile":
+        options.set_preference("general.useragent.override", mobile_agent)
+    options.set_preference("devtools.console.stdout.content", True)
+    options.set_capability('acceptInsecureCerts', True)
+    options.set_capability('se:recordVideo', True)
+    options.set_preference("media.navigator.streams.fake", True)
+    options.set_preference("media.navigator.permission.disabled", True)
+
+    return webdriver.Remote(
+        command_executor=hub_url,
+        options=options
+    )
+
+
+def new_chrome_driver(hub_url, ui_mode):
+    #desktop_agent = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:104.0) Gecko/20100101 Firefox/100.0"
+    mobile_agent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Mobile/15E148 Safari/604.1"
+ 
+    options = webdriver.ChromeOptions()
+    if ui_mode == "mobile":
+        options.add_argument('user-agent={}'.format(mobile_agent))
+    #options.add_argument('--headless')
+    options.add_argument('--no-sandbox')
+    options.add_argument('--disable-dev-shm-usage')
+    options.set_capability('goog:loggingPrefs', {'performance': 'ALL'})
+    options.set_capability('acceptInsecureCerts', True)
+    options.set_capability('se:recordVideo', True)
+    options.add_argument("--use-fake-ui-for-media-stream")
+    options.add_argument("--use-fake-device-for-media-stream")
+    return webdriver.Remote(
+        command_executor=hub_url,
+        options=options
+    )
+
+
+@pytest.fixture(scope="session")
+def driver(ui_mode, browser, browser_height, request):
+    hub_url = 'http://selenium:4444/wd/hub'
+    width = 1024
+    if ui_mode == "mobile":
+        width = 400
+
+    if browser == "firefox":
+        driver = new_firefox_driver(hub_url, ui_mode)
+    else:
+        driver = new_chrome_driver(hub_url, ui_mode)
+    driver.set_window_rect(0, 0, width, browser_height)
+
+    def driver_quit():
+        driver.quit()
+
+    request.addfinalizer(driver_quit)
+
+    return driver
+
+
+@pytest.fixture(scope="session")
+def ssh_env_vars(app):
+    return get_ssh_env_vars(app)
+
+
+@pytest.fixture(scope='function')
+def device_session(device):
+    return device.login()
+
+
+@pytest.fixture(scope="session")
+def device(domain, device_user,
+           device_password, redirect_user, redirect_password, ssh_env_vars):
+    return Device(domain, device_user,
+                  device_password, redirect_user, redirect_password, ssh_env_vars)
+
+
+@pytest.fixture(scope="session")
+def log_dir(project_dir):
+    dir = join(project_dir, 'log')
+    if not exists(dir):
+        os.mkdir(dir)
+    return dir
+
+
+@pytest.fixture(scope="session")
+def artifact_dir(project_dir, distro):
+    dir = join(project_dir, 'artifact', distro)
+    if not exists(dir):
+        os.mkdir(dir)
+    return dir
+
+
+@pytest.fixture(scope="session")
+def screenshot_dir(artifact_dir, ui_mode):
+    ui_dir = join(artifact_dir, ui_mode)
+    if not exists(ui_dir):
+        os.mkdir(ui_dir)
+    dir = join(ui_dir, 'screenshot')
+    if not exists(dir):
+        os.mkdir(dir)
+    return dir
+
+
+@pytest.fixture(scope="session")
+def selenium_timeout():
+    return 30
+
+
+@pytest.fixture(scope="session")
+def selenium(driver, ui_mode, screenshot_dir, app_domain, selenium_timeout, browser):
+    return SeleniumWrapper(driver, ui_mode, screenshot_dir, app_domain, selenium_timeout, browser)

syncloudlib/integration/device.py

@@ -0,0 +1,111 @@
+import requests
+
+from syncloudlib.integration.installer import wait_for_platform_web, wait_for_installer
+from syncloudlib.http import wait_for_rest
+from syncloudlib.integration.ssh import run_scp, run_ssh
+from requests.adapters import HTTPAdapter 
+import socket
+
+class Device:
+
+    def __init__(self, domain, device_user, device_password, redirect_user, redirect_password,
+                 ssh_env_vars):
+        self.domain = domain
+        self.device_user = device_user
+        self.device_password = device_password
+        self.redirect_user = redirect_user
+        self.redirect_password = redirect_password
+        self.ssh_env_vars = ssh_env_vars
+        self.ssh_password = 'syncloud'
+        self.session = None
+
+    def deactivate(self):
+        run_ssh(self.domain, 'rm /var/snap/platform/common/platform.db', password=self.ssh_password)
+
+    def activate(self, channel="stable"):
+        ip = socket.gethostbyname(self.domain)
+        run_ssh(self.domain, 'echo "{0} auth.{1}" >> /etc/hosts'.format(ip, self.domain), password=self.ssh_password, retries=10)
+        run_ssh(self.domain, '/snap/platform/current/bin/upgrade-snapd.sh {0}'.format(channel), password=self.ssh_password, retries=10)
+        run_ssh(self.domain, 'snap refresh platform --channel={0}'.format(channel), password=self.ssh_password, retries=10)
+
+        wait_for_rest(requests.session(), "https://{0}/rest/id".format(self.domain), 200, 10)
+
+        response = requests.post('https://{0}/rest/activate/managed'.format(self.domain),
+                                 json={'redirect_email': self.redirect_user,
+                                       'redirect_password': self.redirect_password,
+                                       'domain': self.domain,
+                                       'device_username': self.device_user,
+                                       'device_password': self.device_password}, verify=False)
+        if response.status_code == 200:
+            self.activated()
+            self.login()
+        return response
+
+    def activate_custom(self, channel="stable"):
+        ip = socket.gethostbyname(self.domain)
+        run_ssh(self.domain, 'echo "{0} auth.{1}" >> /etc/hosts'.format(ip, self.domain), password=self.ssh_password, retries=10)
+        run_ssh(self.domain, '/snap/platform/current/bin/upgrade-snapd.sh {0}'.format(channel), password=self.ssh_password, retries=10)
+        run_ssh(self.domain, 'snap refresh platform --channel={0}'.format(channel), password=self.ssh_password, retries=10)
+
+        wait_for_rest(requests.session(), "https://{0}/rest/id".format(self.domain), 200, 10)
+        response = requests.post('https://{0}/rest/activate/custom'.format(self.domain),
+                                 json={'domain': self.domain,
+                                       'device_username': self.device_user,
+                                       'device_password': self.device_password}, verify=False)
+        if response.status_code == 200:
+            self.activated()
+            self.login()
+        return response
+
+    def activated(self):
+        self.ssh_password = self.device_password
+
+    def login(self, retries=5):
+        session = requests.session()
+        session.mount('https://{0}'.format(self.domain), HTTPAdapter(max_retries=retries)) 
+        retry = 0
+        while True:
+            try:
+                session.post('https://{0}/rest/login'.format(self.domain), verify=False, allow_redirects=False,
+                             json={'username': self.device_user, 'password': self.device_password})
+                response = session.get('https://{0}/rest/user'.format(self.domain), verify=False,
+                                       allow_redirects=False)
+                if response.status_code == 200:
+                    self.session = session
+                    return session
+            except Exception as e:
+                print(str(e))
+                print('retry {0} of {1}'.format(retry, retries))
+            retry += 1
+            if retry > retries:
+                raise Exception('cannot login')
+
+    def app_remove(self, app, attempts=200):
+        response = self.session.post('https://{0}/rest/app/remove'.format(self.domain), json={'app_id': app},
+                                     verify=False, allow_redirects=False)
+
+        wait_for_installer(self.session, self.domain, attempts=attempts)
+        return response
+
+    def app_install(self, app, attempts=200):
+        response = self.session.post('https://{0}/rest/app/install'.format(self.domain), json={'app_id': app},
+                                     verify=False, allow_redirects=False)
+
+        wait_for_installer(self.session, self.domain, attempts=attempts)
+        return response
+
+    def run_ssh(self, cmd, retries=0, throw=True, env_vars='', debug=True, sleep=1):
+        ssh_env_vars = self.ssh_env_vars + ' ' + env_vars
+        return run_ssh(self.domain, cmd, password=self.ssh_password, env_vars=ssh_env_vars, retries=retries,
+                       throw=throw, debug=debug, sleep=sleep)
+
+    def scp_from_device(self, dir_from, dir_to, throw=False):
+        return run_scp('-r root@{0}:{1} {2}'.format(self.domain, dir_from, dir_to), password=self.ssh_password,
+                       throw=throw)
+
+    def scp_to_device(self, dir_from, dir_to, throw=False):
+        return run_scp('-r {0} root@{1}:{2}'.format(dir_from, self.domain, dir_to), password=self.ssh_password,
+                       throw=throw)
+
+    def http_get(self, url):
+        return self.session.get('https://{0}{1}'.format(self.domain, url), allow_redirects=False, verify=False)

syncloudlib/integration/hosts.py

@@ -0,0 +1,9 @@
+import socket
+
+def add_host_alias(app,  host, domain, hosts_file='/etc/hosts'):
+    ip = socket.gethostbyname(host)
+    with open(hosts_file, "a") as hosts:
+        print("adding hosts: {0} {1}".format(ip, domain))
+        hosts.write("{0} {1}\n".format(ip, domain))
+        print("adding hosts: {0} {1}.{2}".format(ip, app, domain))
+        hosts.write("{0} {1}.{2}\n".format(ip, app, domain))

syncloudlib/integration/installer.py

@@ -0,0 +1,78 @@
+import time
+from syncloudlib.integration.ssh import run_scp, run_ssh
+from subprocess import check_output
+from os.path import split
+import json
+import os
+
+SNAP = 'snap'
+SNAP_INSTALL = '{0} install --devmode'.format(SNAP)
+
+
+def get_data_dir(app):
+    return '/var/snap/{0}/common'.format(app)
+
+def get_snap_data_dir(app):
+    return '/var/snap/{0}/current'.format(app)
+
+def get_app_dir(app):
+    return '/snap/{0}/current'.format(app)
+
+
+def get_service_prefix():
+    return 'snap.'
+
+
+def get_ssh_env_vars(app):
+    return 'SNAP={0} SNAP_COMMON={1}'.format(get_app_dir(app), get_data_dir(app))
+
+
+def local_install(host, password, app_archive_path):
+    run_ssh(host, 'ls -la /', password=password)
+    _, app_archive = split(app_archive_path)
+    run_scp('{0} root@{1}:/'.format(app_archive_path, host), password=password, retries=3)
+    run_ssh(host, 'ls -la /{0}'.format(app_archive), password=password)
+    run_ssh(host, '{0} /{1}'.format(SNAP_INSTALL, app_archive), password=password)
+
+
+def local_remove(host, password, app):
+    run_ssh(host, '{0} remove {1}'.format(SNAP, app), password=password)
+
+
+def wait_for_platform_web(host):
+    print(check_output('while ! nc -w 1 -z {0} 81; do sleep 1; done'.format(host), shell=True).decode())
+    print(check_output('while ! nc -w 1 -z {0} 80; do sleep 1; done'.format(host), shell=True).decode())
+
+
+def wait_for_installer(web_session, host, attempts=60, throw_on_error=False):
+    is_running = True
+    attempt = 0
+    while is_running and attempt < attempts:
+        try:
+            response = web_session.get('https://{0}/rest/installer/status'.format(host), verify=False)
+            if response.status_code == 200:
+                status = json.loads(response.text)
+                is_running = status['data']['is_running']
+            else:
+                if throw_on_error:
+                    raise Exception("error http status code: {0}".format(response.status_code))
+        except Exception as e:
+            print(e.message)
+            if throw_on_error:
+                raise e
+            
+        print("attempt: {0}/{1}".format(attempt, attempts))
+        attempt += 1
+        time.sleep(10)
+    
+    if is_running:
+        raise Exception("time out waiting for thr installer")
+
+def wait_for_file(file, attempts=10):
+    attempt=0
+    attempt_limit=attempts
+    while attempt < attempt_limit:
+        if os.path.isfile(file):
+            return
+        time.sleep(10)
+        attempt = attempt + 1