fdroidserver 2.3.5__tar.gz → 2.4a1__tar.gz

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/.gitignore

@@ -27,7 +27,6 @@ tmp/
 /tests/repo/status
 
 # files used in manual testing
-/config.py
 /config.yml
 /tmp/
 /logs/

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/.gitlab-ci.yml

@@ -274,6 +274,35 @@ safety:
     - python3 -m safety --key "$SAFETY_API_KEY" --stage cicd scan
 
 
+# TODO tests/*/*/*.yaml are not covered
+yamllint:
+  image: debian:bookworm-slim
+  rules:
+    # once only:/changes: are ported to rules:, this could be removed:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "push"
+      changes:
+        - .gitlab-ci.yml
+        - .safety-policy.yml
+        - .yamllint
+        - tests/*.yml
+        - tests/*/*.yml
+        - tests/*/*/.*.yml
+  <<: *apt-template
+  variables:
+    LANG: C.UTF-8
+  script:
+    - apt-get install yamllint
+    - yamllint
+        .gitlab-ci.yml
+        .safety-policy.yml
+        .yamllint
+        tests/*.yml
+        tests/*/*.yml
+        tests/*/*/.*.yml
+
+
 # Run all the various linters and static analysis tools.
 locales:
   image: debian:bookworm-slim
@@ -555,11 +584,11 @@ servergitmirrors:
     - ./tests/key-tricks.py
     - ssh-keyscan gitlab.com >> /root/.ssh/known_hosts
     - test -d /tmp/fdroid/repo || mkdir -p /tmp/fdroid/repo
-    - cp tests/config.py tests/keystore.jks /tmp/fdroid/
+    - cp tests/config.yml tests/keystore.jks /tmp/fdroid/
     - cp tests/repo/com.politedroid_6.apk /tmp/fdroid/repo/
     - cd /tmp/fdroid
     - touch fdroid-icon.png
-    - printf "\nservergitmirrors = 'git@gitlab.com:fdroid/ci-test-servergitmirrors-repo.git'\n" >> config.py
+    - printf "\nservergitmirrors\x3a 'git@gitlab.com:fdroid/ci-test-servergitmirrors-repo.git'\n" >> config.yml
     - $PYTHONPATH/fdroid update --verbose --create-metadata
     - $PYTHONPATH/fdroid deploy --verbose
     - export DLURL=`grep -Eo 'https://gitlab.com/fdroid/ci-test-servergitmirrors-repo[^"]+' repo/index-v1.json`
@@ -681,3 +710,67 @@ docker:
       fi
     - docker push $RELEASE_IMAGE
     - docker push $RELEASE_IMAGE-bookworm
