ceph启动脚本

放在/etc/init.d/目录下，用法如下：

 root@u253:~# /etc/init.d/ceph
 === mon.a ===
 usage: /etc/init.d/ceph [options] {start|stop|restart} [mon|osd|mds]...
     -c ceph.conf
     --valgrind    run via valgrind
     --hostname [hostname]    override hostname lookup

源码如下:

 文件名：ceph
 #!/bin/sh
 # Start/stop ceph daemons
 # chkconfig:   

 ### BEGIN INIT INFO
 # Provides:          ceph
 # Default-Start:
 # Default-Stop:
 # Required-Start:    $remote_fs $named $network $time
 # Required-Stop:     $remote_fs $named $network $time
 # Short-Description: Start Ceph distributed file system daemons at boot time
 # Description:       Enable Ceph distributed file system services.
 ### END INIT INFO

 # if we start up as ./mkcephfs, assume everything else is in the
 # current directory too.
 if [ `dirname $` = "." ] && [ $PWD != "/etc/init.d" ]; then
     BINDIR=.
     LIBDIR=.
     ETCDIR=.
 else
     BINDIR=/usr/bin
     LIBDIR=/usr/lib/ceph
     ETCDIR=/etc/ceph
 fi

 usage_exit() {
     echo "usage: $0 [options] {start|stop|restart} [mon|osd|mds]..."
     printf "\t-c ceph.conf\n"
     printf "\t--valgrind\trun via valgrind\n"
     printf "\t--hostname [hostname]\toverride hostname lookup\n"
     exit
 }

 . $LIBDIR/ceph_common.sh

 EXIT_STATUS=

 signal_daemon() {
     name=$
     daemon=$
     pidfile=$
     signal=$
     action=$
     [ -z "$action" ] && action="Stopping"
     echo -n "$action Ceph $name on $host..."
     do_cmd "if [ -e $pidfile ]; then
         pid=`cat $pidfile`
         if [ -e /proc/\$pid ] && grep -q $daemon /proc/\$pid/cmdline ; then
         cmd=\"kill $signal \$pid\"
         echo -n \$cmd...
         \$cmd
         fi
     fi"
     echo done
 }

 daemon_is_running() {
     name=$
     daemon=$
     daemon_id=$
     pidfile=$
     do_cmd "[ -e $pidfile ] || exit 1   # no pid, presumably not running
     pid=\`cat $pidfile\`
     [ -e /proc/\$pid ] && grep -q $daemon /proc/\$pid/cmdline && grep -qwe -i.$daemon_id /proc/\$pid/cmdline && exit  # running
         exit   # pid is something else" "" "okfail"
 }

 stop_daemon() {
     name=$
     daemon=$
     pidfile=$
     signal=$
     action=$
     [ -z "$action" ] && action="Stopping"
     echo -n "$action Ceph $name on $host..."
     do_cmd "while [ 1 ]; do
     [ -e $pidfile ] || break
     pid=\`cat $pidfile\`
     while [ -e /proc/\$pid ] && grep -q $daemon /proc/\$pid/cmdline ; do
         cmd=\"kill $signal \$pid\"
         echo -n \$cmd...
         \$cmd
         sleep
         continue
     done
     break
     done"
     echo done
 }

 ## command line options
 options=

 version=
 dovalgrind=
 docrun=
 allhosts=
 debug=
 monaddr=
 dobtrfs=
 dobtrfsumount=
 verbose=

 while echo $ | grep -q '^-'; do     # FIXME: why not '^-'?
 case $ in
     -v | --verbose)
         verbose=
         ;;
     --valgrind)
         dovalgrind=
         ;;
     --novalgrind)
         dovalgrind=
         ;;
     --allhosts | -a)
         allhosts=;
         ;;
     --restart)
         docrun=
         ;;
     --norestart)
         docrun=
         ;;
     -m )
         [ -z "$2" ] && usage_exit
         options="$options $1"
         shift
         MON_ADDR=$
         ;;
     --btrfs)
         dobtrfs=
         ;;
     --nobtrfs)
         dobtrfs=
         ;;
     --btrfsumount)
         dobtrfsumount=
         ;;
     --conf | -c)
         [ -z "$2" ] && usage_exit
         options="$options $1"
         shift
         conf=$
         ;;
     --hostname )
         [ -z "$2" ] && usage_exit
         options="$options $1"
         shift
         hostname=$
             ;;
     *)
         echo unrecognized option \'$1\'
         usage_exit
         ;;
 esac
 options="$options $1"
 shift
 done

 verify_conf

 command=$
 [ -n "$*" ] && shift

 get_name_list "$@"

 for name in $what; do
     type=`echo $name | cut -c -`   # e.g. 'mon', if $item is 'mon1'
     id=`echo $name | cut -c - | sed 's/^\\.//'`
     num=$id
     name="$type.$id"

     get_conf auto_start "" "auto start"
     if [ -z "$@" ] || [ "$@" = "mds" ]; then
     if [ "$auto_start" = "no" ] || [ "$auto_start" = "false" ] || [ "$auto_start" = "" ]; then
         continue
     fi
     fi

     check_host || continue

     get_conf pid_file "/var/run/ceph/$type.$id.pid" "pid file"
     [ -n "$pid_file" ] && do_cmd "mkdir -p "`dirname $pid_file`

     get_conf log_dir "" "log dir"
     get_conf log_sym_dir "" "log sym dir"
     [ -n "$log_dir" ] && do_cmd "mkdir -p $log_dir"
     [ -n "$log_sym_dir" ] && do_cmd "mkdir -p $log_sym_dir"

     # start, and already running?  (do this check early to avoid unnecessary work!)
     if [ "$command" = "start" ]; then
     if daemon_is_running $name ceph-$type $id $pid_file; then
         echo "Starting Ceph $name on $host...already running"
         continue
     fi
     fi

     # binary?
     binary="$BINDIR/ceph-$type"
     if [ "$command" = "start" ]; then
     get_conf copy_executable_to "" "copy executable to"
     if [ -n "$copy_executable_to" ]; then
         scp $binary "$host:$copy_executable_to"
         binary="$copy_executable_to"
     fi
     fi

     cmd="$binary -i $id"

     # conf file
     if [ "$host" = "$hostname" ]; then
     cur_conf=$conf
     else
     if echo $pushed_to | grep -v -q " $host "; then
         scp -q $conf $host:/tmp/ceph.conf.$$
         pushed_to="$pushed_to $host "
     fi
     cur_conf="/tmp/ceph.conf.$$"
     fi
     cmd="$cmd -c $cur_conf"

     if echo $name | grep -q ^osd; then
     get_conf osd_data "" "osd data"
     get_conf btrfs_path "$osd_data" "btrfs path"  # mount point defaults so osd data
     get_conf btrfs_devs "" "btrfs devs"
     first_dev=`echo $btrfs_devs | cut '-d ' -f `
     fi

     # do lockfile, if RH
     get_conf lockfile "/var/lock/subsys/ceph" "lock file"
     lockdir=`dirname $lockfile`
     if [ ! -d "$lockdir" ]; then
     lockfile=""
     fi

     case "$command" in
     start)
             # Increase max_open_files, if the configuration calls for it.
             get_conf max_open_files "" "max open files"
             if [ $max_open_files != "" ]; then
                 # Note: Don't try to do math with these numbers, because POSIX shells
                 # can't do 64-bit math (natively). Just treat them as strings.
                 cur=`ulimit -n`
                 if [ "x$max_open_files" != "x$cur" ]; then
                     ulimit -n $max_open_files
                 fi
             fi

             # build final command
         wrap=""
         runmode=""
         runarg=""

         [ -z "$crun" ] && get_conf_bool crun "" "restart on core dump"
         [ "$crun" -eq  ] && wrap="$BINDIR/ceph-run"

         [ -z "$dovalgrind" ] && get_conf_bool valgrind "" "valgrind"
         [ -n "$valgrind" ] && wrap="$wrap valgrind $valgrind"

         [ -n "$wrap" ] && runmode="-f &" && runarg="-f"

         cmd="$wrap $cmd $runmode"

         if [ $dobtrfs -eq  ] && [ -n "$btrfs_devs" ]; then
         get_conf pre_mount "true" "pre mount command"
         get_conf btrfs_opt "noatime" "btrfs options"
         [ -n "$btrfs_opt" ] && btrfs_opt="-o $btrfs_opt"
         [ -n "$pre_mount" ] && do_cmd "$pre_mount"
         echo Mounting Btrfs on $host:$btrfs_path
         do_root_cmd "modprobe btrfs ; btrfsctl -a ; egrep -q '^[^ ]+ $btrfs_path' /proc/mounts || mount -t btrfs $btrfs_opt $first_dev $btrfs_path"
         fi
         echo Starting Ceph $name on $host...
         get_conf pre_start_eval "" "pre start eval"
         [ -n "$pre_start_eval" ] && $pre_start_eval
         get_conf pre_start "" "pre start command"
         get_conf post_start "" "post start command"
         [ -n "$pre_start" ] && do_cmd "$pre_start"
         do_cmd "$cmd" $runarg
         [ -n "$post_start" ] && do_cmd "$post_start"
         [ -n "$lockfile" ] && [ "$?" -eq  ] && touch $lockfile
         ;;

     stop)
         get_conf pre_stop "" "pre stop command"
         get_conf post_stop "" "post stop command"
         [ -n "$pre_stop" ] && do_cmd "$pre_stop"
         stop_daemon $name ceph-$type $pid_file
         [ -n "$post_stop" ] && do_cmd "$post_stop"
         [ -n "$lockfile" ] && [ "$?" -eq  ] && rm -f $lockfile
         if [ $dobtrfsumount -eq  ] && [ -n "$btrfs_devs" ]; then
         echo Unmounting Btrfs on $host:$btrfs_path
         do_root_cmd "umount $btrfs_path || true"
         fi
         ;;

     status)
         if daemon_is_running $name ceph-$type $id $pid_file; then
                 echo "$name: running..."
             elif [ -e "$pid_file" ]; then
                 # daemon is dead, but pid file still exists
                 echo "$name: dead."
                 EXIT_STATUS=
             else
                 # daemon is dead, and pid file is gone
                 echo "$name: not running."
                 EXIT_STATUS=
             fi
         ;;

     ssh)
         $ssh
         ;;

     forcestop)
         get_conf pre_forcestop "" "pre forcestop command"
         get_conf post_forcestop "" "post forcestop command"
         [ -n "$pre_forcestop" ] && do_cmd "$pre_forcestop"
         stop_daemon $name ceph-$type $pid_file -
         [ -n "$post_forcestop" ] && do_cmd "$post_forcestop"
         [ -n "$lockfile" ] && [ "$?" -eq  ] && rm -f $lockfile
         ;;

     killall)
         echo "killall ceph-$type on $host"
         do_cmd "pkill ^ceph-$type || true"
         [ -n "$lockfile" ] && [ "$?" -eq  ] && rm -f $lockfile
         ;;

     force-reload | reload)
         signal_daemon $name ceph-$type $pid_file - "Reloading"
         ;;

     restart)
         $ $options stop $name
         $ $options start $name
         ;;

     cleanlogs)
         echo removing logs
         if [ -n "$log_sym_dir" ]; then
         do_cmd "for f in $log_sym_dir/$type.$id.*; do rm -f \`readlink \$f\` ; rm -f \$f ; done ; rm -f $log_dir/$type.$id.*"
         fi
         [ -n "$log_dir" ] && do_cmd "rm -f $log_dir/$type.$id.*"
         ;;

     cleanalllogs)
         echo removing all logs
         [ -n "$log_sym_dir" ] && do_cmd "rm -f $log_sym_dir/* || true"
         [ -n "$log_dir" ] && do_cmd "rm -f $log_dir/* || true"
         ;;

     *)
         usage_exit
         ;;
     esac
 done

 exit $EXIT_STATUS