cisco_node_utils_mgx 2.1.0.1

data/bin/check_metric_limits.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+#
+# October 2015, Glenn F. Matthews
+#
+# Copyright (c) 2015 Cisco and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This is a helper script for developers.
+# If you're doing refactoring work to reduce the code complexity metrics,
+# you can run this script to report the worst offenders for each metric
+# and whether you've managed to improve any metrics compared to the baseline.
+
+require 'pathname'
+require 'yaml'
+
+base = Pathname.new(File.expand_path('../..', __FILE__))
+
+['lib/', 'tests/'].each do |subdir|
+  # Read in the base config file:
+  base_config = {}
+  File.open(base + subdir + '.rubocop.yml', 'r') do |f|
+    base_config = YAML.parse(f).transform
+  end
+
+  # Create a fake config file that's identical to baseline except for the
+  # metric Max limits:
+
+  new_config = {}
+  base_config.each do |cop, options|
+    next unless options.is_a?(Hash)
+    new_config[cop] = {}
+    options.each do |option, value|
+      new_config[cop][option] = value unless option == 'Max'
+    end
+  end
+
+  tempfile = base + '.rubocop_temp.yml'
+
+  File.open(tempfile, 'w') do |f|
+    f.write new_config.to_yaml
+  end
+
+  output = `rubocop -c #{tempfile} --only Metrics -f emacs \
+-D #{subdir} 2>/dev/null`
+  `rm -f #{tempfile}`
+
+  results = {}
+  output.split("\n").each do |line|
+    # emacs output format:
+    # foo/bar.rb:92:81: C: Metrics/LineLength: Line is too long. [81/80]
+    file, row, col, _err, cop, msg = line.split(':')
+    file = Pathname.new(file).relative_path_from(base).to_s
+    cop.strip!
+    value = msg[/\[([0-9.]+)/, 1].to_f.ceil
+    results[cop] ||= {}
+    results[cop][value] ||= []
+    results[cop][value] << {
+      file: file,
+      row:  row.to_i,
+      col:  col.to_i,
+    }
+  end
+
+  # Print each failing cop in alphabetical order...
+  results.keys.sort.each do |cop|
+    puts "\n#{cop}"
+    offenses = results[cop]
+    # List the two highest failing values...
+    offenses.keys.sort.reverse[0..1].each do |value|
+      puts "  #{value}:"
+      offenses[value].each do |offender|
+        # and list the file and line where each failure was seen
+        puts "    #{offender[:file]}:#{offender[:row]}"
+      end
+    end
+  end
+
+  puts "\n"
+
+  base_config.keys.sort.each do |cop|
+    next unless cop =~ /Metrics/
+    base_val = base_config[cop]['Max']
+    base_val ||= 0
+    actual_val = results[cop].keys.sort.last if results[cop]
+    actual_val ||= 0
+    if base_val == actual_val
+      if base_val == 0
+        puts "#{cop}: still passing in full"
+      else
+        puts "#{cop}: value unchanged (#{base_val})"
+      end
+    elsif base_val > actual_val
+      puts "#{cop}: value improved! (#{base_val} -> #{actual_val})"
+    else
+      puts "#{cop}: value WORSENED (#{base_val} -> #{actual_val})"
+    end
+  end
+end

data/bin/git/hooks/commit-msg/enforce_style

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+#
+# Enforce rules of good commit message style
+# http://chris.beams.io/posts/git-commit/#seven-rules
+
+message_file = ARGV[0]
+full_message = File.read(message_file)
+message_lines = full_message.split("\n")
+# Omit comment lines - they don't need to be validated!
+message_lines = message_lines.select { |i| i.empty? || i[/^[^#]/] }
+
+$errors = 0 # rubocop:disable Style/GlobalVars
+
+def failure(msg)
+  if STDOUT.tty?
+    puts "\t...[ \033[31mFAIL\033[0m ] #{msg}"
+  else
+    puts msg
+  end
+  $errors += 1 # rubocop:disable Style/GlobalVars
+end
+
+# 1. Separate subject from body with a blank line
+if message_lines.length > 1
+  unless message_lines[1].empty?
+    failure 'Separate subject (first line) from body with a blank line'
+  end
+end
+
+# 2. Limit the subject line to 50 characters
+if message_lines.first.length > 50
+  failure 'First line of commit message should be no more than 50 characters'
+  puts message_lines.first
+  puts '^' * 50
+end
+
+# 3. Capitalize the subject line
+unless message_lines.first =~ /^[A-Z]/
+  failure 'Begin commit message subject line with a capital letter'
+end
+
+# 4. Do not end the subject line with a period
+if message_lines.first =~ /[!.,;]\s*$/
+  failure 'Do not end the subject line with punctuation'
+end
+
+# 5. Use the imperative mood in the subject line
+# This is very hard to enforce by automation, so
+# let's just check some likely cases:
+non_imperatives = [/adds$/,
+                   /added$/,
+                   /change[ds]$/,
+                   /fixe[ds]$/,
+                   /merge[ds]$/,
+                   /remove[ds]$/,
+                   /update[ds]$/,
+                  ]
+s = message_lines.first.split(' ').first.downcase
+if non_imperatives.any? { |re| re.match(s) }
+  failure 'Use the imperative mood in the subject line'
+end
+
+# 6. Wrap the body at 72 characters
+if message_lines.any? { |line| line.length > 72 }
+  failure 'Wrap the body at 72 characters'
+  puts '-' * 72
+  puts message_lines.select { |line| line.length > 72 }.join("\n")
+  puts '-' * 72
+end
+
+# 7. Use the body to explain what and why vs. how
+# The user will just need to exercise judgment on this one :)
+
+if $errors > 0 # rubocop:disable Style/GlobalVars
+  puts 'Rejected commit message:'
+  puts '{'
+  puts message_lines.join("\n")
+  puts '}'
+
+  fd = IO.sysopen('/dev/tty', 'w+')
+  a = IO.new(fd, 'w+')
+  a.puts 'Continue anyway? [y/N] '
+  response = a.gets.chomp
+  # rubocop:disable Style/GlobalVars
+  $errors = 0 if response.downcase[0] == 'y'
+  # rubocop:enable Style/GlobalVars
+end
+
+exit $errors # rubocop:disable Style/GlobalVars

data/bin/git/hooks/hook_lib

@@ -0,0 +1,115 @@
+#!/bin/bash
+#
+# Shared library for git hooks
+
+# Colors
+DULL=0
+FG_BLACK=30
+FG_RED=31
+FG_GREEN=32
+FG_YELLOW=33
+FG_BLUE=34
+FG_MAGENTA=35
+FG_CYAN=36
+FG_WHITE=37
+FG_NULL=00
+BG_NULL=00
+ESC="["
+RESET="${ESC}0m"
+BOLD="${ESC}1m"
+BLACK="${ESC}${DULL};${FG_BLACK}m"
+RED="${ESC}${DULL};${FG_RED}m"
+GREEN="${ESC}${DULL};${FG_GREEN}m"
+YELLOW="${ESC}${DULL};${FG_YELLOW}m"
+BLUE="${ESC}${DULL};${FG_BLUE}m"
+MAGENTA="${ESC}${DULL};${FG_MAGENTA}m"
+CYAN="${ESC}${DULL};${FG_CYAN}m"
+WHITE="${ESC}${DULL};${FG_WHITE}m"
+
+# Top-level directory of our repository
+export REPO_DIR="$(git rev-parse --show-toplevel 2>/dev/null)"
+
+#DEBUG=1
+debug() {
+    [ "$DEBUG" == 1 ] && echo $1
+}
+export -f debug
+
+script_name() {
+    echo -e "*** ${BLUE}Running Git hook script: $*${RESET}..."
+}
+export -f script_name
+
+step_name() {
+    echo -e "\t${BOLD}$*${RESET}"
+}
+export -f step_name
+
+success() {
+    echo -e "\t...[ ${GREEN}OK${RESET} ]"
+}
+export -f success
+
+fail() {
+    local RC=$1
+    local msg=$2
+    echo -e "\t...[ ${RED}FAIL${RESET} ] $msg"
+    exit $RC
+}
+export -f fail
+
+check_rc() {
+    rc=$?
+    [ $rc -eq 0 ] || fail $rc "$*"
+    return $rc
+}
+export -f check_rc
+
+check_rc_optional() {
+    local RC=$?
+    local msg=$1
+    [ $RC -eq 0 ] && return $RC
+    echo -e "\t...[ ${YELLOW}WARNING${RESET} ] $msg"
+    read -p "Continue anyway? [y/N] " yn < /dev/tty
+    case $yn in
+      [Yy]* ) return 0;;
+      [Nn]* ) exit $RC;;
+      * ) exit $RC;;
+    esac
+}
+export -f check_rc_optional
+
+get_last_version() {
+    # Get the first subheading in the CHANGELOG, not counting 'Unreleased'
+    VER=$(grep -v "Unreleased" $REPO_DIR/CHANGELOG.md | egrep -m 1 '## \[.*]' | cut -d ' ' -f 2 | tr -d '[]')
+    echo "Detected previous release version as '$VER'"
+}
+export -f get_last_version
+
+get_staged_ruby_files() {
+  rubocop_target=$(rubocop --list-target-files)
+  staged_files=$(git diff --name-only --staged)
+  echo $(printf "$rubocop_target $staged_files " | tr ' ' '\n' | sort | uniq -d)
+}
+export -f get_staged_ruby_files
+
+add_changelog_diff_link() {
+    local OLD_VERSION=$1
+    local NEW_VERSION=$2
+
+    step_name "Adding link for diffs $OLD_VERSION..$NEW_VERSION in CHANGELOG.md"
+
+    # Automatically add diff link to the CHANGELOG
+    sed -i "/master...develop/ a\
+[$VERSION]: https://github.com/cisco/cisco-network-node-utils/compare/$OLD_VERSION...$NEW_VERSION" $REPO_DIR/CHANGELOG.md
+}
+export -f add_changelog_diff_link
+
+set_gem_version() {
+    local VERSION=$1
+
+    step_name "Updating version.rb to version '$VERSION'"
+
+    sed -i -e "s/VERSION =.*/VERSION = '$VERSION'/" $REPO_DIR/lib/cisco_node_utils/version.rb
+}
+export -f set_gem_version

data/bin/git/hooks/hooks-wrapper

@@ -0,0 +1,38 @@
+#!/bin/bash
+#
+# Generic git hook. Calls all associated helper scripts.
+#
+# Based on:
+# http://stackoverflow.com/questions/8730514/chaining-git-hooks
+# https://github.com/henrik/dotfiles/blob/master/git_template/hooks/pre-commit
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+
+. "$GIT_DIR"/hooks/hook_lib
+
+# What hook are we supposed to be?
+hookname=`basename $0`
+
+debug "Running wrapper script for '$hookname'..."
+
+exitcodes=()
+
+# Run each hook, passing through STDIN and storing the exit code.
+# We don't want to bail at the first failure, so the user can see everything.
+
+for hook in "$GIT_DIR"/hooks/$hookname-*; do
+    debug "Checking hook '$hook'"
+    test -x "$hook" || continue
+    script_name "${hook##*/}"
+    "$hook" "$@"
+    rc=$?
+    [ "$rc" == 0 ] && success
+    exitcodes+=($rc)
+done
+
+# If any exit code isn't 0, bail.
+for i in "${exitcodes[@]}"; do
+    [ "$i" == 0 ] || fail $i "One or more hook scripts reported an error"
+done
+debug "Wrapper script executed successfully"
+exit 0

data/bin/git/hooks/post-flow-hotfix-start/update-version

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+VERSION=$1
+debug "Detected VERSION as '$VERSION'"
+STRIP_VERSION=$(echo "$VERSION" | tr -c -d '0-9.')
+debug "Detected STRIP_VERSION as '$STRIP_VERSION'"
+
+LAST_VERSION=get_last_version
+
+step_name "Adding new release subheading in CHANGELOG.md"
+
+# Automatically update the CHANGELOG to mark the new release.
+# Unlike our post-flow-release-start script, there is no'Unreleased' tag
+# so we just insert the new version number immediately after the header
+sed -i "/^=========$/ a\
+\\\n## [$VERSION] - $(date +%Y-%m-%d)\nTODO
+" "$REPO_DIR/CHANGELOG.md"
+
+add_changelog_diff_link "$LAST_VERSION" "$STRIP_VERSION"
+
+set_gem_version "$STRIP_VERSION"

data/bin/git/hooks/post-flow-release-finish/update-version

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+VERSION=$1
+debug "Detected VERSION as '$VERSION'"
+STRIP_VERSION=$(echo "$VERSION" | tr -c -d '0-9.')
+debug "Detected STRIP_VERSION as '$STRIP_VERSION'"
+
+step_name "Adding 'Unreleased' subheader to CHANGELOG.md in development branch."
+
+# Add new 'Unreleased' section header to the CHANGELOG
+sed -i "/^=========$/ a\
+\\\n## [Unreleased]\n
+" $REPO_DIR/CHANGELOG.md
+
+# Bump the minor version number
+BUGFIX_NUM=$(($(echo $STRIP_VERSION | cut -d. -f 3)+1))
+NEW_VERSION="$(echo $STRIP_VERSION | cut -d. -f 1-2).$BUGFIX_NUM-dev"
+
+echo "New development version will be $NEW_VERSION"
+
+set_gem_version "$NEW_VERSION"
+
+step_name "Commit CHANGELOG.md and version.rb to develop branch"
+
+git commit -a -m "Post-release fixup"
+check_rc "Git commit to develop failed?"

data/bin/git/hooks/post-flow-release-start/update-version

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+VERSION=$1
+debug "Detected VERSION as '$VERSION'"
+STRIP_VERSION=$(echo "$VERSION" | tr -c -d '0-9.')
+debug "Detected STRIP_VERSION as '$STRIP_VERSION'"
+
+LAST_VERSION=get_last_version
+
+step_name "Change 'Unreleased' subhead to '$VERSION' in CHANGELOG.md"
+
+sed -i -e "s/^## \[Unreleased\]$/## [$VERSION] - $(date +%Y-%m-%d)/" "$REPO_DIR"/CHANGELOG.md
+
+add_changelog_diff_link "$LAST_VERSION" "$STRIP_VERSION"
+
+set_gem_version "$STRIP_VERSION"

data/bin/git/hooks/post-merge/update-hooks

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+[ -x "$REPO_DIR"/bin/git/update-hooks ] && "$REPO_DIR"/bin/git/update-hooks

data/bin/git/hooks/post-rewrite/update-hooks

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+[ -x "$REPO_DIR"/bin/git/update-hooks ] && "$REPO_DIR"/bin/git/update-hooks

data/bin/git/hooks/pre-commit/check_unstaged_changes

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+#
+# Check if a staged file has unstaged changes and print a warning
+
+staged_files = `git diff --name-only --staged`.split(' ')
+unstaged_files = `git diff --name-only`.split(' ')
+files = (staged_files << unstaged_files).flatten!
+
+if files.length != files.uniq.length
+  puts 'Warning: a staged file has unstaged changes!'
+  fd = IO.sysopen('/dev/tty', 'w+')
+  a = IO.new(fd, 'w+')
+  a.print 'Continue anyway? [y/N] '
+  input = a.gets.chomp
+  exit input =~ /^y/i ? 0 : -1
+end
+
+exit 0

data/bin/git/hooks/pre-commit/rubocop

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+# Run the rubocop lint checks (only).
+# We don't enforce a full rubocop run here because we want to let people
+# commit work-in-progress code to their local branch. We will do a full
+# rubocop run of all checks as part of the pre-push hook
+
+step_name "Running RuboCop lint checks"
+staged_ruby_files=$(get_staged_ruby_files)
+if [ -z "$staged_ruby_files" ]; then
+  # quit since there are no ruby files to check
+  exit 0
+fi
+rubocop --lint $staged_ruby_files
+check_rc "Please fix RuboCop lint failures before committing."
+
+# Do a full rubocop run to warn the user, but don't block a commit by it.
+step_name "Running all RuboCop checks"
+rubocop $staged_ruby_files
+check_rc_optional "Fix all RuboCop failures before pushing upstream"
+
+exit 0

data/bin/git/hooks/pre-commit/validate-diffs

@@ -0,0 +1,45 @@
+#!/bin/bash
+#
+# Hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+# What are we diffing this commit against?
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+    against=HEAD
+else
+    # Initial commit: diff against an empty tree object
+    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+step_name 'Checking for non-ASCII filenames'
+# We exploit the fact that the printable range starts at the space character
+# and ends with tilde.
+# Note that the use of brackets around a tr range is ok here, (it's
+# even required, for portability to Solaris 10's /usr/bin/tr), since
+# the square bracket bytes happen to fall in the designated range.
+added_files=$(git diff --cached --name-only --diff-filter=A -z $against | tr '\0' ' ')
+added_files_array=(`echo $added_files`)
+# Print the files that have non-ascii text
+for i in ${added_files_array[@]}; do
+  bad_chars=$(echo -n $i | LC_ALL=C tr -d '[ -~]\0')
+  if [ -n "$bad_chars" ]; then echo $i; fi
+done
+# Fail if any non-ASCII characters are discovered
+(echo -n $added_files | LC_ALL=C tr -d '[ -~]\0' | exit $(wc -c))
+check_rc "Rename non-ASCII file name(s) before committing"
+
+step_name 'Checking for trailing whitespace in non-Ruby files'
+# If there are whitespace errors, print the offending file names and fail.
+# Ignore .rb files, as whitespace in these files is managed by Rubocop
+# Ignore .proto files, as they are generated code
+non_ruby_files=`git diff --staged --name-only | grep -v \.rb | grep -v \.proto`
+if [ -n "$non_ruby_files" ]; then
+  ! git grep -n -I '\s$' -- $non_ruby_files
+  check_rc "Fix trailing whitespace before committing"
+fi

data/bin/git/hooks/pre-commit/validate-yaml

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+# Run the Kwalify YAML schema validation
+
+step_name "Validating YAML files"
+rspec "$REPO_DIR"/spec/yaml_spec.rb
+check_rc "Please fix YAML schema validation failures before committing"
+
+# Ensure that command_reference can parse all the YAML as well
+
+step_name "Checking command_reference YAML parsing"
+ruby "$REPO_DIR"/tests/test_command_reference.rb
+check_rc "Please fix command_reference unit test failures before committing"
+
+exit 0

data/bin/git/hooks/pre-push/check-changelog

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+z40=0000000000000000000000000000000000000000
+
+IFS=' '
+
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local sha1> <remote ref> <remote sha1>
+while read local_ref local_sha remote_ref remote_sha
+do
+    # do nothing if we're creating or deleting a new branch.
+    if [ "$local_sha" != $z40 ] && [ "$remote_sha" != $z40 ] ; then
+        # Make sure CHANGELOG.md is updated
+        step_name "Checking CHANGELOG.md..."
+        git diff --name-only --diff-filter=ACM $remote_sha $local_sha |
+            grep 'CHANGELOG.md' >> /dev/null
+        check_rc_optional "Please update CHANGELOG.md before pushing code upstream"
+    fi
+done

data/bin/git/hooks/pre-push/rubocop

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+rubocop
+check_rc "Please fix RuboCop failures before pushing code upstream."