Merge lp:~vds/charms/precise/mongodb/mongodb_persistent_volume_support into lp:charms/mongodb

[Vincenzo Di Somma]

Shamelessly copy the permanent volume support from the postgresql charm.
In order to test it, deploy the charm, attach a permanent volume to the unit VM, change the configuration like in the following line, but using the correct value for volume-dev-regexp and the right volid in volume-map.

juju set mongodb volume-dev-regexp="/dev/vdc" volume-map='{"mongodb/0": "volid-000000000"}' volume-ephemeral-storage=false

[Juan L. Negron (negronjl)]

Approved. Nice work

review: Approve

=== modified file 'README.md'
--- README.md	2013-02-14 16:21:46 +0000
+++ README.md	2013-09-20 14:13:30 +0000
@@ -327,6 +327,11 @@
 - run sh.status()
 You should see your the hosts for your shards in the status output.
 
+To deploy mongodb using permanent volume on Openstack, the permanent volume should be attached to the mongodb unit just after the deployment, then the configuration should be updated like follows.
+
+### Use a permanent Openstack volume to store mongodb data.
+    juju set mongodb volume-dev-regexp="/dev/vdc" volume-map='{"mongodb/0": "vol-id-00000000000000"}' volume-ephemeral-storage=false
+
 ## Backups
 
 Backups can be enabled via config. Note that destroying the service cannot
 
=== modified file 'config.yaml'
--- config.yaml	2013-02-14 16:21:46 +0000
+++ config.yaml	2013-09-20 14:13:30 +0000
@@ -155,3 +155,32 @@
     default: 7
     type: int
     description: Number of backups to keep. Keeps one week's worth by default.
+  #------------------------------------------------------------------------
+  # Volume management
+  #   volume-map, volume-dev_regexp are only used 
+  #   if volume-ephemeral-storage == False
+  #------------------------------------------------------------------------
+  volume-ephemeral-storage:
+    type: boolean
+    default: true
+    description: >
+      If false, a configure-error state will be raised if
+         volume-map[$JUJU_UNIT_NAME] is not set (see "volume-map"
+         below) - see "volume-map" below.
+      If true, service units won't try to use "volume-map" (and
+         related variables) to mount and use external (EBS) volumes,
+         thus storage lifetime will equal VM, thus ephemeral.
+         YOU'VE BEEN WARNED.
+  volume-map:
+    type: string
+    default: ""
+    description: >
+      YAML map as e.g. "{ mongodb/0: vol-0000010, mongodb/1: vol-0000016 }".
+      Service units will raise a "configure-error" condition if no volume-map
+      value is set for it - it's expected a human to set it properly to resolve it.
+  volume-dev-regexp:
+    type: string
+    default: "/dev/vd[b-z]"
+    description: >
+      Block device for attached volumes as seen by the VM, will be "scanned"
+      for an unused device when "volume-map" is valid for the unit.
 
