From fd6daaa73b7a6db07644b7804e848b817ae204f5 Mon Sep 17 00:00:00 2001 From: Cameron Sparr Date: Thu, 7 Jan 2016 15:21:10 -0700 Subject: [PATCH 1/3] 0.3.0: update README and documentation --- CONFIGURATION.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CONFIGURATION.md b/CONFIGURATION.md index ee79da98a..60a18e18b 100644 --- a/CONFIGURATION.md +++ b/CONFIGURATION.md @@ -70,6 +70,10 @@ fields which begin with `time_`. precision = "s" # INPUTS +<<<<<<< HEAD +======= +[inputs] +>>>>>>> ac13af0... 0.3.0: update README and documentation [[inputs.cpu]] percpu = true totalcpu = false @@ -80,6 +84,10 @@ fields which begin with `time_`. ### Input Config: tagpass and tagdrop ```toml +<<<<<<< HEAD +======= +[inputs] +>>>>>>> ac13af0... 0.3.0: update README and documentation [[inputs.cpu]] percpu = true totalcpu = false From 07b4a4dbca76d68b7b49b6559c82f173a9715c96 Mon Sep 17 00:00:00 2001 From: Ross McDonald Date: Fri, 8 Jan 2016 09:47:09 -0600 Subject: [PATCH 2/3] Added a `build.py` script for compiling and packaging. Added post and pre install scripts to handle installation and upgrades in a cleaner way. Minor fixes to the init script and service unit file. --- .gitignore | 2 + CONFIGURATION.md | 8 - build.py | 671 +++++++++++++++++++++++++++++++++++++++ scripts/init.sh | 11 +- scripts/post-install.sh | 69 ++++ scripts/pre-install.sh | 14 + scripts/telegraf.service | 2 +- 7 files changed, 762 insertions(+), 15 deletions(-) create mode 100755 build.py create mode 100644 scripts/post-install.sh create mode 100644 scripts/pre-install.sh diff --git a/.gitignore b/.gitignore index d432f6865..7d27d694e 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,5 @@ tivan .vagrant /telegraf .idea +*~ +*# diff --git a/CONFIGURATION.md b/CONFIGURATION.md index 60a18e18b..ee79da98a 100644 --- a/CONFIGURATION.md +++ b/CONFIGURATION.md @@ -70,10 +70,6 @@ fields which begin with `time_`. precision = "s" # INPUTS -<<<<<<< HEAD -======= -[inputs] ->>>>>>> ac13af0... 0.3.0: update README and documentation [[inputs.cpu]] percpu = true totalcpu = false @@ -84,10 +80,6 @@ fields which begin with `time_`. ### Input Config: tagpass and tagdrop ```toml -<<<<<<< HEAD -======= -[inputs] ->>>>>>> ac13af0... 0.3.0: update README and documentation [[inputs.cpu]] percpu = true totalcpu = false diff --git a/build.py b/build.py new file mode 100755 index 000000000..1186a239b --- /dev/null +++ b/build.py @@ -0,0 +1,671 @@ +#!/usr/bin/env python2.7 +# +# This is the Telegraf build script. +# +# Current caveats: +# - Does not checkout the correct commit/branch (for now, you will need to do so manually) +# - Has external dependencies for packaging (fpm) and uploading (boto) +# + +import sys +import os +import subprocess +import time +import datetime +import shutil +import tempfile +import hashlib +import re + +try: + import boto + from boto.s3.key import Key +except ImportError: + pass + +# PACKAGING VARIABLES +INSTALL_ROOT_DIR = "/usr/bin" +LOG_DIR = "/var/log/telegraf" +DATA_DIR = "/var/lib/telegraf" +SCRIPT_DIR = "/usr/lib/telegraf/scripts" +CONFIG_DIR = "/etc/telegraf" +LOGROTATE_DIR = "/etc/logrotate.d" + +INIT_SCRIPT = "scripts/init.sh" +SYSTEMD_SCRIPT = "scripts/telegraf.service" +LOGROTATE_SCRIPT = "etc/logrotate.d/telegraf" +DEFAULT_CONFIG = "etc/telegraf.conf" +POSTINST_SCRIPT = "scripts/post-install.sh" +PREINST_SCRIPT = "scripts/pre-install.sh" + +# META-PACKAGE VARIABLES +PACKAGE_LICENSE = "MIT" +PACKAGE_URL = "https://github.com/influxdata/telegraf" +MAINTAINER = "support@influxdb.com" +VENDOR = "InfluxData" +DESCRIPTION = "Plugin-driven server agent for reporting metrics into InfluxDB." + +# SCRIPT START +prereqs = [ 'git', 'go' ] +optional_prereqs = [ 'gvm', 'fpm', 'rpmbuild' ] + +fpm_common_args = "-f -s dir --log error \ + --vendor {} \ + --url {} \ + --license {} \ + --maintainer {} \ + --config-files {} \ + --config-files {} \ + --after-install {} \ + --before-install {} \ + --description \"{}\"".format( + VENDOR, + PACKAGE_URL, + PACKAGE_LICENSE, + MAINTAINER, + CONFIG_DIR + '/telegraf.conf', + LOGROTATE_DIR + '/telegraf', + POSTINST_SCRIPT, + PREINST_SCRIPT, + DESCRIPTION) + +targets = { + 'telegraf' : './cmd/telegraf/telegraf.go', +} + +supported_builds = { + # TODO(rossmcdonald): Add support for multiple GOARM values + 'darwin': [ "amd64", "386" ], + # 'windows': [ "amd64", "386", "arm", "arm64" ], + 'linux': [ "amd64", "386", "arm" ] +} +supported_go = [ '1.5.1' ] +supported_packages = { + "darwin": [ "tar", "zip" ], + "linux": [ "deb", "rpm", "tar", "zip" ], + "windows": [ "tar", "zip" ], +} + +def run(command, allow_failure=False, shell=False): + out = None + try: + if shell: + out = subprocess.check_output(command, stderr=subprocess.STDOUT, shell=shell) + else: + out = subprocess.check_output(command.split(), stderr=subprocess.STDOUT) + except subprocess.CalledProcessError as e: + print "" + print "" + print "Executed command failed!" + print "-- Command run was: {}".format(command) + print "-- Failure was: {}".format(e.output) + if allow_failure: + print "Continuing..." + return None + else: + print "" + print "Stopping." + sys.exit(1) + except OSError as e: + print "" + print "" + print "Invalid command!" + print "-- Command run was: {}".format(command) + print "-- Failure was: {}".format(e) + if allow_failure: + print "Continuing..." + return out + else: + print "" + print "Stopping." + sys.exit(1) + else: + return out + +def create_temp_dir(): + return tempfile.mkdtemp(prefix="telegraf-build.") + +def get_current_version(): + command = "git describe --always --tags --abbrev=0" + out = run(command) + return out.strip() + +def get_current_commit(short=False): + command = None + if short: + command = "git log --pretty=format:'%h' -n 1" + else: + command = "git rev-parse HEAD" + out = run(command) + return out.strip('\'\n\r ') + +def get_current_branch(): + command = "git rev-parse --abbrev-ref HEAD" + out = run(command) + return out.strip() + +def get_system_arch(): + arch = os.uname()[4] + if arch == "x86_64": + arch = "amd64" + return arch + +def get_system_platform(): + if sys.platform.startswith("linux"): + return "linux" + else: + return sys.platform + +def get_go_version(): + out = run("go version") + matches = re.search('go version go(\S+)', out) + if matches is not None: + return matches.groups()[0].strip() + return None + +def check_path_for(b): + def is_exe(fpath): + return os.path.isfile(fpath) and os.access(fpath, os.X_OK) + + for path in os.environ["PATH"].split(os.pathsep): + path = path.strip('"') + full_path = os.path.join(path, b) + if os.path.isfile(full_path) and os.access(full_path, os.X_OK): + return full_path + +def check_environ(build_dir = None): + print "\nChecking environment:" + for v in [ "GOPATH", "GOBIN", "GOROOT" ]: + print "\t- {} -> {}".format(v, os.environ.get(v)) + + cwd = os.getcwd() + if build_dir == None and os.environ.get("GOPATH") and os.environ.get("GOPATH") not in cwd: + print "\n!! WARNING: Your current directory is not under your GOPATH. This may lead to build failures." + +def check_prereqs(): + print "\nChecking for dependencies:" + for req in prereqs: + print "\t- {} ->".format(req), + path = check_path_for(req) + if path: + print "{}".format(path) + else: + print "?" + for req in optional_prereqs: + print "\t- {} (optional) ->".format(req), + path = check_path_for(req) + if path: + print "{}".format(path) + else: + print "?" + print "" + +def upload_packages(packages, nightly=False): + print "Uploading packages to S3..." + print "" + c = boto.connect_s3() + # TODO(rossmcdonald) - Set to different S3 bucket for release vs nightly + bucket = c.get_bucket('telegraf-nightly') + for p in packages: + name = os.path.basename(p) + if bucket.get_key(name) is None or nightly: + print "\t - Uploading {}...".format(name), + k = Key(bucket) + k.key = name + if nightly: + n = k.set_contents_from_filename(p, replace=True) + else: + n = k.set_contents_from_filename(p, replace=False) + k.make_public() + print "[ DONE ]" + else: + print "\t - Not uploading {}, already exists.".format(p) + print "" + +def run_tests(race, parallel, timeout, no_vet): + get_command = "go get -d -t ./..." + print "Retrieving Go dependencies...", + sys.stdout.flush() + run(get_command) + print "done." + print "Running tests:" + print "\tRace: ", race + if parallel is not None: + print "\tParallel:", parallel + if timeout is not None: + print "\tTimeout:", timeout + sys.stdout.flush() + p = subprocess.Popen(["go", "fmt", "./..."], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, err = p.communicate() + if len(out) > 0 or len(err) > 0: + print "Code not formatted. Please use 'go fmt ./...' to fix formatting errors." + print out + print err + return False + if not no_vet: + p = subprocess.Popen(["go", "tool", "vet", "-composites=false", "./"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, err = p.communicate() + if len(out) > 0 or len(err) > 0: + print "Go vet failed. Please run 'go vet ./...' and fix any errors." + print out + print err + return False + else: + print "Skipping go vet ..." + sys.stdout.flush() + test_command = "go test -v" + if race: + test_command += " -race" + if parallel is not None: + test_command += " -parallel {}".format(parallel) + if timeout is not None: + test_command += " -timeout {}".format(timeout) + test_command += " ./..." + code = os.system(test_command) + if code != 0: + print "Tests Failed" + return False + else: + print "Tests Passed" + return True + +def build(version=None, + branch=None, + commit=None, + platform=None, + arch=None, + nightly=False, + rc=None, + race=False, + clean=False, + outdir=".", + goarm_version="6"): + print "-------------------------" + print "" + print "Build plan:" + print "\t- version: {}".format(version) + if rc: + print "\t- release candidate: {}".format(rc) + print "\t- commit: {}".format(commit) + print "\t- branch: {}".format(branch) + print "\t- platform: {}".format(platform) + print "\t- arch: {}".format(arch) + if arch == 'arm' and goarm_version: + print "\t- ARM version: {}".format(goarm_version) + print "\t- nightly? {}".format(str(nightly).lower()) + print "\t- race enabled? {}".format(str(race).lower()) + print "" + + if not os.path.exists(outdir): + os.makedirs(outdir) + elif clean and outdir != '/': + print "Cleaning build directory..." + shutil.rmtree(outdir) + os.makedirs(outdir) + + if rc: + # If a release candidate, update the version information accordingly + version = "{}rc{}".format(version, rc) + + print "Starting build..." + for b, c in targets.iteritems(): + print "\t- Building '{}'...".format(os.path.join(outdir, b)), + build_command = "" + build_command += "GOOS={} GOARCH={} ".format(platform, arch) + if arch == "arm" and goarm_version: + if goarm_version not in ["5", "6", "7", "arm64"]: + print "!! Invalid ARM build version: {}".format(goarm_version) + build_command += "GOARM={} ".format(goarm_version) + build_command += "go build -o {} ".format(os.path.join(outdir, b)) + if race: + build_command += "-race " + go_version = get_go_version() + if "1.4" in go_version: + build_command += "-ldflags=\"-X main.buildTime '{}' ".format(datetime.datetime.utcnow().isoformat()) + build_command += "-X main.Version {} ".format(version) + build_command += "-X main.Branch {} ".format(branch) + build_command += "-X main.Commit {}\" ".format(get_current_commit()) + else: + build_command += "-ldflags=\"-X main.buildTime='{}' ".format(datetime.datetime.utcnow().isoformat()) + build_command += "-X main.Version={} ".format(version) + build_command += "-X main.Branch={} ".format(branch) + build_command += "-X main.Commit={}\" ".format(get_current_commit()) + build_command += c + run(build_command, shell=True) + print "[ DONE ]" + print "" + +def create_dir(path): + try: + os.makedirs(path) + except OSError as e: + print e + +def rename_file(fr, to): + try: + os.rename(fr, to) + except OSError as e: + print e + # Return the original filename + return fr + else: + # Return the new filename + return to + +def copy_file(fr, to): + try: + shutil.copy(fr, to) + except OSError as e: + print e + +def create_package_fs(build_root): + print "\t- Creating a filesystem hierarchy from directory: {}".format(build_root) + # Using [1:] for the path names due to them being absolute + # (will overwrite previous paths, per 'os.path.join' documentation) + dirs = [ INSTALL_ROOT_DIR[1:], LOG_DIR[1:], DATA_DIR[1:], SCRIPT_DIR[1:], CONFIG_DIR[1:], LOGROTATE_DIR[1:] ] + for d in dirs: + create_dir(os.path.join(build_root, d)) + os.chmod(os.path.join(build_root, d), 0755) + +def package_scripts(build_root): + print "\t- Copying scripts and sample configuration to build directory" + shutil.copyfile(INIT_SCRIPT, os.path.join(build_root, SCRIPT_DIR[1:], INIT_SCRIPT.split('/')[1])) + os.chmod(os.path.join(build_root, SCRIPT_DIR[1:], INIT_SCRIPT.split('/')[1]), 0644) + shutil.copyfile(SYSTEMD_SCRIPT, os.path.join(build_root, SCRIPT_DIR[1:], SYSTEMD_SCRIPT.split('/')[1])) + os.chmod(os.path.join(build_root, SCRIPT_DIR[1:], SYSTEMD_SCRIPT.split('/')[1]), 0644) + shutil.copyfile(LOGROTATE_SCRIPT, os.path.join(build_root, LOGROTATE_DIR[1:], "telegraf")) + os.chmod(os.path.join(build_root, LOGROTATE_DIR[1:], "telegraf"), 0644) + shutil.copyfile(DEFAULT_CONFIG, os.path.join(build_root, CONFIG_DIR[1:], "telegraf.conf")) + os.chmod(os.path.join(build_root, CONFIG_DIR[1:], "telegraf.conf"), 0644) + +def go_get(update=False): + get_command = None + if update: + get_command = "go get -u -f -d ./..." + else: + get_command = "go get -d ./..." + print "Retrieving Go dependencies...", + run(get_command) + print "done.\n" + +def generate_md5_from_file(path): + m = hashlib.md5() + with open(path, 'rb') as f: + for chunk in iter(lambda: f.read(4096), b""): + m.update(chunk) + return m.hexdigest() + +def build_packages(build_output, version, nightly=False, rc=None, iteration=1): + outfiles = [] + tmp_build_dir = create_temp_dir() + try: + print "-------------------------" + print "" + print "Packaging..." + for p in build_output: + # Create top-level folder displaying which platform (linux, etc) + create_dir(os.path.join(tmp_build_dir, p)) + for a in build_output[p]: + current_location = build_output[p][a] + # Create second-level directory displaying the architecture (amd64, etc)p + build_root = os.path.join(tmp_build_dir, p, a) + # Create directory tree to mimic file system of package + create_dir(build_root) + create_package_fs(build_root) + # Copy in packaging and miscellaneous scripts + package_scripts(build_root) + # Copy newly-built binaries to packaging directory + for b in targets: + if p == 'windows': + b = b + '.exe' + fr = os.path.join(current_location, b) + to = os.path.join(build_root, INSTALL_ROOT_DIR[1:], b) + print "\t- [{}][{}] - Moving from '{}' to '{}'".format(p, a, fr, to) + copy_file(fr, to) + # Package the directory structure + for package_type in supported_packages[p]: + print "\t- Packaging directory '{}' as '{}'...".format(build_root, package_type), + name = "telegraf" + package_version = version + package_iteration = iteration + if package_type in ['zip', 'tar']: + if nightly: + name = '{}-nightly_{}_{}'.format(name, p, a) + else: + name = '{}-{}_{}_{}'.format(name, version, p, a) + if package_type == 'tar': + # Add `tar.gz` to path to reduce package size + current_location = os.path.join(current_location, name + '.tar.gz') + if rc is not None: + package_iteration = "0.rc{}".format(rc) + fpm_command = "fpm {} --name {} -a {} -t {} --version {} --iteration {} -C {} -p {} ".format( + fpm_common_args, + name, + a, + package_type, + package_version, + package_iteration, + build_root, + current_location) + if package_type == "rpm": + fpm_command += "--depends coreutils " + out = run(fpm_command, shell=True) + matches = re.search(':path=>"(.*)"', out) + outfile = None + if matches is not None: + outfile = matches.groups()[0] + if outfile is None: + print "[ COULD NOT DETERMINE OUTPUT ]" + else: + # Strip nightly version (the unix epoch) from filename + if nightly and package_type in ['deb', 'rpm']: + outfile = rename_file(outfile, outfile.replace("{}-{}".format(version, iteration), "nightly")) + outfiles.append(os.path.join(os.getcwd(), outfile)) + print "[ DONE ]" + # Display MD5 hash for generated package + print "\t\tMD5 = {}".format(generate_md5_from_file(outfile)) + print "" + return outfiles + finally: + # Cleanup + shutil.rmtree(tmp_build_dir) + +def print_usage(): + print "Usage: ./build.py [options]" + print "" + print "Options:" + print "\t --outdir= \n\t\t- Send build output to a specified path. Defaults to ./build." + print "\t --arch= \n\t\t- Build for specified architecture. Acceptable values: x86_64|amd64, 386, arm, or all" + print "\t --goarm= \n\t\t- Build for specified ARM version (when building for ARM). Default value is: 6" + print "\t --platform= \n\t\t- Build for specified platform. Acceptable values: linux, windows, darwin, or all" + print "\t --version= \n\t\t- Version information to apply to build metadata. If not specified, will be pulled from repo tag." + print "\t --commit= \n\t\t- Use specific commit for build (currently a NOOP)." + print "\t --branch= \n\t\t- Build from a specific branch (currently a NOOP)." + print "\t --rc= \n\t\t- Whether or not the build is a release candidate (affects version information)." + print "\t --iteration= \n\t\t- The iteration to display on the package output (defaults to 0 for RC's, and 1 otherwise)." + print "\t --race \n\t\t- Whether the produced build should have race detection enabled." + print "\t --package \n\t\t- Whether the produced builds should be packaged for the target platform(s)." + print "\t --nightly \n\t\t- Whether the produced build is a nightly (affects version information)." + print "\t --update \n\t\t- Whether dependencies should be updated prior to building." + print "\t --test \n\t\t- Run Go tests. Will not produce a build." + print "\t --parallel \n\t\t- Run Go tests in parallel up to the count specified." + print "\t --timeout \n\t\t- Timeout for Go tests. Defaults to 480s." + print "\t --clean \n\t\t- Clean the build output directory prior to creating build." + print "" + +def print_package_summary(packages): + print packages + +def main(): + # Command-line arguments + outdir = "build" + commit = None + target_platform = None + target_arch = None + nightly = False + race = False + branch = None + version = get_current_version() + rc = None + package = False + update = False + clean = False + upload = False + test = False + parallel = None + timeout = None + iteration = 1 + no_vet = False + goarm_version = "6" + + for arg in sys.argv[1:]: + if '--outdir' in arg: + # Output directory. If none is specified, then builds will be placed in the same directory. + output_dir = arg.split("=")[1] + if '--commit' in arg: + # Commit to build from. If none is specified, then it will build from the most recent commit. + commit = arg.split("=")[1] + if '--branch' in arg: + # Branch to build from. If none is specified, then it will build from the current branch. + branch = arg.split("=")[1] + elif '--arch' in arg: + # Target architecture. If none is specified, then it will build for the current arch. + target_arch = arg.split("=")[1] + elif '--platform' in arg: + # Target platform. If none is specified, then it will build for the current platform. + target_platform = arg.split("=")[1] + elif '--version' in arg: + # Version to assign to this build (0.9.5, etc) + version = arg.split("=")[1] + elif '--rc' in arg: + # Signifies that this is a release candidate build. + rc = arg.split("=")[1] + elif '--race' in arg: + # Signifies that race detection should be enabled. + race = True + elif '--package' in arg: + # Signifies that packages should be built. + package = True + elif '--nightly' in arg: + # Signifies that this is a nightly build. + nightly = True + elif '--update' in arg: + # Signifies that dependencies should be updated. + update = True + elif '--upload' in arg: + # Signifies that the resulting packages should be uploaded to S3 + upload = True + elif '--test' in arg: + # Run tests and exit + test = True + elif '--parallel' in arg: + # Set parallel for tests. + parallel = int(arg.split("=")[1]) + elif '--timeout' in arg: + # Set timeout for tests. + timeout = arg.split("=")[1] + elif '--clean' in arg: + # Signifies that the outdir should be deleted before building + clean = True + elif '--iteration' in arg: + iteration = arg.split("=")[1] + elif '--no-vet' in arg: + no_vet = True + elif '--goarm' in arg: + # Signifies GOARM flag to pass to build command when compiling for ARM + goarm_version = arg.split("=")[1] + elif '--help' in arg: + print_usage() + return 0 + else: + print "!! Unknown argument: {}".format(arg) + print_usage() + return 1 + + if nightly: + if rc: + print "!! Cannot be both nightly and a release candidate! Stopping." + return 1 + # In order to support nightly builds on the repository, we are adding the epoch timestamp + # to the version so that version numbers are always greater than the previous nightly. + version = "{}.n{}".format(version, int(time.time())) + + # Pre-build checks + check_environ() + check_prereqs() + + if not commit: + commit = get_current_commit(short=True) + if not branch: + branch = get_current_branch() + if not target_arch: + if 'arm' in get_system_arch(): + # Prevent uname from reporting ARM arch (eg 'armv7l') + target_arch = "arm" + else: + target_arch = get_system_arch() + if not target_platform: + target_platform = get_system_platform() + if rc or nightly: + # If a release candidate or nightly, set iteration to 0 (instead of 1) + iteration = 0 + + build_output = {} + # TODO(rossmcdonald): Prepare git repo for build (checking out correct branch/commit, etc.) + # prepare(branch=branch, commit=commit) + if test: + if not run_tests(race, parallel, timeout, no_vet): + return 1 + return 0 + + go_get(update=update) + + platforms = [] + single_build = True + if target_platform == 'all': + platforms = supported_builds.keys() + single_build = False + else: + platforms = [target_platform] + + for platform in platforms: + build_output.update( { platform : {} } ) + archs = [] + if target_arch == "all": + single_build = False + archs = supported_builds.get(platform) + else: + archs = [target_arch] + for arch in archs: + od = outdir + if not single_build: + od = os.path.join(outdir, platform, arch) + build(version=version, + branch=branch, + commit=commit, + platform=platform, + arch=arch, + nightly=nightly, + rc=rc, + race=race, + clean=clean, + outdir=od, + goarm_version=goarm_version) + build_output.get(platform).update( { arch : od } ) + + # Build packages + if package: + if not check_path_for("fpm"): + print "!! Cannot package without command 'fpm'. Stopping." + return 1 + packages = build_packages(build_output, version, nightly=nightly, rc=rc, iteration=iteration) + # TODO(rossmcdonald): Add nice output for print_package_summary() + # print_package_summary(packages) + # Optionally upload to S3 + if upload: + upload_packages(packages, nightly=nightly) + return 0 + +if __name__ == '__main__': + sys.exit(main()) + diff --git a/scripts/init.sh b/scripts/init.sh index 8a0fd992c..81932bb48 100755 --- a/scripts/init.sh +++ b/scripts/init.sh @@ -51,7 +51,6 @@ if [ ! -f "$STDERR" ]; then mkdir -p `dirname $STDERR` fi - OPEN_FILE_LIMIT=65536 function pidofproc() { @@ -98,7 +97,7 @@ function log_success_msg() { name=telegraf # Daemon name, where is the actual executable -daemon=/opt/telegraf/telegraf +daemon=/usr/bin/telegraf # pid file for the daemon pidfile=/var/run/telegraf/telegraf.pid @@ -106,12 +105,12 @@ piddir=`dirname $pidfile` if [ ! -d "$piddir" ]; then mkdir -p $piddir - chown $GROUP:$USER $piddir + chown $USER:$GROUP $piddir fi # Configuration file -config=/etc/opt/telegraf/telegraf.conf -confdir=/etc/opt/telegraf/telegraf.d +config=/etc/telegraf/telegraf.conf +confdir=/etc/telegraf/telegraf.d # If the daemon is not there, then exit. [ -x $daemon ] || exit 5 @@ -137,7 +136,7 @@ case $1 in log_success_msg "Starting the process" "$name" if which start-stop-daemon > /dev/null 2>&1; then - start-stop-daemon --chuid $GROUP:$USER --start --quiet --pidfile $pidfile --exec $daemon -- -pidfile $pidfile -config $config -config-directory $confdir $TELEGRAF_OPTS >>$STDOUT 2>>$STDERR & + start-stop-daemon --chuid $USER:$GROUP --start --quiet --pidfile $pidfile --exec $daemon -- -pidfile $pidfile -config $config -config-directory $confdir $TELEGRAF_OPTS >>$STDOUT 2>>$STDERR & else nohup $daemon -pidfile $pidfile -config $config -config-directory $confdir $TELEGRAF_OPTS >>$STDOUT 2>>$STDERR & fi diff --git a/scripts/post-install.sh b/scripts/post-install.sh new file mode 100644 index 000000000..19b895808 --- /dev/null +++ b/scripts/post-install.sh @@ -0,0 +1,69 @@ +#!/bin/bash + +BIN_DIR=/usr/bin +LOG_DIR=/var/log/telegraf +SCRIPT_DIR=/usr/lib/telegraf/scripts +LOGROTATE_DIR=/etc/logrotate.d + +function install_init { + cp -f $SCRIPT_DIR/init.sh /etc/init.d/telegraf + chmod +x /etc/init.d/telegraf +} + +function install_systemd { + cp -f $SCRIPT_DIR/telegraf.service /lib/systemd/system/telegraf.service + systemctl enable telegraf +} + +function install_update_rcd { + update-rc.d telegraf defaults +} + +function install_chkconfig { + chkconfig --add telegraf +} + +id telegraf &>/dev/null +if [[ $? -ne 0 ]]; then + useradd --system -U -M telegraf -s /bin/false -d /etc/telegraf +fi + +chown -R -L telegraf:telegraf $LOG_DIR + +# Remove legacy symlink, if it exists +if [[ -L /etc/init.d/telegraf ]]; then + rm -f /etc/init.d/telegraf +fi + +# Add defaults file, if it doesn't exist +if [[ ! -f /etc/default/telegraf ]]; then + touch /etc/default/telegraf +fi + +# Add .d configuration directory +if [[ ! -d /etc/telegraf/telegraf.d ]]; then + mkdir -p /etc/telegraf/telegraf.d +fi + +# Distribution-specific logic +if [[ -f /etc/redhat-release ]]; then + # RHEL-variant logic + which systemctl &>/dev/null + if [[ $? -eq 0 ]]; then + install_systemd + else + # Assuming sysv + install_init + install_chkconfig + fi +elif [[ -f /etc/lsb-release ]]; then + # Debian/Ubuntu logic + which systemctl &>/dev/null + if [[ $? -eq 0 ]]; then + install_systemd + else + # Assuming sysv + install_init + install_update_rcd + fi +fi diff --git a/scripts/pre-install.sh b/scripts/pre-install.sh new file mode 100644 index 000000000..443d6bc87 --- /dev/null +++ b/scripts/pre-install.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +if [[ -f /etc/opt/telegraf/telegraf.conf ]]; then + # Legacy configuration found + if [[ ! -d /etc/telegraf ]]; then + # New configuration does not exist, move legacy configuration to new location + echo -e "Please note, Telegraf's configuration is now located at '/etc/telegraf' (previously '/etc/opt/telegraf')." + mv /etc/opt/telegraf /etc/telegraf + + backup_name="telegraf.conf.$(date +%s).backup" + echo "A backup of your current configuration can be found at: /etc/telegraf/$backup_name" + cp -a /etc/telegraf/telegraf.conf /etc/telegraf/$backup_name + fi +fi diff --git a/scripts/telegraf.service b/scripts/telegraf.service index 62fc23a25..d92f3072c 100644 --- a/scripts/telegraf.service +++ b/scripts/telegraf.service @@ -6,7 +6,7 @@ After=network.target [Service] EnvironmentFile=-/etc/default/telegraf User=telegraf -ExecStart=/opt/telegraf/telegraf -config /etc/opt/telegraf/telegraf.conf -config-directory /etc/opt/telegraf/telegraf.d $TELEGRAF_OPTS +ExecStart=/usr/bin/telegraf -config /etc/telegraf/telegraf.conf -config-directory /etc/telegraf/telegraf.d ${TELEGRAF_OPTS} Restart=on-failure KillMode=process From 81fa063338bedbf62f06c3965732a171faa264a4 Mon Sep 17 00:00:00 2001 From: Ross McDonald Date: Fri, 8 Jan 2016 15:34:11 -0600 Subject: [PATCH 3/3] Removed data directory entries, since Telegraf doesn't need them. --- build.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/build.py b/build.py index 1186a239b..d6d6bee01 100755 --- a/build.py +++ b/build.py @@ -26,7 +26,6 @@ except ImportError: # PACKAGING VARIABLES INSTALL_ROOT_DIR = "/usr/bin" LOG_DIR = "/var/log/telegraf" -DATA_DIR = "/var/lib/telegraf" SCRIPT_DIR = "/usr/lib/telegraf/scripts" CONFIG_DIR = "/etc/telegraf" LOGROTATE_DIR = "/etc/logrotate.d" @@ -362,7 +361,7 @@ def create_package_fs(build_root): print "\t- Creating a filesystem hierarchy from directory: {}".format(build_root) # Using [1:] for the path names due to them being absolute # (will overwrite previous paths, per 'os.path.join' documentation) - dirs = [ INSTALL_ROOT_DIR[1:], LOG_DIR[1:], DATA_DIR[1:], SCRIPT_DIR[1:], CONFIG_DIR[1:], LOGROTATE_DIR[1:] ] + dirs = [ INSTALL_ROOT_DIR[1:], LOG_DIR[1:], SCRIPT_DIR[1:], CONFIG_DIR[1:], LOGROTATE_DIR[1:] ] for d in dirs: create_dir(os.path.join(build_root, d)) os.chmod(os.path.join(build_root, d), 0755)