calagoapi 1.0.dev1__py3-none-any.whl

calagoapi/api/files.py

@@ -0,0 +1,210 @@
+import requests
+
+from calagoapi.utils.model import Page
+from calagoapi.utils.exceptions import PanelConnectionError
+
+
+# Internal Calagopus FilesAPI
+class FilesAPI:
+    def __init__(self, client):
+        self.client = client
+
+    def _path(self, server_id, action):
+        return f'/api/client/servers/{server_id}/files/{action}'
+
+    # browsing
+    def list(self, server_id, directory='/', sort=None, page=None, per_page=None):
+        params = {'directory': directory, 'sort': sort}
+        if page is not None:
+            params.update(page=page, per_page=per_page or 100)
+            result = self.client.get(self._path(server_id, 'list'), params=params)
+            entries = result['entries']
+            return result, Page(entries['data'], entries['total'], entries['page'], entries['per_page'])
+
+        items = []
+        current = 1
+        while True:
+            params.update(page=current, per_page=per_page or 500)
+            result = self.client.get(self._path(server_id, 'list'), params=params)
+            entries = result['entries']
+            items.extend(entries['data'])
+            if not entries['data'] or len(items) >= entries['total']:
+                return result, Page(items, entries['total'], 1, len(items))
+            current += 1
+
+    def stat(self, server_id, files, root='/'):
+        return self.client.post(self._path(server_id, 'stat'), json={'root': root, 'files': files})['entries']
+
+    def search(self, server_id, root='/', path_filter=None, size_filter=None, content_filter=None, match_context=None):
+        return self.client.post(self._path(server_id, 'search'), json={
+            'root': root,
+            'path_filter': path_filter,
+            'size_filter': size_filter,
+            'content_filter': content_filter,
+            'match_context': match_context,
+        })
+
+    def directorySizes(self, server_id, directory='/', depth=None):
+        return self.client.get(
+            self._path(server_id, 'directory-sizes'),
+            params={'directory': directory, 'depth': depth}
+        )['directory_sizes']
+
+    def largestDirectories(self, server_id, directory='/'):
+        return self.client.get(
+            self._path(server_id, 'largest-directories'),
+            params={'directory': directory}
+        )['largest_directories']
+
+    def fingerprint(self, server_id, file, algorithm=None):
+        return self.client.get(
+            self._path(server_id, 'fingerprint'),
+            params={'file': file, 'algorithm': algorithm}
+        )['fingerprint']
+
+    # reading and writing
+    def contents(self, server_id, file):
+        return self.client.get(self._path(server_id, 'contents'), params={'file': file})
+
+    def lines(self, server_id, file, start_line=None, end_line=None):
+        return self.client.get(
+            self._path(server_id, 'lines'),
+            params={'file': file, 'start_line': start_line, 'end_line': end_line}
+        )
+
+    def write(self, server_id, file, content):
+        return self.client.postText(self._path(server_id, 'write'), content, params={'file': file})
+
+    def revisions(self, server_id, file):
+        return self.client.get(self._path(server_id, 'revisions'), params={'file': file})['revisions']
+
+    def revision(self, server_id, file, revision_id):
+        return self.client.get(self._path(server_id, f'revisions/{revision_id}'), params={'file': file})
+
+    # transfer
+    def downloadUrl(self, server_id, files=None, root='/', directory=None, archive_format=None):
+        params = {'root': root, 'directory': directory, 'archive_format': archive_format}
+        if files is not None:
+            params['files'] = files
+        return self.client.get(self._path(server_id, 'download'), params=params)['url']
+
+    def uploadUrl(self, server_id):
+        return self.client.get(self._path(server_id, 'upload'))['url']
+
+    def upload(self, server_id, directory, files):
+        '''`files` is a list of (name, data) tuples'''
+        url = self.uploadUrl(server_id)
+        payload = [('files', (name, data)) for name, data in files]
+        try:
+            r = requests.post(
+                url,
+                params={'directory': directory},
+                files=payload,
+                verify=self.client.session.verify,
+                timeout=max(self.client.timeout, 300),
+            )
+        except requests.RequestException as e:
+            raise PanelConnectionError(f'Upload failed: {e}') from e
+        if r.status_code >= 400:
+            self.client.raiseError(r)
+        return self.client.parse(r)
+
+    def fetch(self, url, stream=False):
+        '''Downloads a signed URL returned by the panel'''
+        try:
+            r = requests.get(url, verify=self.client.session.verify, timeout=max(self.client.timeout, 300), stream=stream)
+        except requests.RequestException as e:
+            raise PanelConnectionError(f'Download failed: {e}') from e
+        if r.status_code >= 400:
+            self.client.raiseError(r)
+        return r
+
+    def pull(self, server_id, url, root='/', name=None, use_header=None, foreground=None):
+        return self.client.post(self._path(server_id, 'pull'), json={
+            'url': url,
+            'root': root,
+            'name': name,
+            'use_header': use_header,
+            'foreground': foreground,
+        })
+
+    def queryPull(self, server_id, url):
+        return self.client.post(self._path(server_id, 'pull/query'), json={'url': url})['query_result']
+
+    # management
+    def delete(self, server_id, root, files):
+        return self.client.post(self._path(server_id, 'delete'), json={'root': root, 'files': files})
+
+    def rename(self, server_id, root, files):
+        '''`files` is a list of {'from': ..., 'to': ...}'''
+        return self.client.put(self._path(server_id, 'rename'), json={'root': root, 'files': files})
+
+    def copy(self, server_id, path, destination=None, overwrite=None, foreground=None):
+        return self.client.post(self._path(server_id, 'copy'), json={
+            'path': path,
+            'destination': destination,
+            'overwrite': overwrite,
+            'foreground': foreground,
+        })
+
+    def copyMany(self, server_id, root, files, overwrite=None, foreground=None):
+        return self.client.post(self._path(server_id, 'copy-many'), json={
+            'root': root,
+            'files': files,
+            'overwrite': overwrite,
+            'foreground': foreground,
+        })
+
+    def copyRemote(self, server_id, root, files, destination, destination_server, foreground=None):
+        return self.client.post(self._path(server_id, 'copy-remote'), json={
+            'root': root,
+            'files': files,
+            'destination': destination,
+            'destination_server': destination_server,
+            'foreground': foreground,
+        })
+
+    def copyRemoteMany(self, server_id, root, files, destination, destination_servers):
+        return self.client.post(self._path(server_id, 'copy-remote-many'), json={
+            'root': root,
+            'files': files,
+            'destination': destination,
+            'destination_servers': destination_servers,
+        })['results']
+
+    def createDirectory(self, server_id, root, name):
+        return self.client.post(self._path(server_id, 'create-directory'), json={'root': root, 'name': name})
+
+    def createSymlink(self, server_id, root, link, target):
+        return self.client.post(self._path(server_id, 'create-symlink'), json={'root': root, 'link': link, 'target': target})
+
+    def compress(self, server_id, root, files, format='tar_gz', name=None, foreground=None):
+        return self.client.post(self._path(server_id, 'compress'), json={
+            'root': root,
+            'files': files,
+            'format': format,
+            'name': name,
+            'foreground': foreground,
+        })
+
+    def decompress(self, server_id, root, file, foreground=None):
+        return self.client.post(self._path(server_id, 'decompress'), json={
+            'root': root,
+            'file': file,
+            'foreground': foreground,
+        })
+
+    def chmod(self, server_id, root, files):
+        '''`files` is a list of {'file': ..., 'mode': ..., 'recursive': ...}'''
+        return self.client.put(self._path(server_id, 'chmod'), json={'root': root, 'files': files})
+
+    def sqliteQuery(self, server_id, file, query, rows=None, read_only=None):
+        return self.client.post(self._path(server_id, 'sqlite-query'), json={
+            'file': file,
+            'query': query,
+            'rows': rows,
+            'read_only': read_only,
+        })['results']
+
+    def cancelOperation(self, server_id, operation_id):
+        return self.client.delete(self._path(server_id, f'operations/{operation_id}'))

