.gitmodules

@@ -1,3 +0,0 @@
-[submodule "data"]
-	path = data
-	url = git@git.bitmessage.org:Sysdeploy/cloud-init-cherrypy-data.git

data

@@ -1 +0,0 @@
-Subproject commit 9b424a478883ccac83e2a1f95cd8a674f5b083e9

main.py

@@ -1,329 +1,101 @@
-#!/usr/bin/env python3
-"""
-Serve cloud init files
-"""
-
-import configparser
 import os
-import socket
 import sys
-import uuid as uuid_module
-from ipaddress import AddressValueError, IPv4Address, IPv6Address
-from os import access, R_OK
 
 import cherrypy
-# from cherrypy.lib.static import serve_file
+from cherrypy.lib.static import serve_file
-from jinja2 import Template
 import yaml
+import socket
+
+import configparser
 
 PATH = os.path.dirname(os.path.abspath(__file__))
 
-CONFIG = configparser.ConfigParser()
+config = configparser.ConfigParser()
-CONFIG.read(os.path.join(PATH, "config.ini"))
+config.read("config.ini")
 
-USER_DATA_FILENAME = CONFIG["app"].get("user_data", "user-data")
+user_data_filename = config["app"].get("user_data", "sample_file.txt")
-META_DATA_FILENAME = CONFIG["app"].get("meta_data", "meta-data")
+meta_data_filename = config["app"].get("meta_data", "meta_data_extra.txt")
-REDIRECT_FILENAME = CONFIG["app"].get("redirect", "redirect")
 
 
-class CloudInitRequest:
+class MainApp:
-    """
-    Request data for persistence across methods
-    """
-    def __init__(self, request, uuid=None):
-        self.remoteip = None
-        self.hostinfo = ('localhost', )
-        self.request = request
-        self.meta_data = None
-        self.meta_data_loaded = False
-        self.user_data = None
-
-        try:
-            self.uuid = str(uuid_module.UUID('{' + uuid + '}'))
-        # ValueError is wrong UUID syntax
-        # TypeError is None
-        except (ValueError, TypeError):
-            self.uuid = None
-
-        self._init_ip()
-        self._generate_default_meta_data()
-
-    def _can_ip_be_proxy(self):
-        """
-        Assuming the connection is through a proxy, is this proxy permitted?
-        Can't proxy from a publicly reachable IP.
-        """
-        self.remoteip = self.request.remote.ip
-        try:
-            ipobj = IPv4Address(self.remoteip)
-        except AddressValueError:
-            try:
-                ipobj = IPv6Address(self.remoteip)
-            except AddressValueError:
-                return False
-        return not ipobj.is_global
-
     def _init_ip(self):
         """
         Get remote IP
         """
-        if self._can_ip_be_proxy():
         try:
-                self.remoteip = self.request.headers.get(
+            self.remoteip = cherrypy.request.headers.get(
                 'X-Real-Ip',
-                    self.request.remote.ip
+                cherrypy.request.remote.ip
             )
-            except KeyError:
+        except:
-                pass
+            self.remoteip = cherrypy.request.remote.ip
 
         try:
             self.hostinfo = socket.gethostbyaddr(self.remoteip)
-            forward_lookup = socket.gethostbyname(self.hostinfo[0])
-            if forward_lookup != self.remoteip:
-                self.hostinfo = ('localhost', )
         except socket.herror:
             self.hostinfo = ('localhost', )
-        except socket.gaierror:
-            self.hostinfo = (self.remoteip, )
-
-    def _generate_default_meta_data(self):
-        """
-        Build default meta-data based on the requesting IP
-        """
-        hostname = self.hostinfo[0]
-        base = self.request.base
-        self.meta_data = {
-            "instance-id": hostname.split(".")[0],
-            "local-hostname": hostname,
-            "baseurl": base
-        }
-
-    def _update_meta_data_from_file(self, filename):
-        """
-        Load meta-data from a file
-        """
-        with open(filename, "r") as metadata:
-            self.meta_data.update(yaml.safe_load(metadata))
-
-    def _get_filename(self, filetype):
-        """
-        Get the best available filename for a given type
-        """
-        check_dirs = ['localhost', ]
-        if self.uuid:
-            check_dirs.insert(0, self.uuid)
-        if self.meta_data['local-hostname'] != 'localhost':
-            check_dirs.insert(0, self.meta_data['local-hostname'])
-        for subdir in check_dirs:
-            filepath = os.path.join(PATH, "data",
-                                    subdir,
-                                    filetype)
-            if not os.path.isfile(filepath) \
-               or not access(filepath, R_OK):
-                continue
-            return filepath
-        return None
-
-    def get_meta_data(self):
-        """
-        Return the appropriate meta-data for this request
-        """
-        if self.meta_data_loaded:
-            return self.meta_data
-        self._generate_default_meta_data()
-        filename = self._get_filename(META_DATA_FILENAME)
-        if filename:
-            self._update_meta_data_from_file(
-                filename
-                )
-        self.meta_data_loaded = True
-        return self.meta_data
-
-    def save_meta_data(self, data):
-        """
-        Save metadata
-        """
-        filename = self._get_filename(META_DATA_FILENAME)
-        with open(filename, "wt") as filehandle:
-            filehandle.write(data)
-
-    def get_user_data(self):
-        """
-        Return the appropriate meta-data for this request
-        """
-        if self.user_data:
-            return self.user_data
-        filename = self._get_filename(USER_DATA_FILENAME)
-        if not filename:
-            return None
-        with open(filename, "r") as userdata:
-            self.user_data = userdata.read()
-            return self.user_data
-        return None
-
-    def optional_redirect(self):
-        """
-        Return optional redirect, or None
-        """
-        filename = self._get_filename(REDIRECT_FILENAME)
-        if not (filename and os.path.exists(filename)):
-            return None
-        try:
-            with open(filename) as redirect:
-                content = redirect.read().splitlines()
-                return content[0]
-        except IOError:
-            return None
-        return None
-
-
-class CloudInitApp:
-    """
-    Serve cloud init files
-    """
-
-    @staticmethod
-    def _redirect_if_needed(request):
-        redirect = request.optional_redirect()
-        if redirect:
-            raise cherrypy.HTTPRedirect(redirect, 301)
-        return False
-
-    @staticmethod
-    def _content_type(data):
-        if not data:
-            return "text/cloud-config"
-        if data.startswith("#include"):
-            return "text/x-include-url"
-        if data.startswith("## template: jinja"):
-            return "text/jinja2"
-        return "text/cloud-config"
-
-    @staticmethod
-    def _wrap_metadata(metadata):
-        return {'ds': {
-            'meta_data': metadata
-            }}
-
-    def _user_data(self, uuid=None, SYSUUID=None):
-        """
-        Serves a static file
-        But can process a template if x-include-url
-        """
-        if SYSUUID:  # SYSLINUX support
-            uuid = SYSUUID
-        request = CloudInitRequest(cherrypy.request, uuid)
-        self._redirect_if_needed(request)
-        user_data = request.get_user_data()
-
-        c__ = self._content_type(user_data)
-
-        cherrypy.response.headers['Content-Type'] = c__
-        cherrypy.response.headers['Content-Disposition'] = \
-            'attachment; filename="user-data"'
-
-        if c__ == "text/x-include-url":
-            t__ = Template(user_data)
-            metadata = request.get_meta_data()
-            wrapped = CloudInitApp._wrap_metadata(metadata)
-            return t__.render(**wrapped)
-        return user_data
-
-    def _meta_data(self, uuid=None):
-        """
-        Return meta-data in YAML
-        """
-        request = CloudInitRequest(cherrypy.request, uuid)
-        self._redirect_if_needed(request)
-
-        cherrypy.response.headers['Content-Type'] = \
-            'text/yaml'
-        cherrypy.response.headers['Content-Disposition'] = \
-            'attachment; filename="meta-data"'
-        return yaml.dump(request.get_meta_data())
-
-    @staticmethod
-    def _vendor_data():
-        return ""
 
     @cherrypy.expose
     def user_data(self):
         """
-        v1 api endpoint user-data
+        Serves a static file
         """
-        return self._user_data()
+        self._init_ip()
+        filepath = os.path.join(PATH, "data", self.hostinfo[0],
+                                user_data_filename)
+        if not os.path.exists(filepath):
+            filepath = os.path.join(PATH, "data", user_data_filename)
+        return serve_file(filepath, "application/x-download", "attachment")
 
     @cherrypy.expose
     def meta_data(self):
         """
-        v1 api endpoint meta-data
+        Return meta-data in YAML
         """
-        return self._meta_data()
+        self._init_ip()
+        hostname =self.hostinfo[0]
+        data = {"instance-id": hostname.split(".")[0], "local-hostname": hostname}
+
+        filepath = os.path.join(PATH, "data", hostname, meta_data_filename)
+        if os.path.exists(filepath):
+            with open(filepath, "r") as f:
+                line = f.readlines()[0]
+                ls = list(map(lambda k: k.strip(), line.split(":")))
+                data[ls[0]] = ls[1]
+
+        return yaml.dump(data)
 
     @cherrypy.expose
-    def vendor_data(self):
-        """
-        v1 api endpoint vendor-data
-        """
-        return self._vendor_data()
-
-    @cherrypy.expose
-    def apiv2(self, uuid=None, filetype="user-data"):
-        """
-        API endpoint v2
-        extract command from arguments
-        """
-        if filetype == "user-data":
-            return self._user_data(uuid)
-        if filetype == "meta-data":
-            return self._meta_data(uuid)
-        if filetype == "vendor-data":
-            return self._vendor_data()
-        return ""
-
-    # unused
-    # @cherrypy.expose
     def finished(self, data):
         """
         Saves additional meta-data
 
         :param data: meta-data to be added
         """
-        request = CloudInitRequest(cherrypy.request)
+        self._init_ip()
-        self._redirect_if_needed(request)
+        folder = os.path.join(PATH, "data", self.hostinfo[0])
-        request.save_meta_data(data)
+        if not os.path.exists(folder):
+            os.makedirs(folder)
+
+        with open(os.path.join(folder, meta_data_filename), "w") as f:
+            f.write(data)
 
 
-ROOT = CloudInitApp()
+ROOT = MainApp()
 
 if __name__ == "__main__":
-    cherrypy.server.socket_host = \
+    cherrypy.server.socket_host = config["server"].get("server_host", "127.0.0.1")
-        CONFIG["server"].get("server_host", "127.0.0.1")
+    cherrypy.server.socket_port = config["server"].getint("server_port", 8081)
-    cherrypy.server.socket_port = \
-        CONFIG["server"].getint("server_port", 8081)
     ENGINE = cherrypy.engine
 
-    CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+    cherrypy.tree.mount(ROOT)
-    CONFIG = {
-        '/include': {
-            'tools.staticdir.on': True,
-            'tools.staticdir.dir': os.path.join(CURRENT_DIR,
-                                                'data',
-                                                'include'),
-            'tools.staticdir.content_types': {
-                'yml': 'text/yaml'
-                }
-            }
-        }
-    cherrypy.tree.mount(ROOT, config=CONFIG)
-
     if hasattr(ENGINE, "signal_handler"):
         ENGINE.signal_handler.subscribe()
     if hasattr(ENGINE, "console_control_handler"):
         ENGINE.console_control_handler.subscribe()
     try:
         ENGINE.start()
-    except Exception:  # pylint: disable=broad-except
+    except Exception:
         sys.exit(1)
     else:
         ENGINE.block()