+
+
+# PUBLISH is the signing server.  It has a very minimal manual setup.
+PUBLISH:
+  image: debian:bullseye-backports
+  script:
+    - apt-get update
+    - apt-get -qy upgrade
+    - apt-get -qy install --no-install-recommends -t bullseye-backports
+        androguard
+        apksigner
+        curl
+        default-jdk-headless
+        git
+        gpg
+        gpg-agent
+        python3-asn1crypto
+        python3-defusedxml
+        python3-git
+        python3-ruamel.yaml
+        python3-yaml
+        rsync
+
+    # Run only relevant parts of the test suite, other parts will fail
+    # because of this minimal base setup.
+    - python3 -m unittest
+        tests/test_gpgsign.py
+        tests/test_metadata.py
+        tests/test_publish.py
+        tests/test_signindex.py
+
+    - cd tests
+    - mkdir archive
+    - mkdir unsigned
+    - cp urzip-release-unsigned.apk unsigned/info.guardianproject.urzip_100.apk
+    - grep '^key.*pass' config.yml | sed 's,\x3a ,=,' > $CI_PROJECT_DIR/variables
+    - sed -Ei 's,^(key.*pass|keystore)\x3a.*,\1\x3a {env\x3a \1},' config.yml
+    - printf '\ngpghome\x3a {env\x3a gpghome}\n' >> config.yml
+    - |
+      tee --append $CI_PROJECT_DIR/variables <<EOF
+          gpghome=$CI_PROJECT_DIR/tests/gnupghome
+          keystore=$CI_PROJECT_DIR/tests/keystore.jks
+          serverwebroot=/tmp
+          export gpghome keypass keystorepass keystore serverwebroot
+      EOF
+    - source $CI_PROJECT_DIR/variables
+    # silence warnings
+    - chmod 0600 config.yml config/*.yml config/*/*.yml
+    - chmod 0700 $gpghome
+    # make fake 'ciarang' index signing key
+    - keytool -keyclone -alias 4e7da5b7 -dest ciarang
+        -keypass:env keypass -new:env keypass -storepass:env keystorepass -keystore $keystore
+
+    - export PATH=$CI_PROJECT_DIR:$PATH
+
+    # run signpkg.sh
+    - fdroid publish --verbose
+    - fdroid gpgsign --verbose
+    - rsync --progress repo/* $serverwebroot/
+
+    # run signindex.sh
+    - fdroid gpgsign --verbose
+    - fdroid signindex --verbose
+    - rsync --stats repo/* $serverwebroot/

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/CHANGELOG.md

@@ -8,10 +8,30 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 ### Added
 
+* lint: support the base _config.yml_.
+  https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1606
+
 ### Fixed
 
+* Expand {env: foo} config syntax to be allowed any place a string is.
+  https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1610
+* Only show "unsafe permissions on config.yml" when secrets are present.
+* Standardized config files on ruamel.yaml with a YAML 1.2 data format.
+  https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1611
+* Brought back error when a package has multiple package types (e.g. xapk and
+  apk).  https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1602
+* Reworked test suite to be entirely based on Python unittest (thanks @mindston).
+  https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1587
+* publish/signindex/gpgsign no longer load the _qrcode_ and _requests_ modules,
+  and can operate without them installed.
+
 ### Removed
 
+* checkupdates: remove auto_author: config, it is no longer used.
+* Purge support for the long-deprecated _config.py_ config file.
+  https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1607
+
+
 ## [2.3.5] - 2025-01-20
 
 ### Fixed

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/MANIFEST.in

@@ -548,7 +548,7 @@ include tests/build-tools/28.0.3/aapt-output-souch.smsbypass_9.txt
 include tests/build-tools/generate.sh
 include tests/check-fdroid-apk
 include tests/com.fake.IpaApp_1000000000001.ipa
-include tests/config.py
+include tests/config.yml
 include tests/config/antiFeatures.yml
 include tests/config/categories.yml
 include tests/config/de/antiFeatures.yml
@@ -721,6 +721,7 @@ include tests/repo/v1.v2.sig_1020.apk
 include tests/run-tests
 include tests/SANAPPSI.RSA
 include tests/SANAPPSI.SF
+include tests/shared_test_code.py
 include tests/signindex/guardianproject.jar
 include tests/signindex/guardianproject-v1.jar
 include tests/signindex/testy.jar
@@ -845,7 +846,6 @@ include tests/source-files/ut.ewh.audiometrytest/settings.gradle
 include tests/source-files/yuriykulikov/AlarmClock/gradle/wrapper/gradle-wrapper.properties
 include tests/source-files/Zillode/syncthing-silk/build.gradle
 include tests/SpeedoMeterApp.main_1.apk
-include tests/testcommon.py
 include tests/test_build.py
 include tests/test_checkupdates.py
 include tests/test_common.py

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdroidserver
-Version: 2.3.5
+Version: 2.4a1
 Summary: F-Droid Server Tools
 Home-page: https://f-droid.org
 Author: The F-Droid Project

fdroidserver-2.4a1/fdroidserver/_yaml.py

@@ -0,0 +1,64 @@
+# Copyright (C) 2025, Hans-Christoph Steiner <hans@eds.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program 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 Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Standard YAML parsing and dumping.
+
+YAML 1.2 is the preferred format for all data files.  When loading
+F-Droid formats like config.yml and <Application ID>.yml, YAML 1.2 is
+forced, and older YAML constructs should be considered an error.
+
+It is OK to load and dump files in other YAML versions if they are
+externally defined formats, like FUNDING.yml.  In those cases, these
+common instances might not be appropriate to use.
+
+There is a separate instance for dumping based on the "round trip" aka
+"rt" mode.  The "rt" mode maintains order while the "safe" mode sorts
+the output.  Also, yaml.version is not forced in the dumper because that
+makes it write out a "%YAML 1.2" header.  F-Droid's formats are
+explicitly defined as YAML 1.2 and meant to be human-editable.  So that
+header gets in the way.
+
+"""
+
+import ruamel.yaml
+
+yaml = ruamel.yaml.YAML(typ='safe')
+yaml.version = (1, 2)
+
+yaml_dumper = ruamel.yaml.YAML(typ='rt')
+
+
+def config_dump(config, fp=None):
+    """Dump config data in YAML 1.2 format without headers.
+
+    This outputs YAML in a string that is suitable for use in regexps
+    and string replacements, as well as complete files.  It is therefore
+    explicitly set up to avoid writing out headers and footers.
+
+    This is modeled after PyYAML's yaml.dump(), which can dump to a file
+    or return a string.
+
+    https://yaml.dev/doc/ruamel.yaml/example/#Output_of_%60dump()%60_as_a_string
+
+    """
+    dumper = ruamel.yaml.YAML(typ='rt')
+    dumper.default_flow_style = False
+    dumper.explicit_start = False
+    dumper.explicit_end = False
+    if fp is None:
+        with ruamel.yaml.compat.StringIO() as fp:
+            dumper.dump(config, fp)
+            return fp.getvalue()
+    dumper.dump(config, fp)

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/fdroidserver/checkupdates.py

@@ -381,7 +381,8 @@ def dirs_with_manifest(startdir: str):
         A directory that contains a manifest file of an Android project, None if
         no directory could be found
     """
-    for root, _dirs, files in os.walk(startdir):
+    for root, dirs, files in os.walk(startdir):
+        dirs.sort()
         if any(m in files for m in [
                 'AndroidManifest.xml', 'pom.xml', 'build.gradle', 'build.gradle.kts']):
             yield Path(root)
@@ -674,8 +675,6 @@ def checkupdates_app(app: metadata.App, auto: bool, commit: bool = False) -> Non
         if commit:
             logging.info("Commiting update for " + app.metadatapath)
             gitcmd = ["git", "commit", "-m", commitmsg]
-            if 'auto_author' in config:
-                gitcmd.extend(['--author', config['auto_author']])
             gitcmd.extend(["--", app.metadatapath])
             if subprocess.call(gitcmd) != 0:
                 raise FDroidException("Git commit failed")

{fdroidserver-2.3.5 → fdroidserver-2.4a1}/fdroidserver/common.py

@@ -25,8 +25,32 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-# common.py is imported by all modules, so do not import third-party
-# libraries here as they will become a requirement for all commands.
+
+"""Collection of functions shared by subcommands.
+
+This is basically the "shared library" for all the fdroid subcommands.
+The contains core functionality and a number of utility functions.
+This is imported by all modules, so do not import third-party
+libraries here as they will become a requirement for all commands.
+
+Config
+------
+
+Parsing and using the configuration settings from config.yml is
+handled here. The data format is YAML 1.2. The config has its own
+supported data types:
+
+* Boolean (e.g. deploy_process_logs:)
+* Integer (e.g. archive_older:, repo_maxage:)
+* String-only (e.g. repo_name:, sdk_path:)
+* Multi-String (string, list of strings, or list of dicts with
+  strings, e.g. serverwebroot:, mirrors:)
+
+String-only fields can also use a special value {env: varname}, which
+is a dict with a single key 'env' and a value that is the name of the
+environment variable to include.
+
+"""
 
 import copy
 import difflib
@@ -48,7 +72,6 @@ import logging
 import hashlib
 import socket
 import base64
-import yaml
 import zipfile
 import tempfile
 import json
@@ -66,8 +89,8 @@ from urllib.parse import urlparse, urlsplit, urlunparse
 from zipfile import ZipFile
 
 import fdroidserver.metadata
-import fdroidserver.lint
 from fdroidserver import _
+from fdroidserver._yaml import yaml, config_dump
 from fdroidserver.exception import FDroidException, VCSException, NoSubmodulesException, \
     BuildException, VerificationException, MetaDataException
 from .asynchronousfilereader import AsynchronousFileReader
@@ -126,6 +149,7 @@ CONFIG_NAMES = (
     RELEASECHANNELS_CONFIG_NAME,
 )
 
+CONFIG_FILE = 'config.yml'
 
 config = None
 options = None
@@ -186,7 +210,6 @@ default_config = {
     'archive_name': 'My First F-Droid Archive Demo',
     'archive_description': _('These are the apps that have been archived from the main repo.'),  # type: ignore
     'archive_older': 0,
-    'lint_licenses': fdroidserver.lint.APPROVED_LICENSES,  # type: ignore
     'git_mirror_size_limit': 10000000000,
     'scanner_signature_sources': ['suss'],
 }
@@ -361,7 +384,7 @@ def fill_config_defaults(thisconfig):
 
     # Expand paths (~users and $vars)
     def expand_path(path):
-        if path is None:
+        if not path or not isinstance(path, str):
             return None
         orig = path
         path = os.path.expanduser(path)
@@ -525,14 +548,13 @@ def config_type_check(path, data):
 def read_config():
     """Read the repository config.
 
-    The config is read from config_file, which is in the current
+    The config is read from config.yml, which is in the current
     directory when any of the repo management commands are used. If
     there is a local metadata file in the git repo, then the config is
     not required, just use defaults.
 
     config.yml is the preferred form because no code is executed when
-    reading it.  config.py is deprecated and supported for backwards
-    compatibility.
+    reading it.  config.py is deprecated and no longer supported.
 
     config.yml requires ASCII or UTF-8 encoding because this code does
     not auto-detect the file's encoding.  That is left up to the YAML
@@ -547,33 +569,22 @@ def read_config():
         return config
 
     config = {}
-    config_file = 'config.yml'
-    old_config_file = 'config.py'
-
-    if os.path.exists(config_file) and os.path.exists(old_config_file):
-        logging.error(_("""Conflicting config files! Using {newfile}, ignoring {oldfile}!""")
-                      .format(oldfile=old_config_file, newfile=config_file))
 
-    if os.path.exists(config_file):
-        logging.debug(_("Reading '{config_file}'").format(config_file=config_file))
-        with open(config_file, encoding='utf-8') as fp:
-            config = yaml.safe_load(fp)
+    if os.path.exists(CONFIG_FILE):
+        logging.debug(_("Reading '{config_file}'").format(config_file=CONFIG_FILE))
+        with open(CONFIG_FILE, encoding='utf-8') as fp:
+            config = yaml.load(fp)
         if not config:
             config = {}
-        config_type_check(config_file, config)
-    elif os.path.exists(old_config_file):
-        logging.warning(_("""{oldfile} is deprecated, use {newfile}""")
-                        .format(oldfile=old_config_file, newfile=config_file))
-        with io.open(old_config_file, "rb") as fp:
-            code = compile(fp.read(), old_config_file, 'exec')
-            exec(code, None, config)  # nosec TODO automatically migrate
-
-        for k in ('mirrors', 'install_list', 'uninstall_list', 'serverwebroot', 'servergitroot'):
-            if k in config:
-                if not type(config[k]) in (str, list, tuple):
-                    logging.warning(
-                        _("'{field}' will be in random order! Use () or [] brackets if order is important!")
-                        .format(field=k))
+        config_type_check(CONFIG_FILE, config)
+
+    old_config_file = 'config.py'
+    if os.path.exists(old_config_file):
+        logging.warning(
+            _("""Ignoring deprecated {oldfile}, use {newfile}!""").format(
+                oldfile=old_config_file, newfile=CONFIG_FILE
+            )
+        )
 
     # smartcardoptions must be a list since its command line args for Popen
     smartcardoptions = config.get('smartcardoptions')
@@ -587,25 +598,18 @@ def read_config():
                                       'sun.security.pkcs11.SunPKCS11',
                                       '-providerArg', 'opensc-fdroid.cfg']
 
-    if any(k in config for k in ["keystore", "keystorepass", "keypass"]):
-        if os.path.exists(config_file):
-            f = config_file
-        elif os.path.exists(old_config_file):
-            f = old_config_file
-        st = os.stat(f)
-        if st.st_mode & stat.S_IRWXG or st.st_mode & stat.S_IRWXO:
-            logging.warning(_("unsafe permissions on '{config_file}' (should be 0600)!")
-                            .format(config_file=f))
-
     fill_config_defaults(config)
 
     if 'serverwebroot' in config:
-        roots = parse_mirrors_config(config['serverwebroot'])
+        roots = parse_list_of_dicts(config['serverwebroot'])
         rootlist = []
         for d in roots:
             # since this is used with rsync, where trailing slashes have
             # meaning, ensure there is always a trailing slash
-            rootstr = d['url']
+            rootstr = d.get('url')
+            if not rootstr:
+                logging.error('serverwebroot: has blank value!')
+                continue
             if rootstr[-1] != '/':
                 rootstr += '/'
             d['url'] = rootstr.replace('//', '/')
@@ -613,7 +617,7 @@ def read_config():
         config['serverwebroot'] = rootlist
 
     if 'servergitmirrors' in config:
-        config['servergitmirrors'] = parse_mirrors_config(config['servergitmirrors'])
+        config['servergitmirrors'] = parse_list_of_dicts(config['servergitmirrors'])
 
         limit = config['git_mirror_size_limit']
         config['git_mirror_size_limit'] = parse_human_readable_size(limit)
@@ -653,19 +657,63 @@ def read_config():
     for configname in confignames_to_delete:
         del config[configname]
 
+    if any(
+        k in config and config.get(k)
+        for k in ["awssecretkey", "keystorepass", "keypass"]
+    ):
+        st = os.stat(CONFIG_FILE)
+        if st.st_mode & stat.S_IRWXG or st.st_mode & stat.S_IRWXO:
+            logging.warning(
+                _("unsafe permissions on '{config_file}' (should be 0600)!").format(
+                    config_file=CONFIG_FILE
+                )
+            )
+
     return config
 
 
-def parse_mirrors_config(mirrors):
-    """Mirrors can be specified as a string, list of strings, or dictionary map."""
-    if isinstance(mirrors, str):
-        return [{"url": mirrors}]
-    elif all(isinstance(item, str) for item in mirrors):
-        return [{'url': i} for i in mirrors]
-    elif all(isinstance(item, dict) for item in mirrors):
-        return mirrors
-    else:
-        raise TypeError(_('only accepts strings, lists, and tuples'))
+def expand_env_dict(s):
+    """Expand env var dict to a string value.
+
+    {env: varName} syntax can be used to replace any string value in the
+    config with the value of an environment variable "varName".  This
+    allows for secrets management when commiting the config file to a
+    public git repo.
+
+    """
+    if not s or type(s) not in (str, dict):
+        return
+    if isinstance(s, dict):
+        if 'env' not in s or len(s) > 1:
+            raise TypeError(_('Only accepts a single key "env"'))
+        var = s['env']
+        s = os.getenv(var)
+        if not s:
+            logging.error(
+                _('Environment variable {{env: {var}}} is not set!').format(var=var)
+            )
+            return
+    return os.path.expanduser(s)
+
+
+def parse_list_of_dicts(l_of_d):
+    """Parse config data structure that is a list of dicts of strings.
+
+    The value can be specified as a string, list of strings, or list of dictionary maps
+    where the values are strings.
+
+    """
+    if isinstance(l_of_d, str):
+        return [{"url": expand_env_dict(l_of_d)}]
+    if isinstance(l_of_d, dict):
+        return [{"url": expand_env_dict(l_of_d)}]
+    if all(isinstance(item, str) for item in l_of_d):
+        return [{'url': expand_env_dict(i)} for i in l_of_d]
+    if all(isinstance(item, dict) for item in l_of_d):
+        for item in l_of_d:
+            item['url'] = expand_env_dict(item['url'])
+        return l_of_d
+    raise TypeError(_('only accepts strings, lists, and tuples'))
 
 
 def get_mirrors(url, filename=None):
@@ -677,7 +725,7 @@ def get_mirrors(url, filename=None):
     if url.netloc == 'f-droid.org':
         mirrors = FDROIDORG_MIRRORS
     else:
-        mirrors = parse_mirrors_config(url.geturl())
+        mirrors = parse_list_of_dicts(url.geturl())
 
     if filename:
         return append_filename_to_mirrors(filename, mirrors)
@@ -720,7 +768,7 @@ def load_localized_config(name, repodir):
         if len(f.parts) == 2:
             locale = DEFAULT_LOCALE
         with open(f, encoding="utf-8") as fp:
-            elem = yaml.safe_load(fp)
+            elem = yaml.load(fp)
             if not isinstance(elem, dict):
                 msg = _('{path} is not "key: value" dict, but a {datatype}!')
                 raise TypeError(msg.format(path=f, datatype=type(elem).__name__))
@@ -1126,13 +1174,23 @@ def apk_parse_release_filename(apkname):
     return None, None, None
 
 
+def get_output_extension(build):
+    if build.output:
+        return get_file_extension(replace_build_vars(build.output, build))
+    return 'apk'
+
+
+def get_release_apk_filename(appid, versionCode):
+    return f"{appid}_{versionCode}.apk"
+
+
 def get_release_filename(app, build, extension=None):
     if extension:
         return "%s_%s.%s" % (app.id, build.versionCode, extension)
     if build.output and get_file_extension(build.output):
         return "%s_%s.%s" % (app.id, build.versionCode, get_file_extension(build.output))
     else:
-        return "%s_%s.apk" % (app.id, build.versionCode)
+        return get_release_apk_filename(app.id, build.versionCode)
 
 
 def get_toolsversion_logname(app, build):
@@ -4192,8 +4250,16 @@ def load_stats_fdroid_signing_key_fingerprints():
         return json.loads(str(f.read('publishsigkeys.json'), 'utf-8'))
 
 
-def write_to_config(thisconfig, key, value=None, config_file=None):
-    """Write a key/value to the local config.yml or config.py.
+def write_config_file(config):
+    """Write the provided string to config.yml with the right path and encoding."""
+    Path(CONFIG_FILE).write_text(config, encoding='utf-8')
+
+
+def write_to_config(thisconfig, key, value=None):
+    """Write a key/value to the local config.yml.
+
+    The config.yml is defined as YAML 1.2 in UTF-8 encoding on all
+    platforms.
 
     NOTE: only supports writing string variables.
 
@@ -4206,61 +4272,42 @@ def write_to_config(thisconfig, key, value=None, config_file=None):
     value
         optional value to be written, instead of fetched
         from 'thisconfig' dictionary.
+
     """
     if value is None:
         origkey = key + '_orig'
         value = thisconfig[origkey] if origkey in thisconfig else thisconfig[key]
-    if config_file:
-        cfg = config_file
-    elif os.path.exists('config.py') and not os.path.exists('config.yml'):
-        cfg = 'config.py'
-    else:
-        cfg = 'config.yml'
 
     # load config file, create one if it doesn't exist
-    if not os.path.exists(cfg):
-        open(cfg, 'a').close()
-        logging.info("Creating empty " + cfg)
-    with open(cfg, 'r') as f:
-        lines = f.readlines()
+    if not os.path.exists(CONFIG_FILE):
+        write_config_file('')
+        logging.info(_("Creating empty {config_file}").format(config_file=CONFIG_FILE))
+    with open(CONFIG_FILE) as fp:
+        lines = fp.readlines()
 
     # make sure the file ends with a carraige return
     if len(lines) > 0:
         if not lines[-1].endswith('\n'):
             lines[-1] += '\n'
 
-    # regex for finding and replacing python string variable
-    # definitions/initializations
-    if cfg.endswith('.py'):
-        pattern = re.compile(r'^[\s#]*' + key + r'\s*=\s*"[^"]*"')
-        repl = key + ' = "' + value + '"'
-        pattern2 = re.compile(r'^[\s#]*' + key + r"\s*=\s*'[^']*'")
-        repl2 = key + " = '" + value + "'"
-    else:
-        # assume .yml as default
-        pattern = re.compile(r'^[\s#]*' + key + r':.*')
-        repl = yaml.dump({key: value}, default_flow_style=False)
-        pattern2 = pattern
-        repl2 = repl
+    pattern = re.compile(r'^[\s#]*' + key + r':.*\n')
+    repl = config_dump({key: value})
 
     # If we replaced this line once, we make sure won't be a
     # second instance of this line for this key in the document.
     didRepl = False
     # edit config file
-    with open(cfg, 'w') as f:
+    with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
         for line in lines:
-            if pattern.match(line) or pattern2.match(line):
+            if pattern.match(line):
                 if not didRepl:
                     line = pattern.sub(repl, line)
-                    line = pattern2.sub(repl2, line)
                     f.write(line)
                     didRepl = True
             else:
                 f.write(line)
         if not didRepl:
-            f.write('\n')
             f.write(repl)
-            f.write('\n')
 
 
 def parse_xml(path):