calagoapi/api/network.py

@@ -0,0 +1,84 @@
+# Internal Calagopus NetworkAPI (allocations, subdomains, tunnels, firewall)
+class NetworkAPI:
+    def __init__(self, client):
+        self.client = client
+
+    def _path(self, server_id, suffix=''):
+        return f'/api/client/servers/{server_id}{suffix}'
+
+    # allocations
+    def allocations(self, server_id, search=None, page=None, per_page=None):
+        return self.client.list(self._path(server_id, '/allocations'), 'allocations', {'search': search}, page, per_page)
+
+    def createAllocation(self, server_id):
+        return self.client.post(self._path(server_id, '/allocations'))['allocation']
+
+    def updateAllocation(self, server_id, allocation_id, notes=None, primary=None):
+        return self.client.patch(
+            self._path(server_id, f'/allocations/{allocation_id}'),
+            json={'notes': notes, 'primary': primary}
+        )
+
+    def deleteAllocation(self, server_id, allocation_id):
+        return self.client.delete(self._path(server_id, f'/allocations/{allocation_id}'))
+
+    # subdomains
+    def subdomains(self, server_id, search=None, page=None, per_page=None):
+        return self.client.list(self._path(server_id, '/subdomains'), 'subdomains', {'search': search}, page, per_page)
+
+    def subdomainDomains(self, server_id):
+        return self.client.get(self._path(server_id, '/subdomains/domains'))['domains']
+
+    def createSubdomain(self, server_id, domain_uuid, allocation_uuid, subdomain):
+        return self.client.post(self._path(server_id, '/subdomains'), json={
+            'domain_uuid': domain_uuid,
+            'allocation_uuid': allocation_uuid,
+            'subdomain': subdomain,
+        })['subdomain']
+
+    def updateSubdomain(self, server_id, subdomain_id, allocation_uuid):
+        return self.client.patch(
+            self._path(server_id, f'/subdomains/{subdomain_id}'),
+            json={'allocation_uuid': allocation_uuid}
+        )
+
+    def deleteSubdomain(self, server_id, subdomain_id):
+        return self.client.delete(self._path(server_id, f'/subdomains/{subdomain_id}'))
+
+    # tunnel
+    def tunnel(self, server_id):
+        return self.client.get(self._path(server_id, '/tunnel'))
+
+    def createTunnel(self, server_id, name=None):
+        return self.client.post(self._path(server_id, '/tunnel'), json={'name': name})['tunnel']
+
+    def renameTunnel(self, server_id, name):
+        return self.client.patch(self._path(server_id, '/tunnel'), json={'name': name})['tunnel']
+
+    def deleteTunnel(self, server_id):
+        return self.client.delete(self._path(server_id, '/tunnel'))
+
+    def setTunnelPorts(self, server_id, ports):
+        return self.client.put(self._path(server_id, '/tunnel/ports'), json={'ports': ports})
+
+    def tunnelConnectable(self, server_id, search=None, other=None, page=None, per_page=None):
+        return self.client.list(
+            self._path(server_id, '/tunnel/connections/available'), 'servers',
+            {'search': search, 'other': other}, page, per_page
+        )
+
+    def connectTunnel(self, server_id, target_server):
+        return self.client.post(self._path(server_id, '/tunnel/connections'), json={'server': target_server})
+
+    def disconnectTunnel(self, server_id, connection_id, incoming=None):
+        return self.client.delete(
+            self._path(server_id, f'/tunnel/connections/{connection_id}'),
+            params={'incoming': incoming}
+        )
+
+    # firewall
+    def firewall(self, server_id):
+        return self.client.get(self._path(server_id, '/firewall'))
+
+    def setFirewallRules(self, server_id, rules):
+        return self.client.put(self._path(server_id, '/firewall'), json={'rules': rules})

