Initial commit

Author: ltkum

.dockerignore

@@ -0,0 +1,21 @@
+# Git
+.git
+.gitignore
+.gitmodules
+**/*.md
+
+# Docker
+docker-compose.yml
+docker-compose.yml.in
+.docker
+
+# Python
+*.pyc
+__pycache__
+
+# Files not used within docker
+./tests/*
+Makefile
+.venv
+lib-makefiles/*
+buildspec.yml

.gitignore

@@ -0,0 +1,47 @@
+notification-configuration.json
+packaged.yaml
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+_env
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+local/
+
+# virtualenv
+.venv
+
+# mypy
+.mypy_cache/
+
+# PyCharm generated files
+*.idea
+*/bin/
+*/lib64
+*/pip-selfcheck.json
+*/pyvenv.cfg
+
+#vim
+*.swp

.style.yapf

@@ -0,0 +1,23 @@
+[style]
+based_on_style=google
+# Put closing brackets on a separate line, dedented, if the bracketed
+# expression can't fit in a single line. Applies to all kinds of brackets,
+# including function definitions and calls. For example:
+#
+#   config = {
+#       'key1': 'value1',
+#       'key2': 'value2',
+#   }        # <--- this bracket is dedented and on a separate line
+#
+#   time_series = self.remote_client.query_entity_counters(
+#       entity='dev3246.region1',
+#       key='dns.query_latency_tcp',
+#       transform=Transformation.AVERAGE(window=timedelta(seconds=60)),
+#       start_ts=now()-timedelta(days=3),
+#       end_ts=now(),
+#   )        # <--- this bracket is dedented and on a separate line
+dedent_closing_brackets=True
+
+# Split before arguments, but do not split all subexpressions recursively
+# (unless needed).
+split_all_top_level_comma_separated_values=True

Dockerfile

@@ -0,0 +1,25 @@
+# Buster slim python 3.7 base image.
+FROM python:3.7-slim-buster
+ENV HTTP_PORT 8080
+RUN groupadd -r geoadmin && useradd -r -s /bin/false -g geoadmin geoadmin
+
+
+# HERE : install relevant packages
+# RUN apt-get update && apt-get install -y [packages] \
+#  && apt-get clean \
+#  && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY "./requirements.txt" "/app/requirements.txt"
+
+RUN pip3 install -r requirements.txt
+
+COPY "./" "/app/"
+
+RUN chown -R geoadmin:geoadmin /app
+USER geoadmin
+
+EXPOSE $HTTP_PORT
+
+# Use a real WSGI server
+ENTRYPOINT ["python3", "wsgi.py"]

Makefile