=== modified file 'hooks/hooks.py'
--- hooks/hooks.py	2013-02-14 16:30:30 +0000
+++ hooks/hooks.py	2013-09-20 14:13:30 +0000
@@ -5,19 +5,22 @@
 @author: negronjl
 '''
 
+import commands
+import json
 import os
-import sys
-import json
-import subprocess
 import re
 import signal
 import socket
+import subprocess
+import sys
 import time
+import yaml
 
 from os import chmod
 from os import remove
 from os.path import exists
 from string import Template
+from yaml.constructor import ConstructorError
 
 ###############################################################################
 # Supporting functions
@@ -898,6 +901,34 @@
     print "config_data: ", config_data
     mongodb_config = open(default_mongodb_config).read()
 
+    # Trigger volume initialization logic for permanent storage
+    volid = volume_get_volume_id()
+    if not volid:
+        ## Invalid configuration (whether ephemeral, or permanent)
+        stop_hook()
+        mounts = volume_get_all_mounted()
+        if mounts:
+            juju_log("current mounted volumes: {}".format(mounts))
+        juju_log(
+            "Disabled and stopped mongodb service, "
+            "because of broken volume configuration - check "
+            "'volume-ephemeral-storage' and 'volume-map'")
+        sys.exit(1)
+    if volume_is_permanent(volid):
+        ## config_changed_volume_apply will stop the service if it founds
+        ## it necessary, ie: new volume setup
+        if config_changed_volume_apply():
+            start_hook()
+        else:
+            stop_hook()
+            mounts = volume_get_all_mounted()
+            if mounts:
+                juju_log("current mounted volumes: {}".format(mounts))
+            juju_log(
+                "Disabled and stopped mongodb service "
+                "(config_changed_volume_apply failure)")
+            sys.exit(1)
+
     # current ports
     current_mongodb_port = re.search('^#*port\s+=\s+(\w+)',
         mongodb_config,
@@ -1007,6 +1038,7 @@
     try:
         retVal = service('mongodb', 'stop')
         os.remove('/var/lib/mongodb/mongod.lock')
+        #FIXME Need to check if this is still needed
     except Exception, e:
         juju_log(str(e))
         retVal = False
@@ -1194,6 +1226,202 @@
 #    return(update_file(default_mongos_list, '\n'.join(config_servers)))
     return(True)
 
+
+def run(command, exit_on_error=True):
+    '''Run a command and return the output.'''
+    try:
+        juju_log(command)
+        return subprocess.check_output(
+            command, stderr=subprocess.STDOUT, shell=True)
+    except subprocess.CalledProcessError, e:
+        juju_log("status=%d, output=%s" % (e.returncode, e.output))
+        if exit_on_error:
+            sys.exit(e.returncode)
+        else:
+            raise
+
+
+###############################################################################
+# Volume managment
+###############################################################################
+#------------------------------
+# Get volume-id from juju config "volume-map" dictionary as
+#     volume-map[JUJU_UNIT_NAME]
+# @return  volid
+#
+#------------------------------
+def volume_get_volid_from_volume_map():
+    config_data = config_get()
+    volume_map = {}
+    try:
+        volume_map = yaml.load(config_data['volume-map'].strip())
+        if volume_map:
+            juju_unit_name = os.environ['JUJU_UNIT_NAME']
+            volid = volume_map.get(juju_unit_name)
+            juju_log("Juju unit name: %s Volid:%s" % (juju_unit_name, volid))
+            return volid
+    except ConstructorError as e:
+        juju_log("invalid YAML in 'volume-map': {}".format(e))
+    return None
+
+
+# Is this volume_id permanent ?
+# @returns  True if volid set and not --ephemeral, else:
+#           False
+def volume_is_permanent(volid):
+    if volid and volid != "--ephemeral":
+        return True
+    return False
+
+
+#------------------------------
+# Returns a mount point from passed vol-id, e.g. /srv/juju/vol-000012345
+#
+# @param  volid          volume id (as e.g. EBS volid)
+# @return mntpoint_path  eg /srv/juju/vol-000012345
+#------------------------------
+def volume_mount_point_from_volid(volid):
+    if volid and volume_is_permanent(volid):
+        return "/srv/juju/%s" % volid
+    return None
+
+
+# Do we have a valid storage state?
+# @returns  volid
+#           None    config state is invalid - we should not serve
+def volume_get_volume_id():
+    config_data = config_get()
+    ephemeral_storage = config_data['volume-ephemeral-storage']
+    volid = volume_get_volid_from_volume_map()
+    juju_unit_name = os.environ['JUJU_UNIT_NAME']
+    if ephemeral_storage in [True, 'yes', 'Yes', 'true', 'True']:
+        if volid:
+            juju_log(
+                "volume-ephemeral-storage is True, but " +
+                "volume-map[{!r}] -> {}".format(juju_unit_name, volid))
+            return None
+        else:
+            return "--ephemeral"
+    else:
+        if not volid:
+            juju_log(
+                "volume-ephemeral-storage is False, but "
+                "no volid found for volume-map[{!r}]".format(
+                    juju_unit_name))
+            return None
+        juju_log("Volid:%s" % (volid))
+    return volid
+
+
+# Initialize and/or mount permanent storage, it straightly calls
+# shell helper
+def volume_init_and_mount(volid):
+    juju_log("Initialize and mount volume")
+    command = ("scripts/volume-common.sh call " +
+               "volume_init_and_mount %s" % volid)
+    run(command)
+    return True
+
+
+def volume_get_all_mounted():
+    command = ("mount |egrep /srv/juju")
+    status, output = commands.getstatusoutput(command)
+    if status != 0:
+        return None
+    return output
+
+#------------------------------------------------------------------------------
+# Core logic for permanent storage changes:
+# NOTE the only 2 "True" return points:
+#   1) symlink already pointing to existing storage (no-op)
+#   2) new storage properly initialized:
+#     - volume: initialized if not already (fdisk, mkfs),
+#       mounts it to e.g.:  /srv/juju/vol-000012345
+#     - if fresh new storage dir: rsync existing data
+#     - manipulate /var/lib/mongodb/VERSION/CLUSTER symlink
+#------------------------------------------------------------------------------
+def config_changed_volume_apply():
+    config_data = config_get()
+    data_directory_path = config_data["dbpath"]
+    assert(data_directory_path)
+    volid = volume_get_volume_id()
+    if volid:
+        if volume_is_permanent(volid):
+            if not volume_init_and_mount(volid):
+                juju_log(
+                    "volume_init_and_mount failed, not applying changes")
+                return False
+
+        if not os.path.exists(data_directory_path):
+            juju_log(
+                "mongodb data dir {} not found, "
+                "not applying changes.".format(data_directory_path))
+            return False
+
+        mount_point = volume_mount_point_from_volid(volid)
+        new_mongo_dir = os.path.join(mount_point, "mongodb")
+        if not mount_point:
+            juju_log(
+                "invalid mount point from volid = {}, "
+                "not applying changes.".format(mount_point))
+            return False
+
+        if os.path.islink(data_directory_path):
+            juju_log(
+                "mongodb data dir '%s' already points "
+                "to %s, skipping storage changes." % (data_directory_path, new_mongo_dir))
+            juju_log(
+                "existing-symlink: to fix/avoid UID changes from "
+                "previous units, doing: "
+                "chown -R mongodb:mongodb {}".format(new_mongo_dir))
+            run("chown -R mongodb:mongodb %s" % new_mongo_dir)
+            return True
+
+        # Create a directory structure below "new" mount_point
+        curr_dir_stat = os.stat(data_directory_path)
+        if not os.path.isdir(new_mongo_dir):
+            juju_log("mkdir %s" % new_mongo_dir)
+            os.mkdir(new_mongo_dir)
+            # copy permissions from current data_directory_path
+            os.chown(new_mongo_dir, curr_dir_stat.st_uid, curr_dir_stat.st_gid)
+            os.chmod(new_mongo_dir, curr_dir_stat.st_mode)
+        # Carefully build this symlink, e.g.:
+        # /var/lib/mongodb ->
+        # /srv/juju/vol-000012345/mongodb
+        # but keep previous "main/"  directory, by renaming it to
+        # main-$TIMESTAMP
+        if not stop_hook():
+            juju_log("stop_hook() failed - can't migrate data.")
+            return False
+        if not os.path.exists(new_mongo_dir):
+            juju_log("migrating mongo data {}/ -> {}/".format(
+                data_directory_path, new_mongo_dir))
+            # void copying PID file to perm storage (shouldn't be any...)
+            command = "rsync -a {}/ {}/".format(
+                data_directory_path, new_mongo_dir)
+            juju_log("run: {}".format(command))
+            run(command)
+        try:
+            os.rename(data_directory_path, "{}-{}".format(
+                data_directory_path, int(time.time())))
+            juju_log("NOTICE: symlinking {} -> {}".format(
+                new_mongo_dir, data_directory_path))
+            os.symlink(new_mongo_dir, data_directory_path)
+            juju_log(
+                "after-symlink: to fix/avoid UID changes from "
+                "previous units, doing: "
+                "chown -R mongodb:mongodb {}".format(new_mongo_dir))
+            run("chown -R mongodb:mongodb {}".format(new_mongo_dir))
+            return True
+        except OSError:
+            juju_log("failed to symlink {} -> {}".format(
+                data_directory_path, mount_point))
+            return False
+    else:
+        juju_log(
+            "Invalid volume storage configuration, not applying changes")
+    return False
+
 ###############################################################################
 # Main section
 ###############################################################################
 
=== added directory 'scripts'
=== added file 'scripts/volume-common.sh'
--- scripts/volume-common.sh	1970-01-01 00:00:00 +0000
+++ scripts/volume-common.sh	2013-09-20 14:13:30 +0000
@@ -0,0 +1,220 @@
+#!/bin/bash
+# Author: JuanJo Ciarlante <[e-mail]>
+# Copyright: Canonical Ltd. 2012
+# License: GPLv2
+#
+# juju storage common shell library
+# 
+
+#------------------------------
+# Returns a mount point from passed vol-id, e.g. /srv/juju/vol-000012345
+#
+# @param  $1             volume id
+# @echoes mntpoint-path  eg /srv/juju/vol-000012345
+#------------------------------
+_mntpoint_from_volid() {
+  local volid=${1?missing volid}
+  [[ ${volid} != "" ]] && echo /srv/juju/${volid} || echo ""
+}
+
+
+#------------------------------
+# Assert that passed mount points hold different filesystems
+#
+# @param  $1     mntpoint1
+# @param  $2     mntpoint2
+# @return  0     different FS
+#          1     same FS
+#------------------------------
+_assert_diff_fs() {
+  local mnt1="${1:?missing mntpoint1}"
+  local mnt2="${2:?missing mntpoint2}"
+  local fsid1 fsid2
+  fsid1=$(stat --file-system -c '%i' "${mnt1}" 2>/dev/null)
+  fsid2=$(stat --file-system -c '%i' "${mnt2}" 2>/dev/null)
+  [[ ${fsid1} != ${fsid2} ]]
+  return $?
+}
+
+#------------------------------
+# Initialize volume (sfdisk, mkfs.ext4) IFF NOT already, mount it at
+# /srv/juju/<volume-id>
+#
+# @param  $1 volume-id, can be any arbitrary string, better if
+#            equal to EC2/OS vol-id name (just for consistency)
+# @return  0 success
+#          1 nil volid/etc
+#          2 error while handling the device (non-block device, sfdisk error, etc)
+#------------------------------
+volume_init_and_mount() {
+  ## Find 1st unused device (reverse sort /dev/vdX)
+  local volid=${1:?missing volid}
+  local dev_regexp
+  local dev found_dev=
+  local label="${volid}"
+  local func=${FUNCNAME[0]}
+  dev_regexp=$(config-get volume-dev-regexp) || return 1
+  mntpoint=$(_mntpoint_from_volid ${volid})
+
+  [[ -z ${mntpoint} ]] && return 1
+  if mount | egrep -qw "${mntpoint}";then
+    _assert_diff_fs "/" "${mntpoint}" || {
+       juju-log "ERROR: returning from ${func} with '${mntpoint}' still at '/' filesystem"
+       return 1
+    }
+    juju-log "NOTICE: mntpoint=${mntpoint} already mounted, skipping volume_init_and_mount"
+    return 0
+  fi
+
+  # Sanitize
+  case "${dev_regexp?}" in
+    # Careful: this is glob matching against an regexp -
+    # quite narrowed
+    /dev/*|/dev/disk/by-*)
+      ;; ## Ok
+    *)
+      juju-log "ERROR: invalid 'volume-dev-regexp' specified"
+      return 1
+      ;;
+  esac
+
+  # Assume udev will create only existing devices
+  for dev in $(ls -rd1 /dev/* | egrep "${dev_regexp}" | egrep -v "[1-9]$" 2>/dev/null);do
+    ## Check it's not already mounted
+    mount | egrep -q "${dev}[1-9]?" || { found_dev=${dev}; break;}
+  done
+  [[ -n "${found_dev}" ]] || {
+    juju-log "ERROR: ${func}: coult not find an unused device for regexp: ${dev_regexp}"
+    return 1
+  }
+  partition1_dev=${found_dev}1
+
+  juju-log "INFO: ${func}: found_dev=${found_dev}"
+  [[ -b ${found_dev?}  ]] || {
+    juju-log "ERROR: ${func}: ${found_dev} is not a blockdevice"
+    return 2
+  }
+
+  # Run next set of "dangerous" commands as 'set -e', in a subshell
+  (
+  set -e
+  # Re-read partition - will fail if already in use
+  blockdev --rereadpt ${found_dev}
+
+  # IFF not present, create partition with full disk
+  if [[ -b ${partition1_dev?} ]];then
+    juju-log "INFO: ${func}: ${partition1_dev} already present - skipping sfdisk."
+  else
+    juju-log "NOTICE: ${func}: ${partition1_dev} not present at ${found_dev}, running: sfdisk ${found_dev} ..."
+    # Format partition1_dev as max sized
+    echo ",+," | sfdisk ${found_dev}
+  fi
+
+  # Create an ext4 filesystem if NOT already present
+  # use e.g. LABEl=vol-000012345
+  if file -s ${partition1_dev} | egrep -q ext4 ; then
+    juju-log "INFO: ${func}: ${partition1_dev} already formatted as ext4 - skipping mkfs.ext4."
+    ## Check e2label - log if it has changed (e.g. already used / initialized with a diff label)
+    local curr_label=$(e2label "${partition1_dev}")
+    if [[ ${curr_label} != ${label} ]]; then
+      juju-log "WARNING: ${func}: ${partition1_dev} had label=${curr_label}, overwritting with label=${label}"
+      e2label ${partition1_dev} "${label}"
+    fi
+  else
+    juju-log "NOTICE: ${func}: running: mkfs.ext4 -L ${label} ${partition1_dev}"
+    mkfs.ext4 -L "${label}" ${partition1_dev}
+  fi
+
+  # Mount it at e.g. /srv/juju/vol-000012345
+  [[ -d "${mntpoint}" ]] || mkdir -p "${mntpoint}"
+  mount | fgrep -wq "${partition1_dev}" || {
+    local files_below_mntpoint="$(ls -d "${mntpoint}"/* 2>/dev/null |wc -l )" 
+    if [[ ${files_below_mntpoint} -ne 0 ]]; then
+      juju-log "ERROR: *not* doing 'mount "${partition1_dev}" "${mntpoint}"' because there are already ${files_below_mntpoint} files/dirs beneath '${mntpoint}'"
+      exit 1
+    fi
+    ## should always fsck before mounting (e.g. fsck after max time (-i) / max mounts (-c) )
+    fsck "${partition1_dev}"
+    mount "${partition1_dev}" "${mntpoint}"
+    juju-log "INFO: ${func}: mounted as: '$(mount | fgrep -w ${partition1_dev})'"
+  }
+
+  # Add it to fstab is not already there
+  fgrep -wq "LABEL=${label}" /etc/fstab || {
+    echo "LABEL=${label}    ${mntpoint}    ext4    defaults,nobootwait,comment=${volid}" | tee -a /etc/fstab
+    juju-log "INFO: ${func}: LABEL=${label} added to /etc/fstab"
+  }
+  )
+  # Final assertion: mounted filesystem id is different from '/' (effectively mounted)
+  _assert_diff_fs "/" "${mntpoint}" || {
+     juju-log "ERROR: returning from ${func} with '${mntpoint}' still at '/' filesystem (couldn't mount new volume)"
+     ## try to rmdir mntpoint directory - should not be 'mistakenly' used
+     rmdir ${mntpoint}
+     return 1
+  }
+  return $?
+}
+
+#------------------------------
+# Get volume-id from juju config "volume-map" dictionary as
+#     volume-map[JUJU_UNIT_NAME]
+# @return  0 if volume-map value found ( does echo volid or ""), else:
+#          1 if not found or None
+#
+#------------------------------
+volume_get_volid_from_volume_map() {
+  local volid=$(config-get "volume-map"|python -c$'import sys;import os;from yaml import load;from itertools import chain; volume_map = load(sys.stdin)\nif volume_map: print volume_map.get(os.environ["JUJU_UNIT_NAME"])')
+  [[ $volid == None ]] && return 1
+  echo "$volid"
+}
+
+# Returns true if permanent storage (considers --ephemeral)
+# @returns  0 if volid set and not --ephemeral, else:
+#           1 
+volume_is_permanent() {
+  local volid=${1:?missing volid}
+  [[ -n ${volid} && ${volid} != --ephemeral ]] && return 0 || return 1
+}
+volume_mount_point_from_volid(){
+  local volid=${1:?missing volid}
+  if volume_is_permanent;then
+	  echo "/srv/juju/${volid}"
+    return 0
+  else
+    return 1
+  fi
+}
+# Do we have a valid storage state?
+# @returns  0 does echo $volid (can be "--ephemeral")
+#           1 config state is invalid - we should not serve
+volume_get_volume_id() {
+  local ephemeral_storage
+  local volid
+  ephemeral_storage=$(config-get volume-ephemeral-storage) || return 1
+  volid=$(volume_get_volid_from_volume_map) || return 1
+  if [[ $ephemeral_storage == True ]];then
+    # Ephemeral -> should not have a valid volid
+    if [[ $volid != "" ]];then
+        juju-log "ERROR: volume-ephemeral-storage is True, but $JUJU_UNIT_NAME maps to volid=${volid}"
+        return 1
+    fi
+  else
+    # Durable (not ephemeral) -> must have a valid volid for this unit
+     if [[ $volid == "" ]];then
+        juju-log "ERROR: volume-ephemeral-storage is False, but no volid found for: $JUJU_UNIT_NAME"
+        return 1
+     fi
+  fi
+  echo "$volid"
+  return 0
+}
+
+case "$1" in
+  ## allow non SHELL scripts to call helper functions
+  call)
+    : ${JUJU_UNIT_NAME?} ## Must be called in juju environment
+    shift;
+    function="${1:?usage: ${0##*/} call function arg1 arg2 ...}"
+    shift;
+    ${function} "$@" && exit 0 || exit 1
+esac