calagoapi/api/public.py

@@ -0,0 +1,13 @@
+# Internal Calagopus PublicAPI (unauthenticated panel information)
+class PublicAPI:
+    def __init__(self, client):
+        self.client = client
+
+    def settings(self):
+        return self.client.get('/api/settings')
+
+    def languages(self):
+        return self.client.get('/api/languages')['languages']
+
+    def announcements(self):
+        return self.client.get('/api/announcements')['announcements']

calagoapi/api/schedules.py

@@ -0,0 +1,79 @@
+# Internal Calagopus SchedulesAPI
+class SchedulesAPI:
+    def __init__(self, client):
+        self.client = client
+
+    def _path(self, server_id, suffix=''):
+        return f'/api/client/servers/{server_id}/schedules{suffix}'
+
+    # schedules
+    def list(self, server_id, search=None, page=None, per_page=None):
+        return self.client.list(self._path(server_id), 'schedules', {'search': search}, page, per_page)
+
+    def get(self, server_id, schedule_id):
+        return self.client.get(self._path(server_id, f'/{schedule_id}'))['schedule']
+
+    def create(self, server_id, name, triggers, condition, enabled=True):
+        return self.client.post(self._path(server_id), json={
+            'name': name,
+            'enabled': enabled,
+            'triggers': triggers,
+            'condition': condition,
+        })['schedule']
+
+    def update(self, server_id, schedule_id, name=None, enabled=None, triggers=None, condition=None):
+        return self.client.patch(self._path(server_id, f'/{schedule_id}'), json={
+            'name': name,
+            'enabled': enabled,
+            'triggers': triggers,
+            'condition': condition,
+        })
+
+    def delete(self, server_id, schedule_id):
+        return self.client.delete(self._path(server_id, f'/{schedule_id}'))
+
+    def duplicate(self, server_id, schedule_id, name):
+        return self.client.post(self._path(server_id, f'/{schedule_id}/duplicate'), json={'name': name})['schedule']
+
+    def trigger(self, server_id, schedule_id, skip_condition=None):
+        return self.client.post(self._path(server_id, f'/{schedule_id}/trigger'), json={'skip_condition': skip_condition})
+
+    def abort(self, server_id, schedule_id):
+        return self.client.post(self._path(server_id, f'/{schedule_id}/abort'))
+
+    def status(self, server_id, schedule_id):
+        return self.client.get(self._path(server_id, f'/{schedule_id}/status'))['status']
+
+    def export(self, server_id, schedule_id):
+        return self.client.get(self._path(server_id, f'/{schedule_id}/export'))
+
+    def importSchedule(self, server_id, data):
+        return self.client.post(self._path(server_id, '/import'), json=data)['schedule']
+
+    # steps
+    def steps(self, server_id, schedule_id):
+        return self.client.get(self._path(server_id, f'/{schedule_id}/steps'))['schedule_steps']
+
+    def createStep(self, server_id, schedule_id, action, order):
+        return self.client.post(
+            self._path(server_id, f'/{schedule_id}/steps'),
+            json={'action': action, 'order': order}
+        )['schedule_step']
+
+    def updateStep(self, server_id, schedule_id, step_id, action=None, order=None):
+        return self.client.patch(
+            self._path(server_id, f'/{schedule_id}/steps/{step_id}'),
+            json={'action': action, 'order': order}
+        )
+
+    def deleteStep(self, server_id, schedule_id, step_id):
+        return self.client.delete(self._path(server_id, f'/{schedule_id}/steps/{step_id}'))
+
+    def duplicateStep(self, server_id, schedule_id, step_id):
+        return self.client.post(self._path(server_id, f'/{schedule_id}/steps/{step_id}/duplicate'))['schedule_step']
+
+    def orderSteps(self, server_id, schedule_id, step_order):
+        return self.client.put(
+            self._path(server_id, f'/{schedule_id}/steps/order'),
+            json={'schedule_step_order': step_order}
+        )

