Fix --accel parameter for oneshot

Totally not related to my previous commit

.gitignore

@@ -16,3 +16,5 @@ uncloud/version.py
 build/
 venv/
 dist/
+
+*.iso

bin/gen-version

@@ -1,22 +1,22 @@
 #!/bin/sh
 # -*- coding: utf-8 -*-
 #
-# 2019 Nico Schottelius (nico-ucloud at schottelius.org)
+# 2019-2020 Nico Schottelius (nico-uncloud at schottelius.org)
 #
-# This file is part of ucloud.
+# This file is part of uncloud.
 #
-# ucloud is free software: you can redistribute it and/or modify
+# uncloud is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# ucloud is distributed in the hope that it will be useful,
+# uncloud is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with ucloud. If not, see <http://www.gnu.org/licenses/>.
+# along with uncloud. If not, see <http://www.gnu.org/licenses/>.
 #
 #
 
@@ -26,4 +26,4 @@ dir=${0%/*}
 
 # Ensure version is present - the bundled/shipped version contains a static version,
 # the git version contains a dynamic version
-printf "VERSION = \"%s\"\n" "$(git describe)" > ${dir}/../uncloud/version.py
+printf "VERSION = \"%s\"\n" "$(git describe --tags --abbrev=0)" > ${dir}/../uncloud/version.py

bin/uncloud-run-reinstall

@@ -24,6 +24,6 @@
 dir=${0%/*}
 
 ${dir}/gen-version;
-pip uninstall -y uncloud
-python setup.py install
+pip uninstall -y uncloud >/dev/null
+python setup.py install  >/dev/null
 ${dir}/uncloud "$@"

docs/Makefile

@@ -7,7 +7,7 @@ SPHINXOPTS    ?=
 SPHINXBUILD   ?= sphinx-build
 SOURCEDIR     = source/
 BUILDDIR      = build/
-DESTINATION=root@staticweb.ungleich.ch:/home/services/www/ungleichstatic/staticcms.ungleich.ch/www/ucloud/
+DESTINATION=root@staticweb.ungleich.ch:/home/services/www/ungleichstatic/staticcms.ungleich.ch/www/uncloud/
 
 .PHONY: all build clean
 

docs/source/admin-guide.rst

@@ -56,40 +56,13 @@ To start host we created earlier, execute the following command
 
     ucloud host ungleich.ch
 
-Create OS Image
----------------
+File & image scanners
+--------------------------
 
-Create ucloud-init ready OS image (Optional)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-This step is optional if you just want to test ucloud. However, sooner or later
-you want to create OS images with ucloud-init to properly
-contexualize VMs.
-
-1. Start a VM with OS image on which you want to install ucloud-init
-2. Execute the following command on the started VM
-
-   .. code-block:: sh
-
-    apk add git
-    git clone https://code.ungleich.ch/ucloud/ucloud-init.git
-    cd ucloud-init
-    sh ./install.sh
-3. Congratulations. Your image is now ucloud-init ready.
-
-
-Upload Sample OS Image
-~~~~~~~~~~~~~~~~~~~~~~
-Execute the following to get the sample OS image file.
-
-.. code-block:: sh
-
-    mkdir /var/www/admin
-    (cd /var/www/admin && wget https://cloud.ungleich.ch/s/qTb5dFYW5ii8KsD/download)
-
-Run File Scanner and Image Scanner
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Currently, our uploaded file *alpine-untouched.qcow2* is not tracked by ucloud. We can only make
-images from tracked files. So, we need to track the file by running File Scanner
+Let's assume we have uploaded an *alpine-uploaded.qcow2* disk images to our
+uncloud server. Currently, our *alpine-untouched.qcow2* is not tracked by
+ucloud. We can only make images from tracked files. So, we need to track the
+file by running File Scanner
 
 .. code-block:: sh
 

docs/source/hacking.rst

@@ -0,0 +1,36 @@
+Hacking
+=======
+Using uncloud in hacking (aka development) mode.
+
+
+Get the code
+------------
+.. code-block:: sh
+    :linenos:
+
+     git clone https://code.ungleich.ch/uncloud/uncloud.git
+
+
+
+Install python requirements
+---------------------------
+You need to have python3 installed.
+
+.. code-block:: sh
+    :linenos:
+
+    cd uncloud!
+    python -m venv venv
+    . ./venv/bin/activate
+    ./bin/uncloud-run-reinstall
+
+
+
+Install os requirements
+-----------------------
+Install the following software packages: **dnsmasq**.
+
+If you already have a working IPv6 SLAAC and DNS setup,
+this step can be skipped.
+
+Note that you need at least one /64 IPv6 network to run uncloud.

docs/source/index.rst

@@ -11,14 +11,13 @@ Welcome to ucloud's documentation!
    :caption: Contents:
 
    introduction
-   user-guide
    setup-install
+   vm-images
+   user-guide
    admin-guide
-   user-guide/how-to-create-an-os-image-for-ucloud
    troubleshooting
    hacking
 
-
 Indices and tables
 ==================
 

docs/source/vm-images.rst

@@ -0,0 +1,66 @@
+VM images
+==================================
+
+Overview
+---------
+
+ucloud tries to be least invasise towards VMs and only require
+strictly necessary changes for running in a virtualised
+environment. This includes configurations for:
+
+* Configuring the network
+* Managing access via ssh keys
+* Resizing the attached disk(s)
+
+Upstream images
+---------------
+
+The 'official' uncloud images are defined in the `uncloud/images
+<https://code.ungleich.ch/uncloud/images>`_ repository.
+
+How to make you own Uncloud images
+----------------------------------
+
+.. note::
+  It is fairly easy to create your own images for uncloud, as the common
+  operations (which are detailed below) can be automatically handled by the
+  `uncloud/uncloud-init <https://code.ungleich.ch/uncloud/uncloud-init>`_ tool.
+
+Network configuration
+~~~~~~~~~~~~~~~~~~~~~
+All VMs in ucloud are required to support IPv6. The primary network
+configuration is always done using SLAAC. A VM thus needs only to be
+configured to
+
+* accept router advertisements on all network interfaces
+* use the router advertisements to configure the network interfaces
+* accept the DNS entries from the router advertisements
+
+
+Configuring SSH keys
+~~~~~~~~~~~~~~~~~~~~
+
+To be able to access the VM, ucloud support provisioning SSH keys.
+
+To accept ssh keys in your VM, request the URL
+*http://metadata/ssh_keys*. Add the content to the appropriate user's
+**authorized_keys** file. Below you find sample code to accomplish
+this task:
+
+.. code-block:: sh
+
+    tmp=$(mktemp)
+    curl -s http://metadata/ssk_keys > "$tmp"
+    touch ~/.ssh/authorized_keys # ensure it exists
+    cat ~/.ssh/authorized_keys >> "$tmp"
+    sort "$tmp" | uniq > ~/.ssh/authorized_keys
+
+
+Disk resize
+~~~~~~~~~~~
+In virtualised environments, the disk sizes might grow. The operating
+system should detect disks that are bigger than the existing partition
+table and resize accordingly. This task is os specific.
+
+ucloud does not support shrinking disks due to the complexity and
+intra OS dependencies.

scripts/uncloud

@@ -3,56 +3,86 @@ import logging
 import sys
 import importlib
 import argparse
-import multiprocessing as mp
+import os
 
+from etcd3.exceptions import ConnectionFailedError
+
+from uncloud.common import settings
 from uncloud import UncloudException
-from contextlib import suppress
+from uncloud.common.cli import resolve_otp_credentials
 
+# Components that use etcd
+ETCD_COMPONENTS = ['api', 'scheduler', 'host', 'filescanner',
+                   'imagescanner', 'metadata', 'configure', 'hack']
 
-def exception_hook(exc_type, exc_value, exc_traceback):
-    logging.getLogger(__name__).error(
-        'Uncaught exception',
-        exc_info=(exc_type, exc_value, exc_traceback)
-    )
+ALL_COMPONENTS = ETCD_COMPONENTS.copy()
+ALL_COMPONENTS.append('oneshot')
+#ALL_COMPONENTS.append('cli')
 
 
-sys.excepthook = exception_hook
-
 if __name__ == '__main__':
-    # Setting up root logger
-    logger = logging.getLogger()
-    logger.setLevel(logging.DEBUG)
-
     arg_parser = argparse.ArgumentParser()
     subparsers = arg_parser.add_subparsers(dest='command')
 
     parent_parser = argparse.ArgumentParser(add_help=False)
     parent_parser.add_argument('--debug', '-d', action='store_true', default=False,
                                help='More verbose logging')
+    parent_parser.add_argument('--conf-dir', '-c', help='Configuration directory',
+                               default=os.path.expanduser('~/uncloud'))
 
-    for component in ['api', 'scheduler', 'host', 'filescanner', 'imagescanner',
-                      'metadata', 'configure', 'cli']:
+    etcd_parser = argparse.ArgumentParser(add_help=False)
+    etcd_parser.add_argument('--etcd-host')
+    etcd_parser.add_argument('--etcd-port')
+    etcd_parser.add_argument('--etcd-ca-cert', help='CA that signed the etcd certificate')
+    etcd_parser.add_argument('--etcd-cert-cert', help='Path to client certificate')
+    etcd_parser.add_argument('--etcd-cert-key', help='Path to client certificate key')
+
+    for component in ALL_COMPONENTS:
         mod = importlib.import_module('uncloud.{}.main'.format(component))
         parser = getattr(mod, 'arg_parser')
-        subparsers.add_parser(name=parser.prog, parents=[parser, parent_parser])
 
-    args = arg_parser.parse_args()
-    if not args.command:
+        if component in ETCD_COMPONENTS:
+            subparsers.add_parser(name=parser.prog, parents=[parser, parent_parser, etcd_parser])
+        else:
+            subparsers.add_parser(name=parser.prog, parents=[parser, parent_parser])
+
+    arguments = vars(arg_parser.parse_args())
+    etcd_arguments = [key for key, value in arguments.items() if key.startswith('etcd_') and value]
+    etcd_arguments = {
+        'etcd': {
+            key.replace('etcd_', ''): arguments[key]
+            for key in etcd_arguments
+        }
+    }
+    if not arguments['command']:
         arg_parser.print_help()
     else:
+        # Initializing Settings and resolving otp_credentials
+        # It is neccessary to resolve_otp_credentials after argument parsing is done because
+        # previously we were reading config file which was fixed to ~/uncloud/uncloud.conf and
+        # providing the default values for --name, --realm and --seed arguments from the values
+        # we read from file. But, now we are asking user about where the config file lives. So,
+        # to providing default value is not possible before parsing arguments. So, we are doing
+        # it after..
+#        settings.settings = settings.Settings(arguments['conf_dir'], seed_value=etcd_arguments)
+#        resolve_otp_credentials(arguments)
+
+        name = arguments.pop('command')
+        mod = importlib.import_module('uncloud.{}.main'.format(name))
+        main = getattr(mod, 'main')
+
+        if arguments['debug']:
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig(level=logging.INFO)
+
+        log = logging.getLogger()
 
-        # if we start etcd in seperate process with default settings
-        # i.e inheriting few things from parent process etcd3 module
-        # errors out, so the following command configure multiprocessing
-        # module to not inherit anything from parent.
-        # mp.set_start_method('spawn')
-        arguments = vars(args)
         try:
-            name = arguments.pop('command')
-            mod = importlib.import_module('uncloud.{}.main'.format(name))
-            main = getattr(mod, 'main')
-            main(**arguments)
+            main(arguments)
         except UncloudException as err:
-            logger.error(err)
+            log.error(err)
+#        except ConnectionFailedError as err:
+#            log.error('Cannot connect to etcd: {}'.format(err))
         except Exception as err:
-            logger.exception(err)
+            log.exception(err)

uncloud/api/common_fields.py

@@ -1,7 +1,6 @@
 import os
 
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 
 
 class Optional:
@@ -54,9 +53,7 @@ class VmUUIDField(Field):
 
     def vm_uuid_validation(self):
         r = shared.etcd_client.get(
-            os.path.join(settings["etcd"]["vm_prefix"], self.uuid)
+            os.path.join(shared.settings["etcd"]["vm_prefix"], self.uuid)
         )
         if not r:
-            self.add_error(
-                "VM with uuid {} does not exists".format(self.uuid)
-            )
+            self.add_error("VM with uuid {} does not exists".format(self.uuid))

uncloud/api/create_image_store.py

@@ -4,7 +4,6 @@ import os
 from uuid import uuid4
 
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 
 data = {
     'is_public': True,
@@ -15,6 +14,6 @@ data = {
 }
 
 shared.etcd_client.put(
-    os.path.join(settings['etcd']['image_store_prefix'], uuid4().hex),
+    os.path.join(shared.settings['etcd']['image_store_prefix'], uuid4().hex),
     json.dumps(data),
 )

uncloud/api/helper.py

@@ -7,7 +7,6 @@ import requests
 from pyotp import TOTP
 
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 
 logger = logging.getLogger(__name__)
 
@@ -15,9 +14,9 @@ logger = logging.getLogger(__name__)
 def check_otp(name, realm, token):
     try:
         data = {
-            "auth_name": settings["otp"]["auth_name"],
-            "auth_token": TOTP(settings["otp"]["auth_seed"]).now(),
-            "auth_realm": settings["otp"]["auth_realm"],
+            "auth_name": shared.settings["otp"]["auth_name"],
+            "auth_token": TOTP(shared.settings["otp"]["auth_seed"]).now(),
+            "auth_realm": shared.settings["otp"]["auth_realm"],
             "name": name,
             "realm": realm,
             "token": token,
@@ -25,13 +24,13 @@ def check_otp(name, realm, token):
     except binascii.Error as err:
         logger.error(
             "Cannot compute OTP for seed: {}".format(
-                settings["otp"]["auth_seed"]
+                shared.settings["otp"]["auth_seed"]
             )
         )
         return 400
 
     response = requests.post(
-        settings["otp"]["verification_controller_url"], json=data
+        shared.settings["otp"]["verification_controller_url"], json=data
     )
     return response.status_code
 
@@ -87,7 +86,7 @@ def resolve_image_name(name, etcd_client):
         )
 
     images = etcd_client.get_prefix(
-        settings["etcd"]["image_prefix"], value_in_json=True
+        shared.settings["etcd"]["image_prefix"], value_in_json=True
     )
 
     # Try to find image with name == image_name and store_name == store_name
@@ -111,9 +110,7 @@ def random_bytes(num=6):
     return [random.randrange(256) for _ in range(num)]
 
 
-def generate_mac(
-    uaa=False, multicast=False, oui=None, separator=":", byte_fmt="%02x"
-):
+def generate_mac(uaa=False, multicast=False, oui=None, separator=":", byte_fmt="%02x"):
     mac = random_bytes()
     if oui:
         if type(oui) == str:
@@ -148,3 +145,4 @@ def mac2ipv6(mac, prefix):
     lower_part = ipaddress.IPv6Address(":".join(ipv6_parts))
     prefix = ipaddress.IPv6Address(prefix)
     return str(prefix + int(lower_part))
+

uncloud/api/main.py

@@ -15,9 +15,8 @@ from uncloud.common.shared import shared
 from uncloud.common import counters
 from uncloud.common.vm import VMStatus
 from uncloud.common.request import RequestEntry, RequestType
-from uncloud.common.settings import settings
-from . import schemas
-from .helper import generate_mac, mac2ipv6
+from uncloud.api import schemas
+from uncloud.api.helper import generate_mac, mac2ipv6
 from uncloud import UncloudException
 
 logger = logging.getLogger(__name__)
@@ -50,7 +49,7 @@ class CreateVM(Resource):
         validator = schemas.CreateVMSchema(data)
         if validator.is_valid():
             vm_uuid = uuid4().hex
-            vm_key = join_path(settings['etcd']['vm_prefix'], vm_uuid)
+            vm_key = join_path(shared.settings['etcd']['vm_prefix'], vm_uuid)
             specs = {
                 'cpu': validator.specs['cpu'],
                 'ram': validator.specs['ram'],
@@ -60,7 +59,7 @@ class CreateVM(Resource):
             macs = [generate_mac() for _ in range(len(data['network']))]
             tap_ids = [
                 counters.increment_etcd_counter(
-                    shared.etcd_client, settings['etcd']['tap_counter']
+                    shared.etcd_client, shared.settings['etcd']['tap_counter']
                 )
                 for _ in range(len(data['network']))
             ]
@@ -84,7 +83,7 @@ class CreateVM(Resource):
             r = RequestEntry.from_scratch(
                 type=RequestType.ScheduleVM,
                 uuid=vm_uuid,
-                request_prefix=settings['etcd']['request_prefix'],
+                request_prefix=shared.settings['etcd']['request_prefix'],
             )
             shared.request_pool.put(r)
 
@@ -99,7 +98,7 @@ class VmStatus(Resource):
         validator = schemas.VMStatusSchema(data)
         if validator.is_valid():
             vm = shared.vm_pool.get(
-                join_path(settings['etcd']['vm_prefix'], data['uuid'])
+                join_path(shared.settings['etcd']['vm_prefix'], data['uuid'])
             )
             vm_value = vm.value.copy()
             vm_value['ip'] = []
@@ -107,7 +106,7 @@ class VmStatus(Resource):
                 network_name, mac, tap = network_mac_and_tap
                 network = shared.etcd_client.get(
                     join_path(
-                        settings['etcd']['network_prefix'],
+                        shared.settings['etcd']['network_prefix'],
                         data['name'],
                         network_name,
                     ),
@@ -130,7 +129,7 @@ class CreateImage(Resource):
         validator = schemas.CreateImageSchema(data)
         if validator.is_valid():
             file_entry = shared.etcd_client.get(
-                join_path(settings['etcd']['file_prefix'], data['uuid'])
+                join_path(shared.settings['etcd']['file_prefix'], data['uuid'])
             )
             file_entry_value = json.loads(file_entry.value)
 
@@ -144,7 +143,7 @@ class CreateImage(Resource):
             }
             shared.etcd_client.put(
                 join_path(
-                    settings['etcd']['image_prefix'], data['uuid']
+                    shared.settings['etcd']['image_prefix'], data['uuid']
                 ),
                 json.dumps(image_entry_json),
             )
@@ -157,7 +156,7 @@ class ListPublicImages(Resource):
     @staticmethod
     def get():
         images = shared.etcd_client.get_prefix(
-            settings['etcd']['image_prefix'], value_in_json=True
+            shared.settings['etcd']['image_prefix'], value_in_json=True
         )
         r = {'images': []}
         for image in images:
@@ -178,7 +177,7 @@ class VMAction(Resource):
 
         if validator.is_valid():
             vm_entry = shared.vm_pool.get(
-                join_path(settings['etcd']['vm_prefix'], data['uuid'])
+                join_path(shared.settings['etcd']['vm_prefix'], data['uuid'])
             )
             action = data['action']
 
@@ -208,7 +207,7 @@ class VMAction(Resource):
                 type='{}VM'.format(action.title()),
                 uuid=data['uuid'],
                 hostname=vm_entry.hostname,
-                request_prefix=settings['etcd']['request_prefix'],
+                request_prefix=shared.settings['etcd']['request_prefix'],
             )
             shared.request_pool.put(r)
             return (
@@ -231,10 +230,10 @@ class VMMigration(Resource):
                 type=RequestType.InitVMMigration,
                 uuid=vm.uuid,
                 hostname=join_path(
-                    settings['etcd']['host_prefix'],
+                    shared.settings['etcd']['host_prefix'],
                     validator.destination.value,
                 ),
-                request_prefix=settings['etcd']['request_prefix'],
+                request_prefix=shared.settings['etcd']['request_prefix'],
             )
 
             shared.request_pool.put(r)
@@ -254,7 +253,7 @@ class ListUserVM(Resource):
 
         if validator.is_valid():
             vms = shared.etcd_client.get_prefix(
-                settings['etcd']['vm_prefix'], value_in_json=True
+                shared.settings['etcd']['vm_prefix'], value_in_json=True
             )
             return_vms = []
             user_vms = filter(
@@ -287,7 +286,7 @@ class ListUserFiles(Resource):
 
         if validator.is_valid():
             files = shared.etcd_client.get_prefix(
-                settings['etcd']['file_prefix'], value_in_json=True
+                shared.settings['etcd']['file_prefix'], value_in_json=True
             )
             return_files = []
             user_files = [f for f in files if f.value['owner'] == data['name']]
@@ -312,7 +311,7 @@ class CreateHost(Resource):
         validator = schemas.CreateHostSchema(data)
         if validator.is_valid():
             host_key = join_path(
-                settings['etcd']['host_prefix'], uuid4().hex
+                shared.settings['etcd']['host_prefix'], uuid4().hex
             )
             host_entry = {
                 'specs': data['specs'],
@@ -354,7 +353,7 @@ class GetSSHKeys(Resource):
 
                 # {user_prefix}/{realm}/{name}/key/
                 etcd_key = join_path(
-                    settings['etcd']['user_prefix'],
+                    shared.settings['etcd']['user_prefix'],
                     data['realm'],
                     data['name'],
                     'key',
@@ -372,7 +371,7 @@ class GetSSHKeys(Resource):
 
                 # {user_prefix}/{realm}/{name}/key/{key_name}
                 etcd_key = join_path(
-                    settings['etcd']['user_prefix'],
+                    shared.settings['etcd']['user_prefix'],
                     data['realm'],
                     data['name'],
                     'key',
@@ -405,7 +404,7 @@ class AddSSHKey(Resource):
 
             # {user_prefix}/{realm}/{name}/key/{key_name}
             etcd_key = join_path(
-                settings['etcd']['user_prefix'],
+                shared.settings['etcd']['user_prefix'],
                 data['realm'],
                 data['name'],
                 'key',
@@ -439,7 +438,7 @@ class RemoveSSHKey(Resource):
 
             # {user_prefix}/{realm}/{name}/key/{key_name}
             etcd_key = join_path(
-                settings['etcd']['user_prefix'],
+                shared.settings['etcd']['user_prefix'],
                 data['realm'],
                 data['name'],
                 'key',
@@ -471,23 +470,23 @@ class CreateNetwork(Resource):
 
             network_entry = {
                 'id': counters.increment_etcd_counter(
-                    shared.etcd_client, settings['etcd']['vxlan_counter']
+                    shared.etcd_client, shared.settings['etcd']['vxlan_counter']
                 ),
                 'type': data['type'],
             }
             if validator.user.value:
                 try:
                     nb = pynetbox.api(
-                        url=settings['netbox']['url'],
-                        token=settings['netbox']['token'],
+                        url=shared.settings['netbox']['url'],
+                        token=shared.settings['netbox']['token'],
                     )
                     nb_prefix = nb.ipam.prefixes.get(
-                        prefix=settings['network']['prefix']
+                        prefix=shared.settings['network']['prefix']
                     )
                     prefix = nb_prefix.available_prefixes.create(
                         data={
                             'prefix_length': int(
-                                settings['network']['prefix_length']
+                                shared.settings['network']['prefix_length']
                             ),
                             'description': '{}\'s network "{}"'.format(
                                 data['name'], data['network_name']
@@ -506,7 +505,7 @@ class CreateNetwork(Resource):
                 network_entry['ipv6'] = 'fd00::/64'
 
             network_key = join_path(
-                settings['etcd']['network_prefix'],
+                shared.settings['etcd']['network_prefix'],
                 data['name'],
                 data['network_name'],
             )
@@ -526,7 +525,7 @@ class ListUserNetwork(Resource):
 
         if validator.is_valid():
             prefix = join_path(
-                settings['etcd']['network_prefix'], data['name']
+                shared.settings['etcd']['network_prefix'], data['name']
             )
             networks = shared.etcd_client.get_prefix(
                 prefix, value_in_json=True
@@ -563,11 +562,14 @@ api.add_resource(ListHost, '/host/list')
 api.add_resource(CreateNetwork, '/network/create')
 
 
-def main(debug=False, port=None):
+def main(arguments):
+    debug = arguments['debug']
+    port = arguments['port']
+
     try:
         image_stores = list(
             shared.etcd_client.get_prefix(
-                settings['etcd']['image_store_prefix'], value_in_json=True
+                shared.settings['etcd']['image_store_prefix'], value_in_json=True
             )
         )
     except KeyError:
@@ -587,18 +589,12 @@ def main(debug=False, port=None):
 
     #     shared.etcd_client.put(
     #         join_path(
-    #             settings['etcd']['image_store_prefix'], uuid4().hex
+    #             shared.settings['etcd']['image_store_prefix'], uuid4().hex
     #         ),
     #         json.dumps(data),
     #     )
 
     try:
-        app.run(host='::',
-                port=port,
-                debug=debug)
+        app.run(host='::', port=port, debug=debug)
     except OSError as e:
         raise UncloudException('Failed to start Flask: {}'.format(e))
-
-
-if __name__ == '__main__':
-    main()

uncloud/api/schemas.py

@@ -22,7 +22,6 @@ import bitmath
 from uncloud.common.host import HostStatus
 from uncloud.common.vm import VMStatus
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 from . import helper, logger
 from .common_fields import Field, VmUUIDField
 from .helper import check_otp, resolve_vm_name
@@ -112,7 +111,7 @@ class CreateImageSchema(BaseSchema):
     def file_uuid_validation(self):
         file_entry = shared.etcd_client.get(
             os.path.join(
-                settings["etcd"]["file_prefix"], self.uuid.value
+                shared.shared.shared.shared.shared.settings["etcd"]["file_prefix"], self.uuid.value
             )
         )
         if file_entry is None:
@@ -125,7 +124,7 @@ class CreateImageSchema(BaseSchema):
     def image_store_name_validation(self):
         image_stores = list(
             shared.etcd_client.get_prefix(
-                settings["etcd"]["image_store_prefix"]
+                shared.shared.shared.shared.shared.settings["etcd"]["image_store_prefix"]
             )
         )
 
@@ -283,7 +282,7 @@ class CreateVMSchema(OTPSchema):
             for net in _network:
                 network = shared.etcd_client.get(
                     os.path.join(
-                        settings["etcd"]["network_prefix"],
+                        shared.shared.shared.shared.shared.settings["etcd"]["network_prefix"],
                         self.name.value,
                         net,
                     ),
@@ -488,7 +487,7 @@ class VmMigrationSchema(OTPSchema):
             self.add_error("Can't migrate non-running VM")
 
         if vm.hostname == os.path.join(
-            settings["etcd"]["host_prefix"], self.destination.value
+            shared.shared.shared.shared.shared.settings["etcd"]["host_prefix"], self.destination.value
         ):
             self.add_error(
                 "Destination host couldn't be same as Source Host"
@@ -539,9 +538,7 @@ class CreateNetwork(OTPSchema):
         super().__init__(data, fields=fields)
 
     def network_name_validation(self):
-        print(self.name.value, self.network_name.value)
-        key = os.path.join(settings["etcd"]["network_prefix"], self.name.value, self.network_name.value)
-        print(key)
+        key = os.path.join(shared.shared.shared.shared.shared.settings["etcd"]["network_prefix"], self.name.value, self.network_name.value)
         network = shared.etcd_client.get(key, value_in_json=True)
         if network:
             self.add_error(

uncloud/cli/helper.py

@@ -5,15 +5,15 @@ import binascii
 
 from pyotp import TOTP
 from os.path import join as join_path
-from uncloud.common.settings import settings
+from uncloud.common.shared import shared
 
 
 def get_otp_parser():
     otp_parser = argparse.ArgumentParser('otp')
-    otp_parser.add_argument('--name', default=settings['client']['name'])
-    otp_parser.add_argument('--realm', default=settings['client']['realm'])
-    otp_parser.add_argument('--seed', type=get_token, default=settings['client']['seed'],
-                            dest='token', metavar='SEED')
+    otp_parser.add_argument('--name')
+    otp_parser.add_argument('--realm')
+    otp_parser.add_argument('--seed', type=get_token, dest='token', metavar='SEED')
+
     return otp_parser
 
 
@@ -25,11 +25,15 @@ def load_dump_pretty(content):
 
 
 def make_request(*args, data=None, request_method=requests.post):
-    r = request_method(join_path(settings['client']['api_server'], *args), json=data)
     try:
-        print(load_dump_pretty(r.content))
-    except Exception:
-        print('Error occurred while getting output from api server.')
+        r = request_method(join_path(shared.settings['client']['api_server'], *args), json=data)
+    except requests.exceptions.RequestException:
+        print('Error occurred while connecting to API server.')
+    else:
+        try:
+            print(load_dump_pretty(r.content))
+        except Exception:
+            print('Error occurred while getting output from api server.')
 
 
 def get_token(seed):

uncloud/cli/main.py

@@ -12,12 +12,12 @@ for component in ['user', 'host', 'image', 'network', 'vm']:
     subparser.add_parser(name=parser.prog, parents=[parser])
 
 
-def main(**kwargs):
-    if not kwargs['subcommand']:
+def main(arguments):
+    if not arguments['subcommand']:
         arg_parser.print_help()
     else:
-        name = kwargs.pop('subcommand')
-        kwargs.pop('debug')
+        name = arguments.pop('subcommand')
+        arguments.pop('debug')
         mod = importlib.import_module('uncloud.cli.{}'.format(name))
         _main = getattr(mod, 'main')
-        _main(**kwargs)
+        _main(**arguments)

uncloud/common/cli.py

@@ -0,0 +1,26 @@
+from uncloud.common.shared import shared
+from pyotp import TOTP
+
+
+def get_token(seed):
+    if seed is not None:
+        try:
+            token = TOTP(seed).now()
+        except Exception:
+            raise Exception('Invalid seed')
+        else:
+            return token
+
+
+def resolve_otp_credentials(kwargs):
+    d = {
+        'name': shared.settings['client']['name'],
+        'realm': shared.settings['client']['realm'],
+        'token': get_token(shared.settings['client']['seed'])
+    }
+
+    for k, v in d.items():
+        if k in kwargs and kwargs[k] is None:
+            kwargs.update({k: v})
+
+    return d

uncloud/common/etcd_wrapper.py

@@ -61,33 +61,15 @@ class Etcd3Wrapper:
 
     @readable_errors
     def get_prefix(self, *args, value_in_json=False, raise_exception=True, **kwargs):
-        try:
-            event_iterator = self.client.get_prefix(*args, **kwargs)
-            for e in event_iterator:
-                yield EtcdEntry(*e[::-1], value_in_json=value_in_json)
-        except Exception as err:
-            if raise_exception:
-                raise Exception('Exception in etcd_wrapper.get_prefix') from err
-            else:
-                logger.exception('Error in etcd_wrapper')
-                return iter([])
+        event_iterator = self.client.get_prefix(*args, **kwargs)
+        for e in event_iterator:
+            yield EtcdEntry(*e[::-1], value_in_json=value_in_json)
 
     @readable_errors
     def watch_prefix(self, key, raise_exception=True, value_in_json=False):
-        try:
-            event_iterator, cancel = self.client.watch_prefix(key)
-            for e in event_iterator:
-                if hasattr(e, '_event'):
-                    e = e._event
-                    if e.type == e.PUT:
-                        yield EtcdEntry(e.kv.key, e.kv.value, value_in_json=value_in_json)
-        except Exception as err:
-            if raise_exception:
-                raise Exception('Exception in etcd_wrapper.get_prefix') from err
-            else:
-                logger.exception('Error in etcd_wrapper.watch_prefix')
-                try:
-                    cancel()
-                except Exception:
-                    pass
-                return iter([])
+        event_iterator, cancel = self.client.watch_prefix(key)
+        for e in event_iterator:
+            if hasattr(e, '_event'):
+                e = e._event
+                if e.type == e.PUT:
+                    yield EtcdEntry(e.kv.key, e.kv.value, value_in_json=value_in_json)

uncloud/common/settings.py

@@ -8,6 +8,7 @@ from uncloud.common.etcd_wrapper import Etcd3Wrapper
 from os.path import join as join_path
 
 logger = logging.getLogger(__name__)
+settings = None
 
 
 class CustomConfigParser(configparser.RawConfigParser):
@@ -25,9 +26,8 @@ class CustomConfigParser(configparser.RawConfigParser):
 
 
 class Settings(object):
-    def __init__(self):
+    def __init__(self, conf_dir, seed_value=None):
         conf_name = 'uncloud.conf'
-        conf_dir = os.environ.get('UCLOUD_CONF_DIR', os.path.expanduser('~/uncloud/'))
         self.config_file = join_path(conf_dir, conf_name)
 
         # this is used to cache config from etcd for 1 minutes. Without this we
@@ -38,15 +38,19 @@ class Settings(object):
         self.config_parser.add_section('etcd')
         self.config_parser.set('etcd', 'base_prefix', '/')
 
-        try:
+        if os.access(self.config_file, os.R_OK):
             self.config_parser.read(self.config_file)
-        except Exception as err:
-            logger.error('%s', err)
-
+        else:
+            raise FileNotFoundError('Config file %s not found!', self.config_file)
         self.config_key = join_path(self['etcd']['base_prefix'] + 'uncloud/config/')
 
         self.read_internal_values()
 
+        if seed_value is None:
+            seed_value = dict()
+
+        self.config_parser.read_dict(seed_value)
+
     def get_etcd_client(self):
         args = tuple()
         try:
@@ -99,12 +103,10 @@ class Settings(object):
     def read_config_file_values(self, config_file):
         try:
             # Trying to read configuration file
-            with open(config_file, 'r') as config_file_handle:
+            with open(config_file) as config_file_handle:
                 self.config_parser.read_file(config_file_handle)
         except FileNotFoundError:
-            sys.exit(
-                'Configuration file {} not found!'.format(config_file)
-            )
+            sys.exit('Configuration file {} not found!'.format(config_file))
         except Exception as err:
             logger.exception(err)
             sys.exit('Error occurred while reading configuration file')
@@ -130,4 +132,5 @@ class Settings(object):
         return self.config_parser[key]
 
 
-settings = Settings()
+def get_settings():
+    return settings

uncloud/common/shared.py

@@ -1,34 +1,34 @@
-from uncloud.common.settings import settings
+from uncloud.common.settings import get_settings
 from uncloud.common.vm import VmPool
 from uncloud.common.host import HostPool
 from uncloud.common.request import RequestPool
-from uncloud.common.storage_handlers import get_storage_handler
+import uncloud.common.storage_handlers as storage_handlers
 
 
 class Shared:
+    @property
+    def settings(self):
+        return get_settings()
+
     @property
     def etcd_client(self):
-        return settings.get_etcd_client()
+        return self.settings.get_etcd_client()
 
     @property
     def host_pool(self):
-        return HostPool(
-            self.etcd_client, settings["etcd"]["host_prefix"]
-        )
+        return HostPool(self.etcd_client, self.settings["etcd"]["host_prefix"])
 
     @property
     def vm_pool(self):
-        return VmPool(self.etcd_client, settings["etcd"]["vm_prefix"])
+        return VmPool(self.etcd_client, self.settings["etcd"]["vm_prefix"])
 
     @property
     def request_pool(self):
-        return RequestPool(
-            self.etcd_client, settings["etcd"]["request_prefix"]
-        )
+        return RequestPool(self.etcd_client, self.settings["etcd"]["request_prefix"])
 
     @property
     def storage_handler(self):
-        return get_storage_handler()
+        return storage_handlers.get_storage_handler()
 
 
 shared = Shared()

uncloud/common/storage_handlers.py

@@ -6,8 +6,7 @@ import stat
 from abc import ABC
 from . import logger
 from os.path import join as join_path
-
-from uncloud.common.settings import settings as config
+import uncloud.common.shared as shared
 
 
 class ImageStorageHandler(ABC):
@@ -193,16 +192,16 @@ class CEPHBasedImageStorageHandler(ImageStorageHandler):
 
 
 def get_storage_handler():
-    __storage_backend = config["storage"]["storage_backend"]
+    __storage_backend = shared.shared.settings["storage"]["storage_backend"]
     if __storage_backend == "filesystem":
         return FileSystemBasedImageStorageHandler(
-            vm_base=config["storage"]["vm_dir"],
-            image_base=config["storage"]["image_dir"],
+            vm_base=shared.shared.settings["storage"]["vm_dir"],
+            image_base=shared.shared.settings["storage"]["image_dir"],
         )
     elif __storage_backend == "ceph":
         return CEPHBasedImageStorageHandler(
-            vm_base=config["storage"]["ceph_vm_pool"],
-            image_base=config["storage"]["ceph_image_pool"],
+            vm_base=shared.shared.settings["storage"]["ceph_vm_pool"],
+            image_base=shared.shared.settings["storage"]["ceph_image_pool"],
         )
     else:
-        raise Exception("Unknown Image Storage Handler")
+        raise Exception("Unknown Image Storage Handler")

uncloud/configure/main.py

@@ -1,7 +1,6 @@
 import os
 import argparse
 
-from uncloud.common.settings import settings
 from uncloud.common.shared import shared
 
 arg_parser = argparse.ArgumentParser('configure', add_help=False)
@@ -40,19 +39,19 @@ ceph_storage_parser.add_argument('--ceph-image-pool', required=True)
 
 
 def update_config(section, kwargs):
-    uncloud_config = shared.etcd_client.get(settings.config_key, value_in_json=True)
+    uncloud_config = shared.etcd_client.get(shared.settings.config_key, value_in_json=True)
     if not uncloud_config:
         uncloud_config = {}
     else:
         uncloud_config = uncloud_config.value
 
     uncloud_config[section] = kwargs
-    shared.etcd_client.put(settings.config_key, uncloud_config, value_in_json=True)
+    shared.etcd_client.put(shared.settings.config_key, uncloud_config, value_in_json=True)
 
 
-def main(**kwargs):
-    subcommand = kwargs.pop('subcommand')
+def main(arguments):
+    subcommand = arguments['subcommand']
     if not subcommand:
         arg_parser.print_help()
     else:
-        update_config(subcommand, kwargs)
+        update_config(subcommand, arguments)

uncloud/docs/source/hacking.rst

@@ -1,17 +0,0 @@
-Hacking
-=======
-How to hack on the code.
-
-[ to be done by Balazs:
-
-* make nice
-* indent with shell script mode
-
-]
-
-* git clone the repo
-* cd to the repo
-* Setup your venv: python -m venv venv
-* . ./venv/bin/activate # you need the leading dot for sourcing!
-* Run ./bin/ucloud-run-reinstall - it should print you an error
-  message on how to use ucloud

uncloud/filescanner/main.py

@@ -9,7 +9,6 @@ import bitmath
 from uuid import uuid4
 
 from . import logger
-from uncloud.common.settings import settings
 from uncloud.common.shared import shared
 
 arg_parser = argparse.ArgumentParser('filescanner', add_help=False)
@@ -53,7 +52,7 @@ def track_file(file, base_dir, host):
         file_path = file_path.relative_to(owner)
         creation_date = time.ctime(os.stat(file_str).st_ctime)
 
-        entry_key = os.path.join(settings['etcd']['file_prefix'], str(uuid4()))
+        entry_key = os.path.join(shared.settings['etcd']['file_prefix'], str(uuid4()))
         entry_value = {
             'filename': str(file_path),
             'owner': owner,
@@ -68,8 +67,9 @@ def track_file(file, base_dir, host):
         shared.etcd_client.put(entry_key, entry_value, value_in_json=True)
 
 
-def main(hostname, debug=False):
-    base_dir = settings['storage']['file_dir']
+def main(arguments):
+    hostname = arguments['hostname']
+    base_dir = shared.settings['storage']['file_dir']
     # Recursively Get All Files and Folder below BASE_DIR
     files = glob.glob('{}/**'.format(base_dir), recursive=True)
     files = [pathlib.Path(f) for f in files if pathlib.Path(f).is_file()]
@@ -77,7 +77,7 @@ def main(hostname, debug=False):
     # Files that are already tracked
     tracked_files = [
         pathlib.Path(os.path.join(base_dir, f.value['owner'], f.value['filename']))
-        for f in shared.etcd_client.get_prefix(settings['etcd']['file_prefix'], value_in_json=True)
+        for f in shared.etcd_client.get_prefix(shared.settings['etcd']['file_prefix'], value_in_json=True)
         if f.value['host'] == hostname
     ]
     untracked_files = set(files) - set(tracked_files)

uncloud/hack/config.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# 2020 Nico Schottelius (nico.schottelius at ungleich.ch)
+#
+# This file is part of uncloud.
+#
+# uncloud is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# uncloud is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with uncloud. If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+class Config(object):
+    def __init__(self, arguments):
+        """ read arguments dicts as a base """
+
+        self.arguments = arguments
+
+        # Split them so *etcd_args can be used and we can
+        # iterate over etcd_hosts
+        self.etcd_hosts = [ arguments['etcd_host'] ]
+        self.etcd_args = {
+            'ca_cert': arguments['etcd_ca_cert'],
+            'cert_cert': arguments['etcd_cert_cert'],
+            'cert_key': arguments['etcd_cert_key'],
+#            'user': None,
+#            'password': None
+        }
+        self.etcd_prefix = '/nicohack/'

uncloud/hack/db.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# 2020 Nico Schottelius (nico.schottelius at ungleich.ch)
+#
+# This file is part of uncloud.
+#
+# uncloud is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# uncloud is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with uncloud. If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+import etcd3
+import json
+import logging
+
+from functools import wraps
+from uncloud import UncloudException
+
+log = logging.getLogger(__name__)
+
+
+def readable_errors(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except etcd3.exceptions.ConnectionFailedError as e:
+            raise UncloudException('Cannot connect to etcd: is etcd running and reachable? {}'.format(e))
+        except etcd3.exceptions.ConnectionTimeoutError as e:
+            raise UncloudException('etcd connection timeout. {}'.format(e))
+
+    return wrapper
+
+
+class DB(object):
+    def __init__(self, config, prefix="/"):
+        self.config = config
+
+        # Root for everything
+        self.base_prefix= '/nicohack'
+
+        # Can be set from outside
+        self.prefix = prefix
+
+        self.connect()
+
+    @readable_errors
+    def connect(self):
+        self._db_clients = []
+        for endpoint in self.config.etcd_hosts:
+            client = etcd3.client(host=endpoint, **self.config.etcd_args)
+            self._db_clients.append(client)
+
+    def realkey(self, key):
+        return "{}{}/{}".format(self.base_prefix,
+                                self.prefix,
+                                key)
+
+    @readable_errors
+    def get(self, key, as_json=False, **kwargs):
+        value, _ = self._db_clients[0].get(self.realkey(key), **kwargs)
+
+        if as_json:
+            value = json.loads(value)
+
+        return value
+
+
+    @readable_errors
+    def set(self, key, value, as_json=False, **kwargs):
+        if as_json:
+            value = json.dumps(value)
+
+        # FIXME: iterate over clients in case of failure ?
+        return self._db_clients[0].put(self.realkey(key), value, **kwargs)
+
+    @readable_errors
+    def increment(self, key, **kwargs):
+        print(self.realkey(key))
+
+
+        print("prelock")
+        lock = self._db_clients[0].lock('/nicohack/foo')
+        print("prelockacq")
+        lock.acquire()
+        print("prelockrelease")
+        lock.release()
+
+        with self._db_clients[0].lock("/nicohack/mac/last_used_index") as lock:
+            print("in lock")
+            pass
+
+#        with self._db_clients[0].lock(self.realkey(key)) as lock:#            value = int(self.get(self.realkey(key), **kwargs))
+#            self.set(self.realkey(key), str(value + 1), **kwargs)
+
+
+if __name__ == '__main__':
+    endpoints = [ "https://etcd1.ungleich.ch:2379",
+                  "https://etcd2.ungleich.ch:2379",
+                  "https://etcd3.ungleich.ch:2379" ]
+
+    db = DB(url=endpoints)

uncloud/hack/hackcloud/.gitignore

@@ -0,0 +1,3 @@
+*.iso
+radvdpid
+foo

uncloud/hack/hackcloud/__init__.py

@@ -0,0 +1 @@
+

uncloud/hack/hackcloud/etcd-client.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+etcdctl  --cert=$HOME/vcs/ungleich-dot-cdist/files/etcd/nico.pem \
+         --key=/home/nico/vcs/ungleich-dot-cdist/files/etcd/nico-key.pem \
+         --cacert=$HOME/vcs/ungleich-dot-cdist/files/etcd/ca.pem \
+         --endpoints https://etcd1.ungleich.ch:2379,https://etcd2.ungleich.ch:2379,https://etcd3.ungleich.ch:2379 "$@"

uncloud/hack/hackcloud/ifdown.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo $@

uncloud/hack/hackcloud/ifup.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+dev=$1; shift
+
+# bridge is setup from outside
+ip link set dev "$dev" master ${bridge}
+ip link set dev "$dev" up

uncloud/hack/hackcloud/mac-last

@@ -0,0 +1 @@
+000000000252

uncloud/hack/hackcloud/mac-prefix

@@ -0,0 +1 @@
+02:00

uncloud/hack/hackcloud/net.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+set -x
+
+netid=100
+dev=wlp2s0
+dev=wlp0s20f3
+#dev=wlan0
+
+ip=2a0a:e5c1:111:888::48/64
+vxlandev=vxlan${netid}
+bridgedev=br${netid}
+
+ip -6 link add ${vxlandev} type vxlan \
+    id ${netid} \
+    dstport 4789 \
+    group ff05::${netid} \
+    dev ${dev} \
+    ttl 5
+
+ip link set ${vxlandev} up
+
+
+ip link add ${bridgedev} type bridge
+ip link set ${bridgedev} up
+
+ip link set ${vxlandev} master ${bridgedev} up
+
+ip addr add ${ip} dev ${bridgedev}

uncloud/hack/hackcloud/nftrules

@@ -0,0 +1,31 @@
+flush ruleset
+
+table bridge filter {
+    chain prerouting {
+        type filter hook prerouting priority 0;
+        policy accept;
+
+        ibrname br100 jump br100
+    }
+
+    chain br100 {
+        # Allow all incoming traffic from outside
+        iifname vxlan100 accept
+
+        # Default blocks: router advertisements, dhcpv6, dhcpv4
+        icmpv6 type nd-router-advert drop
+        ip6 version 6 udp sport 547 drop
+        ip  version 4 udp sport 67 drop
+
+        jump br100_vmlist
+        drop
+    }
+    chain br100_vmlist {
+        # VM1
+        iifname tap1 ether saddr 02:00:f0:a9:c4:4e ip6 saddr 2a0a:e5c1:111:888:0:f0ff:fea9:c44e accept
+
+        # VM2
+        iifname v343a-0 ether saddr 02:00:f0:a9:c4:4f ip6 saddr 2a0a:e5c1:111:888:0:f0ff:fea9:c44f accept
+        iifname v343a-0 ether saddr 02:00:f0:a9:c4:4f ip6 saddr 2a0a:e5c1:111:1234::/64 accept
+    }
+}

uncloud/hack/hackcloud/radvd.conf

@@ -0,0 +1,13 @@
+interface br100
+{
+  AdvSendAdvert on;
+  MinRtrAdvInterval 3;
+  MaxRtrAdvInterval 5;
+  AdvDefaultLifetime 3600;
+
+  prefix 2a0a:e5c1:111:888::/64 {
+  };
+
+  RDNSS 2a0a:e5c0::3 2a0a:e5c0::4 { AdvRDNSSLifetime 6000; };
+  DNSSL place7.ungleich.ch {  AdvDNSSLLifetime 6000; } ;
+};

uncloud/hack/hackcloud/radvd.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+radvd -C ./radvd.conf  -n -p ./radvdpid

uncloud/hack/hackcloud/vm.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+# if [ $# -ne 1 ]; then
+#     echo "$0: owner"
+#     exit 1
+# fi
+
+qemu=/usr/bin/qemu-system-x86_64
+
+accel=kvm
+#accel=tcg
+
+memory=1024
+cores=2
+uuid=$(uuidgen)
+mac=$(./mac-gen.py)
+owner=nico
+
+export bridge=br100
+
+set -x
+$qemu -name "uncloud-${uuid}" \
+      -machine pc,accel=${accel} \
+      -m ${memory} \
+      -smp ${cores} \
+      -uuid ${uuid} \
+      -drive file=alpine-virt-3.11.2-x86_64.iso,media=cdrom \
+      -netdev tap,id=netmain,script=./ifup.sh,downscript=./ifdown.sh \
+      -device virtio-net-pci,netdev=netmain,id=net0,mac=${mac}

uncloud/hack/mac.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# 2012 Nico Schottelius (nico-cinv at schottelius.org)
+#
+# This file is part of cinv.
+#
+# cinv is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# cinv is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with cinv. If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+import argparse
+import logging
+import os.path
+import os
+import re
+import json
+
+from uncloud import UncloudException
+from uncloud.hack.db import DB
+
+log = logging.getLogger(__name__)
+
+
+class MAC(object):
+    def __init__(self, config):
+        self.config = config
+        self.no_db = self.config.arguments['no_db']
+        if not self.no_db:
+            self.db = DB(config, prefix="/mac")
+
+        self.prefix = 0x420000000000
+        self._number = 0 # Not set by default
+
+    @staticmethod
+    def validate_mac(mac):
+        if not re.match(r'([0-9A-F]{2}[-:]){5}[0-9A-F]{2}$', mac, re.I):
+            raise Error("Not a valid mac address: %s" % mac)
+
+    def last_used_index(self):
+        if not self.no_db:
+            value = self.db.get("last_used_index")
+            if not value:
+                self.db.set("last_used_index", "0")
+                value = self.db.get("last_used_index")
+
+        else:
+            value = "0"
+
+        return int(value)
+
+    def last_used_mac(self):
+        return self.int_to_mac(self.prefix + self.last_used_index())
+
+    def to_colon_format(self):
+        b = self._number.to_bytes(6, byteorder="big")
+        return ':'.join(format(s, '02x') for s in b)
+
+    def to_str_format(self):
+        b = self._number.to_bytes(6, byteorder="big")
+        return ''.join(format(s, '02x') for s in b)
+
+    def create(self):
+        last_number = self.last_used_index()
+
+        if last_number == int('0xffffffff', 16):
+            raise UncloudException("Exhausted all possible mac addresses - try to free some")
+
+        next_number = last_number + 1
+        self._number = self.prefix + next_number
+
+        #next_number_string = "{:012x}".format(next_number)
+        #next_mac = self.int_to_mac(next_mac_number)
+        # db_entry = {}
+        # db_entry['vm_uuid'] = vmuuid
+        # db_entry['index'] = next_number
+        # db_entry['mac_address'] = next_mac
+
+        # should be one transaction
+        # self.db.increment("last_used_index")
+        # self.db.set("used/{}".format(next_mac),
+        #             db_entry, as_json=True)
+
+    def __int__(self):
+        return self._number
+
+    def __repr__(self):
+        return self.to_str_format()
+
+    def __str__(self):
+        return self.to_colon_format()

uncloud/hack/main.py

@@ -0,0 +1,92 @@
+import argparse
+import logging
+
+from uncloud.hack.vm import VM
+from uncloud.hack.config import Config
+from uncloud.hack.mac import MAC
+from uncloud.hack.net import VXLANBridge, DNSRA
+
+from uncloud import UncloudException
+
+arg_parser = argparse.ArgumentParser('hack', add_help=False)
+                                     #description="Commands that are unfinished - use at own risk")
+arg_parser.add_argument('--last-used-mac', action='store_true')
+arg_parser.add_argument('--get-new-mac', action='store_true')
+
+arg_parser.add_argument('--init-network', help="Initialise networking", action='store_true')
+arg_parser.add_argument('--create-vxlan', help="Initialise networking", action='store_true')
+arg_parser.add_argument('--network', help="/64 IPv6 network")
+arg_parser.add_argument('--vxlan-uplink-device', help="The VXLAN underlay device, i.e. eth0")
+arg_parser.add_argument('--vni', help="VXLAN ID (decimal)", type=int)
+arg_parser.add_argument('--run-dns-ra', action='store_true',
+                        help="Provide router advertisements and DNS resolution via dnsmasq")
+arg_parser.add_argument('--use-sudo', help="Use sudo for command requiring root!", action='store_true')
+
+arg_parser.add_argument('--create-vm', action='store_true')
+arg_parser.add_argument('--destroy-vm', action='store_true')
+arg_parser.add_argument('--get-vm-status', action='store_true')
+arg_parser.add_argument('--get-vm-vnc', action='store_true')
+arg_parser.add_argument('--list-vms', action='store_true')
+arg_parser.add_argument('--memory', help="Size of memory (GB)", type=int)
+arg_parser.add_argument('--cores', help="Amount of CPU cores", type=int)
+arg_parser.add_argument('--image', help="Path (under hackprefix) to OS image")
+arg_parser.add_argument('--uuid', help="VM UUID")
+
+arg_parser.add_argument('--no-db', help="Disable connection to etcd. For local testing only!", action='store_true')
+arg_parser.add_argument('--hackprefix', help="hackprefix, if you need it you know it (it's where the iso is located and ifup/down.sh")
+
+
+log = logging.getLogger(__name__)
+
+
+def main(arguments):
+    config = Config(arguments)
+
+    if arguments['create_vm']:
+        vm = VM(config)
+        vm.create()
+
+    if arguments['destroy_vm']:
+        vm = VM(config)
+        vm.stop()
+
+    if arguments['get_vm_status']:
+        vm = VM(config)
+        vm.status()
+
+    if arguments['get_vm_vnc']:
+        vm = VM(config)
+        vm.vnc_addr()
+
+    if arguments['list_vms']:
+        vm = VM(config)
+        vm.list()
+
+    if arguments['last_used_mac']:
+        m = MAC(config)
+        print(m.last_used_mac())
+
+    if arguments['get_new_mac']:
+        print(MAC(config).get_next())
+
+    #if arguments['init_network']:
+    if arguments['create_vxlan']:
+        if not arguments['network'] or not arguments['vni'] or not arguments['vxlan_uplink_device']:
+            raise UncloudException("Initialising the network requires an IPv6 network and a VNI. You can use fd00::/64 and vni=1 for testing (non production!)")
+        vb = VXLANBridge(vni=arguments['vni'],
+                         route=arguments['network'],
+                         uplinkdev=arguments['vxlan_uplink_device'],
+                         use_sudo=arguments['use_sudo'])
+        vb._setup_vxlan()
+        vb._setup_bridge()
+        vb._add_vxlan_to_bridge()
+        vb._route_network()
+
+    if arguments['run_dns_ra']:
+        if not arguments['network'] or not arguments['vni']:
+            raise UncloudException("Providing DNS/RAs requires a /64 IPv6 network and a VNI. You can use fd00::/64 and vni=1 for testing (non production!)")
+
+        dnsra = DNSRA(route=arguments['network'],
+                      vni=arguments['vni'],
+                      use_sudo=arguments['use_sudo'])
+        dnsra._setup_dnsmasq()

uncloud/hack/net.py

@@ -0,0 +1,116 @@
+import subprocess
+import ipaddress
+import logging
+
+
+from uncloud import UncloudException
+
+log = logging.getLogger(__name__)
+
+
+class VXLANBridge(object):
+    cmd_create_vxlan = "{sudo}ip -6 link add {vxlandev} type vxlan id {vni_dec} dstport 4789 group {multicast_address} dev {uplinkdev} ttl 5"
+    cmd_up_dev = "{sudo}ip link set {dev} up"
+    cmd_create_bridge="{sudo}ip link add {bridgedev} type bridge"
+    cmd_add_to_bridge="{sudo}ip link set {vxlandev} master {bridgedev} up"
+    cmd_add_addr="{sudo}ip addr add {ip} dev {bridgedev}"
+    cmd_add_route_dev="{sudo}ip route add {route} dev {bridgedev}"
+
+    # VXLAN ids are at maximum 24 bit - use a /104
+    multicast_network = ipaddress.IPv6Network("ff05::/104")
+    max_vni = (2**24)-1
+
+    def __init__(self,
+                 vni,
+                 uplinkdev,
+                 route=None,
+                 use_sudo=False):
+        self.config = {}
+
+        if vni > self.max_vni:
+            raise UncloudException("VNI must be in the range of 0 .. {}".format(self.max_vni))
+
+        if use_sudo:
+            self.config['sudo'] = 'sudo '
+        else:
+            self.config['sudo'] = ''
+
+        self.config['vni_dec'] = vni
+        self.config['vni_hex'] = "{:x}".format(vni)
+        self.config['multicast_address'] = self.multicast_network[vni]
+
+        self.config['route_network'] = ipaddress.IPv6Network(route)
+        self.config['route'] = route
+
+        self.config['uplinkdev'] = uplinkdev
+        self.config['vxlandev'] = "vx{}".format(self.config['vni_hex'])
+        self.config['bridgedev'] = "br{}".format(self.config['vni_hex'])
+
+
+    def setup_networking(self):
+        pass
+
+    def _setup_vxlan(self):
+        self._execute_cmd(self.cmd_create_vxlan)
+        self._execute_cmd(self.cmd_up_dev, dev=self.config['vxlandev'])
+
+    def _setup_bridge(self):
+        self._execute_cmd(self.cmd_create_bridge)
+        self._execute_cmd(self.cmd_up_dev, dev=self.config['bridgedev'])
+
+    def _route_network(self):
+        self._execute_cmd(self.cmd_add_route_dev)
+
+    def _add_vxlan_to_bridge(self):
+        self._execute_cmd(self.cmd_add_to_bridge)
+
+    def _execute_cmd(self, cmd_string, **kwargs):
+        cmd = cmd_string.format(**self.config, **kwargs)
+        log.info("Executing: {}".format(cmd))
+        subprocess.run(cmd.split())
+
+class ManagementBridge(VXLANBridge):
+    pass
+
+
+class DNSRA(object):
+    # VXLAN ids are at maximum 24 bit
+    max_vni = (2**24)-1
+
+
+    # Command to start dnsmasq
+    cmd_start_dnsmasq="{sudo}dnsmasq --interface={bridgedev} --bind-interfaces --dhcp-range={route},ra-only,infinite --enable-ra"
+
+    def __init__(self,
+                 vni,
+                 route=None,
+                 use_sudo=False):
+        self.config = {}
+
+        if vni > self.max_vni:
+            raise UncloudException("VNI must be in the range of 0 .. {}".format(self.max_vni))
+
+        if use_sudo:
+            self.config['sudo'] = 'sudo '
+        else:
+            self.config['sudo'] = ''
+
+        #TODO: remove if not needed
+        #self.config['vni_dec'] = vni
+        self.config['vni_hex'] = "{:x}".format(vni)
+
+        # dnsmasq only wants the network without the prefix, therefore, cut it off
+        self.config['route'] = ipaddress.IPv6Network(route).network_address
+        self.config['bridgedev'] = "br{}".format(self.config['vni_hex'])
+
+    def _setup_dnsmasq(self):
+         self._execute_cmd(self.cmd_start_dnsmasq)
+
+    def _execute_cmd(self, cmd_string, **kwargs):
+        cmd = cmd_string.format(**self.config, **kwargs)
+        log.info("Executing: {}".format(cmd))
+        print("Executing: {}".format(cmd))
+        subprocess.run(cmd.split())
+
+class Firewall(object):
+    pass

uncloud/hack/uncloud-hack-init-host

@@ -0,0 +1,26 @@
+id=100
+rawdev=eth0
+
+# create vxlan
+ip -6 link add vxlan${id} type vxlan \
+    id ${id} \
+    dstport 4789 \
+    group ff05::${id} \
+    dev ${rawdev} \
+    ttl 5
+
+ip link set vxlan${id} up
+
+# create bridge
+ip link set vxlan${id} up
+ip link set br${id} up
+
+# Add vxlan into bridge
+ip link set vxlan${id} master br${id}
+
+
+#  useradd -m uncloud
+# [18:05] tablett.place10:~# id uncloud
+# uid=1000(uncloud) gid=1000(uncloud) groups=1000(uncloud),34(kvm),36(qemu)
+# apk add qemu-system-x86_64
+# also needs group netdev

uncloud/hack/uncloud-run-vm

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+if [ $# -ne 1 ]; then
+    echo $0 vmid
+    exit 1
+fi
+
+id=$1; shift
+
+memory=512
+macaddress=02:00:b9:cb:70:${id}
+netname=net${id}-1
+
+qemu-system-x86_64 \
+    -name uncloud-${id} \
+    -accel kvm \
+    -m ${memory} \
+    -smp 2,sockets=2,cores=1,threads=1 \
+    -device virtio-net-pci,netdev=net0,mac=$macaddress \
+    -netdev tap,id=net0,ifname=${netname},script=no,downscript=no \
+    -vnc [::]:0
+
+# To be changed:
+# -vnc to unix path
+# or -spice

uncloud/hack/vm.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# 2020 Nico Schottelius (nico.schottelius at ungleich.ch)
+#
+# This file is part of uncloud.
+#
+# uncloud is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# uncloud is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with uncloud. If not, see <http://www.gnu.org/licenses/>.
+
+# This module is directly called from the hack module, and can be used as follow:
+#
+#   Create a new VM with default CPU/Memory. The path of the image file is relative to $hackprefix.
+#   `uncloud hack --hackprefix /tmp/hackcloud --create-vm --image mysuperimage.qcow2`
+#
+#   List running VMs (returns a list of UUIDs).
+#   `uncloud hack --hackprefix /tmp/hackcloud --list-vms
+#
+#   Get VM status:
+#   `uncloud hack --hackprefix /tmp/hackcloud --get-vm-status --uuid my-vm-uuid`
+#
+#   Stop a VM:
+#   `uncloud hack --hackprefix /tmp/hackcloud --destroy-vm --uuid my-vm-uuid`
+#    ``
+
+import subprocess
+import uuid
+import os
+import logging
+
+from uncloud.hack.db import DB
+from uncloud.hack.mac import MAC
+from uncloud.vmm import VMM
+
+log = logging.getLogger(__name__)
+log.setLevel(logging.DEBUG)
+
+class VM(object):
+    def __init__(self, config):
+        self.config = config
+
+        #TODO: Enable etcd lookup
+        self.no_db = self.config.arguments['no_db']
+        if not self.no_db:
+             self.db = DB(self.config, prefix="/vm")
+
+        # General CLI arguments.
+        self.hackprefix = self.config.arguments['hackprefix']
+        self.uuid = self.config.arguments['uuid']
+        self.memory = self.config.arguments['memory'] or '1024M'
+        self.cores = self.config.arguments['cores'] or 1
+        if self.config.arguments['image']:
+            self.image = os.path.join(self.hackprefix, self.config.arguments['image'])
+        else:
+            self.image = None
+
+        # External components.
+        self.vmm = VMM(vmm_backend=self.hackprefix)
+        self.mac = MAC(self.config)
+
+        # Harcoded & generated values.
+        self.owner = 'uncoud'
+        self.image_format='qcow2'
+        self.accel = 'kvm'
+        self.threads = 1
+        self.ifup = os.path.join(self.hackprefix, "ifup.sh")
+        self.ifdown = os.path.join(self.hackprefix, "ifdown.sh")
+        self.ifname = "uc{}".format(self.mac.to_str_format())
+
+    def get_qemu_args(self):
+        command = (
+            "-name {owner}-{name}"
+            " -machine pc,accel={accel}"
+            " -drive file={image},format={image_format},if=virtio"
+            " -device virtio-rng-pci"
+            " -m {memory} -smp cores={cores},threads={threads}"
+            " -netdev tap,id=netmain,script={ifup},downscript={ifdown},ifname={ifname}"
+            " -device virtio-net-pci,netdev=netmain,id=net0,mac={mac}"
+        ).format(
+            owner=self.owner, name=self.uuid,
+            accel=self.accel,
+            image=self.image, image_format=self.image_format,
+            memory=self.memory, cores=self.cores, threads=self.threads,
+            ifup=self.ifup, ifdown=self.ifdown, ifname=self.ifname,
+            mac=self.mac
+        )
+
+        return command.split(" ")
+
+    def create(self):
+        # New VM: new UUID, new MAC.
+        self.uuid = str(uuid.uuid4())
+        self.mac.create()
+
+        qemu_args = self.get_qemu_args()
+        log.debug("QEMU args passed to VMM: {}".format(qemu_args))
+        self.vmm.start(
+                uuid=self.uuid,
+                migration=False,
+                *qemu_args
+                )
+
+    def stop(self):
+        if not self.uuid:
+            print("Please specific an UUID with the --uuid flag.")
+            exit(1)
+
+        self.vmm.stop(self.uuid)
+
+    def status(self):
+        if not self.uuid:
+            print("Please specific an UUID with the --uuid flag.")
+            exit(1)
+
+        print(self.vmm.get_status(self.uuid))
+
+    def vnc_addr(self):
+        if not self.uuid:
+            print("Please specific an UUID with the --uuid flag.")
+            exit(1)
+
+        print(self.vmm.get_vnc(self.uuid))
+
+    def list(self):
+        print(self.vmm.discover())
+

uncloud/host/main.py

@@ -6,7 +6,6 @@ from uuid import uuid4
 
 from uncloud.common.request import RequestEntry, RequestType
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 from uncloud.common.vm import VMStatus
 from uncloud.vmm import VMM
 from os.path import join as join_path
@@ -36,7 +35,7 @@ def maintenance(host):
         if vmm.is_running(vm_uuid) and vmm.get_status(vm_uuid) == 'running':
             logger.debug('VM {} is running on {}'.format(vm_uuid, host))
             vm = shared.vm_pool.get(
-                join_path(settings['etcd']['vm_prefix'], vm_uuid)
+                join_path(shared.settings['etcd']['vm_prefix'], vm_uuid)
             )
             vm.status = VMStatus.running
             vm.vnc_socket = vmm.get_vnc(vm_uuid)
@@ -44,14 +43,15 @@ def maintenance(host):
             shared.vm_pool.put(vm)
 
 
-def main(hostname, debug=False):
+def main(arguments):
+    hostname = arguments['hostname']
     host_pool = shared.host_pool
     host = next(filter(lambda h: h.hostname == hostname, host_pool.hosts), None)
 
     # Does not yet exist, create it
     if not host:
         host_key = join_path(
-            settings['etcd']['host_prefix'], uuid4().hex
+            shared.settings['etcd']['host_prefix'], uuid4().hex
         )
         host_entry = {
             'specs': '',
@@ -79,9 +79,9 @@ def main(hostname, debug=False):
     # get prefix until either success or deamon death comes.
     while True:
         for events_iterator in [
-            shared.etcd_client.get_prefix(settings['etcd']['request_prefix'], value_in_json=True,
+            shared.etcd_client.get_prefix(shared.settings['etcd']['request_prefix'], value_in_json=True,
                                           raise_exception=False),
-            shared.etcd_client.watch_prefix(settings['etcd']['request_prefix'], value_in_json=True,
+            shared.etcd_client.watch_prefix(shared.settings['etcd']['request_prefix'], value_in_json=True,
                                             raise_exception=False)
         ]:
             for request_event in events_iterator:
@@ -94,7 +94,7 @@ def main(hostname, debug=False):
 
                     shared.request_pool.client.client.delete(request_event.key)
                     vm_entry = shared.etcd_client.get(
-                        join_path(settings['etcd']['vm_prefix'], request_event.uuid)
+                        join_path(shared.settings['etcd']['vm_prefix'], request_event.uuid)
                     )
 
                     logger.debug('VM hostname: {}'.format(vm_entry.value))

uncloud/host/virtualmachine.py

@@ -17,7 +17,6 @@ from uncloud.common.network import create_dev, delete_network_interface
 from uncloud.common.schemas import VMSchema, NetworkSchema
 from uncloud.host import logger
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 from uncloud.vmm import VMM
 
 from marshmallow import ValidationError
@@ -91,7 +90,7 @@ class VM:
                         self.vmm.socket_dir, self.uuid
                     ),
                     destination_host_key=destination_host_key,  # Where source host transfer VM
-                    request_prefix=settings["etcd"]["request_prefix"],
+                    request_prefix=shared.settings["etcd"]["request_prefix"],
                 )
                 shared.request_pool.put(r)
             else:
@@ -119,7 +118,7 @@ class VM:
             network_name, mac, tap = network_mac_and_tap
 
             _key = os.path.join(
-                settings["etcd"]["network_prefix"],
+                shared.settings["etcd"]["network_prefix"],
                 self.vm["owner"],
                 network_name,
             )
@@ -133,13 +132,13 @@ class VM:
             if network["type"] == "vxlan":
                 tap = create_vxlan_br_tap(
                     _id=network["id"],
-                    _dev=settings["network"]["vxlan_phy_dev"],
+                    _dev=shared.settings["network"]["vxlan_phy_dev"],
                     tap_id=tap,
                     ip=network["ipv6"],
                 )
 
                 all_networks = shared.etcd_client.get_prefix(
-                    settings["etcd"]["network_prefix"],
+                    shared.settings["etcd"]["network_prefix"],
                     value_in_json=True,
                 )
 
@@ -229,7 +228,7 @@ class VM:
 def resolve_network(network_name, network_owner):
     network = shared.etcd_client.get(
         join_path(
-            settings["etcd"]["network_prefix"],
+            shared.settings["etcd"]["network_prefix"],
             network_owner,
             network_name,
         ),

uncloud/imagescanner/main.py

@@ -4,7 +4,6 @@ import argparse
 import subprocess as sp
 
 from os.path import join as join_path
-from uncloud.common.settings import settings
 from uncloud.common.shared import shared
 from uncloud.imagescanner import logger
 
@@ -30,10 +29,10 @@ def qemu_img_type(path):
         return qemu_img_info["format"]
 
 
-def main(debug=False):
+def main(arguments):
     # We want to get images entries that requests images to be created
     images = shared.etcd_client.get_prefix(
-        settings["etcd"]["image_prefix"], value_in_json=True
+        shared.settings["etcd"]["image_prefix"], value_in_json=True
     )
     images_to_be_created = list(
         filter(lambda im: im.value["status"] == "TO_BE_CREATED", images)
@@ -46,13 +45,13 @@ def main(debug=False):
             image_filename = image.value["filename"]
             image_store_name = image.value["store_name"]
             image_full_path = join_path(
-                settings["storage"]["file_dir"],
+                shared.settings["storage"]["file_dir"],
                 image_owner,
                 image_filename,
             )
 
             image_stores = shared.etcd_client.get_prefix(
-                settings["etcd"]["image_store_prefix"],
+                shared.settings["etcd"]["image_store_prefix"],
                 value_in_json=True,
             )
             user_image_store = next(

uncloud/metadata/main.py

@@ -5,7 +5,6 @@ from flask import Flask, request
 from flask_restful import Resource, Api
 from werkzeug.exceptions import HTTPException
 
-from uncloud.common.settings import settings
 from uncloud.common.shared import shared
 
 app = Flask(__name__)
@@ -13,8 +12,10 @@ api = Api(app)
 
 app.logger.handlers.clear()
 
+DEFAULT_PORT=1234
+
 arg_parser = argparse.ArgumentParser('metadata', add_help=False)
-arg_parser.add_argument('--port', '-p', default=80, help='By default bind to port 80')
+arg_parser.add_argument('--port', '-p', default=DEFAULT_PORT, help='By default bind to port {}'.format(DEFAULT_PORT))
 
 
 @app.errorhandler(Exception)
@@ -72,7 +73,7 @@ class Root(Resource):
             )
         else:
             etcd_key = os.path.join(
-                settings["etcd"]["user_prefix"],
+                shared.settings["etcd"]["user_prefix"],
                 data.value["owner_realm"],
                 data.value["owner"],
                 "key",
@@ -88,9 +89,7 @@ class Root(Resource):
 api.add_resource(Root, "/")
 
 
-def main(port=None, debug=False):
+def main(arguments):
+    port = arguments['port']
+    debug = arguments['debug']
     app.run(debug=debug, host="::", port=port)
-
-
-if __name__ == "__main__":
-    main()

uncloud/oneshot/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger(__name__)

uncloud/oneshot/main.py

@@ -0,0 +1,123 @@
+import argparse
+import os
+
+
+from pathlib import Path
+from uncloud.vmm import VMM
+from uncloud.host.virtualmachine import update_radvd_conf, create_vxlan_br_tap
+
+from . import virtualmachine, logger
+
+###
+# Argument parser loaded by scripts/uncloud.
+arg_parser = argparse.ArgumentParser('oneshot', add_help=False)
+
+# Actions.
+arg_parser.add_argument('--list', action='store_true',
+        help='list UUID and name of running VMs')
+arg_parser.add_argument('--start', nargs=3,
+        metavar=('IMAGE', 'UPSTREAM_INTERFACE', 'NETWORK'),
+        help='start a VM using the OS IMAGE (full path), configuring networking on NETWORK IPv6 prefix')
+arg_parser.add_argument('--stop', metavar='UUID',
+        help='stop a VM')
+arg_parser.add_argument('--get-status', metavar='UUID',
+        help='return the status of the VM')
+arg_parser.add_argument('--get-vnc', metavar='UUID',
+        help='return the path of the VNC socket of the VM')
+arg_parser.add_argument('--reconfigure-radvd', metavar='NETWORK',
+        help='regenerate and reload RADVD configuration for NETWORK IPv6 prefix')
+
+# Arguments.
+arg_parser.add_argument('--workdir', default=Path.home(),
+        help='Working directory, defaulting to $HOME')
+arg_parser.add_argument('--mac',
+        help='MAC address of the VM to create (--start)')
+arg_parser.add_argument('--memory', type=int,
+        help='Memory (MB) to allocate (--start)')
+arg_parser.add_argument('--cores', type=int,
+        help='Number of cores to allocate (--start)')
+arg_parser.add_argument('--threads', type=int,
+        help='Number of threads to allocate (--start)')
+arg_parser.add_argument('--image-format', choices=['raw', 'qcow2'],
+        help='Format of OS image (--start)')
+arg_parser.add_argument('--accel', choices=['kvm', 'tcg'], default='kvm',
+        help='QEMU acceleration to use (--start)')
+arg_parser.add_argument('--upstream-interface', default='eth0',
+        help='Name of upstream interface (--start)')
+
+###
+# Helpers.
+
+# XXX: check if it is possible to use the type returned by ETCD queries.
+class UncloudEntryWrapper:
+    def __init__(self, value):
+        self.value = value
+
+    def value(self):
+        return self.value
+
+def status_line(vm):
+     return "VM: {} {} {}".format(vm.get_uuid(), vm.get_name(), vm.get_status())
+
+###
+# Entrypoint.
+
+def main(arguments):
+    # Initialize VMM.
+    workdir = arguments['workdir']
+    vmm = VMM(vmm_backend=workdir)
+
+    # Harcoded debug values.
+    net_id = 0
+
+    # Build VM configuration.
+    vm_config = {}
+    vm_options = [
+            'mac', 'memory', 'cores', 'threads', 'image', 'image_format',
+            '--upstream_interface', 'upstream_interface', 'network', 'accel'
+            ]
+    for option in vm_options:
+        if arguments.get(option):
+            vm_config[option] = arguments[option]
+
+    vm_config['net_id'] = net_id
+
+    # Execute requested VM action.
+    if arguments['reconfigure_radvd']:
+        # TODO: check that RADVD is available.
+        prefix = arguments['reconfigure_radvd']
+        network = UncloudEntryWrapper({
+                'id': net_id,
+                'ipv6': prefix
+                })
+
+        # Make use of uncloud.host.virtualmachine for network configuration.
+        update_radvd_conf([network])
+    elif arguments['start']:
+        # Extract from --start positional arguments. Quite fragile.
+        vm_config['image'] = arguments['start'][0]
+        vm_config['network'] = arguments['start'][1]
+        vm_config['upstream_interface'] = arguments['start'][2]
+
+        vm_config['tap_interface'] = "uc{}".format(len(vmm.discover()))
+        vm = virtualmachine.VM(vmm, vm_config)
+        vm.start()
+    elif arguments['stop']:
+        vm = virtualmachine.VM(vmm, {'uuid': arguments['stop']})
+        vm = virtualmachine.VM(vmm, vm_config)
+        vm.stop()
+    elif arguments['get_status']:
+        vm = virtualmachine.VM(vmm, {'uuid': arguments['get_status']})
+        print(status_line(vm))
+    elif arguments['get_vnc']:
+        vm = virtualmachine.VM(vmm, {'uuid': arguments['get_vnc']})
+        print(vm.get_vnc_addr())
+    elif arguments['list']:
+        vms = vmm.discover()
+        print("Found {} VMs.".format(len(vms)))
+        for uuid in vms:
+            vm = virtualmachine.VM(vmm, {'uuid': uuid})
+            print(status_line(vm))
+    else:
+        print('Please specify an action: --start, --stop, --list,\
+--get-status, --get-vnc, --reconfigure-radvd')

uncloud/oneshot/virtualmachine.py

@@ -0,0 +1,81 @@
+import uuid
+import os
+
+from uncloud.host.virtualmachine import create_vxlan_br_tap
+from uncloud.oneshot import logger
+
+class VM(object):
+    def __init__(self, vmm, config):
+        self.config = config
+        self.vmm = vmm
+
+        # Extract VM specs/metadata from configuration.
+        self.name         = config.get('name', 'no-name')
+        self.memory       = config.get('memory', 1024)
+        self.cores        = config.get('cores', 1)
+        self.threads      = config.get('threads', 1)
+        self.image_format = config.get('image_format', 'qcow2')
+        self.image        = config.get('image')
+        self.uuid         = config.get('uuid', str(uuid.uuid4()))
+        self.mac          = config.get('mac')
+        self.accel        = config.get('accel', 'kvm')
+
+        self.net_id             = config.get('net_id', 0)
+        self.upstream_interface = config.get('upstream_interface', 'eth0')
+        self.tap_interface      = config.get('tap_interface', 'uc0')
+        self.network            = config.get('network')
+
+    def get_qemu_args(self):
+        command = (
+            "-uuid {uuid} -name {name} -machine pc,accel={accel}"
+            " -drive file={image},format={image_format},if=virtio"
+            " -device virtio-rng-pci"
+            " -m {memory} -smp cores={cores},threads={threads}"
+            " -netdev tap,id=vmnet{net_id},ifname={tap},script=no,downscript=no"
+            " -device virtio-net-pci,netdev=vmnet{net_id},mac={mac}"
+        ).format(
+            uuid=self.uuid, name=self.name, accel=self.accel,
+            image=self.image, image_format=self.image_format,
+            memory=self.memory, cores=self.cores, threads=self.threads,
+            net_id=self.net_id, tap=self.tap_interface, mac=self.mac
+        )
+
+        return command.split(" ")
+
+    def start(self):
+        # Check that VM image is available.
+        if not os.path.isfile(self.image):
+            logger.error("Image {} does not exist. Aborting.".format(self.image))
+
+        # Create Bridge, VXLAN and tap interface for VM.
+        create_vxlan_br_tap(
+                self.net_id, self.upstream_interface, self.tap_interface, self.network
+                )
+
+        # Generate config for and run QEMU.
+        qemu_args = self.get_qemu_args()
+        logger.debug("QEMU args for VM {}: {}".format(self.uuid, qemu_args))
+        self.vmm.start(
+                uuid=self.uuid,
+                migration=False,
+                *qemu_args
+                )
+
+    def stop(self):
+        self.vmm.stop(self.uuid)
+
+    def get_status(self):
+        return self.vmm.get_status(self.uuid)
+
+    def get_vnc_addr(self):
+        return self.vmm.get_vnc(self.uuid)
+
+    def get_uuid(self):
+        return self.uuid
+
+    def get_name(self):
+        success, json = self.vmm.execute_command(uuid, 'query-name')
+        if success:
+            return json['return']['name']
+
+        return None

uncloud/scheduler/helper.py

@@ -7,7 +7,6 @@ from uncloud.common.host import HostStatus
 from uncloud.common.request import RequestEntry, RequestType
 from uncloud.common.vm import VMStatus
 from uncloud.common.shared import shared
-from uncloud.common.settings import settings
 
 
 def accumulated_specs(vms_specs):
@@ -130,7 +129,7 @@ def assign_host(vm):
         type=RequestType.StartVM,
         uuid=vm.uuid,
         hostname=vm.hostname,
-        request_prefix=settings["etcd"]["request_prefix"],
+        request_prefix=shared.settings["etcd"]["request_prefix"],
     )
     shared.request_pool.put(r)
 

uncloud/scheduler/main.py

@@ -6,7 +6,6 @@
 
 import argparse
 
-from uncloud.common.settings import settings
 from uncloud.common.request import RequestEntry, RequestType
 from uncloud.common.shared import shared
 from uncloud.scheduler import logger
@@ -16,7 +15,7 @@ from uncloud.scheduler.helper import (dead_host_mitigation, dead_host_detection,
 arg_parser = argparse.ArgumentParser('scheduler', add_help=False)
 
 
-def main(debug=False):
+def main(arguments):
     # The below while True is neccessary for gracefully handling leadership transfer and temporary
     # unavailability in etcd. Why does it work? It works because the get_prefix,watch_prefix return
     # iter([]) that is iterator of empty list on exception (that occur due to above mentioned reasons)
@@ -24,9 +23,9 @@ def main(debug=False):
     # get prefix until either success or deamon death comes.
     while True:
         for request_iterator in [
-            shared.etcd_client.get_prefix(settings['etcd']['request_prefix'], value_in_json=True,
+            shared.etcd_client.get_prefix(shared.settings['etcd']['request_prefix'], value_in_json=True,
                                           raise_exception=False),
-            shared.etcd_client.watch_prefix(settings['etcd']['request_prefix'], value_in_json=True,
+            shared.etcd_client.watch_prefix(shared.settings['etcd']['request_prefix'], value_in_json=True,
                                             raise_exception=False),
         ]:
             for request_event in request_iterator:
@@ -50,7 +49,3 @@ def main(debug=False):
                         shared.vm_pool.put(vm_entry)
 
                         logger.info('No Resource Left. Emailing admin....')
-
-
-if __name__ == '__main__':
-    main()

uncloud/vmm/__init__.py

@@ -100,9 +100,9 @@ class TransferVM(Process):
 class VMM:
     # Virtual Machine Manager
     def __init__(
-        self,
-        qemu_path="/usr/bin/qemu-system-x86_64",
-        vmm_backend=os.path.expanduser("~/uncloud/vmm/"),
+            self,
+            qemu_path="/usr/bin/qemu-system-x86_64",
+            vmm_backend=os.path.expanduser("~/uncloud/vmm/"),
     ):
         self.qemu_path = qemu_path
         self.vmm_backend = vmm_backend
@@ -125,7 +125,7 @@ class VMM:
             os.makedirs(self.socket_dir, exist_ok=True)
 
     def is_running(self, uuid):
-        sock_path = os.path.join(self.vmm_backend, uuid)
+        sock_path = os.path.join(self.socket_dir, uuid)
         try:
             sock = socket.socket(socket.AF_UNIX)
             sock.connect(sock_path)
@@ -163,7 +163,7 @@ class VMM:
             qmp_arg = (
                 "-qmp",
                 "unix:{},server,nowait".format(
-                    join_path(self.vmm_backend, uuid)
+                    join_path(self.socket_dir, uuid)
                 ),
             )
             vnc_arg = (
@@ -212,7 +212,7 @@ class VMM:
     def execute_command(self, uuid, command, **kwargs):
         # execute_command -> sucess?, output
         try:
-            with VMQMPHandles(os.path.join(self.vmm_backend, uuid)) as (
+            with VMQMPHandles(os.path.join(self.socket_dir, uuid)) as (
                 sock_handle,
                 file_handle,
             ):
@@ -255,8 +255,8 @@ class VMM:
     def discover(self):
         vms = [
             uuid
-            for uuid in os.listdir(self.vmm_backend)
-            if not isdir(join_path(self.vmm_backend, uuid))
+            for uuid in os.listdir(self.socket_dir)
+            if not isdir(join_path(self.socket_dir, uuid))
         ]
         return vms