@@ -0,0 +1,115 @@
+SHELL = /bin/bash
+
+.DEFAULT_GOAL := help
+
+CURRENT_DIR := $(shell pwd)
+INSTALL_DIR := $(CURRENT_DIR)/.venv
+PYTHON_FILES := $(shell find ./* -type f -name "*.py" -print)
+
+#FIXME: put this variable in config file
+PYTHON_VERSION=3.7.4
+CURRENT_PYTHON_VERSION := $(shell python3 -c "import sys;t='{v[0]}.{v[1]}.{v[2]}'.format(v=list(sys.version_info[:]));sys.stdout.write(t)")
+PYTHON_VERSION_OK := $(shell python3 -c "import sys; t=sys.version_info[0:3]; print(int('{}.{}.{}'.format(*t) == '$(PYTHON_VERSION)'))")
+
+# Commands
+SYSTEM_PYTHON_CMD := $(shell which python3)
+PYTHON_CMD := $(INSTALL_DIR)/bin/python3
+PIP_CMD := $(INSTALL_DIR)/bin/pip3
+FLASK_CMD := $(INSTALL_DIR)/bin/flask
+YAPF_CMD := $(INSTALL_DIR)/bin/yapf
+all: help
+
+# This bit check define the build/python "target": if the system has an acceptable version of python, there will be no need to install python locally.
+
+ifeq ($(PYTHON_VERSION_OK),1)
+PYTHON_BINDIR := $(shell dirname $(PYTHON_CMD))
+PYTHONHOME := $(shell eval "cd $(PYTHON_BINDIR); pwd; cd > /dev/null")
+build/python:
+		@echo $(CURRENT_PYTHON_VERSION)
+		@echo $(shell $(PYTHON_CMD) -c "print('OK')")
+		mkdir -p build
+		touch build/python;
+else
+build/python: local/bin/python3.7
+	mkdir -p build
+	touch build/python;
+
+SYSTEM_PYTHON_CMD := $(CURRENT_DIR)/local/bin/python3.7
+endif
+
+
+
+.PHONY: help
+help:
+	@echo "Usage: make <target>"
+	@echo
+	@echo "Possible targets:"
+	@echo -e " \033[1mBUILD TARGETS\033[0m "
+	@echo "- setup			Create the python virtual environment"
+	@echo -e " \033[1mLINTING TOOLS TARGETS\033[0m "
+	@echo "- lint			Lint the python source code"
+	@echo -e " \033[1mLOCAL SERVER TARGETS\033[0m "
+	@echo "- serve			Run the project using the flask debug server"
+	@echo "- gunicornserve		Run the project using the gunicorn WSGI server"
+	@echo "- dockerrun		Run the project using the gunicorn WSGI server inside a container. Env variable HTTP_PORT should be set"
+	@echo "- shutdown		Stop the aforementioned container"
+	@echo -e " \033[1mCLEANING TARGETS\033[0m "
+	@echo "- clean			Clean genereated files"
+	@echo "- clean_venv		Clean python venv"
+
+# Build targets. Calling setup is all that is needed for the local files to be installed as needed. Bundesnetz may cause problem.
+
+python: build/python
+	@echo "Python installed"
+
+.PHONY: setup
+setup: python .venv/build.timestamp
+
+
+local/bin/python3.7:
+	mkdir -p $(CURRENT_DIR)/local;
+	curl -z $(CURRENT_DIR)/local/Python-$(PYTHON_VERSION).tar.xz https://www.python.org/ftp/python/$(PYTHON_VERSION)/Python-$(PYTHON_VERSION).tar.xz -o $(CURRENT_DIR)/local/Python-$(PYTHON_VERSION).tar.xz;
+	cd $(CURRENT_DIR)/local && tar -xf Python-$(PYTHON_VERSION).tar.xz && Python-$(PYTHON_VERSION)/configure --prefix=$(CURRENT_DIR)/local/ && make altinstall
+
+.venv/build.timestamp: build/python
+	$(SYSTEM_PYTHON_CMD) -m venv $(INSTALL_DIR) && $(PIP_CMD) install --upgrade pip setuptools
+	${PIP_CMD} install -r dev_requirements.txt
+	$(PIP_CMD) install -r requirements.txt
+	touch .venv/build.timestamp
+
+# linting target, calls upon yapf to make sure your code is easier to read and respects some conventions.
+
+.PHONY: lint
+lint: .venv/build.timestamp
+		$(YAPF_CMD) -i --style .style.yapf $(PYTHON_FILES)
+
+# Serve targets. Using these will run the application on your local machine. You can either serve with a wsgi front (like it would be within the container), or without.
+.PHONY: serve
+serve: .venv/build.timestamp
+		FLASK_APP=service_launcher FLASK_DEBUG=1 ${FLASK_CMD} run --host=0.0.0.0 --port=${HTTP_PORT}
+
+.PHONY: gunicornserve
+gunicornserve: .venv/build.timestamp
+		${SYSTEM_PYTHON_CMD} wsgi.py
+
+
+# Docker related functions.
+
+.PHONY: dockerrun
+dockerrun:
+	docker-compose up -d;
+	sleep 10
+
+.PHONY: shutdown
+shutdown:
+	docker-compose down
+
+# Cleaning functions. clean_venv will only remove the virtual environment, while clean will also remove the local python installation.
+
+.PHONY: clean
+clean: clean_venv
+	rm -rf local;
+
+.PHONY: clean_venv
+clean_venv:
+	rm -rf ${INSTALL_DIR};

README.md

@@ -0,0 +1,73 @@
+# service-name
+
+## Summary of the project
+A simple description of the service should go here
+
+## How to run locally
+
+### dependencies
+
+The **Make** targets assume you have **bash**, **curl**, **tar**, **docker** and **docker-compose** installed. 
+
+### Setting up to work
+
+First, you'll need to clone the repo
+
+    git clone git@github.com:geoadmin/service-name
+
+Then, you can run the setup target to ensure you have everything needed to develop, test and serve locally
+
+    make setup
+
+That's it, you're ready to work.
+
+### Test your work
+
+Testing if what you developed work is made simple. You have four targets at your disposal. **test, serve, gunicornserve, dockerrun**
+
+    make test
+
+This command run the integration and unit tests.
+
+    make serve
+    
+This will serve the application through Flask without any wsgi in front.
+    
+    make gunicornserve
+    
+This will serve the application with the Gunicorn layer in front of the application
+    
+    make dockerrun
+
+This will serve the application with the wsgi server, inside a container. 
+To stop serving through containers, 
+
+    make shutdown
+    
+Is the command you're looking for. 
+
+## Endpoints
+all trailing slashes are optionals
+
+
+### /checker/ [GET]
+
+#### description of the route
+this is a simple route meant to test if the server is up.
+#### parameters ####
+
+None
+
+#### expected results
+
+**Success**
+
+    "OK", 200
+
+    
+## Deploying the project and continuous integration
+When creating a PR, terraform should run a codebuild job to test, build and push automatically your PR as a tagged container.
+
+This service is to be delployed to the Kubernetes cluster once it is merged.
+
+TO DO: give instructions to deploy to kubernetes.

app/__init__.py

@@ -0,0 +1,22 @@
+from flask import Flask
+from app.middleware import ReverseProxied
+
+# Standard Flask application initialisation
+
+app = Flask(__name__)
+app.wsgi_app = ReverseProxied(app.wsgi_app, script_name='/')
+
+
+from app import routes
+
+
+def main():
+    app.run()
+
+
+if __name__ == '__main__':
+    """
+    Entrypoint for the application. At the moment, we do nothing specific, but there might be preparatory steps in the 
+    future
+    """
+    main()

app/helpers/__init__.py

@@ -0,0 +1,49 @@
+class ReverseProxied(object):
+    """
+    Reverse proxies can cause some problems within applications, as they change routes, redirect traffic, and
+    applications might have errors because of that. This piece of middlewar make sure everything runs smoothly.
+    """
+    def __init__(self, app, script_name=None, scheme=None, server=None, port=None):
+        self.app = app
+        self.script_name = script_name
+        self.scheme = scheme
+        self.server = server
+        self.port = port
+
+    def __call__(self, environ, start_response):
+        """
+        This function modifies the environment received by the WSGI, mostly making sure we serve the right routes and
+        that the application answers as if it were the initial host (for example, an error should say that the site at
+        reverse-proxied.admin.ch/generic_name/generate encountered a problem, not that it was at internal.server/generate
+        :param environ: the WSGI environment
+        :param start_response: A callable accepting headers, a status code and can accept an exception to start the
+        response
+        :return: a call to the wsgi app, with an updated WSGI environment.
+        """
+
+        """
+        The first part makes sure the route goes to the right resource. 
+        If we have a query made to reverse-proxy.admin.ch/generic_name/generate, 
+        HTTP_X_SCRIPT_NAME will be /generic_name, and PATH_INFO would be /generic_name/generate.
+        
+        PATH_INFO is used to handle the route called (in this case, it would use /generate)
+        SCRIPT_NAME is used to prefix the routes so that the application returns a correct answer (namely: that the 
+        query was hitting /generic_name/generate).
+        """
+        # The syntax here means : try to get HTTP_X_SCRIPT_NAME, or get me an empty string, and the command or, in the
+        # context of a string, returns the first "truthy" value
+        script_name = environ.get('HTTP_X_SCRIPT_NAME', '') or self.script_name
+        if script_name:
+            environ['SCRIPT_NAME'] = script_name
+            path_info = environ['PATH_INFO']
+            if path_info.startswith(script_name):
+                environ['PATH_INFO'] = path_info[len(script_name):]
+        # The scheme is the protocol used (http/s) to connect to the server.
+        scheme = environ.get('HTTP_X_SCHEME', '') or self.scheme
+        if scheme:
+            environ['wsgi.url_scheme'] = scheme
+        # this sets our own HOST parameter to be the one that was queried in the first place.
+        server = environ.get('HTTP_X_FORWARDED_HOST', '') or self.server
+        if server:
+            environ['HTTP_HOST'] = server
+        return self.app(environ, start_response)