calagoapi/api/servers.py

@@ -0,0 +1,114 @@
+# Internal Calagopus ServersAPI
+class ServersAPI:
+    def __init__(self, client):
+        self.client = client
+
+    # listing
+    def list(self, search=None, other=None, page=None, per_page=None):
+        return self.client.list('/api/client/servers', 'servers', {'search': search, 'other': other}, page, per_page)
+
+    def get(self, server_id):
+        return self.client.get(f'/api/client/servers/{server_id}')['server']
+
+    def eggs(self, search=None, page=None, per_page=None):
+        return self.client.list('/api/client/servers/eggs', 'nest_eggs', {'search': search}, page, per_page)
+
+    def eggCommandSnippets(self, egg_id):
+        return self.client.get(f'/api/client/servers/eggs/{egg_id}/command-snippets')['command_snippets']
+
+    def nodeResources(self, node_id):
+        return self.client.get(f'/api/client/servers/nodes/{node_id}/resources')['resources']
+
+    # status and console
+    def resources(self, server_id):
+        return self.client.get(f'/api/client/servers/{server_id}/resources')['resources']
+
+    def power(self, server_id, action):
+        return self.client.post(f'/api/client/servers/{server_id}/power', json={'action': action})
+
+    def command(self, server_id, command):
+        return self.client.post(f'/api/client/servers/{server_id}/command', json={'command': command})
+
+    def logs(self, server_id, lines=None):
+        return self.client.get(f'/api/client/servers/{server_id}/logs', params={'lines': lines})
+
+    def websocket(self, server_id):
+        return self.client.get(f'/api/client/servers/{server_id}/websocket')
+
+    def activity(self, server_id, user=None, search=None, page=None, per_page=None):
+        return self.client.list(
+            f'/api/client/servers/{server_id}/activity', 'activities',
+            {'user': user, 'search': search}, page, per_page
+        )
+
+    def announcements(self, server_id):
+        return self.client.get(f'/api/client/servers/{server_id}/announcements')['announcements']
+
+    # settings
+    def rename(self, server_id, name=None, description=None):
+        return self.client.post(
+            f'/api/client/servers/{server_id}/settings/rename',
+            json={'name': name, 'description': description}
+        )
+
+    def setTimezone(self, server_id, timezone):
+        return self.client.put(f'/api/client/servers/{server_id}/settings/timezone', json={'timezone': timezone})
+
+    def setAutoKill(self, server_id, enabled, seconds=None):
+        payload = {'enabled': enabled}
+        if seconds is not None:
+            payload['seconds'] = seconds
+        return self.client.put(f'/api/client/servers/{server_id}/settings/auto-kill', json=payload)
+
+    def setAutoStart(self, server_id, behavior):
+        return self.client.put(f'/api/client/servers/{server_id}/settings/auto-start', json={'behavior': behavior})
+
+    def reinstall(self, server_id, truncate_directory=False, start_on_completion=None):
+        payload = {'truncate_directory': truncate_directory}
+        if start_on_completion is not None:
+            payload['start_on_completion'] = start_on_completion
+        return self.client.post(f'/api/client/servers/{server_id}/settings/install', json=payload)
+
+    def cancelInstall(self, server_id):
+        return self.client.post(f'/api/client/servers/{server_id}/settings/install/cancel')
+
+    def unlockInstall(self, server_id):
+        return self.client.post(f'/api/client/servers/{server_id}/settings/install/unlock')
+
+    # startup
+    def startupVariables(self, server_id):
+        return self.client.get(f'/api/client/servers/{server_id}/startup/variables')['variables']
+
+    def updateStartupVariables(self, server_id, variables):
+        return self.client.put(f'/api/client/servers/{server_id}/startup/variables', json={'variables': variables})
+
+    def setStartupCommand(self, server_id, command):
+        return self.client.put(f'/api/client/servers/{server_id}/startup/command', json={'command': command})
+
+    def setDockerImage(self, server_id, image):
+        return self.client.put(f'/api/client/servers/{server_id}/startup/docker-image', json={'image': image})
+
+    # server groups
+    def groups(self):
+        return self.client.get('/api/client/servers/groups')['server_groups']
+
+    def groupServers(self, group_id, search=None, page=None, per_page=None):
+        return self.client.list(f'/api/client/servers/groups/{group_id}', 'servers', {'search': search}, page, per_page)
+
+    def createGroup(self, name, server_order=None):
+        return self.client.post(
+            '/api/client/servers/groups',
+            json={'name': name, 'server_order': server_order or []}
+        )['server_group']
+
+    def updateGroup(self, group_id, name, server_order=None):
+        payload = {'name': name}
+        if server_order is not None:
+            payload['server_order'] = server_order
+        return self.client.patch(f'/api/client/servers/groups/{group_id}', json=payload)
+
+    def deleteGroup(self, group_id):
+        return self.client.delete(f'/api/client/servers/groups/{group_id}')
+
+    def orderGroups(self, group_order):
+        return self.client.put('/api/client/servers/groups/order', json={'server_group_order': group_order})

calagoapi/api/users.py

@@ -0,0 +1,27 @@
+# Internal Calagopus UsersAPI (server subusers)
+class UsersAPI:
+    def __init__(self, client):
+        self.client = client
+
+    def _path(self, server_id, suffix=''):
+        return f'/api/client/servers/{server_id}/subusers{suffix}'
+
+    def list(self, server_id, search=None, page=None, per_page=None):
+        return self.client.list(self._path(server_id), 'subusers', {'search': search}, page, per_page)
+
+    def create(self, server_id, email, permissions, ignored_files=None, captcha=None):
+        return self.client.post(self._path(server_id), json={
+            'email': email,
+            'permissions': permissions,
+            'ignored_files': ignored_files or [],
+            'captcha': captcha,
+        })['subuser']
+
+    def update(self, server_id, subuser_id, permissions=None, ignored_files=None):
+        return self.client.patch(self._path(server_id, f'/{subuser_id}'), json={
+            'permissions': permissions,
+            'ignored_files': ignored_files,
+        })
+
+    def delete(self, server_id, subuser_id):
+        return self.client.delete(self._path(server_id, f'/{subuser_id}'))

calagoapi/api/versions.py

@@ -0,0 +1,29 @@
+from calagoapi.api.client import segment
+
+
+# Internal Calagopus VersionsAPI (Minecraft Version Changer extension)
+class VersionsAPI:
+    def __init__(self, client):
+        self.client = client
+
+    def _path(self, server_id, suffix=''):
+        return f'/api/client/servers/{server_id}/minecraft/versions{suffix}'
+
+    def installed(self, server_id):
+        return self.client.get(self._path(server_id, '/installed'))['build']
+
+    def types(self, server_id):
+        return self.client.get(self._path(server_id, '/types'))['types']
+
+    def versions(self, server_id, type, search=None, page=None, per_page=None):
+        return self.client.list(self._path(server_id, f'/types/{segment(type)}'), 'versions', {'search': search}, page, per_page)
+
+    def builds(self, server_id, type, version, search=None, page=None, per_page=None):
+        return self.client.list(self._path(server_id, f'/types/{segment(type)}/{segment(version)}'), 'builds', {'search': search}, page, per_page)
+
+    def install(self, server_id, build_uuid, truncate_directory=False, accept_eula=True):
+        return self.client.post(self._path(server_id, '/install'), json={
+            'build_uuid': build_uuid,
+            'truncate_directory': truncate_directory,
+            'accept_eula': accept_eula,
+        })

calagoapi/backups/__init__.py

@@ -0,0 +1,8 @@
+from .backup import Backup, BackupGroup
+from .manager import BackupManager
+
+__all__ = [
+    'Backup',
+    'BackupGroup',
+    'BackupManager',
+]